handout binary

Reviewed-on: https://git.onlyoffice.com/ONLYOFFICE/core/pulls/636

Common/3dParty/apple/fetch.py

@@ -6,12 +6,13 @@ import os
 if not base.is_dir("glm"):
     base.cmd("git", ["clone", "https://github.com/g-truc/glm.git"])
     base.cmd_in_dir("glm", "git", ["checkout", "33b4a621a697a305bc3a7610d290677b96beb181", "--quiet"])
+    base.replaceInFile("./glm/glm/detail/func_common.inl", "vec<L, T, Q> v;", "vec<L, T, Q> v{};")
 
 if not base.is_dir("mdds"):
     base.cmd("git", ["clone", "https://github.com/kohei-us/mdds.git"])
     base.cmd_in_dir("mdds", "git", ["checkout", "0783158939c6ce4b0b1b89e345ab983ccb0f0ad0"], "--quiet")
 
-    fix_cpp_version  = "#if __cplusplus < 201402L\n"
+    fix_cpp_version  = "#if __cplusplus < 201703L\n"
     fix_cpp_version += "#ifndef _MSC_VER\n"
     fix_cpp_version += "namespace std {\n"
     fix_cpp_version += "  template<bool __v>\n"

Common/3dParty/html/css/CssCalculator.pri

@@ -3,6 +3,8 @@ DEPENDPATH += $$PWD
 
 CORE_ROOT_DIR = $$PWD/../../../..
 
+include($$CORE_ROOT_DIR/Common/3dParty/boost/boost.pri)
+
 css_calculator_without_xhtml {
 	HEADERS += \
 		$$PWD/src/CCssCalculator_Private.h \

Common/3dParty/html/css/src/CCssCalculator_Private.cpp

@@ -514,6 +514,9 @@ namespace NSCSS
 			return true;
 		}
 
+		if (!arSelectors.back().m_pCompiledStyle->Empty())
+			return true;
+
 		arSelectors.back().m_pCompiledStyle->SetDpi(m_nDpi);
 		unsigned int unStart = 0;
 
@@ -522,7 +525,7 @@ namespace NSCSS
 		if (itFound != arSelectors.crend())
 			unStart = itFound.base() - arSelectors.cbegin();
 
-		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors, unStart);
+		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors, unStart, arSelectors.size());
 		std::vector<std::wstring> arPrevNodes = CalculateAllNodes(arSelectors, 0, unStart);
 		bool bInTable = false;
 
@@ -548,6 +551,7 @@ namespace NSCSS
 			{
 				arSelectors[i].m_pCompiledStyle->m_oBackground.Clear();
 				arSelectors[i].m_pCompiledStyle->m_oBorder.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oDisplay.Clear();
 			}
 
 			arSelectors[i].m_pCompiledStyle->AddStyle(arSelectors[i].m_mAttributes, i + 1);
@@ -594,7 +598,7 @@ namespace NSCSS
 
 	std::vector<std::wstring> CCssCalculator_Private::CalculateAllNodes(const std::vector<CNode> &arSelectors, unsigned int unStart, unsigned int unEnd)
 	{
-		if (0 != unEnd && (unEnd < unStart || unEnd > arSelectors.size()))
+		if ((0 != unEnd && (unEnd < unStart || unEnd > arSelectors.size())) || (unStart == unEnd))
 			return std::vector<std::wstring>();
 
 		std::vector<std::wstring> arNodes;
@@ -630,7 +634,7 @@ namespace NSCSS
 		if (arNextNodes.empty())
 			return;
 
-		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.crbegin() + 1, arNextNodes.crend());
+		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.cbegin(), arNextNodes.cend());
 		const std::vector<CElement*> arTempKins = pElement->GetNextOfKin(wsName, arClasses);
 
 		if (!arTempPrev.empty())
@@ -647,20 +651,19 @@ namespace NSCSS
 
 		std::vector<const CElement*> arFindedElements;
 
-		std::wstring wsName, wsId;
+		std::wstring wsName, wsClasses, wsId;
 		std::vector<std::wstring> arClasses;
 
 		if (!arNodes.empty() && arNodes.back()[0] == L'#')
 		{
 			wsId = arNodes.back();
 			arNodes.pop_back();
-			arNextNodes.push_back(wsId);
 		}
 
 		if (!arNodes.empty() && arNodes.back()[0] == L'.')
 		{
-			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arNodes.back(), false, L" ");
-			arNextNodes.push_back(arNodes.back());
+			wsClasses = arNodes.back();
+			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(wsClasses, false, L" ");
 			arNodes.pop_back();
 		}
 
@@ -668,7 +671,6 @@ namespace NSCSS
 		{
 			wsName = arNodes.back();
 			arNodes.pop_back();
-			arNextNodes.push_back(wsName);
 		}
 
 		if (!wsId.empty())
@@ -727,6 +729,14 @@ namespace NSCSS
 			          { return oFirstElement->GetWeight() > oSecondElement->GetWeight(); });
 		}
 
+		if (!wsId.empty())
+			arNextNodes.push_back(wsId);
+
+		if (!wsClasses.empty())
+			arNextNodes.push_back(wsClasses);
+
+		arNextNodes.push_back(wsName);
+
 		return arFindedElements;
 	}
 
@@ -741,7 +751,7 @@ namespace NSCSS
 		if (arSelectors.empty())
 			return false;
 
-		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors);
+		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors, 0, arSelectors.size());
 		std::vector<std::wstring> arNextNodes;
 
 		for (size_t i = 0; i < arSelectors.size(); ++i)

Common/3dParty/html/css/src/CCssCalculator_Private.h

@@ -110,7 +110,7 @@ namespace NSCSS
 		void ClearPageData();
 		#endif
 
-		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors, unsigned int unStart = 0, unsigned int unEnd = 0);
+		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors, unsigned int unStart, unsigned int unEnd);
 		std::vector<const CElement*> FindElements(std::vector<std::wstring>& arNodes, std::vector<std::wstring>& arNextNodes);
 
 		void AddStyles(const std::string& sStyle);

Common/3dParty/html/css/src/CElement.cpp

@@ -176,14 +176,14 @@ namespace NSCSS
 		return arElements;
 	}
 
-	std::vector<CElement *> CElement::GetPrevElements(const std::vector<std::wstring>::const_reverse_iterator& oNodesRBegin, const std::vector<std::wstring>::const_reverse_iterator& oNodesREnd) const
+	std::vector<CElement *> CElement::GetPrevElements(const std::vector<std::wstring>::const_iterator& oNodesBegin, const std::vector<std::wstring>::const_iterator& oNodesEnd) const
 	{
-		if (oNodesRBegin >= oNodesREnd || m_arPrevElements.empty())
+		if (oNodesBegin >= oNodesEnd || m_arPrevElements.empty())
 			return std::vector<CElement*>();
 
 		std::vector<CElement*> arElements;
 
-		for (std::vector<std::wstring>::const_reverse_iterator iWord = oNodesRBegin; iWord != oNodesREnd; ++iWord)
+		for (std::vector<std::wstring>::const_iterator iWord = oNodesBegin; iWord != oNodesEnd; ++iWord)
 		{
 			if ((*iWord)[0] == L'.' && ((*iWord).find(L" ") != std::wstring::npos))
 			{
@@ -195,7 +195,7 @@ namespace NSCSS
 						if (oPrevElement->m_sSelector == wsClass)
 						{
 							arElements.push_back(oPrevElement);
-							std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesREnd);
+							std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesEnd);
 							arElements.insert(arElements.end(), arTempElements.begin(), arTempElements.end());
 						}
 					}
@@ -208,9 +208,8 @@ namespace NSCSS
 					if (oPrevElement->m_sSelector == *iWord)
 					{
 						arElements.push_back(oPrevElement);
-						std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesREnd);
+						std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesEnd);
 						arElements.insert(arElements.end(), arTempElements.begin(), arTempElements.end());
-	//                    return arElements;
 					}
 				}
 			}

Common/3dParty/html/css/src/CElement.h

@@ -39,7 +39,7 @@ namespace NSCSS
 		std::map<std::wstring, std::wstring> GetFullStyle(const std::vector<CNode>& arSelectors) const;
 		std::map<std::wstring, std::wstring> GetFullStyle(const std::vector<std::wstring>& arNodes) const;
 		std::vector<CElement *> GetNextOfKin(const std::wstring& sName, const std::vector<std::wstring>& arClasses = {}) const;
-		std::vector<CElement *> GetPrevElements(const std::vector<std::wstring>::const_reverse_iterator& oNodesRBegin, const std::vector<std::wstring>::const_reverse_iterator& oNodesREnd) const;
+		std::vector<CElement *> GetPrevElements(const std::vector<std::wstring>::const_iterator& oNodesBegin, const std::vector<std::wstring>::const_iterator& oNodesEnd) const;
 		std::map<std::wstring, std::wstring> GetConvertStyle(const std::vector<CNode>& arNodes) const;
 
 		CElement *FindPrevElement(const std::wstring& sSelector) const;

Common/3dParty/html/css/src/CUnitMeasureConverter.cpp

@@ -149,7 +149,7 @@ namespace NSCSS
 			case NSCSS::Millimeter:
 				return dValue * 0.01764;
 			case NSCSS::Inch:
-				return dValue * 1440.;
+				return dValue / 1440.;
 			case NSCSS::Peak:
 				return dValue * 0.004167; // 0.004167 = 6 / 1440
 			default:

Common/3dParty/html/css/src/ConstValues.h

@@ -69,7 +69,8 @@ namespace NSCSS
 				R_Highlight,
 				R_Shd,
 				R_SmallCaps,
-				R_Kern
+				R_Kern,
+				R_Vanish
 			} RunnerProperties;
 
 			typedef enum

Common/3dParty/html/css/src/StyleProperties.h

@@ -4,11 +4,14 @@
 #include <map>
 #include <string>
 #include <vector>
-#include <sstream>
 
 #include "../../../../DesktopEditor/graphics/Matrix.h"
 #include "CUnitMeasureConverter.h"
 
+#include <boost/optional.hpp>
+#include "boost/blank.hpp"
+#include <boost/variant2/variant.hpp>
+
 namespace NSCSS
 {
 	namespace NSProperties
@@ -16,33 +19,34 @@ namespace NSCSS
 	#define NEXT_LEVEL UINT_MAX, true
 
 	template<typename T>
-	class CValue
+	class CValueBase
 	{
-		friend class CString;
-		friend class CMatrix;
-		friend class CDigit;
-		friend class CColor;
-		friend class CEnum;
-		friend class CURL;
+	protected:
+		CValueBase()
+			: m_unLevel(0), m_bImportant(false)
+		{}
+		CValueBase(const CValueBase& oValue)
+			: m_oValue(oValue.m_oValue), m_unLevel(oValue.m_unLevel), m_bImportant(oValue.m_bImportant)
+		{}
+
+		CValueBase(const T& oValue, unsigned int unLevel, bool bImportant)
+		    : m_oValue(oValue), m_unLevel(unLevel), m_bImportant(bImportant)
+		{}
 
 		T            m_oValue;
 		unsigned int m_unLevel;
 		bool         m_bImportant;
 	public:
-		CValue(const T& oValue, unsigned int unLevel, bool bImportant) :
-		    m_oValue(oValue), m_unLevel(unLevel), m_bImportant(bImportant)
-		{
-		}
+		virtual bool Empty() const = 0;
+		virtual void Clear() = 0;
 
 		virtual bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode) = 0;
 
-		virtual bool Empty() const = 0;
-		virtual void Clear() = 0;
 		virtual int ToInt() const = 0;
 		virtual double ToDouble() const = 0;
 		virtual std::wstring ToWString() const = 0;
 
-		static void Equation(CValue &oFirstValue, CValue &oSecondValue)
+		static void Equation(CValueBase &oFirstValue, CValueBase &oSecondValue)
 		{
 			if (oFirstValue.m_bImportant && !oSecondValue.m_bImportant && oFirstValue.Empty())
 				oSecondValue.Clear();
@@ -57,18 +61,39 @@ namespace NSCSS
 			}
 		}
 
-		static bool LevelIsSame(const CValue& oFirstValue, const CValue& oSecondValue)
+		static bool LevelIsSame(const CValueBase& oFirstValue, const CValueBase& oSecondValue)
 		{
 			return oFirstValue.m_unLevel == oSecondValue.m_unLevel;
 		}
 
-		bool operator==(const T& oValue) const { return m_oValue == oValue; }
-		bool operator>=(const T& oValue) const { return m_oValue >= oValue; }
-		bool operator<=(const T& oValue) const { return m_oValue <= oValue; }
-		bool operator> (const T& oValue) const { return m_oValue > oValue; }
-		bool operator< (const T& oValue) const { return m_oValue < oValue; }
+		friend bool operator==(const CValueBase& oLeftValue, const CValueBase& oRightValue)
+		{
+			if (oLeftValue.Empty() && oRightValue.Empty())
+				return true;
 
-		virtual CValue& operator =(const CValue& oValue)
+			if (( oLeftValue.Empty() && !oRightValue.Empty()) ||
+			    (!oLeftValue.Empty() &&  oRightValue.Empty()))
+				return false;
+
+			return oLeftValue.m_oValue == oRightValue.m_oValue;
+		}
+
+		friend bool operator!=(const CValueBase& oLeftValue, const CValueBase& oRightValue)
+		{
+			return !(oLeftValue == oRightValue);
+		}
+
+		bool operator==(const T& oValue) const
+		{
+			return m_oValue == oValue;
+		}
+
+		bool operator!=(const T& oValue) const
+		{
+			return m_oValue != oValue;
+		}
+
+		virtual CValueBase& operator =(const CValueBase& oValue)
 		{
 			m_oValue     = oValue.m_oValue;
 			m_unLevel    = oValue.m_unLevel;
@@ -77,70 +102,93 @@ namespace NSCSS
 			return *this;
 		}
 
-		virtual CValue& operator =(const T& oValue)
+		virtual CValueBase& operator =(const T& oValue)
 		{
-			//m_oValue = oValue.m_oValue;
+			m_oValue = oValue;
+
 			return *this;
 		}
 
-		virtual CValue& operator+=(const CValue& oValue)
+		virtual CValueBase& operator+=(const CValueBase& oValue)
 		{
 			if (m_unLevel > oValue.m_unLevel || (m_bImportant && !oValue.m_bImportant) || oValue.Empty())
 				return *this;
 
-			m_oValue     = oValue.m_oValue;
-			m_unLevel    = oValue.m_unLevel;
-			m_bImportant = oValue.m_bImportant;
+			*this = oValue;
 
 			return *this;
 		}
+	};
 
-		virtual bool operator==(const CValue& oValue) const
+	template<typename T>
+	class CValueOptional : public CValueBase<boost::optional<T>>
+	{
+	protected:
+		CValueOptional() = default;
+
+		CValueOptional(const T& oValue, unsigned int unLevel = 0, bool bImportant = false)
+		    : CValueBase<boost::optional<T>>(oValue, unLevel, bImportant)
+		{}
+	public:
+		virtual bool Empty() const override
 		{
-			return m_oValue == oValue.m_oValue;
+			return !this->m_oValue.has_value();
+		}
+		void Clear() override
+		{
+			this->m_oValue.reset();
+			this->m_unLevel = 0;
+			this->m_bImportant = false;
 		}
 
-		virtual bool operator!=(const CValue& oValue) const
+		bool operator==(const T& oValue) const
 		{
-			return m_oValue != oValue.m_oValue;
+			if (!this->m_oValue.has_value())
+				return false;
+
+			return this->m_oValue.value() == oValue;
+		}
+
+		virtual CValueOptional& operator=(const T& oValue)
+		{
+			this->m_oValue = oValue;
+
+			return *this;
 		}
 	};
 
-	class CString : public CValue<std::wstring>
+	class CString : public CValueOptional<std::wstring>
 	{
 	public:
-		CString();
-		CString(const std::wstring& wsValue, unsigned int unLevel, bool bImportant = false);
+		CString() = default;
+		CString(const std::wstring& wsValue, unsigned int unLevel = 0, bool bImportant = false);
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode) override;
 		bool SetValue(const std::wstring& wsValue, const std::vector<std::wstring>& arValiableValues, unsigned int unLevel, bool bHardMode);
 		bool SetValue(const std::wstring& wsValue, const std::map<std::wstring, std::wstring>& arValiableValues, unsigned int unLevel, bool bHardMode);
 
 		bool Empty() const override;
-		void Clear() override;
 
 		int          ToInt()     const override;
 		double       ToDouble()  const override;
 		std::wstring ToWString() const override;
 
-		CString& operator+=(const CString& oString);
+		bool operator==(const wchar_t* pValue) const;
+		bool operator!=(const wchar_t* pValue) const;
+
+		using CValueOptional<std::wstring>::operator=;
 	};
 
-	class CDigit : public CValue<double>
+	class CDigit : public CValueOptional<double>
 	{
-		UnitMeasure m_enUnitMeasure;
-
-		double ConvertValue(double dPrevValue, UnitMeasure enUnitMeasure) const;
 	public:
 		CDigit();
-		CDigit(double dValue);
-		CDigit(double dValue, unsigned int unLevel, bool bImportant = false);
+		CDigit(const double& dValue, unsigned int unLevel = 0, bool bImportant = false);
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true) override;
 		bool SetValue(const CDigit& oValue);
 		bool SetValue(const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel = 0, bool bHardMode = true);
 
-		bool Empty() const override;
 		bool Zero() const;
 		void Clear() override;
 
@@ -156,7 +204,7 @@ namespace NSCSS
 
 		UnitMeasure GetUnitMeasure() const;
 
-		bool operator==(const double& oValue) const;
+		bool operator==(const double& dValue) const;
 		bool operator==(const CDigit& oDigit) const;
 
 		bool operator!=(const double& oValue) const;
@@ -171,11 +219,19 @@ namespace NSCSS
 
 		CDigit& operator+=(const CDigit& oDigit);
 		CDigit& operator-=(const CDigit& oDigit);
-		CDigit& operator+=(double dValue);
-		CDigit& operator-=(double dValue);
-		CDigit& operator*=(double dValue);
-		CDigit& operator/=(double dValue);
-		CDigit& operator =(double dValue);
+		CDigit& operator+=(const double& dValue);
+		CDigit& operator-=(const double& dValue);
+		CDigit& operator*=(const double& dValue);
+		CDigit& operator/=(const double& dValue);
+
+		using CValueOptional<double>::operator=;
+	private:
+		UnitMeasure m_enUnitMeasure;
+
+		double ConvertValue(double dPrevValue, UnitMeasure enUnitMeasure) const;
+
+		template <typename Operation>
+		CDigit ApplyOperation(const CDigit& oDigit, Operation operation) const;
 	};
 
 	struct TRGB
@@ -186,6 +242,8 @@ namespace NSCSS
 
 		bool Empty() const;
 
+		int ToInt() const;
+
 		bool operator==(const TRGB& oRGB) const;
 		bool operator!=(const TRGB& oRGB) const;
 	};
@@ -211,31 +269,58 @@ namespace NSCSS
 	
 	typedef enum
 	{
-		ColorEmpty,
 		ColorNone,
 		ColorRGB,
 		ColorHEX,
 		ColorUrl,
 		ColorContextStroke,
 		ColorContextFill
-	} ColorType;
+	} EColorType;
 
-	class CColor : public CValue<void*>
+	class CColorValue
+	{
+		using color_value = boost::variant2::variant<boost::blank, std::wstring, TRGB, CURL>;
+	protected:
+		EColorType  m_eType;
+	public:
+		CColorValue();
+		CColorValue(const CColorValue& oValue);
+		CColorValue(const std::wstring& wsValue);
+		CColorValue(const TRGB& oValue);
+		CColorValue(const CURL& oValue);
+
+		EColorType GetType() const;
+
+		bool operator==(const CColorValue& oValue) const;
+
+		color_value m_oValue;
+	};
+
+	class CColorValueContextStroke : public CColorValue
+	{
+	public:
+		CColorValueContextStroke();
+	};
+
+	class CColorValueContextFill : public CColorValue
+	{
+	public:
+		CColorValueContextFill();
+	};
+
+	class CColor : public CValueOptional<CColorValue>
 	{
 	public:
 		CColor();
-		CColor(const CColor& oColor);
-		~CColor();
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true) override;
 		bool SetOpacity(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true);
 
-		bool Empty() const override;
 		bool None() const;
 		bool Url() const;
 		void Clear() override;
 
-		ColorType GetType() const;
+		EColorType GetType() const;
 
 		double GetOpacity() const;
 
@@ -249,20 +334,15 @@ namespace NSCSS
 		static TRGB ConvertHEXtoRGB(const std::wstring& wsValue);
 		static std::wstring ConvertRGBtoHEX(const TRGB& oValue);
 
-		bool operator==(const CColor& oColor) const;
-		bool operator!=(const CColor& oColor) const;
-
-		CColor& operator =(const CColor& oColor);
-		CColor& operator+=(const CColor& oColor);
+		using CValueOptional<CColorValue>::operator=;
 	private:
-		CDigit    m_oOpacity;
-		ColorType m_enType;
+		CDigit m_oOpacity;
 
 		void SetEmpty(unsigned int unLevel = 0);
 		void SetRGB(unsigned char uchR, unsigned char uchG, unsigned char uchB);
 		void SetRGB(const TRGB& oRGB);
 		void SetHEX(const std::wstring& wsValue);
-		void SetUrl(const std::wstring& wsValue);
+		bool SetUrl(const std::wstring& wsValue);
 		void SetNone();
 	};
 
@@ -279,7 +359,7 @@ namespace NSCSS
 
 	typedef std::vector<std::pair<std::vector<double>, TransformType>> MatrixValues;
 
-	class CMatrix : public CValue<MatrixValues>
+	class CMatrix : public CValueBase<MatrixValues>
 	{
 		std::vector<std::wstring> CutTransforms(const std::wstring& wsValue) const;
 	public:
@@ -304,29 +384,27 @@ namespace NSCSS
 		bool operator==(const CMatrix& oMatrix) const;
 		CMatrix& operator+=(const CMatrix& oMatrix);
 		CMatrix& operator-=(const CMatrix& oMatrix);
+
+		using CValueBase<MatrixValues>::operator=;
 	};
 
-	class CEnum : public CValue<int>
+	class CEnum : public CValueOptional<int>
 	{
-		std::map<std::wstring, int> m_mMap;
 	public:
 		CEnum();
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode) override;
 		void SetMapping(const std::map<std::wstring, int>& mMap, int nDefaulvalue = -1);
 
-		bool Empty() const override;
-		void Clear() override;
-
-		CEnum &operator =(int nValue);
-
-		bool operator==(int nValue) const;
-		bool operator!=(int nValue) const;
-
 		int ToInt() const override;
+
+		using CValueOptional<int>::operator=;
 	private:
 		double ToDouble() const override;
 		std::wstring ToWString() const override;
+
+		int m_nDefaultValue;
+		std::map<std::wstring, int> m_mMap;
 	};
 
 	// PROPERTIES
@@ -373,6 +451,7 @@ namespace NSCSS
 		const CEnum& GetWhiteSpace() const;
 
 		bool Empty() const;
+		void Clear();
 
 		CDisplay& operator+=(const CDisplay& oDisplay);
 		bool      operator==(const CDisplay& oDisplay) const;
@@ -618,6 +697,30 @@ namespace NSCSS
 		bool operator==(const TTextDecoration& oTextDecoration) const;
 	};
 
+	typedef enum
+	{
+		Baseline,
+		Sub,
+		Super,
+		Percentage,
+		Length
+	} EBaselineShift;
+
+	class CBaselineShift
+	{
+		CEnum   m_eType;
+		CDigit  m_oValue;
+	public:
+		CBaselineShift();
+
+		bool Empty() const;
+
+		EBaselineShift GetType() const;
+		double         GetValue() const;
+
+		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+	};
+
 	class CText
 	{
 	public:
@@ -625,11 +728,12 @@ namespace NSCSS
 
 		static void Equation(CText &oFirstText, CText &oSecondText);
 
-		bool SetIndent    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetAlign     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetDecoration(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetColor     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetHighlight (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetIndent        (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetAlign         (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetDecoration    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetColor         (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetHighlight     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetBaselineShift (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		const CDigit&          GetIndent()     const;
 		const CString&         GetAlign()      const;
@@ -637,6 +741,9 @@ namespace NSCSS
 		const CColor&          GetColor()      const;
 		const CColor&          GetHighlight()  const;
 
+		EBaselineShift GetBaselineShiftType()  const;
+		double         GetBaselineShiftValue() const;
+
 		bool Empty() const;
 
 		bool Underline()   const;
@@ -646,6 +753,7 @@ namespace NSCSS
 		CText& operator+=(const CText& oText);
 		bool   operator==(const CText& oText) const;
 	private:
+		CBaselineShift  m_oBaselineShift;
 		TTextDecoration m_oDecoration;
 		CDigit          m_oIndent;
 		CString         m_oAlign;

Common/3dParty/html/css/src/xhtml/CDocumentStyle.cpp

@@ -509,6 +509,9 @@ namespace NSCSS
 		else if (L"serif" == wsFontFamily)
 			wsFontFamily = L"Times New Roman";
 
+		if (oStyle.m_oDisplay.GetDisplay() == L"none")
+			oXmlElement.AddPropertiesInR(RProperties::R_Vanish, L"true");
+
 		oXmlElement.AddPropertiesInR(RProperties::R_RFonts, oStyle.m_oFont.GetFamily().ToWString());
 		oXmlElement.AddPropertiesInR(RProperties::R_I, oStyle.m_oFont.GetStyle().ToWString());
 		oXmlElement.AddPropertiesInR(RProperties::R_B, oStyle.m_oFont.GetWeight().ToWString());

Common/3dParty/html/css/src/xhtml/CXmlElement.cpp

@@ -473,6 +473,12 @@ std::wstring CXmlElement::ConvertRStyle(bool bIsLite) const
 				sRStyle += L"<w:kern w:val=\"" + oItem.second + L"\"/>";
 				break;
 			}
+			case CSSProperties::RunnerProperties::R_Vanish:
+			{
+				if (oItem.second == L"true")
+					sRStyle += L"<w:vanish/>";
+				break;
+			}
 			default:
 				break;
 		}

Common/3dParty/md/md2html.cpp

@@ -5,6 +5,9 @@
 
 namespace Md
 {
+#define MD_PARSER_FLAGS MD_DIALECT_GITHUB | MD_FLAG_NOINDENTEDCODEBLOCKS | MD_HTML_FLAG_SKIP_UTF8_BOM | MD_FLAG_HARD_SOFT_BREAKS | MD_HTML_FLAG_XHTML | MD_FLAG_LATEXMATHSPANS
+#define MD_RENDERER_FLAGS MD_HTML_FLAG_XHTML
+
 void ToHtml(const MD_CHAR* pValue, MD_SIZE uSize, void* pData)
 {
 	if (NULL != pData)
@@ -14,7 +17,7 @@ void ToHtml(const MD_CHAR* pValue, MD_SIZE uSize, void* pData)
 std::string ConvertMdStringToHtml(const std::string& sMdString)
 {
 	std::string sData;
-	md_html(sMdString.c_str(), sMdString.length(), ToHtml, &sData, 0, 0);
+	md_html(sMdString.c_str(), sMdString.length(), ToHtml, &sData, MD_PARSER_FLAGS, MD_RENDERER_FLAGS);
 	return sData;
 }
 
@@ -36,14 +39,13 @@ void WriteBaseHtmlStyles(NSFile::CFileBinary& oFile)
 	oFile.WriteStringUTF8(L"img { vertical-align: middle; }");
 
 	// Styles for tables
-	oFile.WriteStringUTF8(L"table { margin-bottom: 20px; width: 100%; max-width: 100%; border-spacing:0; border-collapse: collapse; border-color: gray;}");
-	oFile.WriteStringUTF8(L"thead { display: table-header-group; vertical-align: middle; }");
+	oFile.WriteStringUTF8(L"table { margin-bottom: 20px; width: 100%; max-width: 100%; border-spacing:0; border-collapse: collapse; border-color: gray; vertical-align:middle;}");
+	oFile.WriteStringUTF8(L"thead { display: table-header-group;}");
 	oFile.WriteStringUTF8(L"tr { display: table-row; }");
-	oFile.WriteStringUTF8(L"th { text-align: left; display: table-cell; font-weight: bold; }");
+	oFile.WriteStringUTF8(L"th { text-align: center; display: table-cell; font-weight: bold; }");
 
-	oFile.WriteStringUTF8(L"table thead tr th { vertical-align: bottom; border-bottom: 2px solid #ddd; }");
-	oFile.WriteStringUTF8(L"table thead tr th, table tbody tr th, table thead tr td, table tbody tr td { padding 8px; line-height: 1.4; vertical-align: top; border-top: 1px solid #ddd; }");
-	oFile.WriteStringUTF8(L"table > caption + thead > tr > th, table > colgroup + thead > tr > th, table > thead > tr > th, table > caption + thead > tr > td, table > colgroup + thead > tr > td, table > thead > tr > td { border-top: 0; }");
+	oFile.WriteStringUTF8(L"table thead tr th, table thead tr td { border-bottom: 2px solid #ddd; border-top: none; }");
+	oFile.WriteStringUTF8(L"table tbody tr th, table tbody tr td { padding 8px; line-height: 1.4; border-top: 1px solid #ddd; }");
 
 	// Styles for blockquote
 	oFile.WriteStringUTF8(L"blockquote { border-left: 3px solid #e9e9e9;  margin: 1.5em 0; padding: 0.5em 10px 0.5em 24px; font-size: 1.25rem; display: block; margin-top: 8pt; font-style: italic; color: #404040; }");
@@ -87,9 +89,7 @@ bool ConvertMdFileToHtml(const std::wstring& wsPathToMdFile, const std::wstring&
 
 	bool bResult = true;
 
-	if (0 != md_html(sMdData.c_str(), sMdData.length(), ToHtmlFile, &oFile,
-					 MD_DIALECT_GITHUB | MD_FLAG_NOINDENTEDCODEBLOCKS | MD_HTML_FLAG_SKIP_UTF8_BOM,
-					 0))
+	if (0 != md_html(sMdData.c_str(), sMdData.length(), ToHtmlFile, &oFile, MD_PARSER_FLAGS, MD_RENDERER_FLAGS))
 		bResult = false;
 
 	oFile.WriteStringUTF8(L"</body></html>");

Common/3dParty/pole/pole.h

@@ -90,7 +90,7 @@ static std::wstring convertUtf16ToWString(const UTF16 * Data, int nLength)
         return std::wstring();
     }
 
-    std::wstring wstr ((wchar_t *) pStrUtf32);
+    std::wstring wstr ((wchar_t *) pStrUtf32, nLength);
 
     delete [] pStrUtf32;
     return wstr;

Common/3dParty/socketio/patches/sio_client_impl_encode.patch

@@ -1,5 +0,0 @@
-<<<<<<<
-            if((c >= 'a' && c <= 'z') || (c>= 'A' && c<= 'Z') || (c >= '0' && c<= '9')){
-=======
-            if((c >= 'a' && c <= 'z') || (c>= 'A' && c<= 'Z') || (c >= '0' && c<= '9') || ('-' == c) || ('_' == c) || ('.' == c) || ('~' == c)){
->>>>>>>

Common/3dParty/v8_89/.gitignore

@@ -1,6 +1,6 @@
 .cipd
-.gclient
-.gclient_entries
+.gclient*
+.gcs*
 v8
 depot_tools
 v8.data

Common/OfficeFileFormatChecker.h

@@ -74,6 +74,7 @@ public:
 	bool isDocFormatFile(const std::wstring& fileName);
 	bool isXlsFormatFile(const std::wstring& fileName);
 
+	bool isCompoundFile     (POLE::Storage* storage);
 	bool isOleObjectFile(POLE::Storage* storage);
 	bool isDocFormatFile(POLE::Storage* storage);
 	bool isXlsFormatFile(POLE::Storage* storage);

Common/OfficeFileFormatChecker2.cpp

@@ -552,6 +552,15 @@ bool COfficeFileFormatChecker::isPptFormatFile(POLE::Storage *storage)
 	return true;
 }
 
+bool COfficeFileFormatChecker::isCompoundFile(POLE::Storage* storage)
+{
+	if (storage == NULL) return false;
+
+	if (storage->GetAllStreams(L"/").size() == 1) return true;
+
+	return false;
+}
+
 std::wstring COfficeFileFormatChecker::getDocumentID(const std::wstring &_fileName)
 {
 #if defined(_WIN32) || defined(_WIN32_WCE) || defined(_WIN64)
@@ -749,6 +758,11 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT;
 			return true;
 		}
+		else if (isCompoundFile(&storage))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_COMPOUND;
+			return true;
+		}
 		else if (isHwpFile(&storage))
 		{
 			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP;
@@ -953,7 +967,12 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_MHT;
 	else if (0 == sExt.compare(L".md"))
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_MD;
-	else if (0 == sExt.compare(L".csv") || 0 == sExt.compare(L".xls") || 0 == sExt.compare(L".xlsx") || 0 == sExt.compare(L".xlsb"))
+	else if (0 == sExt.compare(L".tsv"))
+		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_TSV;
+	else if (0 == sExt.compare(L".scsv"))
+		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_SCSV;	
+	else if (0 == sExt.compare(L".csv") || 0 == sExt.compare(L".tsv") || 0 == sExt.compare(L".dsv") || 0 == sExt.compare(L".cssv")
+		|| 0 == sExt.compare(L".xls") || 0 == sExt.compare(L".xlsx") || 0 == sExt.compare(L".xlsb"))
 		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV;
 	else if (0 == sExt.compare(L".html") || 0 == sExt.compare(L".htm"))
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML;
@@ -1785,6 +1804,10 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
 		return L".ods";
 	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV:
 		return L".csv";
+	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_TSV:
+		return L".tsv";
+	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_SCSV:
+		return L".scsv";
 	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS_FLAT:
 		return L".fods";
 	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS:
@@ -1974,7 +1997,11 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring &sExt)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB;
 	if (L".xls" == ext)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS;
-	if (L".csv" == ext)
+	if (L".tsv" == ext)
+		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_TSV;
+	if (L".scsv" == ext)
+		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_SCSV;
+	if (L".csv" == ext || L".dsv" == ext)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV;
 	if (L".fods" == ext)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS_FLAT;

Common/OfficeFileFormats.h

@@ -87,13 +87,14 @@
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0005
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0006
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0007
-
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0008
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS_FLAT		AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0009
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000a
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX_FLAT		AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000b
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX_PACKAGE	AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000c
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS		AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000d
+#define AVS_OFFICESTUDIO_FILE_SPREADSHEET_TSV			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0014
+#define AVS_OFFICESTUDIO_FILE_SPREADSHEET_SCSV			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0024
 
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM				0x0200
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF			AVS_OFFICESTUDIO_FILE_CROSSPLATFORM + 0x0001
@@ -136,6 +137,7 @@
 #define AVS_OFFICESTUDIO_FILE_OTHER_MS_MITCRYPTO		AVS_OFFICESTUDIO_FILE_OTHER + 0x000b
 #define AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT		AVS_OFFICESTUDIO_FILE_OTHER + 0x000c
 #define AVS_OFFICESTUDIO_FILE_OTHER_PACKAGE_IN_OLE		AVS_OFFICESTUDIO_FILE_OTHER + 0x000d
+#define AVS_OFFICESTUDIO_FILE_OTHER_COMPOUND			AVS_OFFICESTUDIO_FILE_OTHER + 0x000e
 
 #define AVS_OFFICESTUDIO_FILE_TEAMLAB					0x1000
 #define AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY				AVS_OFFICESTUDIO_FILE_TEAMLAB + 0x0001

Common/base.pri

@@ -33,8 +33,7 @@ OO_BUILD_BRANDING = $$(OO_BRANDING)
 OO_DESTDIR_BUILD_OVERRIDE = $$(DESTDIR_BUILD_OVERRIDE)
 
 win32 {
-	CURRENT_YEAR = $$system(wmic PATH Win32_LocalTime GET ^Year /FORMAT:VALUE | find \"=\")
-	CURRENT_YEAR = $$replace(CURRENT_YEAR, "Year=", "")
+	CURRENT_YEAR = $$system(powershell -NoLogo -NoProfile -Command "(Get-Date).Year")
 	CURRENT_YEAR = $$replace(CURRENT_YEAR, "\r", "")
 	CURRENT_YEAR = $$replace(CURRENT_YEAR, "\n", "")
 	CURRENT_YEAR = $$replace(CURRENT_YEAR, "\t", "")
@@ -119,13 +118,13 @@ win32:contains(QMAKE_TARGET.arch, arm64): {
 }
 
 linux-clang-libc++ {
-    CONFIG += core_linux
+	CONFIG += core_linux
 	CONFIG += core_linux_64
 	CONFIG += core_linux_clang
 	message("linux-64-clang-libc++")
 }
 linux-clang-libc++-32 {
-    CONFIG += core_linux
+	CONFIG += core_linux
 	CONFIG += core_linux_32
 	CONFIG += core_linux_clang
 	message("linux-32-clang-libc++")
@@ -181,9 +180,9 @@ mac {
 	!core_ios {
 		CONFIG += core_mac
 		CONFIG += core_mac_64
-
-		DEFINES += _LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION
 	}
+
+	DEFINES += _LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION
 }
 
 # DEFINES
@@ -200,32 +199,58 @@ core_win_64 {
 	DEFINES += WIN64 _WIN64
 }
 
+defineTest(startsWith) {
+    tmp = $$2
+    tmp ~= s,^$$re_escape($$1),,
+    !equals(tmp, $$2): return(true)
+    return(false)
+}
+
 core_linux {
 	DEFINES += LINUX _LINUX
 
-    QMAKE_CUSTOM_SYSROOT = $$(QMAKE_CUSTOM_SYSROOT)
-	QMAKE_CUSTOM_SYSROOT_BIN = $$(QMAKE_CUSTOM_SYSROOT)/usr/bin/
+	QMAKE_CUSTOM_SYSROOT = $$(QMAKE_CUSTOM_SYSROOT)
+	!isEmpty(QMAKE_CUSTOM_SYSROOT) {
+		CONFIG += core_linix_use_sysroot
+		message("using custom sysroot $$QMAKE_CUSTOM_SYSROOT")
 
-    core_linux_64 {
-	    !linux_arm64 { # x86_64
-		    QMAKE_CUSTOM_SYSROOT_LIB = $$(QMAKE_CUSTOM_SYSROOT)/usr/lib/x86_64-linux-gnu
-			!isEmpty(QMAKE_CUSTOM_SYSROOT) {
-			    message("using custom sysroot $$QMAKE_CUSTOM_SYSROOT")
-				QMAKE_CC          = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "gcc")
-				QMAKE_CXX         = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
-				QMAKE_LINK        = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
-				QMAKE_LINK_SHLIB  = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
-
-                QMAKE_CFLAGS      += --sysroot $$QMAKE_CUSTOM_SYSROOT
-				QMAKE_CXXFLAGS    += --sysroot $$QMAKE_CUSTOM_SYSROOT
-				QMAKE_LFLAGS      += --sysroot $$QMAKE_CUSTOM_SYSROOT
-			}
+		QMAKE_CUSTOM_SYSROOT_BIN = $$(QMAKE_CUSTOM_SYSROOT_BIN)
+		isEmpty(QMAKE_CUSTOM_SYSROOT_BIN) {
+			QMAKE_CUSTOM_SYSROOT_BIN = $$QMAKE_CUSTOM_SYSROOT/usr/bin
 		}
+		QMAKE_CUSTOM_SYSROOT_BIN = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , /)
+
+		startsWith($$QMAKE_CUSTOM_SYSROOT, $$QMAKE_CUSTOM_SYSROOT_BIN) {
+			message("Using compilers from same sysroot")
+			QMAKE_CC          = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "gcc")
+			QMAKE_CXX         = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
+			QMAKE_LINK        = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
+			QMAKE_LINK_SHLIB  = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
+			QMAKE_AR          = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "ar") cqs
+			QMAKE_RANLIB      = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "ranlib")
+			QMAKE_STRIP       = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "strip")
+		} else {
+			message("Using cross-compilers from host sysroot")
+			QMAKE_CC          = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-gcc")
+			QMAKE_CXX         = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-g++")
+			QMAKE_LINK        = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-g++")
+			QMAKE_LINK_SHLIB  = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-g++")
+			QMAKE_AR          = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-ar") cqs
+			QMAKE_RANLIB      = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-ranlib")
+			QMAKE_STRIP       = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-strip")
+			QMAKE_OBJCOPY     = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "aarch64-linux-gnu-objcopy")
+		}
+
+		QMAKE_CFLAGS      += --sysroot=$$QMAKE_CUSTOM_SYSROOT
+		QMAKE_CXXFLAGS    += --sysroot=$$QMAKE_CUSTOM_SYSROOT -std=gnu++1y
+
+		QMAKE_LFLAGS      += --sysroot=$$QMAKE_CUSTOM_SYSROOT
+		QMAKE_INCDIR      += $$QMAKE_CUSTOM_SYSROOT/usr/include
 	}
 }
 
 gcc {
-    COMPILER_VERSION = $$system($$QMAKE_CXX " -dumpversion")
+	COMPILER_VERSION = $$system($$QMAKE_CXX " -dumpversion")
 	COMPILER_MAJOR_VERSION_ARRAY = $$split(COMPILER_VERSION, ".")
 	COMPILER_MAJOR_VERSION = $$member(COMPILER_MAJOR_VERSION_ARRAY, 0)
 	lessThan(COMPILER_MAJOR_VERSION, 5): CONFIG += build_gcc_less_5
@@ -255,6 +280,11 @@ core_mac {
 		QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.12
 		!apple_silicon:QMAKE_APPLE_DEVICE_ARCHS = x86_64
 	}
+
+	!core_debug {
+		equals(TEMPLATE, app):QMAKE_POST_LINK += strip $(TARGET)
+		# TODO: plugin!
+	}
 }
 
 core_linux_clang {
@@ -313,6 +343,10 @@ core_linux {
 core_linux {
 	equals(TEMPLATE, app):CONFIG += core_static_link_libstd
 	plugin:CONFIG += core_static_link_libstd
+
+
+	equals(TEMPLATE, app):QMAKE_LFLAGS_RELEASE += -Wl,-s
+	plugin:QMAKE_LFLAGS_RELEASE += -Wl,-s
 }
 
 core_win_32 {
@@ -322,7 +356,7 @@ core_win_64 {
 	CORE_BUILDS_PLATFORM_PREFIX = win_64
 }
 core_win_arm64 {
-    CORE_BUILDS_PLATFORM_PREFIX = win_arm64
+	CORE_BUILDS_PLATFORM_PREFIX = win_arm64
 }
 core_linux_32 {
 	CORE_BUILDS_PLATFORM_PREFIX = linux_32
@@ -344,27 +378,6 @@ core_linux_arm {
 linux_arm64 {
 	CORE_BUILDS_PLATFORM_PREFIX = linux_arm64
 	DEFINES += _ARM_ALIGN_
-
-	ARM64_TOOLCHAIN_BIN = $$(ARM64_TOOLCHAIN_BIN)
-	ARM64_TOOLCHAIN_BIN_PREFIX = $$(ARM64_TOOLCHAIN_BIN_PREFIX)
-
-	!isEmpty(ARM64_TOOLCHAIN_BIN){
-		!isEmpty(ARM64_TOOLCHAIN_BIN_PREFIX){
-			ARM64_TOOLCHAIN_BIN_FULL = $$ARM64_TOOLCHAIN_BIN/$$ARM64_TOOLCHAIN_BIN_PREFIX
-			message("using arm64 toolchain $$ARM64_TOOLCHAIN_BIN")
-
-			QMAKE_CC          = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "gcc")
-			QMAKE_CXX         = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "g++")
-			QMAKE_LINK        = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "g++")
-			QMAKE_LINK_SHLIB  = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "g++")
-
-			QMAKE_AR          = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "ar cqs")
-			QMAKE_OBJCOPY     = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "objcopy")
-			QMAKE_NM          = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "nm -P")
-			QMAKE_STRIP       = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "strip")
-
-		}
-	}
 }
 core_ios {
 	CORE_BUILDS_PLATFORM_PREFIX = ios
@@ -691,3 +704,105 @@ ADD_INC_PATH = $$(ADDITIONAL_INCLUDE_PATH)
 !disable_precompiled_header {
 	CONFIG += precompile_header
 }
+
+SWIFT_SOURCES=
+defineTest(UseSwift) {
+	isEmpty(SWIFT_SOURCES): return(false)
+	# work only on ios and mac
+	!core_ios:!core_mac {
+		return(false)
+	}
+
+	# path to the bridging header that exposes Objective-C code to Swift
+	BRIDGING_HEADER = $$1
+	# sdk and toolchain (set from environment variables)
+	SDK_PATH = $$(SDK_PATH)
+	XCODE_TOOLCHAIN_PATH = $$(XCODE_TOOLCHAIN_PATH)
+
+	IOS_TARGET_PLATFORM = apple-ios11.0
+	SWIFT_GEN_HEADERS_PATH = $$PWD_ROOT_DIR/core_build/$$CORE_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX
+	ARCHS = arm64
+	# simulator
+	xcframework_platform_ios_simulator {
+		IOS_TARGET_PLATFORM = $${IOS_TARGET_PLATFORM}-simulator
+		SWIFT_GEN_HEADERS_PATH = $$SWIFT_GEN_HEADERS_PATH/simulator
+		ARCHS += x86_64
+	}
+
+	# add swift compiler for each architecture
+	SWIFT_COMPILERS_OUT =
+	for(ARCH, ARCHS) {
+		COMPILER_NAME = swift_compiler_$${ARCH}
+		COMPILER_OUTPUT = $$SWIFT_GEN_HEADERS_PATH/swift_module_$${ARCH}.o
+		SWIFT_COMPILERS_OUT += $$COMPILER_OUTPUT
+
+		$${COMPILER_NAME}.name = SwiftCompiler_$${ARCH}
+		$${COMPILER_NAME}.input = SWIFT_SOURCES
+		$${COMPILER_NAME}.output = $$COMPILER_OUTPUT
+		SWIFT_CMD = swiftc -c $$SWIFT_SOURCES \
+					-module-name SwiftModule \
+					-whole-module-optimization \
+					-emit-objc-header \
+					-emit-objc-header-path $$SWIFT_GEN_HEADERS_PATH/SwiftModule-Swift.h \
+					-emit-object \
+					-sdk $$SDK_PATH \
+					-target $${ARCH}-$${IOS_TARGET_PLATFORM} \
+					-o $$COMPILER_OUTPUT \
+					-framework UIKit
+
+		!isEmpty(BRIDGING_HEADER) {
+			SWIFT_CMD += -import-objc-header $$BRIDGING_HEADER
+		}
+
+		$${COMPILER_NAME}.commands = $$SWIFT_CMD
+		$${COMPILER_NAME}.CONFIG = combine target_predeps no_link
+
+		export($${COMPILER_NAME}.name)
+		export($${COMPILER_NAME}.input)
+		export($${COMPILER_NAME}.output)
+		export($${COMPILER_NAME}.commands)
+		export($${COMPILER_NAME}.CONFIG)
+		QMAKE_EXTRA_COMPILERS += $${COMPILER_NAME}
+	}
+
+	# add lipo tool execution to form universal binary
+	LIPO_OUT = $$SWIFT_GEN_HEADERS_PATH/swift_module.o
+	lipo_tool.name = LipoTool
+	# as input for lipo_tool we set SWIFT_SOURCES (not SWIFT_COMPILERS_OUT as it won't be executed otherwise!)
+	lipo_tool.input = SWIFT_SOURCES
+	# compiled swift sources go into depends
+	lipo_tool.depends = $$SWIFT_COMPILERS_OUT
+	lipo_tool.output = $$LIPO_OUT
+	lipo_tool.commands = lipo -create $$SWIFT_COMPILERS_OUT -output $$LIPO_OUT
+	lipo_tool.CONFIG = combine target_predeps no_link
+	lipo_tool.variable_out = OBJECTS
+
+	export(lipo_tool.name)
+	export(lipo_tool.input)
+	export(lipo_tool.depends)
+	export(lipo_tool.output)
+	export(lipo_tool.commands)
+	export(lipo_tool.CONFIG)
+	export(lipo_tool.variable_out)
+	QMAKE_EXTRA_COMPILERS += lipo_tool
+
+	export(QMAKE_EXTRA_COMPILERS)
+
+	INCLUDEPATH += $$SWIFT_GEN_HEADERS_PATH
+	export(INCLUDEPATH)
+
+	# link with libs from toolchain
+	SWIFT_LIB_PATH = $$XCODE_TOOLCHAIN_PATH/usr/lib/swift/iphoneos
+	xcframework_platform_ios_simulator {
+		SWIFT_LIB_PATH = $$XCODE_TOOLCHAIN_PATH/usr/lib/swift/iphonesimulator
+	}
+	LIBS += -L$$SWIFT_LIB_PATH
+	LIBS += -lswiftCore -lswiftFoundation -lswiftObjectiveC
+
+	export(LIBS)
+
+	OTHER_FILES += $$SWIFT_SOURCES
+	export(OTHER_FILES)
+	return(true)
+}
+

DesktopEditor/common/File.h

@@ -45,6 +45,10 @@
 #undef DeleteFile
 #endif
 
+#if defined(GetSystemDirectory)
+#undef GetSystemDirectory
+#endif
+
 #ifndef _BUILD_FILE_CROSSPLATFORM_H_
 #define _BUILD_FILE_CROSSPLATFORM_H_
 

DesktopEditor/common/Path.cpp

@@ -246,6 +246,11 @@ namespace NSSystemPath
 
 		wsNewPath.pop_back();
 
+		#if !defined(_WIN32) && !defined(_WIN64)
+		if (L'/' == strPath[0] || L'\\' == strPath[0])
+			return L'/' + wsNewPath;
+		#endif
+
 		return wsNewPath;
 	}
 	

DesktopEditor/common/SystemUtils.h

@@ -60,6 +60,7 @@ namespace NSSystemUtils
 	static const wchar_t* gc_EnvModified = L"MODIFIED";
 	static const wchar_t* gc_EnvMemoryLimit = L"X2T_MEMORY_LIMIT";
 	static const wchar_t* gc_EnvMemoryLimitDefault = L"4GiB";
+	static const wchar_t* gc_EnvSigningKeystorePassphrase = L"SIGNING_KEYSTORE_PASSPHRASE";
 
 	KERNEL_DECL std::string GetEnvVariableA(const std::wstring& strName);
 	KERNEL_DECL std::wstring GetEnvVariable(const std::wstring& strName);

DesktopEditor/cximage/CxImage/tif_xfile.cpp

@@ -16,7 +16,15 @@
 static tsize_t 
 _tiffReadProcEx(thandle_t fd, tdata_t buf, tsize_t size)
 {
-	return (tsize_t)((CxFile*)fd)->Read(buf, 1, size);
+	tsize_t nReadCount = (tsize_t)((CxFile*)fd)->Read(buf, 1, size);
+
+	if (nReadCount < size)
+	{
+		memset(static_cast<char*>(buf) + nReadCount, 0, size - nReadCount);
+		return size;
+	}
+
+	return nReadCount;
 }
 
 static tsize_t

DesktopEditor/doctrenderer/docbuilder.python/src/docbuilder.py

@@ -26,7 +26,7 @@ def _loadLibrary(path):
         library_name = 'libdocbuilder.c.dylib'
         # if there is no dylib file, get library from framework
         if not os.path.exists(path + '/' + library_name):
-            path = path + '/docbuilder.c.framework'
+            path = path + '/docbuilder.c.framework/Versions/A'
             library_name = 'docbuilder.c'
 
     _lib = ctypes.CDLL(path + '/' + library_name)

DesktopEditor/doctrenderer/drawingfile.h

@@ -120,7 +120,7 @@ public:
 	}
 
 public:
-	bool OpenFile(const std::wstring& sFile, const std::wstring& sPassword)
+	bool OpenFile(const std::wstring& sFile, const wchar_t* sPassword)
 	{
 		CloseFile();
 
@@ -171,7 +171,7 @@ public:
 
 		return m_pFile ? true : false;
 	}
-	bool OpenFile(BYTE* data, LONG size, const std::wstring& sPassword)
+	bool OpenFile(BYTE* data, LONG size, const wchar_t* sPassword)
 	{
 		CloseFile();
 
@@ -245,7 +245,18 @@ public:
 
 		return 0;
 	}
-
+	bool CheckOwnerPassword(const wchar_t* sPassword)
+	{
+		if (m_nType == 0)
+			return ((CPdfFile*)m_pFile)->CheckOwnerPassword(sPassword);
+		return true;
+	}
+	bool CheckPerm(int nPerm)
+	{
+		if (m_nType == 0)
+			return ((CPdfFile*)m_pFile)->CheckPerm(nPerm);
+		return true;
+	}
 	BYTE* GetInfo()
 	{
 		NSWasm::CData oRes;
@@ -443,6 +454,20 @@ public:
 		if (m_nType == 0)
 			((CPdfFile*)m_pFile)->SetCMapMemory(data, size);
 	}
+	void SetScanPageFonts(int nPageIndex)
+	{
+		if (NULL == m_pImageStorage)
+			m_pImageStorage = NSDocxRenderer::CreateWasmImageStorage();
+
+		CDocxRenderer oRenderer(m_pApplicationFonts);
+		oRenderer.SetExternalImageStorage(m_pImageStorage);
+		oRenderer.SetTextAssociationType(NSDocxRenderer::TextAssociationType::tatParagraphToShape);
+
+		oRenderer.ScanPageBin(m_pFile, nPageIndex);
+
+		if (m_nType == 0)
+			((CPdfFile*)m_pFile)->SetPageFonts(nPageIndex);
+	}
 	BYTE* ScanPage(int nPageIndex, int mode)
 	{
 		if (NULL == m_pImageStorage)
@@ -479,6 +504,9 @@ public:
 				return NULL;
 		}
 
+		if (m_nType == 0)
+			((CPdfFile*)m_pFile)->SetPageFonts(nPageIndex);
+
 		BYTE* res = oRes.GetBuffer();
 		oRes.ClearWithoutAttack();
 		return res;
@@ -567,6 +595,13 @@ public:
 		}
 		return NULL;
 	}
+	BYTE* GetGIDByUnicode(const std::string& sPathA)
+	{
+		if (m_nType != 0)
+			return NULL;
+		std::wstring sFontName = UTF8_TO_U(sPathA);
+		return ((CPdfFile*)m_pFile)->GetGIDByUnicode(sFontName);
+	}
 
 	std::wstring GetFontBinaryNative(const std::wstring& sName)
 	{

DesktopEditor/doctrenderer/embed/DrawingFileEmbed.cpp

@@ -26,7 +26,8 @@ CDrawingFileEmbed::~CDrawingFileEmbed()
 
 JSSmart<CJSValue> CDrawingFileEmbed::OpenFile(JSSmart<CJSValue> sFile, JSSmart<CJSValue> sPassword)
 {
-	bool bResult = m_pFile->OpenFile(sFile->toStringW(), sPassword->isString() ? sPassword->toStringW() : L"");
+	std::wstring wsPassword = sPassword->isString() ? sPassword->toStringW() : L"";
+	bool bResult = m_pFile->OpenFile(sFile->toStringW(), sPassword->isString() ? wsPassword.c_str() : NULL);
 	return CJSContext::createBool(bResult);
 }
 JSSmart<CJSValue> CDrawingFileEmbed::CloseFile()

DesktopEditor/doctrenderer/embed/NativeControlEmbed.cpp

@@ -194,6 +194,9 @@ JSSmart<CJSValue> CNativeControlEmbed::ZipOpenBase64(JSSmart<CJSValue> name)
 
 JSSmart<CJSValue> CNativeControlEmbed::ZipFileAsString(JSSmart<CJSValue> name)
 {
+	if (m_pInternal->m_oZipWorker.m_sTmpFolder.empty())
+		return CJSContext::createUndefined();
+
 	BYTE* pData = NULL;
 	DWORD len = 0;
 	m_pInternal->m_oZipWorker.GetFileData(name->toStringW(), pData, len);
@@ -202,6 +205,9 @@ JSSmart<CJSValue> CNativeControlEmbed::ZipFileAsString(JSSmart<CJSValue> name)
 
 JSSmart<CJSValue> CNativeControlEmbed::ZipFileAsBinary(JSSmart<CJSValue> name)
 {
+	if (m_pInternal->m_oZipWorker.m_sTmpFolder.empty())
+		return CJSContext::createUndefined();
+
 	return CJSContext::createUint8Array(m_pInternal->m_oZipWorker.m_sTmpFolder + L"/" + name->toStringW());
 }
 

DesktopEditor/doctrenderer/embed/jsc/jsc_DrawingFileEmbed.mm

@@ -30,6 +30,8 @@
 -(JSValue*) SplitPages : (JSValue*)arrPageIndexes : (JSValue*)data;
 -(JSValue*) MergePages : (JSValue*)data : (JSValue*)nMaxID : (JSValue*)sPrefixForm;
 -(JSValue*) UnmergePages;
+-(JSValue*) RedactPage : (JSValue*)nPageIndex : (JSValue*)arrRedactBox : (JSValue*)dataFiller;
+-(JSValue*) UndoRedact;
 @end
 
 @interface CJSCDrawingFileEmbed : NSObject<IJSCDrawingFileEmbed, JSEmbedObjectProtocol>
@@ -67,6 +69,8 @@ FUNCTION_WRAPPER_JS_1(FreeWasmData, FreeWasmData)
 FUNCTION_WRAPPER_JS_2(SplitPages, SplitPages)
 FUNCTION_WRAPPER_JS_3(MergePages, MergePages)
 FUNCTION_WRAPPER_JS_0(UnmergePages, UnmergePages)
+FUNCTION_WRAPPER_JS_3(RedactPage, RedactPage)
+FUNCTION_WRAPPER_JS_0(UndoRedact, UndoRedact)
 @end
 
 class CDrawingFileEmbedAdapter : public CJSEmbedObjectAdapterJSC

DesktopEditor/doctrenderer/embed/v8/v8_DrawingFileEmbed.cpp

@@ -67,7 +67,7 @@ namespace NSDrawingFileEmbed
 		NSV8Objects::Template_Set(result, "SplitPages",	_SplitPages);
 		NSV8Objects::Template_Set(result, "MergePages",	_MergePages);
 		NSV8Objects::Template_Set(result, "UnmergePages",	_UnmergePages);
-		NSV8Objects::Template_Set(result, "RedactPage", _RedactPage);
+		NSV8Objects::Template_Set(result, "RedactPage",	_RedactPage);
 		NSV8Objects::Template_Set(result, "UndoRedact",	_UndoRedact);
 
 		return handle_scope.Escape(result);

DesktopEditor/doctrenderer/js_internal/v8/v8_base.cpp

@@ -461,6 +461,8 @@ namespace NSJSBase
 		v8::SnapshotCreator snapshotCreator;
 		v8::Isolate* isolate = snapshotCreator.GetIsolate();
 		{
+			CV8TryCatch try_catch(isolate);
+
 			v8::HandleScope handle_scope(isolate);
 			// Create a new context
 			v8::Local<v8::Context> context = v8::Context::New(isolate);
@@ -472,11 +474,12 @@ namespace NSJSBase
 			global->Set(context, v8::String::NewFromUtf8Literal(isolate, "self"), global).Check();
 			global->Set(context, v8::String::NewFromUtf8Literal(isolate, "native"), v8::Undefined(isolate)).Check();
 
-			// Compile and run
+			// Compile
 			v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, script.c_str()).ToLocalChecked();
 			v8::Local<v8::Script> script = v8::Script::Compile(context, source).ToLocalChecked();
-
+			// Run
 			script->Run(context).IsEmpty();
+
 			snapshotCreator.SetDefaultContext(context);
 		}
 		v8::StartupData data = snapshotCreator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kKeep);

DesktopEditor/doctrenderer/js_internal/v8/v8_base.h

@@ -62,7 +62,13 @@ v8::Local<v8::String> CreateV8String(v8::Isolate* i, const std::string& str);
 #include <android/log.h>
 #define  LOGW(...)  __android_log_print(ANDROID_LOG_WARN, "js", __VA_ARGS__)
 #define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR, "js", __VA_ARGS__)
-#endif
+#ifdef _DEBUG
+#define  LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, "js", __VA_ARGS__)
+#else
+// should be disabled for release builds
+#define  LOGD(...)
+#endif	// _DEBUG
+#endif	// ANDROID_LOGS
 
 #endif
 
@@ -799,6 +805,9 @@ namespace NSJSBase
 		CV8TryCatch() : CJSTryCatch(), try_catch(V8IsolateOneArg)
 		{
 		}
+		CV8TryCatch(v8::Isolate* isolate) : CJSTryCatch(), try_catch(isolate)
+		{
+		}
 		virtual ~CV8TryCatch()
 		{
 		}

DesktopEditor/fontengine/ApplicationFontsWorker.cpp

@@ -837,53 +837,63 @@ public:
 				CSymbolSimpleChecker2 oAllChecker(arSymbolsAll, nMaxSymbol);
 
 				std::map<std::wstring, int> mapFontsPriorityStandard;
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"ASCW3", 1));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Arial", 2));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Times New Roman", 3));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Tahoma", 4));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Cambria", 5));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Calibri", 6));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Verdana", 7));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Georgia", 8));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Open Sans", 9));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Liberation Sans", 10));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Helvetica", 11));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Nimbus Sans L", 12));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"DejaVu Sans", 13));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Liberation Serif", 14));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Trebuchet MS", 15));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Courier New", 16));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Carlito", 17));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Segoe UI", 18));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"SimSun", 19));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"MS Gothic", 20));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Nirmala UI", 21));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Batang", 22));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"MS Mincho", 23));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Wingdings", 24));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Microsoft JhengHei", 25));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Microsoft JhengHei UI", 26));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Microsoft YaHei", 27));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"PMingLiU", 28));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"MingLiU", 29));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"DFKai-SB", 30));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"FangSong", 31));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"KaiTi", 32));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"SimKai", 33));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"SimHei", 34));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Meiryo", 35));
+				int nCurrentPriority = 1;
+
+				#define SET_FONT_PRIORITY(fontName) mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(fontName, nCurrentPriority++))
+
+				SET_FONT_PRIORITY(L"ASCW3");
+				SET_FONT_PRIORITY(L"Arial");
+				SET_FONT_PRIORITY(L"Times New Roman");
+				SET_FONT_PRIORITY(L"Tahoma");
+				SET_FONT_PRIORITY(L"Cambria");
+				SET_FONT_PRIORITY(L"Calibri");
+				SET_FONT_PRIORITY(L"Verdana");
+				SET_FONT_PRIORITY(L"Georgia");
+				SET_FONT_PRIORITY(L"Open Sans");
+				SET_FONT_PRIORITY(L"Liberation Sans");
+				SET_FONT_PRIORITY(L"Helvetica");
+				SET_FONT_PRIORITY(L"Nimbus Sans L");
+				SET_FONT_PRIORITY(L"DejaVu Sans");
+				SET_FONT_PRIORITY(L"Liberation Serif");
+				SET_FONT_PRIORITY(L"Trebuchet MS");
+				SET_FONT_PRIORITY(L"Courier New");
+				SET_FONT_PRIORITY(L"Carlito");
+				SET_FONT_PRIORITY(L"Segoe UI");
+				SET_FONT_PRIORITY(L"SimSun");
+				SET_FONT_PRIORITY(L"MS Gothic");
+				SET_FONT_PRIORITY(L"Nirmala UI");
+				SET_FONT_PRIORITY(L"Batang");
+				SET_FONT_PRIORITY(L"MS Mincho");
+				SET_FONT_PRIORITY(L"Wingdings");
+				SET_FONT_PRIORITY(L"Microsoft JhengHei");
+				SET_FONT_PRIORITY(L"Microsoft JhengHei UI");
+				SET_FONT_PRIORITY(L"Microsoft YaHei");
+				SET_FONT_PRIORITY(L"PMingLiU");
+				SET_FONT_PRIORITY(L"MingLiU");
+				SET_FONT_PRIORITY(L"DFKai-SB");
+				SET_FONT_PRIORITY(L"FangSong");
+				SET_FONT_PRIORITY(L"KaiTi");
+				SET_FONT_PRIORITY(L"SimKai");
+				SET_FONT_PRIORITY(L"SimHei");
+				SET_FONT_PRIORITY(L"Meiryo");
 
 #ifdef _MAC
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"PingFang SC", 36));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"PingFang TC", 37));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"PingFang HK", 38));
+				SET_FONT_PRIORITY(L"PingFang SC");
+				SET_FONT_PRIORITY(L"PingFang TC");
+				SET_FONT_PRIORITY(L"PingFang HK");
 
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Heiti SC", 39));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Heiti TC", 40));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Songti SC", 41));
-				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Songti TC", 42));
+				SET_FONT_PRIORITY(L"Heiti SC");
+				SET_FONT_PRIORITY(L"Heiti TC");
+				SET_FONT_PRIORITY(L"Songti SC");
+				SET_FONT_PRIORITY(L"Songti TC");
 #endif
 
+				SET_FONT_PRIORITY(L"Malgun Gothic");
+				SET_FONT_PRIORITY(L"Nanum Gothic");
+				SET_FONT_PRIORITY(L"NanumGothic");
+				SET_FONT_PRIORITY(L"Noto Sans KR");
+				SET_FONT_PRIORITY(L"TakaoGothic");
+
 				NSFonts::CApplicationFontsSymbols oApplicationChecker;
 
 				// приоритеты шрифтов. по имени (все стили)

DesktopEditor/fontengine/ApplicationFontsWorker.h

@@ -36,7 +36,7 @@
 #include <vector>
 #include "../graphics/pro/Fonts.h"
 
-#define ONLYOFFICE_FONTS_VERSION     14
+#define ONLYOFFICE_FONTS_VERSION     15
 #define ONLYOFFICE_ALL_FONTS_VERSION 2
 
 class CApplicationFontsWorkerBreaker

DesktopEditor/fontengine/FontFile.cpp

@@ -731,10 +731,10 @@ void CFontFile::CheckHintsSupport()
 int CFontFile::SetCMapForCharCode(long lUnicode, int *pnCMapIndex)
 {
 	*pnCMapIndex = -1;
-	if (!m_pFace)
+	if (!m_pFace || !m_pFace->num_charmaps)
 		return 0;
 
-	if ( m_bStringGID || 0 == m_pFace->num_charmaps )
+	if ( m_bStringGID )
 		return lUnicode;
 
 	int nCharIndex = 0;

DesktopEditor/fontengine/js/cpp/text.cpp

@@ -117,7 +117,7 @@ WASM_EXPORT unsigned int ASC_FT_SetCMapForCharCode(FT_Face face, unsigned int un
 		return 0;
 
 	if ( 0 == face->num_charmaps )
-		return unicode;
+		return 0;
 
 	unsigned int nCharIndex = 0;
 

DesktopEditor/fontengine/js/libfont.json

@@ -265,15 +265,15 @@
 	},
 	{
 		"folder": "../../",
-		"files": ["graphics/Image.cpp", "raster/BgraFrame.cpp", "raster/ImageFileFormatChecker.cpp", "graphics/Matrix.cpp"]
+		"files": ["graphics/Image.cpp", "raster/BgraFrame.cpp", "raster/ImageFileFormatChecker.cpp", "graphics/Matrix.cpp", "graphics/GraphicsPath.cpp"]
 	},
 	{
 		"folder": "../../agg-2.4/src/",
-		"files": ["agg_trans_affine.cpp"]
+		"files": ["agg_trans_affine.cpp", "agg_bezier_arc.cpp"]
 	},
 	{
 		"folder": "../../raster/",
-		"files": ["PICT/PICFile.cpp", "PICT/pic.cpp"]
+		"files": ["PICT/PICFile.cpp"]
 	},
 	{
 		"folder": "../../graphics/pro/js/qt/raster",

DesktopEditor/graphics/BooleanOperations.cpp

@@ -737,11 +737,13 @@ CBooleanOperations::CBooleanOperations(const CGraphicsPath& path1,
 									   const CGraphicsPath& path2,
 									   BooleanOpType op,
 									   long fillType,
-									   bool isLuminosity) :
+									   bool isLuminosity,
+									   bool isSelf) :
 	Op(op),
 	Close1(path1.Is_poly_closed()),
 	Close2(path2.Is_poly_closed()),
 	IsLuminosity(isLuminosity),
+	IsSelf(isSelf),
 	FillType(fillType),
 	Path1(path1),
 	Path2(path2)
@@ -784,10 +786,9 @@ bool CBooleanOperations::IsSelfInters(const CGraphicsPath& p)
 void CBooleanOperations::TraceBoolean()
 {
 	bool reverse = false;
-	bool self = Path1 == Path2;
 	if (((Op == Subtraction || Op == Exclusion) ^
 		 Path1.IsClockwise() ^
-		 Path2.IsClockwise()) && !self)
+		 Path2.IsClockwise()) && !IsSelf)
 		reverse = true;
 
 	PreparePath(Path1, 1, Segments1, Curves1);
@@ -798,7 +799,7 @@ void CBooleanOperations::TraceBoolean()
 
 	GetIntersection();
 
-	if (self)
+	if (IsSelf)
 	{
 		if (Op == Subtraction)
 			return;
@@ -823,6 +824,11 @@ void CBooleanOperations::TraceBoolean()
 		CreateNewPath(adj_matr);
 		return;
 	}
+	else if (Path1 == Path2)
+	{
+		Result = std::move(Path1);
+		return;
+	}
 
 	if (!Locations.empty())
 	{
@@ -2355,7 +2361,7 @@ CGraphicsPath CalcBooleanOperation(const CGraphicsPath& path1,
 		CBooleanOperations o;
 		if (i > skip_end2 && o.IsSelfInters(paths2[i]))
 		{
-			CBooleanOperations operation(paths2[i], paths2[i], Intersection, fillType, isLuminosity);
+			CBooleanOperations operation(paths2[i], paths2[i], Intersection, fillType, isLuminosity, true);
 			CGraphicsPath p = std::move(operation.GetResult());
 
 			std::vector<CGraphicsPath> tmp_paths = p.GetSubPaths();
@@ -2370,7 +2376,7 @@ CGraphicsPath CalcBooleanOperation(const CGraphicsPath& path1,
 			CBooleanOperations o2;
 			if (j > skip_end1 && o2.IsSelfInters(paths1[j]))
 			{
-				CBooleanOperations operation(paths1[j], paths1[j], Intersection, fillType, isLuminosity);
+				CBooleanOperations operation(paths1[j], paths1[j], Intersection, fillType, isLuminosity, true);
 				CGraphicsPath p = std::move(operation.GetResult());
 
 				std::vector<CGraphicsPath> tmp_paths = p.GetSubPaths();
@@ -2380,7 +2386,7 @@ CGraphicsPath CalcBooleanOperation(const CGraphicsPath& path1,
 					paths1.insert(paths1.begin() + i + k, tmp_paths[k]);
 			}
 
-			CBooleanOperations operation(paths1[j], paths2[i], op, fillType, isLuminosity);
+			CBooleanOperations operation(paths1[j], paths2[i], op, fillType, isLuminosity, false);
 			paths.push_back(operation.GetResult());
 		}
 

DesktopEditor/graphics/BooleanOperations.h

@@ -108,7 +108,7 @@ namespace Aggplus
 	{
 	public:
 		CBooleanOperations() {};
-		CBooleanOperations(const CGraphicsPath& path1, const CGraphicsPath& path2, BooleanOpType op, long fillType, bool isLuminosity);
+		CBooleanOperations(const CGraphicsPath& path1, const CGraphicsPath& path2, BooleanOpType op, long fillType, bool isLuminosity, bool isSelf);
 		~CBooleanOperations();
 		CGraphicsPath&& GetResult();
 		bool IsSelfInters(const CGraphicsPath& p);
@@ -166,6 +166,7 @@ namespace Aggplus
 		bool Close1 = true;
 		bool Close2 = true;
 		bool IsLuminosity = false;
+		bool IsSelf = false;
 
 		// c_nStroke, c_nWindingFillMode, c_nEvenOddFillMode
 		long FillType = c_nWindingFillMode;

DesktopEditor/graphics/Brush.cpp

@@ -419,6 +419,7 @@ namespace Aggplus
 		m_bReleaseImage = FALSE;
 		Alpha = 255;
         m_bUseBounds = false;
+		m_bIsScale = false;
 	}
 
 	CBrushTexture::CBrushTexture(const std::wstring& strName, WrapMode wrapMode) : CBrush(BrushTypeTextureFill), m_wrapMode(wrapMode)
@@ -427,6 +428,7 @@ namespace Aggplus
 		m_bReleaseImage = TRUE;
 		Alpha = 255;
         m_bUseBounds = false;
+		m_bIsScale = false;
 	}
 
 	CBrushTexture::CBrushTexture(CImage *pImage, WrapMode wrapMode) : CBrush(BrushTypeTextureFill), m_wrapMode(wrapMode)
@@ -435,6 +437,7 @@ namespace Aggplus
 		m_bReleaseImage = FALSE;
 		Alpha = 255;
         m_bUseBounds = false;
+		m_bIsScale = false;
 	}
 	
 	CBrushTexture::~CBrushTexture() 

DesktopEditor/graphics/Brush.h

@@ -205,6 +205,10 @@ public:
 	bool m_bUseBounds;
 	CDoubleRect m_oBounds;
 
+	bool m_bIsScale;
+	double m_dScaleX;
+	double m_dScaleY;
+
 	BYTE Alpha;
 };
 }

DesktopEditor/graphics/Graphics.cpp

@@ -847,6 +847,8 @@ namespace Aggplus
 				double dScaleY = m_dDpiY / m_dDpiTile;
 
 				brushMatrix.Scale(dScaleX, dScaleY, Aggplus::MatrixOrderAppend);
+				if (ptxBrush->m_bIsScale)
+					brushMatrix.Scale(ptxBrush->m_dScaleX, ptxBrush->m_dScaleY, Aggplus::MatrixOrderAppend);
 			}
 
 			brushMatrix.Translate(x, y, Aggplus::MatrixOrderAppend);
@@ -2142,7 +2144,12 @@ namespace Aggplus
 			agg::trans_affine* full_trans = &m_oFullTransform.m_internal->m_agg_mtx;
 			double dDet = full_trans->determinant();
 
-			if (fabs(dDet) < 0.0001)
+			double sx = sqrt(full_trans->sx * full_trans->sx + full_trans->shx * full_trans->shx);
+			double sy = sqrt(full_trans->shy * full_trans->shy + full_trans->sy * full_trans->sy);
+			double scale = std::max(sx, sy);
+			double adaptive_threshold = 1.0 / (scale * scale * 10000.0);
+
+			if (fabs(dDet) < std::max(0.0001, adaptive_threshold))
 			{
 				path_copy.transform_all_paths(m_oFullTransform.m_internal->m_agg_mtx);
 				dWidth *= sqrt(fabs(dDet));
@@ -2240,6 +2247,8 @@ namespace Aggplus
 				LONG lCount2	= lCount / 2;
 
 				double dKoef = 1.0;
+				if (bIsUseIdentity)
+					dKoef = sqrt(fabs(m_oFullTransform.m_internal->m_agg_mtx.determinant()));
 
 				for (LONG i = 0; i < lCount2; ++i)
 				{

DesktopEditor/graphics/GraphicsPath.cpp

@@ -886,17 +886,17 @@ namespace Aggplus
 		if (isCurve)
 		{
 			std::vector<PointD> points = GetPoints(idx, 4);
-			area = (points[3].Y - points[0].Y) * (points[1].X + points[2].X)
-					- (points[3].X - points[0].X) * (points[1].Y + points[2].Y)
-					+ points[1].Y * (points[0].X - points[2].X)
-					- points[1].X * (points[0].Y - points[2].Y)
-					+ points[3].Y * (points[2].X + points[0].X / 3.0)
-					- points[3].X * (points[2].Y + points[0].Y / 3.0);
+			area = 3.0 * ((points[3].Y - points[0].Y) * (points[1].X + points[2].X)
+						  - (points[3].X - points[0].X) * (points[1].Y + points[2].Y)
+						  + points[1].Y * (points[0].X - points[2].X)
+						  - points[1].X * (points[0].Y - points[2].Y)
+						  + points[3].Y * (points[2].X + points[0].X / 3.0)
+						  - points[3].X * (points[2].Y + points[0].Y / 3.0)) / 20.0;
 		}
 		else
 		{
 			std::vector<PointD> points = GetPoints(idx, 2);
-			area = 4.0 * (points[1].Y * points[0].X - points[1].X * points[0].Y) / 3.0;
+			area = (points[1].Y * points[0].X - points[1].X * points[0].Y) / 2.0;
 		}
 
 		return area;
@@ -1007,16 +1007,18 @@ namespace Aggplus
 	bool CGraphicsPath::operator==(const CGraphicsPath& other) noexcept
 	{
 		unsigned pointsCount = GetPointCount(),
-			otherPointsCount = other.GetPointCount();
+				 otherPointsCount = other.GetPointCount();
 
 		if (pointsCount != otherPointsCount)
 			return false;
 
 		std::vector<PointD> points = GetPoints(0, pointsCount),
-			otherPoints = other.GetPoints(0, otherPointsCount);
+							otherPoints = other.GetPoints(0, otherPointsCount);
+
+		bool reverse = IsClockwise() ^ other.IsClockwise();
 
 		for (unsigned i = 0; i < pointsCount; i++)
-			if (!points[i].Equals(otherPoints[i]))
+			if (!points[i].Equals(otherPoints[reverse ? pointsCount - i - 1 : i]))
 				return false;
 
 		return true;
@@ -1549,3 +1551,31 @@ namespace Aggplus
 		return false;
 	}
 }
+
+HRESULT IRenderer::AddPath(const Aggplus::CGraphicsPath& path)
+{
+	if (path.GetPointCount() == 0)
+		return S_FALSE;
+
+	size_t length = path.GetPointCount() + path.GetCloseCount();
+	std::vector<Aggplus::PointD> points = path.GetPoints(0, length);
+
+	for (size_t i = 0; i < length; i++)
+	{
+		if (path.IsCurvePoint(i))
+		{
+			PathCommandCurveTo(points[i].X, points[i].Y,
+							   points[i + 1].X, points[i + 1].Y,
+							   points[i + 2].X, points[i + 2].Y);
+			i += 2;
+		}
+		else if (path.IsMovePoint(i))
+			PathCommandMoveTo(points[i].X, points[i].Y);
+		else if (path.IsLinePoint(i))
+			PathCommandLineTo(points[i].X, points[i].Y);
+		else
+			PathCommandClose();
+	}
+
+	return S_OK;
+}

DesktopEditor/graphics/GraphicsRenderer.cpp

@@ -613,6 +613,32 @@ HRESULT CGraphicsRenderer::put_BrushTransform(const Aggplus::CMatrix& oMatrix)
 	m_oBrush.Transform = oMatrix;
 	return S_OK;
 }
+HRESULT CGraphicsRenderer::get_BrushOffset(double& offsetX, double& offsetY) const
+{
+	offsetX = m_oBrush.OffsetX;
+	offsetY = m_oBrush.OffsetY;
+	return S_OK;
+}
+HRESULT CGraphicsRenderer::put_BrushOffset(const double& offsetX, const double& offsetY)
+{
+	m_oBrush.OffsetX = offsetX;
+	m_oBrush.OffsetY = offsetY;
+	return S_OK;
+}
+HRESULT CGraphicsRenderer::get_BrushScale(bool& isScale, double& scaleX, double& scaleY) const
+{
+	isScale = m_oBrush.IsScale;
+	scaleX = m_oBrush.ScaleX;
+	scaleY = m_oBrush.ScaleY;
+	return S_OK;
+}
+HRESULT CGraphicsRenderer::put_BrushScale(bool isScale, const double& scaleX, const double& scaleY)
+{
+	m_oBrush.IsScale = isScale;
+	m_oBrush.ScaleX = scaleX;
+	m_oBrush.ScaleY = scaleY;
+	return S_OK;
+}
 HRESULT CGraphicsRenderer::BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height)
 {
 	m_oBrush.Rectable = val;
@@ -946,11 +972,18 @@ HRESULT CGraphicsRenderer::DrawPath(const LONG& nType)
 				switch (m_oBrush.TextureMode)
 				{
 				case c_BrushTextureModeTile:
-					oMode = Aggplus::WrapModeTile;
-					break;
 				case c_BrushTextureModeTileCenter:
 					oMode = Aggplus::WrapModeTile;
 					break;
+				case c_BrushTextureModeTileFlipX:
+					oMode = Aggplus::WrapModeTileFlipX;
+					break;
+				case c_BrushTextureModeTileFlipY:
+					oMode = Aggplus::WrapModeTileFlipY;
+					break;
+				case c_BrushTextureModeTileFlipXY:
+					oMode = Aggplus::WrapModeTileFlipXY;
+					break;
 				default: 
 					break;
 				}
@@ -1023,11 +1056,18 @@ HRESULT CGraphicsRenderer::DrawPath(const LONG& nType)
                     if (m_oBrush.Rectable == 1)
                     {
                         pTextureBrush->m_bUseBounds = true;
-                        pTextureBrush->m_oBounds.left = m_oBrush.Rect.X;
-                        pTextureBrush->m_oBounds.top = m_oBrush.Rect.Y;
+						pTextureBrush->m_oBounds.left = m_oBrush.Rect.X + m_oBrush.OffsetX;
+						pTextureBrush->m_oBounds.top = m_oBrush.Rect.Y + m_oBrush.OffsetY;
                         pTextureBrush->m_oBounds.right = pTextureBrush->m_oBounds.left + m_oBrush.Rect.Width;
                         pTextureBrush->m_oBounds.bottom = pTextureBrush->m_oBounds.top + m_oBrush.Rect.Height;
                     }
+
+					if (m_oBrush.IsScale == 1)
+					{
+						pTextureBrush->m_bIsScale = true;
+						pTextureBrush->m_dScaleX = m_oBrush.ScaleX;
+						pTextureBrush->m_dScaleY = m_oBrush.ScaleY;
+					}
 				}
 
 				pBrush = pTextureBrush;

DesktopEditor/graphics/GraphicsRenderer.h

@@ -189,6 +189,10 @@ public:
 	virtual HRESULT put_BrushLinearAngle(const double& dAngle);
 	virtual HRESULT get_BrushTransform(Aggplus::CMatrix& oMatrix);
 	virtual HRESULT put_BrushTransform(const Aggplus::CMatrix& oMatrix);
+	virtual HRESULT get_BrushOffset(double& offsetX, double& offsetY) const;
+	virtual HRESULT put_BrushOffset(const double& offsetX, const double& offsetY);
+	virtual HRESULT get_BrushScale(bool& isScale, double& scaleX, double& scaleY) const;
+	virtual HRESULT put_BrushScale(bool isScale, const double& scaleX, const double& scaleY);
 	virtual HRESULT BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height);
 	virtual HRESULT BrushBounds(const double& left, const double& top, const double& width, const double& height);
 	virtual HRESULT put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount);

DesktopEditor/graphics/IRenderer.h

@@ -117,6 +117,7 @@ const long c_nDarkMode          = 0x0008;
 const long c_nUseDictionaryFonts = 0x0010;
 const long c_nPenWidth0As1px	= 0x0020;
 const long c_nSupportPathTextAsText = 0x0040;
+const long c_nFontSubstitution  = 0x0080;
 
 // типы рендерера
 const long c_nUnknownRenderer   = 0x0000;
@@ -168,7 +169,10 @@ public:
 	AdvancedCommandType GetCommandType() { return m_nCommandType; }
 };
 
-namespace Aggplus { class CImage; }
+namespace Aggplus {
+	class CImage;
+	class CGraphicsPath;
+}
 
 // IRenderer
 class IRenderer : public IGrObject
@@ -240,6 +244,32 @@ public:
 	virtual HRESULT put_BrushTransform(const Aggplus::CMatrix& oMatrix) = 0;
 	virtual HRESULT get_BrushLinearAngle(double* dAngle)				= 0;
 	virtual HRESULT put_BrushLinearAngle(const double& dAngle)			= 0;
+	virtual HRESULT get_BrushOffset(double& offsetX, double& offsetY) const
+	{
+		UNUSED_VARIABLE(offsetX);
+		UNUSED_VARIABLE(offsetY);
+		return S_OK;
+	}
+	virtual HRESULT put_BrushOffset(const double& offsetX, const double& offsetY)
+	{
+		UNUSED_VARIABLE(offsetX);
+		UNUSED_VARIABLE(offsetY);
+		return S_OK;
+	}
+	virtual HRESULT get_BrushScale(bool& isScale, double& scaleX, double& scaleY) const
+	{
+		UNUSED_VARIABLE(isScale);
+		UNUSED_VARIABLE(scaleX);
+		UNUSED_VARIABLE(scaleY);
+		return S_OK;
+	}
+	virtual HRESULT put_BrushScale(bool isScale, const double& scaleX, const double& scaleY)
+	{
+		UNUSED_VARIABLE(isScale);
+		UNUSED_VARIABLE(scaleX);
+		UNUSED_VARIABLE(scaleY);
+		return S_OK;
+	}
 	virtual HRESULT BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height) = 0;
 	virtual HRESULT BrushBounds(const double& left, const double& top, const double& width, const double& height) = 0;
 
@@ -299,6 +329,8 @@ public:
 	virtual HRESULT PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h) = 0;
 	virtual HRESULT PathCommandTextEx(const std::wstring& sText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h) = 0;
 
+	HRESULT AddPath(const Aggplus::CGraphicsPath& path);
+
 	//-------- Функции для вывода изображений ---------------------------------------------------
 	virtual HRESULT DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h)		= 0;
 	virtual HRESULT DrawImageFromFile(const std::wstring&, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha = 255)	= 0;

DesktopEditor/graphics/MetafileToRenderer.cpp

@@ -36,6 +36,7 @@
 #include "../fontengine/FontManager.h"
 #include "../raster/BgraFrame.h"
 #include "../common/StringExt.h"
+#include "GraphicsPath.h"
 
 // этот класс нужно переписать. должно работать как и в js
 // а не просто на каждом символе переключаться, если нужно
@@ -351,7 +352,13 @@ namespace NSOnlineOfficeBinToPdf
 		bool bIsPathOpened = false;
 		bool bIsEnableBrushRect = false;
 
+		double old_t1, old_t2, old_t3, old_t4, old_t5, old_t6;
+
 		CBufferReader oReader(pBuffer, lBufferLen);
+		Aggplus::CGraphicsPath path;
+		Aggplus::CMatrix transMatrRot;
+		Aggplus::RectF_T<double> clipRect;
+		bool isResetRot = false;
 		while (oReader.Check())
 		{
 			eCommand = (CommandType)(oReader.ReadByte());
@@ -382,6 +389,8 @@ namespace NSOnlineOfficeBinToPdf
 				if (bIsPathOpened)
 				{
 					pRenderer->PathCommandEnd();
+					if (path.GetPointCount())
+						path.Reset();
 					pRenderer->EndCommand(c_nPathType);
 				}
 				bIsPathOpened = false;
@@ -471,6 +480,16 @@ namespace NSOnlineOfficeBinToPdf
 				double m2 = oReader.ReadDouble();
 				double m3 = oReader.ReadDouble();
 				double m4 = oReader.ReadDouble();
+
+				long type;
+				pRenderer->get_BrushTextureMode(&type);
+				if (type != c_BrushTextureModeStretch)
+				{
+					m1 = 0.0;
+					m2 = 0.0;
+				}
+
+				clipRect = Aggplus::RectF_T<double>(m1, m2, m3, m4);
 				pRenderer->BrushRect(bIsEnableBrushRect ? 1 : 0, m1, m2, m3, m4);
 				break;
 			}
@@ -590,6 +609,16 @@ namespace NSOnlineOfficeBinToPdf
 				pRenderer->put_BrushTextureAlpha(lAlpha);
 				break;
 			}
+			case ctBrushResetRotation:
+			{
+				pRenderer->GetTransform(&old_t1, &old_t2, &old_t3, &old_t4, &old_t5, &old_t6);
+
+				Aggplus::CMatrix mtr(old_t1, old_t2, old_t3, old_t4, old_t5, old_t6);
+				double rot = mtr.rotation();
+				transMatrRot.Rotate(agg::rad2deg(rot));
+				isResetRot = true;
+				break;
+			}
 			case ctSetTransform:
 			{
 				double m1 = oReader.ReadDouble();
@@ -606,11 +635,15 @@ namespace NSOnlineOfficeBinToPdf
 				if (bIsPathOpened)
 				{
 					pRenderer->PathCommandEnd();
+					if (path.GetPointCount())
+						path.Reset();
 					pRenderer->EndCommand(c_nPathType);
 				}
 
 				pRenderer->BeginCommand(c_nPathType);
 				pRenderer->PathCommandStart();
+				path.Reset();
+				path.StartFigure();
 
 				bIsPathOpened = true;
 				break;
@@ -619,14 +652,14 @@ namespace NSOnlineOfficeBinToPdf
 			{
 				double m1 = oReader.ReadDouble();
 				double m2 = oReader.ReadDouble();
-				pRenderer->PathCommandMoveTo(m1, m2);
+				path.MoveTo(m1, m2);
 				break;
 			}
 			case ctPathCommandLineTo:
 			{
 				double m1 = oReader.ReadDouble();
 				double m2 = oReader.ReadDouble();
-				pRenderer->PathCommandLineTo(m1, m2);
+				path.LineTo(m1, m2);
 				break;
 			}
 			case ctPathCommandCurveTo:
@@ -637,12 +670,12 @@ namespace NSOnlineOfficeBinToPdf
 				double m4 = oReader.ReadDouble();
 				double m5 = oReader.ReadDouble();
 				double m6 = oReader.ReadDouble();
-				pRenderer->PathCommandCurveTo(m1, m2, m3, m4, m5, m6);
+				path.CurveTo(m1, m2, m3, m4, m5, m6);
 				break;
 			}
 			case ctPathCommandClose:
 			{
-				pRenderer->PathCommandClose();
+				path.CloseFigure();
 				break;
 			}
 			case ctPathCommandEnd:
@@ -650,14 +683,108 @@ namespace NSOnlineOfficeBinToPdf
 				if (bIsPathOpened)
 				{
 					pRenderer->PathCommandEnd();
+					if (path.GetPointCount())
+						path.Reset();
 					pRenderer->EndCommand(c_nPathType);
 					bIsPathOpened = false;
 				}
 				break;
 			}
+			case ctPathCommandOffset:
+			{
+				double m1 = oReader.ReadDouble();
+				double m2 = oReader.ReadDouble();
+
+				pRenderer->put_BrushOffset(m1, m2);
+				break;
+			}
+			case ctPathCommandScale:
+			{
+				double m1 = oReader.ReadDouble();
+				double m2 = oReader.ReadDouble();
+
+				pRenderer->put_BrushScale(true, m1, m2);
+				break;
+			}
 			case ctDrawPath:
 			{
-				pRenderer->DrawPath(oReader.ReadInt());
+				long fill = oReader.ReadInt();
+				long type;
+				pRenderer->get_BrushType(&type);
+
+				if (fill != c_nStroke && type == c_BrushTypeTexture)
+				{
+					Aggplus::CGraphicsPath clipPath;
+					Aggplus::CGraphicsPath drawPath(path);
+
+					if (isResetRot)
+					{
+						pRenderer->get_BrushTextureMode(&type);
+						bool isStretch = type == c_BrushTextureModeStretch;
+
+						double left, top, width, height;
+						drawPath.GetBounds(left, top, width, height);
+
+						double rot = transMatrRot.rotation();
+						double cX = left + width / 2.0;
+						double cY = top + height / 2.0;
+
+						bool isZeroPt = clipRect.X < 0.1 && clipRect.X > -0.1 && clipRect.Y < 0.1 && clipRect.Y > -0.1;
+						bool isZeroRot = rot < 1e-6 && rot > -1e-6;
+
+						transMatrRot.Reset();
+						transMatrRot.RotateAt(agg::rad2deg(rot), cX, cY, Aggplus::MatrixOrderAppend);
+
+						double offX = old_t5 - transMatrRot.tx();
+						double offY = old_t6 - transMatrRot.ty();
+
+						drawPath.Transform(&transMatrRot);
+						pRenderer->SetTransform(1.0, 0.0, 0.0, 1.0, offX, offY);
+
+						if (isZeroPt && !isZeroRot && isStretch)
+							drawPath.GetBounds(left, top, width, height);
+						else
+						{
+							Aggplus::CGraphicsPath tmpPath;
+							tmpPath.AddRectangle(left, top, width, height);
+							tmpPath.Transform(&transMatrRot);
+							tmpPath.GetBounds(left, top, width, height);
+						}
+
+						if (isZeroPt || !isStretch)
+							clipRect = Aggplus::RectF_T<double>(left, top, width, height);
+
+						if (isStretch)
+						{
+							if (!isZeroPt)
+								clipRect.Offset(-offX, -offY);
+							pRenderer->BrushRect(true, clipRect.X, clipRect.Y, clipRect.Width, clipRect.Height);
+						}
+						else
+						{
+							double tileOffX, tileOffY;
+							pRenderer->get_BrushOffset(tileOffX, tileOffY);
+							pRenderer->put_BrushOffset(tileOffX - offX, tileOffY - offY);
+						}
+					}
+
+					clipPath.AddRectangle(clipRect.X, clipRect.Y, clipRect.Width, clipRect.Height);
+					path = Aggplus::CalcBooleanOperation(drawPath, clipPath, Aggplus::Intersection);
+					clipRect = Aggplus::RectF_T<double>();
+				}
+
+				pRenderer->AddPath(path);
+				pRenderer->DrawPath(fill);
+
+				if (isResetRot)
+				{
+					pRenderer->SetTransform(old_t1, old_t2, old_t3, old_t4, old_t5, old_t6);
+					transMatrRot.Reset();
+					isResetRot = false;
+				}
+
+				pRenderer->put_BrushScale(false, 1.0, 1.0);
+				pRenderer->put_BrushOffset(0.0, 0.0);
 				break;
 			}
 			case ctDrawImageFromFile:
@@ -734,6 +861,8 @@ namespace NSOnlineOfficeBinToPdf
 				if (bIsPathOpened)
 				{
 					pRenderer->PathCommandEnd();
+					if (path.GetPointCount())
+						path.Reset();
 					pRenderer->EndCommand(4);
 					bIsPathOpened = false;
 				}
@@ -747,8 +876,13 @@ namespace NSOnlineOfficeBinToPdf
 					pRenderer->EndCommand(4);
 					bIsPathOpened = false;
 				}
-				pRenderer->EndCommand((DWORD)(oReader.ReadInt()));
+				int nCommand = oReader.ReadInt();
+				if (path.GetPointCount() && nCommand == c_nClipType)
+					pRenderer->AddPath(path);
+				pRenderer->EndCommand((DWORD)nCommand);
 				pRenderer->PathCommandEnd();
+				if (path.GetPointCount())
+					path.Reset();
 				break;
 			}
 			case ctGradientFill:
@@ -1132,6 +1266,10 @@ namespace NSOnlineOfficeBinToPdf
 				oReader.Skip(1);
 				break;
 			}
+			case ctBrushResetRotation:
+			{
+				break;
+			}
 			case ctSetTransform:
 			{
 				oReader.SkipInt(6);
@@ -1164,6 +1302,16 @@ namespace NSOnlineOfficeBinToPdf
 			{
 				break;
 			}
+			case ctPathCommandOffset:
+			{
+				oReader.SkipInt(2);
+				break;
+			}
+			case ctPathCommandScale:
+			{
+				oReader.SkipInt(2);
+				break;
+			}
 			case ctDrawPath:
 			{
 				oReader.SkipInt();

DesktopEditor/graphics/MetafileToRenderer.h

@@ -108,6 +108,7 @@ namespace NSOnlineOfficeBinToPdf
 		ctBrushRectableEnabled 		    = 30,
 		ctBrushGradient                 = 31,
 		ctBrushTexturePath              = 32,
+		ctBrushResetRotation			= 33,
 
 		// font
 		ctFontXML						= 40,
@@ -153,6 +154,8 @@ namespace NSOnlineOfficeBinToPdf
 		ctPathCommandGetCurrentPoint	= 101,
 		ctPathCommandText				= 102,
 		ctPathCommandTextEx			    = 103,
+		ctPathCommandOffset				= 104,
+		ctPathCommandScale				= 105,
 
 		// image
 		ctDrawImage					    = 110,

DesktopEditor/graphics/aggplustypes.h

@@ -214,6 +214,18 @@ public:
 
 		inline bool IsPositive() { return Width > 0 && Height > 0; }
 
+		RectF_T& operator=(const RectF_T& other)
+		{
+			if (this == &other)
+				return *this;
+
+			X = other.X;
+			Y = other.Y;
+			Width = other.Width;
+			Height = other.Height;
+
+			return *this;
+		};
 public:
 		T X, Y, Width, Height;
 };

DesktopEditor/graphics/commands/AnnotField.cpp

@@ -46,6 +46,92 @@
 // void Set(const std::wstring& ws) { m_ws = ws; }
 // const std::wstring& Get() { return m_ws; }
 
+CAnnotFieldInfo::CActionFieldPr* ReadAction(NSOnlineOfficeBinToPdf::CBufferReader* pReader)
+{
+	CAnnotFieldInfo::CActionFieldPr* pRes = new CAnnotFieldInfo::CActionFieldPr();
+
+	pRes->nActionType = pReader->ReadByte();
+	switch (pRes->nActionType)
+	{
+	case 14: // JavaScript
+	{
+		pRes->wsStr1 = pReader->ReadString();
+		break;
+	}
+	case 1: // GoTo
+	{
+		pRes->nInt1 = pReader->ReadInt();
+		pRes->nKind = pReader->ReadByte();
+		switch (pRes->nKind)
+		{
+		case 0:
+		case 2:
+		case 3:
+		case 6:
+		case 7:
+		{
+			pRes->nFlags = pReader->ReadByte();
+			if (pRes->nFlags & (1 << 0))
+				pRes->dD[0] = pReader->ReadDouble();
+			if (pRes->nFlags & (1 << 1))
+				pRes->dD[1] = pReader->ReadDouble();
+			if (pRes->nFlags & (1 << 2))
+				pRes->dD[2] = pReader->ReadDouble();
+			break;
+		}
+		case 4:
+		{
+			pRes->dD[0] = pReader->ReadDouble();
+			pRes->dD[1] = pReader->ReadDouble();
+			pRes->dD[2] = pReader->ReadDouble();
+			pRes->dD[3] = pReader->ReadDouble();
+			break;
+		}
+		case 1:
+		case 5:
+		default:
+		{
+			break;
+		}
+		}
+		break;
+	}
+	case 10: // Named
+	{
+		pRes->wsStr1 = pReader->ReadString();
+		break;
+	}
+	case 6: // URI
+	{
+		pRes->wsStr1 = pReader->ReadString();
+		break;
+	}
+	case 9: // Hide
+	{
+		pRes->nKind = pReader->ReadByte();
+		int n = pReader->ReadInt();
+		pRes->arrStr.reserve(n);
+		for (int i = 0; i < n; ++i)
+			pRes->arrStr.push_back(pReader->ReadString());
+		break;
+	}
+	case 12: // ResetForm
+	{
+		pRes->nInt1 = pReader->ReadInt();
+		int n = pReader->ReadInt();
+		pRes->arrStr.reserve(n);
+		for (int i = 0; i < n; ++i)
+			pRes->arrStr.push_back(pReader->ReadString());
+		break;
+	}
+	}
+
+	if (pReader->ReadByte())
+		pRes->pNext = ReadAction(pReader);
+
+	return pRes;
+}
+
 CAnnotFieldInfo::CAnnotFieldInfo() : IAdvancedCommand(AdvancedCommandType::Annotaion)
 {
 	m_nType = EAnnotType::Unknown;
@@ -77,6 +163,7 @@ CAnnotFieldInfo::CAnnotFieldInfo() : IAdvancedCommand(AdvancedCommandType::Annot
 	m_pCaretPr        = NULL;
 	m_pStampPr        = NULL;
 	m_pRedactPr       = NULL;
+	m_pLinkPr         = NULL;
 	m_pWidgetPr       = NULL;
 }
 CAnnotFieldInfo::~CAnnotFieldInfo()
@@ -93,6 +180,7 @@ CAnnotFieldInfo::~CAnnotFieldInfo()
 	RELEASEOBJECT(m_pCaretPr);
 	RELEASEOBJECT(m_pStampPr);
 	RELEASEOBJECT(m_pRedactPr);
+	RELEASEOBJECT(m_pLinkPr);
 	RELEASEOBJECT(m_pWidgetPr);
 }
 
@@ -113,6 +201,12 @@ void CAnnotFieldInfo::SetType(int nType)
 		m_pTextPr = new CAnnotFieldInfo::CTextAnnotPr();
 		break;
 	}
+	case EAnnotType::Link:
+	{
+		RELEASEOBJECT(m_pLinkPr);
+		m_pLinkPr = new CAnnotFieldInfo::CLinkAnnotPr();
+		break;
+	}
 	case EAnnotType::FreeText:
 	{
 		CreateMarkup();
@@ -305,6 +399,10 @@ bool CAnnotFieldInfo::IsRedact() const
 {
 	return (m_nType == 25);
 }
+bool CAnnotFieldInfo::IsLink() const
+{
+	return (m_nType == 1);
+}
 
 CAnnotFieldInfo::CMarkupAnnotPr*       CAnnotFieldInfo::GetMarkupAnnotPr()       { return m_pMarkupPr; }
 CAnnotFieldInfo::CTextAnnotPr*         CAnnotFieldInfo::GetTextAnnotPr()         { return m_pTextPr; }
@@ -318,6 +416,7 @@ CAnnotFieldInfo::CFreeTextAnnotPr*     CAnnotFieldInfo::GetFreeTextAnnotPr()
 CAnnotFieldInfo::CCaretAnnotPr*        CAnnotFieldInfo::GetCaretAnnotPr()        { return m_pCaretPr; }
 CAnnotFieldInfo::CStampAnnotPr*        CAnnotFieldInfo::GetStampAnnotPr()        { return m_pStampPr; }
 CAnnotFieldInfo::CRedactAnnotPr*       CAnnotFieldInfo::GetRedactAnnotPr()       { return m_pRedactPr; }
+CAnnotFieldInfo::CLinkAnnotPr*         CAnnotFieldInfo::GetLinkAnnotPr()         { return m_pLinkPr; }
 CAnnotFieldInfo::CWidgetAnnotPr*       CAnnotFieldInfo::GetWidgetAnnotPr()       { return m_pWidgetPr; }
 
 bool CAnnotFieldInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafileToRenderter* pCorrector)
@@ -412,6 +511,8 @@ bool CAnnotFieldInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMeta
 		m_pPopupPr->Read(pReader);
 	else if (IsWidget())
 		m_pWidgetPr->Read(pReader, nType);
+	else if (IsLink())
+		m_pLinkPr->Read(pReader);
 
 	return m_nType != -1;
 }
@@ -721,6 +822,45 @@ void CAnnotFieldInfo::CRedactAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader
 	}
 }
 
+CAnnotFieldInfo::CLinkAnnotPr::CLinkAnnotPr()
+{
+	m_pAction = NULL;
+	m_pPA = NULL;
+}
+CAnnotFieldInfo::CLinkAnnotPr::~CLinkAnnotPr()
+{
+	RELEASEOBJECT(m_pAction);
+	RELEASEOBJECT(m_pPA);
+}
+BYTE CAnnotFieldInfo::CLinkAnnotPr::GetH() const { return m_nH; }
+int CAnnotFieldInfo::CLinkAnnotPr::GetFlags() const { return m_nFlags; }
+const std::vector<double>& CAnnotFieldInfo::CLinkAnnotPr::GetQuadPoints() { return m_arrQuadPoints; }
+CAnnotFieldInfo::CActionFieldPr* CAnnotFieldInfo::CLinkAnnotPr::GetA() { return m_pAction; }
+CAnnotFieldInfo::CActionFieldPr* CAnnotFieldInfo::CLinkAnnotPr::GetPA() { return m_pPA; }
+void CAnnotFieldInfo::CLinkAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader)
+{
+	m_nFlags = pReader->ReadInt();
+	if (m_nFlags & (1 << 0))
+	{
+		pReader->ReadString();
+		m_pAction = ReadAction(pReader);
+	}
+	if (m_nFlags & (1 << 1))
+	{
+		pReader->ReadString();
+		m_pPA = ReadAction(pReader);
+	}
+	if (m_nFlags & (1 << 2))
+		m_nH = pReader->ReadByte();
+	if (m_nFlags & (1 << 3))
+	{
+		int n = pReader->ReadInt();
+		m_arrQuadPoints.reserve(n);
+		for (int i = 0; i < n; ++i)
+			m_arrQuadPoints.push_back(pReader->ReadDouble());
+	}
+}
+
 bool CAnnotFieldInfo::CPopupAnnotPr::IsOpen()      const { return m_bOpen; }
 int  CAnnotFieldInfo::CPopupAnnotPr::GetFlag()     const { return m_nFlag; }
 int  CAnnotFieldInfo::CPopupAnnotPr::GetParentID() const { return m_nParentID; }
@@ -752,7 +892,7 @@ const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::GetFontKey()   { return m_w
 const std::vector<double>& CAnnotFieldInfo::CWidgetAnnotPr::GetTC() { return m_arrTC; }
 const std::vector<double>& CAnnotFieldInfo::CWidgetAnnotPr::GetBC() { return m_arrBC; }
 const std::vector<double>& CAnnotFieldInfo::CWidgetAnnotPr::GetBG() { return m_arrBG; }
-const std::vector<CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget*>& CAnnotFieldInfo::CWidgetAnnotPr::GetActions() { return m_arrAction; }
+const std::vector<CAnnotFieldInfo::CActionFieldPr*>& CAnnotFieldInfo::CWidgetAnnotPr::GetActions() { return m_arrAction; }
 CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr*    CAnnotFieldInfo::CWidgetAnnotPr::GetButtonWidgetPr()    { return m_pButtonPr; }
 CAnnotFieldInfo::CWidgetAnnotPr::CTextWidgetPr*      CAnnotFieldInfo::CWidgetAnnotPr::GetTextWidgetPr()      { return m_pTextPr; }
 CAnnotFieldInfo::CWidgetAnnotPr::CChoiceWidgetPr*    CAnnotFieldInfo::CWidgetAnnotPr::GetChoiceWidgetPr()    { return m_pChoicePr; }
@@ -812,93 +952,8 @@ CAnnotFieldInfo::CWidgetAnnotPr::~CWidgetAnnotPr()
 		RELEASEOBJECT(m_arrAction[i]);
 }
 
-CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget::CActionWidget() : pNext(NULL) {}
-CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget::~CActionWidget() { RELEASEOBJECT(pNext); }
-CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* ReadAction(NSOnlineOfficeBinToPdf::CBufferReader* pReader)
-{
-	CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* pRes = new CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget();
-
-	pRes->nActionType = pReader->ReadByte();
-	switch (pRes->nActionType)
-	{
-	case 14: // JavaScript
-	{
-		pRes->wsStr1 = pReader->ReadString();
-		break;
-	}
-	case 1: // GoTo
-	{
-		pRes->nInt1 = pReader->ReadInt();
-		pRes->nKind = pReader->ReadByte();
-		switch (pRes->nKind)
-		{
-		case 0:
-		case 2:
-		case 3:
-		case 6:
-		case 7:
-		{
-			pRes->nFlags = pReader->ReadByte();
-			if (pRes->nFlags & (1 << 0))
-				pRes->dD[0] = pReader->ReadDouble();
-			if (pRes->nFlags & (1 << 1))
-				pRes->dD[1] = pReader->ReadDouble();
-			if (pRes->nFlags & (1 << 2))
-				pRes->dD[2] = pReader->ReadDouble();
-			break;
-		}
-		case 4:
-		{
-			pRes->dD[0] = pReader->ReadDouble();
-			pRes->dD[1] = pReader->ReadDouble();
-			pRes->dD[2] = pReader->ReadDouble();
-			pRes->dD[3] = pReader->ReadDouble();
-			break;
-		}
-		case 1:
-		case 5:
-		default:
-		{
-			break;
-		}
-		}
-		break;
-	}
-	case 10: // Named
-	{
-		pRes->wsStr1 = pReader->ReadString();
-		break;
-	}
-	case 6: // URI
-	{
-		pRes->wsStr1 = pReader->ReadString();
-		break;
-	}
-	case 9: // Hide
-	{
-		pRes->nKind = pReader->ReadByte();
-		int n = pReader->ReadInt();
-		pRes->arrStr.reserve(n);
-		for (int i = 0; i < n; ++i)
-			pRes->arrStr.push_back(pReader->ReadString());
-		break;
-	}
-	case 12: // ResetForm
-	{
-		pRes->nInt1 = pReader->ReadInt();
-		int n = pReader->ReadInt();
-		pRes->arrStr.reserve(n);
-		for (int i = 0; i < n; ++i)
-			pRes->arrStr.push_back(pReader->ReadString());
-		break;
-	}
-	}
-
-	if (pReader->ReadByte())
-		pRes->pNext = ReadAction(pReader);
-
-	return pRes;
-}
+CAnnotFieldInfo::CActionFieldPr::CActionFieldPr() : pNext(NULL) {}
+CAnnotFieldInfo::CActionFieldPr::~CActionFieldPr() { RELEASEOBJECT(pNext); }
 void CAnnotFieldInfo::CWidgetAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, BYTE nType)
 {
 	m_wsFN = pReader->ReadString();
@@ -957,7 +1012,7 @@ void CAnnotFieldInfo::CWidgetAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader
 	for (int i = 0; i < nAction; ++i)
 	{
 		std::wstring wsType = pReader->ReadString();
-		CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* pA = ReadAction(pReader);
+		CAnnotFieldInfo::CActionFieldPr* pA = ReadAction(pReader);
 		if (pA)
 		{
 			pA->wsType = wsType;
@@ -987,6 +1042,7 @@ const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr::GetCA() {
 const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr::GetRC() { return m_wsRC; }
 const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr::GetAC() { return m_wsAC; }
 const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr::GetAP_N_Yes() { return m_wsAP_N_Yes; }
+const std::vector< std::pair<std::wstring, std::wstring> >& CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr::GetOpt() { return m_arrOpt; }
 void CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, BYTE nType, int nFlags)
 {
 	if (nType == 27)
@@ -1027,6 +1083,17 @@ void CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr::Read(NSOnlineOfficeBinToP
 		if (nFlags & (1 << 9))
 			m_wsV = pReader->ReadString();
 		m_nStyle = pReader->ReadByte();
+		if (nFlags & (1 << 10))
+		{
+			int n = pReader->ReadInt();
+			m_arrOpt.reserve(n);
+			for (int i = 0; i < n; ++i)
+			{
+				std::wstring s1 = pReader->ReadString();
+				std::wstring s2 = pReader->ReadString();
+				m_arrOpt.push_back(std::make_pair(s1, s2));
+			}
+		}
 		if (nFlags & (1 << 14))
 			m_wsAP_N_Yes = pReader->ReadString();
 	}
@@ -1192,7 +1259,7 @@ bool CWidgetsInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafil
 			for (int i = 0; i < nAction; ++i)
 			{
 				std::wstring wsType = pReader->ReadString();
-				CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* pA = ReadAction(pReader);
+				CAnnotFieldInfo::CActionFieldPr* pA = ReadAction(pReader);
 				if (pA)
 				{
 					pA->wsType = wsType;

DesktopEditor/graphics/commands/AnnotField.h

@@ -70,6 +70,23 @@ public:
 		WidgetSignature = 33
 	};
 
+	class GRAPHICS_DECL CActionFieldPr
+	{
+	public:
+		CActionFieldPr();
+		~CActionFieldPr();
+
+		BYTE nKind;
+		BYTE nFlags;
+		BYTE nActionType;
+		int  nInt1;
+		double dD[4]{};
+		std::wstring wsType;
+		std::wstring wsStr1;
+		std::vector<std::wstring> arrStr;
+		CActionFieldPr* pNext;
+	};
+
 	class GRAPHICS_DECL CWidgetAnnotPr
 	{
 	public:
@@ -90,6 +107,7 @@ public:
 			const std::wstring& GetRC();
 			const std::wstring& GetAC();
 			const std::wstring& GetAP_N_Yes();
+			const std::vector< std::pair<std::wstring, std::wstring> >& GetOpt();
 
 			void Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, BYTE nType, int nFlags);
 
@@ -108,6 +126,7 @@ public:
 			std::wstring m_wsRC;
 			std::wstring m_wsAC;
 			std::wstring m_wsAP_N_Yes;
+			std::vector< std::pair<std::wstring, std::wstring> > m_arrOpt;
 		};
 
 		class GRAPHICS_DECL CTextWidgetPr
@@ -159,23 +178,6 @@ public:
 
 		};
 
-		class GRAPHICS_DECL CActionWidget
-		{
-		public:
-			CActionWidget();
-			~CActionWidget();
-
-			BYTE nKind;
-			BYTE nFlags;
-			BYTE nActionType;
-			int  nInt1;
-			double dD[4]{};
-			std::wstring wsType;
-			std::wstring wsStr1;
-			std::vector<std::wstring> arrStr;
-			CActionWidget* pNext;
-		};
-
 		CWidgetAnnotPr(BYTE nType);
 		~CWidgetAnnotPr();
 
@@ -199,7 +201,7 @@ public:
 		const std::vector<double>& GetTC();
 		const std::vector<double>& GetBC();
 		const std::vector<double>& GetBG();
-		const std::vector<CActionWidget*>& GetActions();
+		const std::vector<CActionFieldPr*>& GetActions();
 
 		CButtonWidgetPr*    GetButtonWidgetPr();
 		CTextWidgetPr*      GetTextWidgetPr();
@@ -229,7 +231,7 @@ public:
 		std::vector<double> m_arrTC;
 		std::vector<double> m_arrBC;
 		std::vector<double> m_arrBG;
-		std::vector<CActionWidget*> m_arrAction;
+		std::vector<CActionFieldPr*> m_arrAction;
 
 		CButtonWidgetPr*    m_pButtonPr;
 		CTextWidgetPr*      m_pTextPr;
@@ -389,7 +391,7 @@ public:
 	{
 	public:
 		bool IsOpen()      const;
-		int  GetFlag()     const;
+		int  GetFlag()    const;
 		int  GetParentID() const;
 
 		void Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader);
@@ -478,6 +480,28 @@ public:
 		std::vector<double> m_arrQuadPoints;
 	};
 
+	class GRAPHICS_DECL CLinkAnnotPr
+	{
+	public:
+		CLinkAnnotPr();
+		~CLinkAnnotPr();
+
+		BYTE GetH()    const;
+		int GetFlags() const;
+		const std::vector<double>& GetQuadPoints();
+		CActionFieldPr* GetA();
+		CActionFieldPr* GetPA();
+
+		void Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader);
+
+	private:
+		BYTE m_nH;
+		int m_nFlags;
+		std::vector<double> m_arrQuadPoints;
+		CActionFieldPr* m_pAction;
+		CActionFieldPr* m_pPA;
+	};
+
 	CAnnotFieldInfo();
 	virtual ~CAnnotFieldInfo();
 
@@ -518,6 +542,7 @@ public:
 	bool IsCaret()           const;
 	bool IsStamp()           const;
 	bool IsRedact()          const;
+	bool IsLink()            const;
 
 	CMarkupAnnotPr*       GetMarkupAnnotPr();
 	CTextAnnotPr*         GetTextAnnotPr();
@@ -531,6 +556,7 @@ public:
 	CCaretAnnotPr*        GetCaretAnnotPr();
 	CStampAnnotPr*        GetStampAnnotPr();
 	CRedactAnnotPr*       GetRedactAnnotPr();
+	CLinkAnnotPr*         GetLinkAnnotPr();
 	CWidgetAnnotPr*       GetWidgetAnnotPr();
 
 	bool Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafileToRenderter* pCorrector);
@@ -576,6 +602,7 @@ private:
 	CCaretAnnotPr*        m_pCaretPr;
 	CStampAnnotPr*        m_pStampPr;
 	CRedactAnnotPr*       m_pRedactPr;
+	CLinkAnnotPr*         m_pLinkPr;
 	CWidgetAnnotPr*       m_pWidgetPr;
 };
 
@@ -610,7 +637,7 @@ public:
 		std::wstring sTU;
 		std::vector<int> arrI;
 		std::vector<std::wstring> arrV;
-		std::vector<CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget*> arrAction;
+		std::vector<CAnnotFieldInfo::CActionFieldPr*> arrAction;
 		std::vector< std::pair<std::wstring, std::wstring> > arrOpt;
 	};
 

DesktopEditor/graphics/commands/DocInfo.cpp

@@ -179,7 +179,6 @@ CHeadings::CHeading::CHeading()
 	nPage = 0;
 	dX = 0.0;
 	dY = 0.0;
-	pParent = NULL;
 }
 CHeadings::CHeading::~CHeading()
 {
@@ -196,35 +195,26 @@ CHeadings::~CHeadings()
 const std::vector<CHeadings::CHeading*>& CHeadings::GetHeading() { return m_arrHeading; }
 bool CHeadings::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafileToRenderter* pCorrector)
 {
-	int nPredLevel = 0, nHeaderLevel = 0;
-	std::vector<CHeading*>* arrHeading = &m_arrHeading;
-	CHeading* pParent = NULL;
+	std::vector<CHeading*> arrParentStack;
 	int nHeadings = pReader->ReadInt();
 	for (int i = 0; i < nHeadings; ++i)
 	{
 		int nLevel = pReader->ReadInt();
-		if (nLevel > nPredLevel && i > 0)
-		{
-			nHeaderLevel = nPredLevel;
-			pParent = arrHeading->back();
-			arrHeading = &pParent->arrHeading;
-		}
-		else if (nLevel < nPredLevel && nLevel <= nHeaderLevel)
-		{
-			nHeaderLevel = nLevel;
-			pParent = pParent ? pParent->pParent : NULL;
-			arrHeading = pParent ? &pParent->arrHeading : &m_arrHeading;
-		}
-		nPredLevel = nLevel;
-
 		CHeading* pHeading = new CHeading();
 		pHeading->nPage = pReader->ReadInt();
 		pHeading->dX = pReader->ReadDouble();
 		pHeading->dY = pReader->ReadDouble();
 		pHeading->wsTitle = pReader->ReadString();
-		pHeading->pParent = pParent;
 
-		arrHeading->push_back(pHeading);
+		while (arrParentStack.size() > nLevel)
+			arrParentStack.pop_back();
+
+		if (arrParentStack.empty())
+			m_arrHeading.push_back(pHeading);
+		else
+			arrParentStack.back()->arrHeading.push_back(pHeading);
+
+		arrParentStack.push_back(pHeading);
 	}
 	return true;
 }

DesktopEditor/graphics/commands/DocInfo.h

@@ -181,7 +181,6 @@ public:
 		int nPage;
 		double dX;
 		double dY;
-		CHeading* pParent;
 		std::vector<CHeading*> arrHeading;
 
 		CHeading();

DesktopEditor/graphics/pro/js/drawingfile.json

@@ -46,16 +46,20 @@
 		"_InitializeFontsRanges",
 		"_SetFontBinary",
 		"_GetFontBinary",
+		"_GetGIDByUnicode",
 		"_IsFontBinaryExist",
 		"_DestroyTextInfo",
 		"_IsNeedCMap",
 		"_SetCMapData",
+		"_SetScanPageFonts",
 		"_ScanPage",
 		"_SplitPages",
 		"_MergePages",
 		"_UnmergePages",
 		"_RedactPage",
 		"_UndoRedact",
+		"_CheckOwnerPassword",
+		"_CheckPerm",
 		"_GetImageBase64",
 		"_GetImageBase64Len",
 		"_GetImageBase64Ptr",
@@ -193,7 +197,7 @@
 	},
 	{
 		"folder": "../../../../PdfFile/SrcReader/",
-		"files": ["Adaptors.cpp", "GfxClip.cpp", "RendererOutputDev.cpp", "JPXStream2.cpp", "PdfAnnot.cpp"]
+		"files": ["Adaptors.cpp", "GfxClip.cpp", "RendererOutputDev.cpp", "JPXStream2.cpp", "PdfAnnot.cpp", "PdfFont.cpp"]
 	},
 	{
 		"folder": "../../../../PdfFile/SrcWriter/",

DesktopEditor/graphics/pro/js/qt/nativegraphics.pro

@@ -639,6 +639,7 @@ SOURCES += \
 	$$PDF_ROOT_DIR/SrcReader/Adaptors.cpp \
 	$$PDF_ROOT_DIR/SrcReader/GfxClip.cpp \
 	$$PDF_ROOT_DIR/SrcReader/PdfAnnot.cpp \
+	$$PDF_ROOT_DIR/SrcReader/PdfFont.cpp \
 	$$PDF_ROOT_DIR/Resources/BaseFonts.cpp \
 	$$PDF_ROOT_DIR/Resources/CMapMemory/cmap_memory.cpp
 
@@ -664,6 +665,7 @@ HEADERS +=\
 	$$PDF_ROOT_DIR/SrcReader/MemoryUtils.h \
 	$$PDF_ROOT_DIR/SrcReader/GfxClip.h \
 	$$PDF_ROOT_DIR/SrcReader/FontsWasm.h \
+	$$PDF_ROOT_DIR/SrcReader/PdfFont.h \
 	$$PDF_ROOT_DIR/SrcReader/PdfAnnot.h
 
 DEFINES += CRYPTOPP_DISABLE_ASM

DesktopEditor/graphics/pro/js/wasm/js/drawingfile.js

@@ -145,6 +145,14 @@ CFile.prototype["isNeedPassword"] = function()
 {
 	return this._isNeedPassword;
 };
+CFile.prototype["CheckOwnerPassword"] = function(password)
+{
+	return this._CheckOwnerPassword(password);
+};
+CFile.prototype["CheckPerm"] = function(perm)
+{
+	return this._CheckPerm(perm);
+};
 CFile.prototype["SplitPages"] = function(arrOriginIndex, arrayBufferChanges)
 {
 	let ptr = this._SplitPages(arrOriginIndex, arrayBufferChanges);
@@ -354,6 +362,11 @@ CFile.prototype["getFontByID"] = function(ID)
 	return this._getFontByID(ID);
 };
 
+CFile.prototype["getGIDByUnicode"] = function(ID)
+{
+	return this._getGIDByUnicode(ID);
+};
+
 CFile.prototype["setCMap"] = function(memoryBuffer)
 {
 	if (!this.nativeFile)
@@ -413,9 +426,9 @@ function readAction(reader, rec, readDoubleFunc, readStringFunc)
 			case 4:
 			{
 				rec["left"]   = readDoubleFunc.call(reader);
-				rec["bottom"] = readDoubleFunc.call(reader);
+				rec["top"] = readDoubleFunc.call(reader);
 				rec["right"]  = readDoubleFunc.call(reader);
-				rec["top"]    = readDoubleFunc.call(reader);
+				rec["bottom"]    = readDoubleFunc.call(reader);
 				break;
 			}
 			case 1:
@@ -1027,6 +1040,37 @@ function readAnnotType(reader, rec, readDoubleFunc, readDouble2Func, readStringF
 			rec["font"]["style"] = reader.readInt();
 		}
 	}
+	// Link
+	else if (rec["type"] == 1)
+	{
+		flags = reader.readInt();
+		if (flags & (1 << 0))
+		{
+			rec["A"] = {};
+			if (isRead)
+				readStringFunc.call(reader);
+			readAction(reader, rec["A"], readDoubleFunc, readStringFunc);
+		}
+		if (flags & (1 << 1))
+		{
+			rec["PA"] = {};
+			if (isRead)
+				readStringFunc.call(reader);
+			readAction(reader, rec["PA"], readDoubleFunc, readStringFunc);
+		}
+		// Selection mode - H
+		// 0 - none, 1 - invert, 2 - push, 3 - outline
+		if (flags & (1 << 2))
+			rec["highlight"] = reader.readByte();
+		// QuadPoints
+		if (flags & (1 << 3))
+		{
+			let n = reader.readInt();
+			rec["QuadPoints"] = [];
+			for (let i = 0; i < n; ++i)
+				rec["QuadPoints"].push(readDoubleFunc.call(reader));
+		}
+	}
 }
 function readWidgetType(reader, rec, readDoubleFunc, readDouble2Func, readStringFunc, isRead = false)
 {
@@ -1171,6 +1215,20 @@ function readWidgetType(reader, rec, readDoubleFunc, readDouble2Func, readString
 			rec["value"] = readStringFunc.call(reader);
 		// 0 - check, 1 - cross, 2 - diamond, 3 - circle, 4 - star, 5 - square
 		rec["style"] = reader.readByte();
+		if (flags & (1 << 10))
+		{
+			let n = reader.readInt();
+			rec["opt"] = [];
+			for (let i = 0; i < n; ++i)
+			{
+				let opt1 = readStringFunc.call(reader);
+				let opt2 = readStringFunc.call(reader);
+				if (opt1 == "")
+					rec["opt"].push(opt2);
+				else
+					rec["opt"].push([opt2, opt1]);
+			}
+		}
 		if (flags & (1 << 14))
 			rec["ExportValue"] = readStringFunc.call(reader);
 		// 12.7.4.2.1
@@ -1648,6 +1706,11 @@ CFile.prototype["readAnnotationsInfoFromBinary"] = function(AnnotInfo)
 };
 
 // SCAN PAGES
+CFile.prototype["scanPageFonts"] = function(page)
+{
+	this._setScanPageFonts(page);
+};
+
 CFile.prototype["scanPage"] = function(page, mode)
 {
 	let ptr = this._scanPage(page, mode);

DesktopEditor/graphics/pro/js/wasm/js/drawingfile_native.js

@@ -146,6 +146,16 @@ CFile.prototype._UndoRedact = function()
 	return g_native_drawing_file["UndoRedact"]();
 };
 
+CFile.prototype._CheckOwnerPassword = function(password)
+{
+	return true;
+}
+
+CFile.prototype._CheckPerm = function(perm)
+{
+	return true;
+}
+
 // FONTS
 CFile.prototype._isNeedCMap = function()
 {
@@ -162,6 +172,12 @@ CFile.prototype._getFontByID = function(ID)
 	return g_native_drawing_file["GetFontBinary"](ID);
 };
 
+CFile.prototype._getGIDByUnicode = function(ID)
+{
+	g_module_pointer.ptr = g_native_drawing_file["GetGIDByUnicode"](ID);
+	return g_module_pointer;
+}
+
 CFile.prototype._getInteractiveFormsFonts = function(type)
 {
 	g_module_pointer.ptr = g_native_drawing_file["GetInteractiveFormsFonts"](type);
@@ -236,6 +252,11 @@ CFile.prototype._getInteractiveFormsAP = function(width, height, backgroundColor
 };
 
 // SCAN PAGES
+CFile.prototype._setScanPageFonts = function(page)
+{
+	g_native_drawing_file["SetScanPageFonts"](page);
+};
+
 CFile.prototype._scanPage = function(page, mode)
 {
 	g_module_pointer.ptr = g_native_drawing_file["ScanPage"](page, (mode === undefined) ? 0 : mode);

DesktopEditor/graphics/pro/js/wasm/js/drawingfile_wasm.js

@@ -106,7 +106,7 @@ CFile.prototype._openFile = function(buffer, password)
 	}
 
 	let passwordPtr = 0;
-	if (password)
+	if (password !== undefined)
 	{
 		let passwordBuf = password.toUtf8();
 		passwordPtr = Module["_malloc"](passwordBuf.length);
@@ -224,6 +224,29 @@ CFile.prototype._UndoRedact = function()
 	return Module["_UndoRedact"](this.nativeFile) == 1;
 };
 
+CFile.prototype._CheckOwnerPassword = function(password)
+{
+	let passwordPtr = 0;
+	if (password !== undefined)
+	{
+		let passwordBuf = password.toUtf8();
+		passwordPtr = Module["_malloc"](passwordBuf.length);
+		Module["HEAP8"].set(passwordBuf, passwordPtr);
+	}
+
+	let bRes = Module["_CheckOwnerPassword"](this.nativeFile, passwordPtr);
+
+	if (passwordPtr)
+		Module["_free"](passwordPtr);
+
+	return bRes == 1;
+}
+
+CFile.prototype._CheckPerm = function(perm)
+{
+	return Module["_CheckPerm"](this.nativeFile, perm) == 1;
+}
+
 // FONTS
 CFile.prototype._isNeedCMap = function()
 {
@@ -263,6 +286,34 @@ CFile.prototype._getFontByID = function(ID)
 	return res;
 };
 
+CFile.prototype._getGIDByUnicode = function(ID)
+{
+	if (ID === undefined)
+		return null;
+
+	let idBuffer = ID.toUtf8();
+	let idPointer = Module["_malloc"](idBuffer.length);
+	Module["HEAP8"].set(idBuffer, idPointer);
+	g_module_pointer.ptr = Module["_GetGIDByUnicode"](this.nativeFile, idPointer);
+	Module["_free"](idPointer);
+
+	let reader = g_module_pointer.getReader();
+	if (!reader)
+		return null;
+
+	let res = {};
+	let nFontLength = reader.readInt();
+	for (let i = 0; i < nFontLength; i++)
+	{
+		let np1 = reader.readInt();
+		let np2 = reader.readInt();
+		res[np2] = np1;
+	}
+
+	g_module_pointer.free();
+	return res;
+}
+
 CFile.prototype._getInteractiveFormsFonts = function(type)
 {
 	g_module_pointer.ptr = Module["_GetInteractiveFormsFonts"](this.nativeFile, type);
@@ -337,6 +388,11 @@ CFile.prototype._getInteractiveFormsAP = function(width, height, backgroundColor
 };
 
 // SCAN PAGES
+CFile.prototype._setScanPageFonts = function(page)
+{
+	Module["_SetScanPageFonts"](this.nativeFile, page);
+};
+
 CFile.prototype._scanPage = function(page, mode)
 {
 	g_module_pointer.ptr = Module["_ScanPage"](this.nativeFile, page, (mode === undefined) ? 0 : mode);

DesktopEditor/graphics/pro/js/wasm/src/drawingfile.cpp

@@ -80,7 +80,7 @@ WASM_EXPORT CDrawingFile* Open(BYTE* data, LONG size, const char* password)
 	std::wstring sPassword = L"";
 	if (NULL != password)
 		sPassword = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)password, strlen(password));
-	pFile->OpenFile(data, size, sPassword);
+	pFile->OpenFile(data, size, password ? sPassword.c_str() : NULL);
 	return pFile;
 }
 WASM_EXPORT int GetType(CDrawingFile* pFile)
@@ -150,6 +150,10 @@ WASM_EXPORT BYTE* GetFontBinary(CDrawingFile* pFile, char* path)
 {
 	return pFile->GetFontBinary(std::string(path));
 }
+WASM_EXPORT BYTE* GetGIDByUnicode(CDrawingFile* pFile, char* path)
+{
+	return pFile->GetGIDByUnicode(std::string(path));
+}
 WASM_EXPORT void DestroyTextInfo(CDrawingFile* pFile)
 {
 	return pFile->DestroyTextInfo();
@@ -162,6 +166,10 @@ WASM_EXPORT void SetCMapData(CDrawingFile* pFile, BYTE* data, int size)
 {
 	pFile->SetCMapData(data, size);
 }
+WASM_EXPORT void SetScanPageFonts(CDrawingFile* pFile, int nPageIndex)
+{
+	return pFile->SetScanPageFonts(nPageIndex);
+}
 WASM_EXPORT BYTE* ScanPage(CDrawingFile* pFile, int nPageIndex, int mode)
 {
 	return pFile->ScanPage(nPageIndex, mode);
@@ -191,6 +199,17 @@ WASM_EXPORT int UndoRedact(CDrawingFile* pFile)
 {
 	return pFile->UndoRedact() ? 1 : 0;
 }
+WASM_EXPORT int CheckOwnerPassword(CDrawingFile* pFile, const char* password)
+{
+	std::wstring sPassword = L"";
+	if (NULL != password)
+		sPassword = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)password, strlen(password));
+	return pFile->CheckOwnerPassword(password ? sPassword.c_str() : NULL) ? 1 : 0;
+}
+WASM_EXPORT int CheckPerm(CDrawingFile* pFile, int nPermFlag)
+{
+	return pFile->CheckPerm(nPermFlag) ? 1 : 0;
+}
 
 WASM_EXPORT void* GetImageBase64(CDrawingFile* pFile, int rId)
 {

DesktopEditor/graphics/pro/js/wasm/src/drawingfile_test.cpp

@@ -704,6 +704,23 @@ void ReadInteractiveForms(BYTE* pWidgets, int& i)
 			i += 1;
 			std::cout << "Style " << arrStyle[nPathLength] << ", ";
 
+			if (nFlags & (1 << 10))
+			{
+				int nOptLength = READ_INT(pWidgets + i);
+				i += 4;
+				for (int j = 0; j < nOptLength; ++j)
+				{
+					nPathLength = READ_INT(pWidgets + i);
+					i += 4;
+					std::cout << std::to_string(j) << " Opt1 " << std::string((char*)(pWidgets + i), nPathLength) << ", ";
+					i += nPathLength;
+
+					nPathLength = READ_INT(pWidgets + i);
+					i += 4;
+					std::cout << std::to_string(j) << " Opt2 " << std::string((char*)(pWidgets + i), nPathLength) << ", ";
+					i += nPathLength;
+				}
+			}
 			if (nFlags & (1 << 14))
 			{
 				nPathLength = READ_INT(pWidgets + i);
@@ -938,6 +955,36 @@ void ReadInteractiveFormsFonts(CDrawingFile* pGrFile, int nType)
 				std::cout << "font" << j << ".txt";
 			}
 
+			if (pFont)
+				free(pFont);
+
+			if (false)
+				continue;
+
+			pFont = GetGIDByUnicode(pGrFile, (char*)sFontName.c_str());
+			nLength2 = READ_INT(pFont);
+			i2 = 4;
+			nLength2 -= 4;
+
+			while (i2 < nLength2)
+			{
+				int nFontLength = READ_INT(pFont + i2);
+				i2 += 4;
+
+				std::cout << std::endl << "GIDtoUnicode" << std::endl;
+
+				for (int j = 0; j < nFontLength; ++j)
+				{
+					unsigned int code = READ_INT(pFont + i2);
+					i2 += 4;
+					unsigned int unicode = READ_INT(pFont + i2);
+					i2 += 4;
+					std::cout << "gid\t" << code << "\tunicode\t" << unicode << std::endl;
+				}
+
+				std::cout << std::endl;
+			}
+
 			if (pFont)
 				free(pFont);
 		}
@@ -1025,7 +1072,7 @@ int main(int argc, char* argv[])
 	if (!NSFile::CFileBinary::ReadAllBytes(sFilePath, &pFileData, nFileDataLen))
 		return 1;
 
-	CDrawingFile* pGrFile = Open(pFileData, (LONG)nFileDataLen, "");
+	CDrawingFile* pGrFile = Open(pFileData, (LONG)nFileDataLen, NULL);
 	int nError = GetErrorCode(pGrFile);
 
 	if (nError != 0)
@@ -1033,7 +1080,7 @@ int main(int argc, char* argv[])
 		Close(pGrFile);
 		if (nError == 4)
 		{
-			std::string sPassword = "123456";
+			std::string sPassword = "";
 			pGrFile = Open(pFileData, nFileDataLen, sPassword.c_str());
 		}
 		else
@@ -1053,7 +1100,7 @@ int main(int argc, char* argv[])
 
 		if (true && GetFromBase64(NSFile::GetProcessDirectory() + L"/split.txt", &pBuffer, &nBufferLen))
 		{
-			std::vector<int> arrPages = { 2 };
+			std::vector<int> arrPages = { 0 };
 			BYTE* pSplitPages = SplitPages(pGrFile, arrPages.data(), arrPages.size(), pBuffer, nBufferLen);
 			int nLength = READ_INT(pSplitPages);
 
@@ -1125,26 +1172,38 @@ int main(int argc, char* argv[])
 		}
 	}
 
-	BYTE* pColor = new BYTE[12] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+	// OWNER PASSWORD
+	if (false)
+	{
+		std::string sPassword = "";
+		std::cout << "CheckPerm 4 Edit "  << CheckPerm(pGrFile, 4) << std::endl;
+		std::cout << "CheckPerm 4 Print " << CheckPerm(pGrFile, 3) << std::endl;
+
+		std::cout << "CheckOwnerPassword " << CheckOwnerPassword(pGrFile, sPassword.c_str()) << std::endl;
+		std::cout << "CheckPerm 4 Edit "  << CheckPerm(pGrFile, 4) << std::endl;
+		std::cout << "CheckPerm 4 Print " << CheckPerm(pGrFile, 3) << std::endl;
+	}
+
 	// REDACT
 	if (false)
 	{
+		BYTE* pColor = new BYTE[12] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 		int pRect[8] = { 307499, 217499, 307499, 1124999, 1799999, 1124999, 1799999, 217499 };
 		if (!RedactPage(pGrFile, nTestPage, pRect, 1, pColor, 12))
 			std::cout << "Redact false" << std::endl;
 	}
 
-	int i = nTestPage;
-	//for (int i = 0; i < nPagesCount; ++i)
+	// RASTER
+	if (false)
 	{
-		// RASTER
-		if (true)
+		int i = nTestPage;
+		//for (int i = 0; i < nPagesCount; ++i)
 		{
 			nWidth  = READ_INT(pInfo + i * 16 + 12);
 			nHeight = READ_INT(pInfo + i * 16 + 16);
 
-			//nWidth  *= 3;
-			//nHeight *= 3;
+			//nWidth  *= 2;
+			//nHeight *= 2;
 
 			BYTE* res = NULL;
 			res = GetPixmap(pGrFile, i, nWidth, nHeight, 0xFFFFFF);
@@ -1164,7 +1223,7 @@ int main(int argc, char* argv[])
 	free(pInfo);
 
 	// LINKS
-	if (true && nPagesCount > 0)
+	if (false && nPagesCount > 0)
 	{
 		BYTE* pLinks = GetLinks(pGrFile, nTestPage);
 		nLength = READ_INT(pLinks);
@@ -1200,7 +1259,7 @@ int main(int argc, char* argv[])
 	}
 
 	// STRUCTURE
-	if (true)
+	if (false)
 	{
 		BYTE* pStructure = GetStructure(pGrFile);
 		nLength = READ_INT(pStructure);
@@ -1305,7 +1364,7 @@ int main(int argc, char* argv[])
 	}
 
 	// INTERACTIVE FORMS
-	if (true)
+	if (false)
 	{
 		ReadInteractiveFormsFonts(pGrFile, 1);
 		ReadInteractiveFormsFonts(pGrFile, 2);
@@ -1424,7 +1483,7 @@ int main(int argc, char* argv[])
 	}
 
 	// ANNOTS
-	if (true)
+	if (false)
 	{
 		BYTE* pAnnots = GetAnnotationsInfo(pGrFile, -1);
 		nLength = READ_INT(pAnnots);
@@ -2132,6 +2191,44 @@ int main(int argc, char* argv[])
 						std::cout << nPathLength << ", ";
 					}
 				}
+				else if (sType == "Link")
+				{
+					nFlags = READ_INT(pAnnots + i);
+					i += 4;
+					if (nFlags & (1 << 0))
+					{
+						std::cout << std::endl << "A ";
+						ReadAction(pAnnots, i);
+						std::cout << std::endl;
+					}
+					if (nFlags & (1 << 1))
+					{
+						std::cout << std::endl << "PA ";
+						ReadAction(pAnnots, i);
+						std::cout << std::endl;
+					}
+					if (nFlags & (1 << 2))
+					{
+						std::string arrHighlighting[] = {"none", "invert", "push", "outline"};
+						nPathLength = READ_BYTE(pAnnots + i);
+						i += 1;
+						std::cout << "Highlight " << arrHighlighting[nPathLength] << ", ";
+					}
+					if (nFlags & (1 << 3))
+					{
+						std::cout << "QuadPoints";
+						int nQuadPointsLength = READ_INT(pAnnots + i);
+						i += 4;
+
+						for (int j = 0; j < nQuadPointsLength; ++j)
+						{
+							nPathLength = READ_INT(pAnnots + i);
+							i += 4;
+							std::cout << " " << (double)nPathLength / 100.0;
+						}
+						std::cout << ", ";
+					}
+				}
 
 				std::cout << std::endl << "]" << std::endl;
 			}
@@ -2154,12 +2251,13 @@ int main(int argc, char* argv[])
 			free(pAnnotAP);
 	}
 
-	// SCAN PAGE
-	if (false)
+	// SCAN PAGE Fonts
+	if (true)
 	{
-		BYTE* pScan = ScanPage(pGrFile, nTestPage, 1);
-		if (pScan)
-			free(pScan);
+		SetScanPageFonts(pGrFile, nTestPage);
+
+		ReadInteractiveFormsFonts(pGrFile, 1);
+		ReadInteractiveFormsFonts(pGrFile, 2);
 	}
 
 	Close(pGrFile);

DesktopEditor/graphics/pro/officedrawingfile.h

@@ -63,9 +63,9 @@ public:
 
     // Open
     virtual bool LoadFromFile(const std::wstring& file, const std::wstring& options = L"",
-                                const std::wstring& owner_password = L"", const std::wstring& user_password = L"") = 0;
+								const wchar_t* owner_password = NULL, const wchar_t* user_password = NULL) = 0;
     virtual bool LoadFromMemory(unsigned char* data, unsigned long length, const std::wstring& options = L"",
-                                const std::wstring& owner_password = L"", const std::wstring& user_password = L"") = 0;
+								const wchar_t* owner_password = NULL, const wchar_t* user_password = NULL) = 0;
 
     // Close
     virtual void Close() = 0;

DesktopEditor/graphics/structures.h

@@ -113,7 +113,10 @@ const long c_BrushTypeTensorCurveGradient = 6007;
 
 const long c_BrushTextureModeStretch = 0;
 const long c_BrushTextureModeTile = 1;
-const long c_BrushTextureModeTileCenter = 2;
+const long c_BrushTextureModeTileFlipX = 2;
+const long c_BrushTextureModeTileFlipY = 3;
+const long c_BrushTextureModeTileFlipXY = 4;
+const long c_BrushTextureModeTileCenter = 5;
 // --------------------------------------------------------------
 
 namespace Aggplus { class CImage; }
@@ -284,6 +287,13 @@ namespace NSStructures
 		Aggplus::RectF Rect;
 		Aggplus::CDoubleRect Bounds;
 
+		int IsScale;
+		double ScaleX;
+		double ScaleY;
+
+		double OffsetX;
+		double OffsetY;
+
 		double LinearAngle;
 		std::vector<TSubColor> m_arrSubColors;
 		NSStructures::GradientInfo m_oGradientInfo;
@@ -415,6 +425,13 @@ namespace NSStructures
 			Rect.Width = 0.0F;
 			Rect.Height = 0.0F;
 
+			IsScale = FALSE;
+			ScaleX = 1.0;
+			ScaleY = 1.0;
+
+			OffsetX = 0.0;
+			OffsetY = 0.0;
+
 			Bounds.left = 0;
 			Bounds.top = 0;
 			Bounds.right = 0;
@@ -454,6 +471,10 @@ namespace NSStructures
 			Rect = other.Rect;
 			Bounds = other.Bounds;
 
+			IsScale = other.IsScale;
+			ScaleX = other.ScaleX;
+			ScaleY = other.ScaleY;
+
 			LinearAngle = other.LinearAngle;
 			m_arrSubColors = other.m_arrSubColors;
 			m_oGradientInfo = other.m_oGradientInfo;

DesktopEditor/raster/ImageFileFormatChecker.cpp

@@ -202,6 +202,19 @@ bool CImageFileFormatChecker::isWbcFile(BYTE* pBuffer,DWORD dwBytes)
 
 	return false;
 }
+//raster graphics file format developed by Google
+bool CImageFileFormatChecker::isWebPFile(BYTE* pBuffer, DWORD dwBytes)
+{
+	if (eFileType)return false;
+
+	if ((20 <= dwBytes) && ('R' == pBuffer[0] && 'I' == pBuffer[1] && 'F' == pBuffer[2] && 'F' == pBuffer[3]
+		//4–7	length + 12
+		&& 'W' == pBuffer[8] && 'E' == pBuffer[9] && 'B' == pBuffer[10] && 'P' == pBuffer[11])
+        && 'V' == pBuffer[12] && 'P' == pBuffer[13] && '8' == pBuffer[14])
+		return true;
+
+	return false;
+}
 //webshot(wb ver 1) HEX 57 57 42 42 31 31 31 31
 //webshot (wb ver 2) HEX 00 00 02 00 02 10 c9 00 02 00 c8 06 4c 00 02 00
 bool CImageFileFormatChecker::isWbFile(BYTE* pBuffer,DWORD dwBytes)
@@ -509,6 +522,10 @@ bool CImageFileFormatChecker::isImageFile(const std::wstring& fileName)
 	{
 		eFileType = _CXIMAGE_FORMAT_WB;
 	}
+	else if (isWebPFile(buffer, sizeRead))
+	{
+		eFileType = _CXIMAGE_FORMAT_WEBP;
+	}
 	else if (isPsdFile(buffer,sizeRead))
 	{
 		eFileType = _CXIMAGE_FORMAT_PSD;

DesktopEditor/raster/ImageFileFormatChecker.h

@@ -64,6 +64,7 @@ enum __ENUM_CXIMAGE_FORMATS
 	_CXIMAGE_FORMAT_SVG = 24,
     _CXIMAGE_FORMAT_PIC = 25,
 	_CXIMAGE_FORMAT_HEIF = 26,
+	_CXIMAGE_FORMAT_WEBP = 27
 };
 
 class GRAPHICS_DECL CImageFileFormatChecker
@@ -96,6 +97,7 @@ public:
 	bool isTiffFile(BYTE* pBuffer,DWORD dwBytes);
 	bool isJpgFile(BYTE* pBuffer,DWORD dwBytes);
 	bool isWbFile(BYTE* pBuffer,DWORD dwBytes);
+	bool isWebPFile(BYTE* pBuffer, DWORD dwBytes);
 
 	bool isIcoFile(BYTE* pBuffer,DWORD dwBytes);
 	bool isRasFile(BYTE* pBuffer,DWORD dwBytes);

DesktopEditor/raster/Metafile/Common/MetaFileRenderer.h

@@ -1237,7 +1237,7 @@ namespace MetaFile
 
 			// Вычисление минимально возможной ширины пера
 			// # Код явялется дублированным из Graphics
-			const double dSqrtDet = sqrt(abs(oMatrix.Determinant()));
+			const double dSqrtDet = sqrt(fabs(oMatrix.Determinant()));
 			const double dWidthMinSize = (dSqrtDet != 0) ? (1.0 / dSqrtDet) : dWidth;
 
 			if (0 == pPen->GetWidth())

DesktopEditor/raster/Metafile/MetaFile.cpp

@@ -68,6 +68,10 @@ namespace MetaFile
 	#ifdef METAFILE_SUPPORT_SVM
 		m_oSvmFile.SetFontManager(m_pFontManager);
 	#endif
+
+	#ifdef METAFILE_SUPPORT_SVG
+		m_oSvgFile.SetFontManager(m_pFontManager);
+	#endif
 		m_lType  = 0;
 	}
 
@@ -84,7 +88,6 @@ namespace MetaFile
 
 	std::wstring CMetaFile::ConvertToSvg(unsigned int unWidth, unsigned int unHeight)
 	{
-
 	#ifdef METAFILE_SUPPORT_WMF_EMF
 		if (c_lMetaWmf == m_lType)
 		{

DesktopEditor/raster/Metafile/Wmf/WmfParser/CWmfParserBase.cpp

@@ -1740,8 +1740,8 @@ namespace MetaFile
 					const TRectL& oEmfRect{oEmfParser.GetDCBounds()};
 					const TRectL& oCurentRect{GetDCBounds()};
 
-					const double dScaleX = std::abs((oCurentRect.Right  - oCurentRect.Left) / (oEmfRect.Right  - oEmfRect.Left));
-					const double dScaleY = std::abs((oCurentRect.Bottom - oCurentRect.Top)  / (oEmfRect.Bottom - oEmfRect.Top));
+					const double dScaleX = std::abs((double)(oCurentRect.Right  - oCurentRect.Left) / (double)(oEmfRect.Right  - oEmfRect.Left));
+					const double dScaleY = std::abs((double)(oCurentRect.Bottom - oCurentRect.Top)  / (double)(oEmfRect.Bottom - oEmfRect.Top));
 
 					const bool bAddGElement = !Equals(1., dScaleX) || !Equals(1., dScaleY);
 

DesktopEditor/raster/Metafile/svg/CSvgFile.cpp

@@ -68,7 +68,13 @@ bool CSvgFile::MarkObject(SVG::CObject *pObject)
 	if (NULL == pObject || pObject->GetId().empty())
 		return false;
 
-	pObject->AddRef();
+	pObject->Mark();
+
+	const MarkedMap::const_iterator itFound = m_mMarkedObjects.find(pObject->GetId());
+
+	if (m_mMarkedObjects.cend() != itFound)
+		RELEASEINTERFACE(m_mMarkedObjects[pObject->GetId()])
+
 	m_mMarkedObjects[pObject->GetId()] = pObject;
 
 	return true;
@@ -153,8 +159,7 @@ bool CSvgFile::Draw(IRenderer *pRenderer, double dX, double dY, double dWidth, d
 		dTranslateY -= oViewBox.m_oY.ToDouble(NSCSS::Pixel) * dScaleY * dM22;
 	}
 
-	const double dMinScale = std::min(dScaleX, dScaleY);
-	pRenderer->SetTransform(dM11 * dMinScale, 0, 0, dM22 * dMinScale, dTranslateX, dTranslateY);
+	pRenderer->SetTransform(dM11 * dScaleX, 0, 0, dM22 * dScaleY, dTranslateX, dTranslateY);
 
 	bool bResult = m_pContainer->Draw(pRenderer, this);
 
@@ -165,7 +170,7 @@ bool CSvgFile::Draw(IRenderer *pRenderer, double dX, double dY, double dWidth, d
 
 void CSvgFile::Clear()
 {
-	RELEASEOBJECT(m_pContainer);
+	RELEASEINTERFACE(m_pContainer);
 	m_oSvgCalculator.Clear();
 
 	for (MarkedMap::reference oIter : m_mMarkedObjects)

DesktopEditor/raster/Metafile/svg/CSvgParser.cpp

@@ -117,7 +117,7 @@ namespace SVG
 		ScanStyles(oReader, pFile);
 		oReader.MoveToStart();
 
-		RELEASEOBJECT(pContainer);
+		RELEASEINTERFACE(pContainer);
 
 		pContainer = CObject::Create<CGraphicsContainer>(oReader, pFile);
 
@@ -224,7 +224,7 @@ namespace SVG
 			pObject = CObject::Create<CGraphicsContainer>(oReader, pFile, pParent);
 			if (!ReadChildrens(oReader, (CGraphicsContainer*)pObject, pFile, (CGraphicsContainer*)pObject))
 			{
-				RELEASEOBJECT(pObject);
+				RELEASEINTERFACE(pObject);
 				return false;
 			}
 		}
@@ -290,21 +290,21 @@ namespace SVG
 			if (ReadChildrens(oReader, (CSymbol*)pObject, pFile))
 				return true;
 			else
-				RELEASEOBJECT(pObject);
+				RELEASEINTERFACE(pObject);
 		}
 		else if ("font" == sElementName)
 		{
-			pObject = CObject::Create<CFont>(oReader, pFile);
+			pObject = CObject::Create<CFont>(oReader, pFile, pFile);
 		}
 
 		if (NULL == pObject)
 			return false;
 
-		if ((RendererObject == pObject->GetType() && AddObject((ObjectType*)pObject, pContainer)) ||
+		if ((RendererObject == pObject->GetType() && (AddObject((ObjectType*)pObject, pContainer) || pObject->Marked())) ||
 		    AppliedObject == pObject->GetType())
 			return true;
 
-		RELEASEOBJECT(pObject);
+		RELEASEINTERFACE(pObject);
 		return false;
 	}
 

DesktopEditor/raster/Metafile/svg/SvgObjects/CFont.cpp

@@ -2,22 +2,23 @@
 
 namespace SVG 
 {
-	CGlyph::CGlyph(CSvgReader& oReader)
+	CGlyph::CGlyph(CSvgReader& oReader, CSvgFile* pFile)
 		: CPath(oReader)
-	{
-		START_READ_ATTRIBUTES(oReader)
-		{
-			if ("unicode" == sAttributeName)
-			{
-				const std::wstring wsUnicode{oReader.GetText()};
+	{}
 
-				if (!wsUnicode.empty())
-					m_wchUnicode = wsUnicode[0];
-			}
-			else if ("horiz-adv-x" == sAttributeName)
-				m_oHorizAdvX.SetValue(oReader.GetText());
+	void CGlyph::SetAttribute(const std::string& sName, CSvgReader& oReader)
+	{
+		if ("unicode" == sName)
+		{
+			const std::wstring wsUnicode{oReader.GetText()};
+
+			if (!wsUnicode.empty())
+				m_wchUnicode = wsUnicode[0];
 		}
-		END_READ_ATTRIBUTES(oReader)
+		else if ("horiz-adv-x" == sName)
+			m_oHorizAdvX.SetValue(oReader.GetText());
+		else
+			CPath::SetAttribute(sName, oReader);
 	}
 
 	wchar_t CGlyph::GetUnicode() const
@@ -28,10 +29,10 @@ namespace SVG
 	CFontFace::CFontFace(CSvgReader& oReader)
 	{}
 
-	CFont::CFont(CSvgReader& oReader)
+	CFont::CFont(CSvgReader& oReader, CSvgFile* pFile)
 		: CAppliedObject(oReader), m_pMissingGlyph(NULL)
 	{
-		ParseGlyphs(oReader);
+		ParseGlyphs(oReader, pFile);
 	}
 
 	CFont::~CFont()
@@ -95,7 +96,7 @@ namespace SVG
 		{ \
 			oMatrix.Scale(1. / dGlyphScale, -1. / dGlyphScale); \
 			pRenderer->SetTransform(oMatrix.sx(), oMatrix.shy(), oMatrix.shx(), oMatrix.sy(), oMatrix.tx(), oMatrix.ty()); \
-		} \
+		}
 
 		for (wchar_t wchGlyph : wsText)
 		{
@@ -128,13 +129,13 @@ namespace SVG
 		return true;
 	}
 
-	void CFont::ParseGlyphs(CSvgReader& oReader)
+	void CFont::ParseGlyphs(CSvgReader& oReader, CSvgFile* pFile)
 	{
 		WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 		{
 			if ("glyph" == sNodeName)
 			{
-				CGlyph *pGlyph = new CGlyph(oReader);
+				CGlyph *pGlyph = CObject::Create<CGlyph>(oReader, pFile, pFile);
 
 				if (NULL == pGlyph)
 					continue;

DesktopEditor/raster/Metafile/svg/SvgObjects/CFont.h

@@ -8,7 +8,9 @@ namespace SVG
 	class CGlyph : public CPath
 	{
 	public:
-		CGlyph(CSvgReader& oReader);
+		CGlyph(CSvgReader& oReader, CSvgFile* pFile = nullptr);
+
+		void SetAttribute(const std::string& sName, CSvgReader& oReader) override;
 
 		wchar_t GetUnicode() const;
 	private:
@@ -37,7 +39,7 @@ namespace SVG
 	class CFont : public CAppliedObject
 	{
 		friend class CObject;
-		CFont(CSvgReader& oReader);
+		CFont(CSvgReader& oReader, CSvgFile* pFile = nullptr);
 	public:
 		~CFont();
 
@@ -48,7 +50,7 @@ namespace SVG
 		bool Apply(IRenderer* pRenderer, const CSvgFile *pFile, const TBounds &oObjectBounds) override;
 		bool Draw(const std::wstring& wsText, const double& dX, const double& dY, const double& dFontHeight, IRenderer* pRenderer, const CSvgFile *pFile, CommandeMode oMode = CommandeModeDraw, const TSvgStyles* pStyles = NULL, const CRenderedObject* pContexObject = NULL) const;
 	private:
-		void ParseGlyphs(CSvgReader& oReader);
+		void ParseGlyphs(CSvgReader& oReader, CSvgFile* pFile = nullptr);
 
 		TFontArguments m_oArguments;
 

DesktopEditor/raster/Metafile/svg/SvgObjects/CGradient.cpp

@@ -9,7 +9,7 @@ namespace SVG
 
 	ObjectType CStopElement::GetType() const
 	{
-		return AppliedObject;
+		return DataObject;
 	}
 
 	SvgDigit CStopElement::GetOffset() const
@@ -62,16 +62,7 @@ namespace SVG
 			return;
 
 		WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "stop")
-		{
-			CStopElement *pStopElement = new CStopElement(oReader);
-
-			if (NULL == pStopElement)
-				continue;
-
-			pSvgFile->GetSvgCalculator()->SetData(pStopElement);
-
-			AddObject(pStopElement);
-		}
+			AddObject(CObject::Create<CStopElement>(oReader, pSvgFile));
 		END_WHILE
 	}
 

DesktopEditor/raster/Metafile/svg/SvgObjects/CMarker.cpp

@@ -8,8 +8,8 @@ namespace SVG
 		: CObject(oReader), m_enUnits{EMarkerUnits::StrokeWidth}, m_enOrient{EMarkerOrient::Angle},
 	      m_dAngle(0.), m_oBounds{0., 0., 0., 0.}
 	{
-		m_oWindow.m_oWidth.SetValue(3);
-		m_oWindow.m_oHeight.SetValue(3);
+		m_oWindow.m_oWidth.SetValue(3, NSCSS::Pixel);
+		m_oWindow.m_oHeight.SetValue(3, NSCSS::Pixel);
 	}
 
 	ObjectType CMarker::GetType() const

DesktopEditor/raster/Metafile/svg/SvgObjects/CObjectBase.cpp

@@ -42,6 +42,18 @@ namespace SVG
 		: m_oXmlNode(oObject.m_oXmlNode), m_oTransformation(oObject.m_oTransformation)
 	{}
 
+	void CObject::Mark()
+	{
+		this->AddRef();
+	}
+
+	bool CObject::Marked() const
+	{
+		//Так как по логике кода объект может храниться только в одном контейнере и в списке маркированных элементов,
+		//то хватит и такой проверки
+		return 1 != m_lRef;
+	}
+
 	void CObject::SetAttribute(const std::string& sName, CSvgReader& oReader)
 	{
 		if ("class" == sName)
@@ -141,7 +153,7 @@ namespace SVG
 
 	bool CObject::ApplyClip(IRenderer *pRenderer, const TClip *pClip, const CSvgFile *pFile, const TBounds &oBounds) const
 	{
-		if (NULL == pRenderer || NULL == pClip || NULL == pFile || pClip->m_oHref.Empty() || NSCSS::NSProperties::ColorType::ColorUrl != pClip->m_oHref.GetType())
+		if (NULL == pRenderer || NULL == pClip || NULL == pFile || pClip->m_oHref.Empty() || NSCSS::NSProperties::EColorType::ColorUrl != pClip->m_oHref.GetType())
 			return false;
 
 		if (pClip->m_oRule == L"evenodd")
@@ -157,7 +169,7 @@ namespace SVG
 
 	bool CObject::ApplyMask(IRenderer *pRenderer, const NSCSS::NSProperties::CColor *pMask, const CSvgFile *pFile, const TBounds &oBounds) const
 	{
-		if (NULL == pRenderer || NULL == pMask || NULL == pFile || NSCSS::NSProperties::ColorType::ColorUrl != pMask->GetType())
+		if (NULL == pRenderer || NULL == pMask || NULL == pFile || NSCSS::NSProperties::EColorType::ColorUrl != pMask->GetType())
 			return false;
 
 		return ApplyDef(pRenderer, pFile, pMask->ToWString(), oBounds);
@@ -346,7 +358,7 @@ namespace SVG
 
 	bool CRenderedObject::ApplyStroke(IRenderer *pRenderer, const TStroke *pStroke, bool bUseDefault, const CRenderedObject* pContextObject) const
 	{
-		if (NULL == pRenderer || NULL == pStroke || NSCSS::NSProperties::ColorType::ColorNone == pStroke->m_oColor.GetType() || (!bUseDefault && ((pStroke->m_oWidth.Empty() || pStroke->m_oWidth.Zero()) && pStroke->m_oColor.Empty())))
+		if (NULL == pRenderer || NULL == pStroke || pStroke->m_oColor.None() || (!bUseDefault && ((pStroke->m_oWidth.Empty() || pStroke->m_oWidth.Zero()) && pStroke->m_oColor.Empty())))
 		{
 			pRenderer->put_PenSize(0);
 			return false;
@@ -357,12 +369,12 @@ namespace SVG
 		if (Equals(0., dStrokeWidth))
 			dStrokeWidth = 1.;
 
-		if (NSCSS::NSProperties::ColorType::ColorContextFill == pStroke->m_oColor.GetType() && NULL != pContextObject)
+		if (NSCSS::NSProperties::EColorType::ColorContextFill == pStroke->m_oColor.GetType() && NULL != pContextObject)
 			pRenderer->put_PenColor(pContextObject->m_oStyles.m_oFill.ToInt());
-		else if (NSCSS::NSProperties::ColorType::ColorContextStroke == pStroke->m_oColor.GetType() && NULL != pContextObject)
+		else if (NSCSS::NSProperties::EColorType::ColorContextStroke == pStroke->m_oColor.GetType() && NULL != pContextObject)
 			pRenderer->put_PenColor(pContextObject->m_oStyles.m_oStroke.m_oColor.ToInt());
 		else
-			pRenderer->put_PenColor((pStroke->m_oColor.Empty() || NSCSS::NSProperties::ColorType::ColorNone == pStroke->m_oColor.GetType()) ? 0 : pStroke->m_oColor.ToInt());
+			pRenderer->put_PenColor((pStroke->m_oColor.Empty() || NSCSS::NSProperties::EColorType::ColorNone == pStroke->m_oColor.GetType()) ? 0 : pStroke->m_oColor.ToInt());
 
 		pRenderer->put_PenSize(dStrokeWidth);
 		pRenderer->put_PenAlpha(255. * pStroke->m_oColor.GetOpacity());
@@ -389,18 +401,18 @@ namespace SVG
 
 	bool CRenderedObject::ApplyFill(IRenderer *pRenderer, const NSCSS::NSProperties::CColor *pFill, const CSvgFile *pFile, bool bUseDefault, const CRenderedObject* pContextObject) const
 	{
-		if (NULL == pRenderer || NULL == pFill || NSCSS::NSProperties::ColorType::ColorNone == pFill->GetType() || (!bUseDefault && pFill->Empty()))
+		if (NULL == pRenderer || NULL == pFill || pFill->None() || (!bUseDefault && pFill->Empty()))
 		{
 			pRenderer->put_BrushType(c_BrushTypeNoFill);
 			return false;
 		}
-		else if (NSCSS::NSProperties::ColorType::ColorHEX == pFill->GetType() ||
-				 NSCSS::NSProperties::ColorType::ColorRGB == pFill->GetType())
+		else if (NSCSS::NSProperties::EColorType::ColorHEX == pFill->GetType() ||
+				 NSCSS::NSProperties::EColorType::ColorRGB == pFill->GetType())
 		{
 			pRenderer->put_BrushColor1((pFill->Empty() && bUseDefault) ? 0 : pFill->ToInt());
 			pRenderer->put_BrushType(c_BrushTypeSolid);
 		}
-		else if (NSCSS::NSProperties::ColorType::ColorUrl == pFill->GetType())
+		else if (NSCSS::NSProperties::EColorType::ColorUrl == pFill->GetType())
 		{
 			if (!ApplyDef(pRenderer, pFile, pFill->ToWString(), GetBounds()))
 			{
@@ -413,10 +425,16 @@ namespace SVG
 					return false;
 			}
 		}
-		else if (NSCSS::NSProperties::ColorType::ColorContextFill == pFill->GetType() && NULL != pContextObject)
-			pRenderer->put_BrushColor1(pContextObject->m_oStyles.m_oFill.ToInt());
-		else if (NSCSS::NSProperties::ColorType::ColorContextStroke == pFill->GetType() && NULL != pContextObject)
-			pRenderer->put_BrushColor1(pContextObject->m_oStyles.m_oStroke.m_oColor.ToInt());
+		else if (NSCSS::NSProperties::EColorType::ColorContextFill == pFill->GetType() && NULL != pContextObject)
+		{
+			if (!ApplyFill(pRenderer, &pContextObject->m_oStyles.m_oFill, pFile, bUseDefault, pContextObject))
+				return false;
+		}
+		else if (NSCSS::NSProperties::EColorType::ColorContextStroke == pFill->GetType() && NULL != pContextObject)
+		{
+			if (!ApplyFill(pRenderer, &pContextObject->m_oStyles.m_oStroke.m_oColor, pFile, bUseDefault, pContextObject))
+				return false;
+		}
 		else if (bUseDefault)
 		{
 			pRenderer->put_BrushColor1(0);

DesktopEditor/raster/Metafile/svg/SvgObjects/CObjectBase.h

@@ -34,7 +34,8 @@ namespace SVG
 	enum ObjectType
 	{
 		RendererObject,
-		AppliedObject
+		AppliedObject,
+		DataObject
 	};
 
 	class CObject : public IGrObject
@@ -48,6 +49,9 @@ namespace SVG
 
 		virtual ObjectType GetType() const = 0;
 
+		void Mark();
+		bool Marked() const;
+
 		virtual void SetAttribute(const std::string& sName, CSvgReader& oReader);
 
 		void SetData(const std::wstring wsStyles, unsigned short ushLevel, bool bHardMode = false);
@@ -92,7 +96,8 @@ namespace SVG
 		if (NULL == pSvgFile)
 			return pObject;
 
-		if (!pSvgFile->MarkObject(pObject) && AppliedObject == pObject->GetType())
+		if (DataObject != pObject->GetType() &&
+		    (!pSvgFile->MarkObject(pObject) && AppliedObject == pObject->GetType()))
 		{
 			delete pObject;
 			return NULL;

DesktopEditor/raster/Metafile/svg/SvgObjects/CPath.cpp

@@ -566,7 +566,7 @@ namespace SVG
 
 		#define CALCULATE_ANGLE(firstPoint, secondPoint) std::atan2(secondPoint.dY - firstPoint.dY, secondPoint.dX - firstPoint.dX) * 180. / M_PI
 
-		if (!m_oMarkers.m_oStart.Empty() && NSCSS::NSProperties::ColorType::ColorUrl == m_oMarkers.m_oStart.GetType())
+		if (!m_oMarkers.m_oStart.Empty() && NSCSS::NSProperties::EColorType::ColorUrl == m_oMarkers.m_oStart.GetType())
 		{
 			CMarker *pStartMarker = dynamic_cast<CMarker*>(pFile->GetMarkedObject(m_oMarkers.m_oStart.ToWString()));
 
@@ -610,7 +610,7 @@ namespace SVG
 			}
 		}
 
-		if (!m_oMarkers.m_oMid.Empty() && NSCSS::NSProperties::ColorType::ColorUrl == m_oMarkers.m_oMid.GetType())
+		if (!m_oMarkers.m_oMid.Empty() && NSCSS::NSProperties::EColorType::ColorUrl == m_oMarkers.m_oMid.GetType())
 		{
 			CMarker *pMidMarker = dynamic_cast<CMarker*>(pFile->GetMarkedObject(m_oMarkers.m_oMid.ToWString()));
 
@@ -638,7 +638,7 @@ namespace SVG
 			}
 		}
 
-		if (!m_oMarkers.m_oEnd.Empty() && NSCSS::NSProperties::ColorType::ColorUrl == m_oMarkers.m_oEnd.GetType())
+		if (!m_oMarkers.m_oEnd.Empty() && NSCSS::NSProperties::EColorType::ColorUrl == m_oMarkers.m_oEnd.GetType())
 		{
 			CMarker *pEndMarker = dynamic_cast<CMarker*>(pFile->GetMarkedObject(m_oMarkers.m_oEnd.ToWString()));
 

DesktopEditor/raster/Metafile/svg/SvgObjects/CStyle.cpp

@@ -32,7 +32,7 @@ namespace SVG
 
 		const std::vector<NSCSS::CNode> arSelectors = pSvgObject->GetFullPath();
 
-		std::vector<std::wstring> arNodes = m_pInternal->CalculateAllNodes(arSelectors);
+		std::vector<std::wstring> arNodes = m_pInternal->CalculateAllNodes(arSelectors, 0, arSelectors.size());
 		std::vector<std::wstring> arPrevNodes;
 
 		for (size_t i = 0; i < arSelectors.size(); ++i)

DesktopEditor/raster/Metafile/svg/SvgObjects/CText.cpp

@@ -9,6 +9,8 @@
 
 #include "../../../../Common/3dParty/html/css/src/StaticFunctions.h"
 
+#include <cctype>
+
 #ifndef MININT8
 #define MAXUINT8    ((unsigned char)~((unsigned char)0))
 #define MAXINT8     ((char)(MAXUINT8 >> 1))
@@ -108,6 +110,9 @@ namespace SVG
 		if (mAttributes.end() != mAttributes.find(L"text-decoration"))
 			m_oText.SetDecoration(mAttributes.at(L"text-decoration"), ushLevel, bHardMode);
 
+		if (mAttributes.end() != mAttributes.find(L"baseline-shift"))
+			m_oText.SetBaselineShift(mAttributes.at(L"baseline-shift"), ushLevel, bHardMode);
+
 		//POSITION
 		if (mAttributes.end() != mAttributes.find(L"rotate"))
 		{
@@ -136,7 +141,7 @@ namespace SVG
 					const char* pCheckValue = pValue;
 					while ('\0' != *pCheckValue)
 					{
-						if (0x32 >= *pCheckValue++)
+						if (std::isprint(static_cast<unsigned char>(*pCheckValue++)))
 						{
 							bFoundedSymbol = true;
 							break;
@@ -161,9 +166,9 @@ namespace SVG
 			else if (eNodeType == XmlUtils::XmlNodeType_Element && "tspan" == oReader.GetName())
 			{
 				const TBounds oBounds{GetBounds()};
-				const Point oPoint{oBounds.m_dRight, oBounds.m_dTop};
+				const Point oPoint{oBounds.m_dRight, oBounds.m_dBottom};
 
-				AddObject(CRenderedObject::Create<CTSpan>(oReader, pSvgFile, this, m_pFontManager, oPoint));
+				AddObject(CObject::Create<CTSpan>(oReader, pSvgFile, this, m_pFontManager, oPoint));
 			}
 		}
 	}
@@ -185,8 +190,14 @@ namespace SVG
 		{
 			if (!m_wsText.empty())
 			{
-				ApplyFont(pRenderer, dX, dY);
+				Aggplus::CMatrix oCurrentMatrix;
+				ApplyFont(pRenderer, dX, dY, oCurrentMatrix);
+
 				pRenderer->CommandDrawText(m_wsText, dX, dY, 0, 0);
+
+				pRenderer->SetTransform(oCurrentMatrix.sx(),  oCurrentMatrix.shy(),
+				                        oCurrentMatrix.shx(), oCurrentMatrix.sy(),
+				                        oCurrentMatrix.tx(),  oCurrentMatrix.ty());
 			}
 		}
 
@@ -228,12 +239,32 @@ namespace SVG
 			nTypePath += c_nWindingFillMode;
 	}
 
-	void CTSpan::ApplyFont(IRenderer* pRenderer, double& dX, double& dY) const
+	void CTSpan::ApplyFont(IRenderer* pRenderer, double& dX, double& dY, Aggplus::CMatrix& oOldMatrix) const
 	{
 		std::wstring wsFontFamily = DefaultFontFamily;
 		double dFontSize = ((!m_oFont.GetSize().Empty()) ? m_oFont.GetSize().ToDouble(NSCSS::Pixel) : DEFAULT_FONT_SIZE) * 72. / 25.4;
 
-		Normalize(pRenderer, dX, dY, dFontSize);
+		double dScaleX = 1., dScaleY = 1.;
+
+		NormalizeFontSize(dFontSize, dScaleX, dScaleY);
+
+		if (!Equals(1., dScaleX) || !Equals(1., dScaleY))
+		{
+			dX /= dScaleX;
+			dY /= dScaleY;
+
+			double dM11, dM12, dM21, dM22, dDx, dDy;
+
+			pRenderer->GetTransform(&dM11, &dM12, &dM21, &dM22, &dDx, &dDy);
+
+			oOldMatrix.SetElements(dM11, dM12, dM21, dM22, dDx, dDy);
+
+			Aggplus::CMatrix oMatrix(dM11, dM12, dM21, dM22, dDx, dDy);
+
+			oMatrix.Scale(dScaleX, dScaleY);
+
+			pRenderer->SetTransform(oMatrix.sx(), oMatrix.shy(), oMatrix.shx(), oMatrix.sy(), oMatrix.tx(), oMatrix.ty());
+		}
 
 		if (!m_oFont.GetFamily().Empty())
 		{
@@ -263,12 +294,12 @@ namespace SVG
 			m_pFontManager->LoadFontByName(wsFontFamily, dFontSize, nStyle, 72., 72.);
 			m_pFontManager->SetCharSpacing(0);
 
-			double dKoef     = 25.4 / 72.;
+			const double dKoef = 25.4 / 72.;
 
 			NSFonts::IFontFile* pFontFile = m_pFontManager->GetFile();
 
 			if (pFontFile)
-				dFHeight  *= pFontFile->GetHeight() / pFontFile->Units_Per_Em() * dKoef;
+				dFHeight *= pFontFile->GetHeight() / pFontFile->Units_Per_Em() * dKoef;
 
 			m_pFontManager->LoadString1(m_wsText, 0, 0);
 			TBBox oBox = m_pFontManager->MeasureString2();
@@ -291,6 +322,45 @@ namespace SVG
 		else if (L"center" == m_oText.GetAlign().ToWString())
 			dX += -fW / 2;
 
+		if (NSCSS::NSProperties::EBaselineShift::Baseline != m_oText.GetBaselineShiftType())
+		{
+			switch(m_oText.GetBaselineShiftType())
+			{
+				case NSCSS::NSProperties::Sub:
+				{
+					dY += dFHeight / 2.;
+					break;
+				}
+				case NSCSS::NSProperties::Super:
+				{
+					double dParentHeight{dFHeight};
+
+					if (nullptr != m_pParent)
+						dParentHeight = ((CTSpan*)m_pParent)->GetFontHeight() / dScaleY;
+
+					dY -= dParentHeight - dFHeight / 2.;
+					break;
+				}
+				case NSCSS::NSProperties::Percentage:
+				{
+					double dParentHeight{dFHeight};
+
+					if (nullptr != m_pParent)
+						dParentHeight = ((CTSpan*)m_pParent)->GetFontHeight() / dScaleY;
+
+					dY -= dParentHeight * (m_oText.GetBaselineShiftValue() / 100.);
+					break;
+				}
+				case NSCSS::NSProperties::Length:
+				{
+					dY -= m_oText.GetBaselineShiftValue() / dScaleY;
+					break;
+				}
+				default:
+					break;
+			}
+		}
+
 		if (m_oText.Underline() || m_oText.LineThrough() || m_oText.Overline())
 		{
 			pRenderer->put_PenSize((double)fUndSize);
@@ -327,7 +397,7 @@ namespace SVG
 		pRenderer->put_FontStyle(nStyle);
 		pRenderer->put_BrushType(c_BrushTypeSolid);
 		pRenderer->put_BrushColor1(m_oStyles.m_oFill.ToInt());
-		pRenderer->put_BrushAlpha1(255);
+		pRenderer->put_BrushAlpha1(255 * m_oStyles.m_oFill.GetOpacity());
 	}
 
 	void CTSpan::UpdateFontSize()
@@ -338,7 +408,7 @@ namespace SVG
 
 			if (NULL != pParentTSpan)
 			{
-				m_oFont.UpdateSize((!pParentTSpan->m_oFont.GetSize().Empty()) ? pParentTSpan->m_oFont.GetSize().ToDouble(NSCSS::Pixel) : DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE);
+				m_oFont.UpdateSize((!pParentTSpan->m_oFont.GetSize().Empty()) ? pParentTSpan->m_oFont.GetSize().ToDouble(NSCSS::Point) : DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE);
 				return;
 			}
 		}
@@ -381,7 +451,7 @@ namespace SVG
 		oBounds.m_dRight  = oBounds.m_dLeft + GetWidth();
 
 		oBounds.m_dBottom = m_oY.ToDouble(NSCSS::Pixel);
-		oBounds.m_dTop    = oBounds.m_dBottom + ((!m_oFont.GetSize().Empty()) ? m_oFont.GetSize().ToDouble(NSCSS::Pixel) : DEFAULT_FONT_SIZE);
+		oBounds.m_dTop    = oBounds.m_dBottom - ((!m_oFont.GetSize().Empty()) ? m_oFont.GetSize().ToDouble(NSCSS::Pixel) : DEFAULT_FONT_SIZE);
 
 		if (nullptr != pTransform)
 		{
@@ -476,54 +546,33 @@ namespace SVG
 		dY = m_oY.ToDouble(NSCSS::Pixel, oBounds.m_dBottom - oBounds.m_dTop);
 	}
 
-	void CTSpan::Normalize(IRenderer *pRenderer, double &dX, double &dY, double &dFontHeight) const
+	void CTSpan::NormalizeFontSize(double& dFontHeight, double& dScaleX, double& dScaleY) const
 	{
-		if (NULL == pRenderer)
-			return;
-
 		Aggplus::CMatrix oCurrentMatrix(m_oTransformation.m_oTransform.GetMatrix().GetFinalValue());
 
-		double dXScale = 1., dYScale = 1.;
-
 		const double dModuleM11 = std::abs(oCurrentMatrix.sx());
 		const double dModuleM22 = std::abs(oCurrentMatrix.sy());
 
 		if (!ISZERO(dModuleM11) && (dModuleM11 < MIN_SCALE || dModuleM11 > MAX_SCALE))
-			dXScale /= dModuleM11;
+			dScaleX /= dModuleM11;
 
 		if (!ISZERO(dModuleM22) && (dModuleM22 < MIN_SCALE || dModuleM22 > MAX_SCALE))
-			dYScale /= dModuleM22;
+			dScaleY /= dModuleM22;
 
-		dFontHeight *= dYScale;
+		dFontHeight *= dScaleY;
 
 		if (!Equals(0., dFontHeight) && dFontHeight < MIN_FONT_SIZE)
 		{
-			dXScale *= MIN_FONT_SIZE / dFontHeight;
-			dYScale *= MIN_FONT_SIZE / dFontHeight;
+			dScaleX *= MIN_FONT_SIZE / dFontHeight;
+			dScaleY *= MIN_FONT_SIZE / dFontHeight;
 			dFontHeight = MIN_FONT_SIZE;
 		}
 		else if (!Equals(0., dFontHeight) && dFontHeight > MAX_FONT_SIZE)
 		{
-			dXScale *= dFontHeight / MAX_FONT_SIZE;
-			dYScale *= dFontHeight / MAX_FONT_SIZE;
+			dScaleX *= dFontHeight / MAX_FONT_SIZE;
+			dScaleY *= dFontHeight / MAX_FONT_SIZE;
 			dFontHeight = MAX_FONT_SIZE;
 		}
-
-		if (Equals(1., dXScale) && Equals(1., dYScale))
-			return;
-
-		dX /= dXScale;
-		dY /= dYScale;
-
-		double dM11, dM12, dM21, dM22, dDx, dDy;
-
-		pRenderer->GetTransform(&dM11, &dM12, &dM21, &dM22, &dDx, &dDy);
-
-		Aggplus::CMatrix oMatrix(dM11, dM12, dM21, dM22, dDx, dDy);
-
-		oMatrix.Scale(dXScale, dYScale);
-
-		pRenderer->SetTransform(oMatrix.sx(), oMatrix.shy(), oMatrix.shx(), oMatrix.sy(), oMatrix.tx(), oMatrix.ty());
 	}
 
 	void CTSpan::SetPosition(const Point &oPosition)
@@ -559,6 +608,40 @@ namespace SVG
 
 	}
 
+	double CTSpan::GetFontHeight() const
+	{
+
+		if (NULL == m_pFontManager)
+			return ((!m_oFont.GetSize().Empty()) ? m_oFont.GetSize().ToDouble(NSCSS::Pixel) : DEFAULT_FONT_SIZE) * 72. / 25.4;
+
+		std::wstring wsFontFamily = DefaultFontFamily;
+		double dFontSize = ((!m_oFont.GetSize().Empty()) ? m_oFont.GetSize().ToDouble(NSCSS::Pixel) : DEFAULT_FONT_SIZE) * 72. / 25.4;
+
+		if (!m_oFont.GetFamily().Empty())
+		{
+			wsFontFamily = m_oFont.GetFamily().ToWString();
+			CorrectFontFamily(wsFontFamily);
+		}
+
+		int nStyle = 0;
+
+		if (m_oFont.GetWeight().ToWString() == L"bold")
+			nStyle |= 0x01;
+		if (m_oFont.GetStyle() .ToWString() == L"italic")
+			nStyle |= 0x02;
+		if (m_oText.Underline())
+			nStyle |= (1 << 2);
+
+		// Вычиления размеров текста
+		m_pFontManager->LoadFontByName(wsFontFamily, dFontSize, nStyle, 72., 72.);
+		m_pFontManager->SetCharSpacing(0);
+
+		m_pFontManager->LoadString1(m_wsText, 0, 0);
+		TBBox oBox = m_pFontManager->MeasureString2();
+
+		return (double)(25.4f / 72.f * (oBox.fMaxY - oBox.fMinY));
+	}
+
 	std::vector<CTSpan> CTSpan::Split() const
 	{
 		std::vector<CTSpan> arGlyphs;

DesktopEditor/raster/Metafile/svg/SvgObjects/CText.h

@@ -32,7 +32,7 @@ namespace SVG
 		void InheritStyles(const CTSpan* pTSpan);
 	private:
 		void ApplyStyle(IRenderer* pRenderer, const TSvgStyles* pStyles, const CSvgFile* pFile, int& nTypePath, const CRenderedObject* pContexObject = NULL) const override;
-		void ApplyFont(IRenderer* pRenderer, double& dX, double& dY) const;
+		void ApplyFont(IRenderer* pRenderer, double& dX, double& dY, Aggplus::CMatrix& oOldMatrix) const;
 
 		void UpdateFontSize();
 		bool UseExternalFont(const CSvgFile* pFile, double dX, double dY, IRenderer* pRenderer, CommandeMode oMode = CommandeModeDraw, const TSvgStyles* pOtherStyles = NULL, const CRenderedObject* pContexObject = NULL) const;
@@ -44,11 +44,13 @@ namespace SVG
 
 		void CalculatePosition(double& dX, double& dY) const;
 
-		void Normalize(IRenderer* pRenderer, double& dX, double& dY, double& dFontHeight) const;
+		void NormalizeFontSize(double& dFontHeight, double& dScaleX, double& dScaleY) const;
 		void SetPosition(const Point& oPosition);
 
 		void SetPositionFromParent(CRenderedObject* pParent);
 
+		double GetFontHeight() const;
+
 		std::vector<CTSpan> Split() const;
 
 		NSFonts::IFontManager* m_pFontManager;

DesktopEditor/xmlsec/src/src/Certificate_openssl.h

@@ -24,6 +24,7 @@
 #include <openssl/engine.h>
 #include <openssl/evp.h>
 #include <openssl/conf.h>
+#include <openssl/rand.h>
 
 #include <map>
 #include <memory>
@@ -604,6 +605,12 @@ public:
 			evp = EVP_sha512();
 		else if (m_alg == OOXML_HASH_ALG_ECDSA_384)
 			evp = EVP_sha384();
+		else if (m_alg == OOXML_HASH_ALG_SHA256)
+			evp = EVP_sha256();
+		else if (m_alg == OOXML_HASH_ALG_SHA384)
+			evp = EVP_sha384();
+		else if (m_alg == OOXML_HASH_ALG_SHA512)
+			evp = EVP_sha512();
 
 		if (!PKCS7_sign_add_signer(pkcs7, m_cert, m_key, evp, 0))
 		{

DjVuFile/DjVu.cpp

@@ -42,7 +42,7 @@ CDjVuFile::~CDjVuFile()
 		delete m_pImplementation;
 }
 bool CDjVuFile::LoadFromFile(const std::wstring& file, const std::wstring& options,
-                                const std::wstring& owner_password, const std::wstring& user_password)
+							 const wchar_t* owner_password, const wchar_t* user_password)
 {
     if (m_pImplementation)
         return m_pImplementation->LoadFromFile(file, options);
@@ -50,7 +50,7 @@ bool CDjVuFile::LoadFromFile(const std::wstring& file, const std::wstring& optio
     return false;
 }
 bool CDjVuFile::LoadFromMemory(BYTE* data, DWORD length, const std::wstring& options,
-                               const std::wstring& owner_password, const std::wstring& user_password)
+							   const wchar_t* owner_password, const wchar_t* user_password)
 {
     if (m_pImplementation)
         return m_pImplementation->LoadFromMemory(data, length, options);

DjVuFile/DjVu.h

@@ -55,9 +55,9 @@ public:
     virtual ~CDjVuFile();
 
     virtual bool LoadFromFile(const std::wstring& file, const std::wstring& options = L"",
-                                    const std::wstring& owner_password = L"", const std::wstring& user_password = L"");
+							  const wchar_t* owner_password = NULL, const wchar_t* user_password = NULL);
     virtual bool LoadFromMemory(BYTE* data, DWORD length, const std::wstring& options = L"",
-                                const std::wstring& owner_password = L"", const std::wstring& user_password = L"");
+								const wchar_t* owner_password = NULL, const wchar_t* user_password = NULL);
 
     virtual void Close();
     virtual NSFonts::IApplicationFonts* GetFonts();

DocxRenderer/DocxRenderer.cpp

@@ -92,6 +92,7 @@ int CDocxRenderer::Convert(IOfficeDrawingFile* pFile, const std::wstring& sDst,
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bUseDefaultFont = false;
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bWriteStyleRaw = false;
 	m_pInternal->m_bIsSupportShapeCommands = false;
+	m_pInternal->m_oDocument.m_bIsRecord = true;
 
 	if (bIsOutCompress)
 		m_pInternal->m_oDocument.m_strTempDirectory = NSDirectory::CreateDirectoryWithUniqueName(m_pInternal->m_sTempDirectory);
@@ -130,6 +131,7 @@ std::vector<std::wstring> CDocxRenderer::ScanPage(IOfficeDrawingFile* pFile, siz
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bUseDefaultFont = true;
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bWriteStyleRaw = true;
 	m_pInternal->m_bIsSupportShapeCommands = false;
+	m_pInternal->m_oDocument.m_bIsRecord = false;
 
 	DrawPage(pFile, nPage);
 
@@ -144,7 +146,9 @@ std::vector<std::wstring> CDocxRenderer::ScanPagePptx(IOfficeDrawingFile* pFile,
 	m_pInternal->m_oDocument.Init(false);
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bUseDefaultFont = true;
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bWriteStyleRaw = true;
+	m_pInternal->m_oDocument.m_oCurrentPage.m_bCollectMetaInfo = true;
 	m_pInternal->m_bIsSupportShapeCommands = true;
+	m_pInternal->m_oDocument.m_bIsRecord = false;
 
 	m_pInternal->m_eShapeSerializeType = ShapeSerializeType::sstXml;
 	DrawPage(pFile, nPage);
@@ -160,7 +164,11 @@ NSWasm::CData CDocxRenderer::ScanPageBin(IOfficeDrawingFile* pFile, size_t nPage
 	m_pInternal->m_oDocument.Init(false);
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bUseDefaultFont = true;
 	m_pInternal->m_oDocument.m_oCurrentPage.m_bWriteStyleRaw = true;
+	m_pInternal->m_oDocument.m_oCurrentPage.m_bCollectMetaInfo = true;
+	m_pInternal->m_oDocument.m_bIsRecord = false;
 	m_pInternal->m_bIsSupportShapeCommands = true;
+	m_pInternal->m_oDocument.m_oFontStyleManager.Clear();
+	m_pInternal->m_oDocument.m_oFontSelector.ClearCache();
 
 	DrawPage(pFile, nPage);
 
@@ -732,6 +740,10 @@ HRESULT CDocxRenderer::CommandLong(const LONG& lType, const LONG& lCommand)
 
 		return S_OK;
 	}
+	if (c_nFontSubstitution == lType)
+	{
+		m_pInternal->m_oDocument.m_oCurrentPage.m_bFontSubstitution = true;
+	}
 	return S_OK;
 }
 HRESULT CDocxRenderer::CommandDouble(const LONG& lType, const double& dCommand)

DocxRenderer/src/logic/Document.cpp

@@ -322,6 +322,7 @@ namespace NSDocxRenderer
 	HRESULT CDocument::put_FontName(std::wstring sName)
 	{
 		m_oCurrentPage.m_oFont.Name = sName;
+		m_oCurrentPage.m_bFontSubstitution = false;
 		return S_OK;
 	}
 	HRESULT CDocument::get_FontPath(std::wstring* sPath)
@@ -571,8 +572,11 @@ namespace NSDocxRenderer
 			m_oPageBuilder.ClearNoAttack();
 
 			m_oCurrentPage.Analyze();
-			m_oCurrentPage.Record(m_oPageBuilder, m_lPageNum >= m_lNumberPages - 1);
-			m_arXmlString.push_back(NSFile::CUtf8Converter::GetUtf8StringFromUnicode2(m_oPageBuilder.GetBuffer(), (LONG)m_oPageBuilder.GetCurSize()));
+			if (m_bIsRecord)
+			{
+				m_oCurrentPage.Record(m_oPageBuilder, m_lPageNum >= m_lNumberPages - 1);
+				m_arXmlString.push_back(NSFile::CUtf8Converter::GetUtf8StringFromUnicode2(m_oPageBuilder.GetBuffer(), (LONG)m_oPageBuilder.GetCurSize()));
+			}
 
 			if (m_oPageBuilder.GetCurSize() > 100000000/*100Mb*/)
 				m_oPageBuilder.Clear();

DocxRenderer/src/logic/Document.h

@@ -40,6 +40,7 @@ namespace NSDocxRenderer
 		LONG m_lNumberPages{0};
 
 		bool m_bIsDisablePageCommand {false}; // disable commands inside draw function
+		bool m_bIsRecord {true};
 
 		NSStringUtils::CStringBuilder m_oPageBuilder;
 		std::list<std::string> m_arXmlString;

DocxRenderer/src/logic/Page.cpp

@@ -70,6 +70,8 @@ namespace NSDocxRenderer
 		m_oContBuilder.Clear();
 		m_arCompleteObjectsXml.clear();
 		m_arLuminosityShapes.clear();
+
+		m_bFontSubstitution = false;
 	}
 
 	CPage::~CPage()
@@ -193,14 +195,17 @@ namespace NSDocxRenderer
 
 		if (!m_arShapes.empty())
 		{
-			auto& last_shape = m_arShapes.back();
-			if (last_shape->IsEqual(top, bot, left, right) && rotation == last_shape->m_dRotation)
+			auto& last_shape = m_arShapes.back();			
+			if (last_shape->IsEqual(top, bot, left, right) && rotation == last_shape->m_dRotation && lType != m_lLastType && m_lLastType != 0)
 			{
 				set_fill_mode(last_shape);
+				// Reset stroke/fill logic
+				m_lLastType = 0;
 				return;
 			}
 		}
 
+		m_lLastType = lType;
 		auto shape = std::make_shared<CShape>();
 		shape->m_oPen.Size *= transform_det;
 		set_fill_mode(shape);
@@ -268,7 +273,7 @@ namespace NSDocxRenderer
 
 		if (!skip_shape)
 		{
-			shape->m_nOrder = ++m_nShapeOrder;
+			shape->m_nOrder = ++m_nCurrentOrder;
 			m_arShapes.push_back(shape);
 		}
 	}
@@ -327,13 +332,15 @@ namespace NSDocxRenderer
 			m_oManagers.pFontManager->SetStringGid(0);
 			m_oManagers.pFontManager->MeasureStringGids(pUnicodes, nCount, dTextX, dTextY, _x, _y, _w, _h, CFontManager::mtPosition);
 		}
-
 		_h = m_oManagers.pFontManager->GetFontHeight();
-
 		double baseline = dTextY + fBaseLineOffset;
+
 		double top = baseline - _h;
 		double left = dTextX;
-		double right = left + _w;
+		double right = dTextR;
+
+		if (left == right) // XPS
+			right = left + _w;
 
 		// use forced fold option
 		const auto& oParams = m_oManagers.pFontManager->GetFontSelectParams();
@@ -342,7 +349,23 @@ namespace NSDocxRenderer
 			bForcedBold = true;
 
 		m_oManagers.pParagraphStyleManager->UpdateAvgFontSize(m_oFont.Size);
-		m_oContBuilder.AddUnicode(top, baseline, left, right, m_oFont, m_oBrush, m_oManagers.pFontManager, oText, bForcedBold, m_bUseDefaultFont, m_bWriteStyleRaw);
+		m_nCurrentOrder++;
+		m_oContBuilder.AddUnicode(
+		            top,
+		            baseline,
+		            left,
+		            right,
+		            m_oFont,
+		            m_oBrush,
+		            m_oManagers.pFontManager,
+		            oText,
+		            m_nCurrentOrder,
+		            pGids,
+		            bForcedBold,
+		            m_bUseDefaultFont,
+		            m_bWriteStyleRaw,
+		            m_bCollectMetaInfo
+		        );
 	}
 
 	void CPage::Analyze()
@@ -469,8 +492,6 @@ namespace NSDocxRenderer
 		m_arShapes.erase(right, m_arShapes.end());
 
 		std::sort(m_arShapes.begin(), m_arShapes.end(), [] (const shape_ptr_t& s1, const shape_ptr_t& s2) {
-			if (s1->m_bIsBehindDoc && !s2->m_bIsBehindDoc) return true;
-			if (!s1->m_bIsBehindDoc && s2->m_bIsBehindDoc) return false;
 			return s1->m_nOrder < s2->m_nOrder;
 		});
 	}
@@ -627,20 +648,8 @@ namespace NSDocxRenderer
 	{
 		for (auto& line : m_arTextLines)
 			for (auto& cont : line->m_arConts)
-			{
-				if (cont && cont->m_oSelectedSizes.dHeight == 0.0 && cont->m_oSelectedSizes.dWidth == 0.0)
-				{
-					if (m_bUseDefaultFont)
-					{
-						cont->m_oSelectedSizes.dHeight = cont->m_dHeight;
-						cont->m_oSelectedSizes.dWidth = cont->m_dWidth;
-					}
-					else
-					{
-						cont->CalcSelected();
-					}
-				}
-			}
+				if (cont && !m_bUseDefaultFont)
+					cont->CalcSelected();
 	}
 
 	void CPage::AnalyzeShapes()
@@ -753,6 +762,19 @@ namespace NSDocxRenderer
 			if (line && line->m_arConts.empty())
 				line = nullptr;
 
+		for (auto& line : m_arTextLines)
+			if (line)
+			{
+				bool is_remove = true;
+				for(auto& cont : line->m_arConts)
+					if (cont && !cont->IsOnlySpaces())
+						is_remove = false;
+
+				if (is_remove)
+					line = nullptr;
+			}
+
+
 		auto right = MoveNullptr(m_arTextLines.begin(), m_arTextLines.end());
 		m_arTextLines.erase(right, m_arTextLines.end());
 
@@ -821,7 +843,8 @@ namespace NSDocxRenderer
 		// шейпы из буквиц
 		for (auto&& drop_cap : drop_caps)
 		{
-			drop_cap->CalcSelected();
+			if (!m_bUseDefaultFont)
+				drop_cap->CalcSelected();
 
 			auto line = std::make_shared<CTextLine>();
 			line->AddCont(drop_cap);
@@ -1152,11 +1175,17 @@ namespace NSDocxRenderer
 
 						if ((bIf1 && bIf6) || (bIf2 && bIf7) || (bIf4 && bIf8) || (bIf5 && bIf7))
 						{
-							cont->AddSymBack(d_sym->GetText().at(0), 0);
+							if (m_bCollectMetaInfo)
+								cont->AddSymBack(d_sym->GetText().at(0), 0,  d_sym->m_arOriginLefts.at(0), d_sym->m_arGids.at(0));
+							else
+								cont->AddSymBack(d_sym->GetText().at(0), 0, d_sym->m_arOriginLefts.at(0));
 						}
 						else if (bIf3 && bIf7)
 						{
-							cont->AddSymFront(d_sym->GetText().at(0), 0);
+							if (m_bCollectMetaInfo)
+								cont->AddSymFront(d_sym->GetText().at(0), 0,  d_sym->m_arOriginLefts.at(0), d_sym->m_arGids.at(0));
+							else
+								cont->AddSymFront(d_sym->GetText().at(0), 0, d_sym->m_arOriginLefts.at(0));
 						}
 						isBreak = true;
 						break;
@@ -1331,6 +1360,21 @@ namespace NSDocxRenderer
 
 		return IsHorizontalLineTrough(dummy_cont);
 	}
+	bool CPage::IsTextLineBetween(text_line_ptr_t pFirst, text_line_ptr_t pSecond) const noexcept
+	{
+		double left = std::min(pFirst->m_dLeft, pSecond->m_dLeft);
+		double right = std::max(pFirst->m_dRight, pSecond->m_dRight);
+		double top = std::min(pFirst->m_dBotWithMaxDescent, pSecond->m_dBotWithMaxDescent);
+		double bot = std::max(pFirst->m_dTopWithMaxAscent, pSecond->m_dTopWithMaxAscent);
+
+		auto dummy_cont = std::make_shared<CContText>();
+		dummy_cont->m_dLeft = left - c_dGRAPHICS_ERROR_MM;
+		dummy_cont->m_dRight = right + c_dGRAPHICS_ERROR_MM;
+		dummy_cont->m_dTop = top - c_dGRAPHICS_ERROR_MM;
+		dummy_cont->m_dBot = bot + c_dGRAPHICS_ERROR_MM;
+
+		return IsTextLineTrough(dummy_cont);
+	}
 
 	bool CPage::IsVerticalLineTrough(base_item_ptr_t pFirst) const noexcept
 	{
@@ -1339,7 +1383,9 @@ namespace NSDocxRenderer
 		const auto center = pFirst->m_dTop + height / 2;
 
 		for (const auto& line : ver_lines)
-			if (line.pos > pFirst->m_dLeft && line.pos < pFirst->m_dRight && line.min <= center && line.max >= center)
+			if (line.pos - pFirst->m_dLeft > c_dGRAPHICS_ERROR_IN_LINES_MM &&
+			        pFirst->m_dRight - line.pos > c_dGRAPHICS_ERROR_IN_LINES_MM &&
+			        line.min <= center && line.max >= center)
 				return true;
 
 		return false;
@@ -1356,6 +1402,20 @@ namespace NSDocxRenderer
 
 		return false;
 	}
+	bool CPage::IsTextLineTrough(base_item_ptr_t pFirst) const noexcept
+	{
+		const auto width = pFirst->m_dRight - pFirst->m_dLeft;
+		const auto center = pFirst->m_dLeft + width / 2;
+
+		for (const auto& text_line : m_arShapes)
+			if (text_line && text_line->m_eType == CShape::eShapeType::stTextBox && text_line->m_dBot > pFirst->m_dTop &&
+			        text_line->m_dBot < pFirst->m_dBot &&
+			        text_line->m_dLeft <= center &&
+			        text_line->m_dRight >= center)
+				return true;
+
+		return false;
+	}
 
 	void CPage::SplitLines()
 	{
@@ -1425,7 +1485,7 @@ namespace NSDocxRenderer
 
 		for (const auto& line : m_arTextLines)
 		{
-			if (fabs(line->m_dBotWithMaxDescent - curr_bot) < 4 * c_dTHE_SAME_STRING_Y_PRECISION_MM)
+			if (fabs(line->m_dBot - curr_bot) < 4 * c_dTHE_SAME_STRING_Y_PRECISION_MM)
 			{
 				bot_aligned_text_lines.back().push_back(line);
 			}
@@ -1433,7 +1493,7 @@ namespace NSDocxRenderer
 			{
 				bot_aligned_text_lines.push_back({});
 				bot_aligned_text_lines.back().push_back(line);
-				curr_bot = line->m_dBotWithMaxDescent;
+				curr_bot = line->m_dBot;
 			}
 		}
 
@@ -1551,10 +1611,12 @@ namespace NSDocxRenderer
 					curr_line->CalcFirstWordWidth();
 
 					for (auto& cont : prev_line->m_arConts)
-						cont->CalcSelected();
+						if (!m_bUseDefaultFont)
+							cont->CalcSelected();
 
 					for (auto& cont : curr_line->m_arConts)
-						cont->CalcSelected();
+						if (!m_bUseDefaultFont)
+							cont->CalcSelected();
 
 					m_arShapes.push_back(CreateSingleLineShape(prev_line));
 					m_arShapes.push_back(CreateSingleLineShape(curr_line));
@@ -1586,8 +1648,9 @@ namespace NSDocxRenderer
 		// lamda to setup and add paragpraph
 		auto add_paragraph = [this, &max_right, &min_left, &ar_paragraphs] (paragraph_ptr_t& paragraph) {
 
-			paragraph->m_dBot = paragraph->m_arTextLines.back()->m_dBot;
-			paragraph->m_dTop = paragraph->m_arTextLines.front()->m_dTop;
+			std::shared_ptr<CTextLine>& firstLine = paragraph->m_arTextLines.front();
+			paragraph->m_dBot = paragraph->m_arTextLines.back()->m_dBotWithMaxDescent;
+			paragraph->m_dTop = firstLine->m_dTopWithMaxAscent;
 			paragraph->m_dRight = max_right;
 			paragraph->m_dLeft = min_left;
 
@@ -1604,6 +1667,23 @@ namespace NSDocxRenderer
 
 			paragraph->MergeLines();
 
+			// Correct first line position
+			double firstLine_height = firstLine->m_dBotWithMaxDescent - firstLine->m_dTopWithMaxAscent;
+			if (paragraph->m_dLineHeight > firstLine_height)
+			{
+				double offset = paragraph->m_dLineHeight - firstLine_height;
+				paragraph->m_dTop -= offset;
+				paragraph->m_dBot -= offset;
+			}
+			else
+			{
+				double ascent = firstLine->m_dBot - firstLine->m_dTopWithMaxAscent;
+				double newAscent = ascent * paragraph->m_dLineHeight / firstLine_height;
+				double offset = ascent - newAscent;
+				paragraph->m_dTop += offset;
+				paragraph->m_dBot += offset;
+			}
+
 			// setting TextAlignmentType
 			if (paragraph->m_arTextLines.size() > 1)
 			{
@@ -1665,6 +1745,7 @@ namespace NSDocxRenderer
 			min_left = std::min(min_left, curr_line->m_dLeft);
 			max_right = std::max(max_right, curr_line->m_dRight);
 			paragraph->m_arTextLines.push_back(curr_line);
+			paragraph->m_nOrder = std::max(paragraph->m_nOrder, curr_line->m_nOrder);
 		};
 
 		auto build_paragraphs = [this, add_line, add_paragraph] (const std::vector<text_line_ptr_t>& text_lines) {
@@ -1825,6 +1906,19 @@ namespace NSDocxRenderer
 				}
 			}
 
+			// 2 lines in paragraph fix
+			for (size_t index = 0; index < ar_positions.size() - 1; ++index)
+			{
+				auto& line_top = text_lines[index];
+				auto& line_bot = text_lines[index + 1];
+
+				bool is_start = index == 0 || ar_delims[index - 1] == true;
+				bool is_end = index == ar_positions.size() - 1 || ar_delims[index + 1] == true;
+				bool is_diff = fabs(line_top->m_dHeight - line_bot->m_dHeight) > (line_top->m_dHeight + line_bot->m_dHeight) / 4;
+				if (is_start && is_end && is_diff)
+					ar_delims[index] = true;
+			}
+
 			// gap check
 			//
 			// bla-bla-bla
@@ -1887,6 +1981,8 @@ namespace NSDocxRenderer
 			{
 				if (IsHorizontalLineBetween(text_lines[index], text_lines[index + 1]))
 					ar_delims[index] = true;
+				if (IsTextLineBetween(text_lines[index], text_lines[index + 1]))
+					ar_delims[index] = true;
 			}
 
 			// на основе ar_delims разбиваем на параграфы
@@ -2239,6 +2335,7 @@ namespace NSDocxRenderer
 				if (direction == eLineDirection::ldLeft) return crossing->p.x - p.x;
 				if (direction == eLineDirection::ldBot) return p.y - crossing->p.y;
 				if (direction == eLineDirection::ldTop) return crossing->p.y - p.y;
+				return 0;
 			};
 
 			while (diff() > c_dMAX_TABLE_LINE_WIDTH_MM)
@@ -2518,12 +2615,13 @@ namespace NSDocxRenderer
 
 		pParagraph->m_arTextLines.push_back(pLine);
 		pParagraph->m_dLeft = pLine->m_dLeft;
-		pParagraph->m_dTop = pLine->m_dTop;
-		pParagraph->m_dBot = pLine->m_dBot;
+		pParagraph->m_dTop = pLine->m_dTopWithMaxAscent;
+		pParagraph->m_dBot = pLine->m_dBotWithMaxDescent;
 		pParagraph->m_dWidth = pLine->m_dWidth;
-		pParagraph->m_dHeight = pLine->m_dHeight;
+		pParagraph->m_dHeight = pLine->m_dBotWithMaxDescent - pLine->m_dTopWithMaxAscent;
 		pParagraph->m_dRight = pLine->m_dRight;
 		pParagraph->m_dLineHeight = pParagraph->m_dHeight;
+		pParagraph->m_nOrder = pLine->m_nOrder;
 
 		if (pLine->m_pDominantShape)
 		{
@@ -2537,11 +2635,12 @@ namespace NSDocxRenderer
 		pShape->m_eType = CShape::eShapeType::stTextBox;
 
 		pShape->m_dLeft = pParagraph->m_dLeft;
+		pShape->m_dRight = pParagraph->m_dRight * 1.025;
 		pShape->m_dTop = pParagraph->m_dTop;
 		pShape->m_dBot = pParagraph->m_dBot;
-		pShape->m_dWidth = pParagraph->m_dWidth;
+		pShape->m_dWidth = pShape->m_dRight - pShape->m_dLeft;
 		pShape->m_dHeight = pParagraph->m_dHeight;
-		pShape->m_dRight = pParagraph->m_dRight;
+		pShape->m_nOrder = pParagraph->m_nOrder;
 		pShape->m_bIsBehindDoc = false;
 
 		return pShape;
@@ -2552,11 +2651,13 @@ namespace NSDocxRenderer
 		auto pShape = std::make_shared<CShape>();
 
 		pShape->m_dLeft = pParagraph->m_dLeft;
-		pShape->m_dTop = pParagraph->m_dTop;
 		pShape->m_dRight =  pParagraph->m_dRight;
+		if (pParagraph->m_arTextLines.size() == 1) pShape->m_dRight *= 1.025;
+		pShape->m_dTop = pParagraph->m_dTop;
 		pShape->m_dBot = pParagraph->m_dBot;
 		pShape->m_dHeight = pParagraph->m_dHeight;
-		pShape->m_dWidth = pParagraph->m_dWidth;
+		pShape->m_dWidth = pShape->m_dRight - pShape->m_dLeft;
+		pShape->m_nOrder = pParagraph->m_nOrder;
 
 		if (pParagraph->m_bIsNeedFirstLineIndent && pParagraph->m_dFirstLine < 0)
 			pParagraph->m_dLeftBorder = -pParagraph->m_dFirstLine;

DocxRenderer/src/logic/Page.h

@@ -46,8 +46,10 @@ namespace NSDocxRenderer
 		bool m_bIsGradient			   {false};
 		bool m_bUseDefaultFont		   {false};
 		bool m_bWriteStyleRaw		   {false};
+		bool m_bCollectMetaInfo        {false};
 		bool m_bIsBuildTables		   {false};
 		bool m_bIsLuminosityShapesFiled{false};
+		bool m_bFontSubstitution       {false};
 
 		CPage(NSFonts::IApplicationFonts* pAppFonts, const CManagers& oManagers);
 		~CPage();
@@ -192,9 +194,11 @@ namespace NSDocxRenderer
 
 		bool IsVerticalLineBetween(text_line_ptr_t pFirst, text_line_ptr_t pSecond) const noexcept;
 		bool IsHorizontalLineBetween(text_line_ptr_t pFirst, text_line_ptr_t pSecond) const noexcept;
+		bool IsTextLineBetween(text_line_ptr_t pFirst, text_line_ptr_t pSecond) const noexcept;
 
 		bool IsVerticalLineTrough(base_item_ptr_t pFirst) const noexcept;
 		bool IsHorizontalLineTrough(base_item_ptr_t pFirst) const noexcept;
+		bool IsTextLineTrough(base_item_ptr_t pFirst) const noexcept;
 
 		void ToXml(NSStringUtils::CStringBuilder& oWriter) const noexcept;
 		void WriteSectionToFile(bool bLastPage, NSStringUtils::CStringBuilder& oWriter) const noexcept;
@@ -229,6 +233,8 @@ namespace NSDocxRenderer
 		std::vector<shape_ptr_t> m_arLuminosityShapes;
 		std::vector<shape_ptr_t> m_arOneColorGradientShape;
 
-		size_t m_nShapeOrder = 0;
+		long m_lLastType = 0;
+
+		size_t m_nCurrentOrder = 0;
 	};
 }

DocxRenderer/src/logic/elements/BaseItem.cpp

@@ -178,7 +178,10 @@ namespace NSDocxRenderer
 	}
 	bool CBaseItem::IsEqual(double dTop, double dBot, double dLeft, double dRight) const noexcept
 	{
-		return m_dLeft == dLeft && m_dTop == dTop && m_dBot == dBot && m_dRight == dRight;
+		return fabs(m_dLeft - dLeft) < c_dGRAPHICS_ERROR_MM &&
+			   fabs(m_dTop - dTop) < c_dGRAPHICS_ERROR_MM &&
+			   fabs(m_dBot - dBot) < c_dGRAPHICS_ERROR_MM &&
+			   fabs(m_dRight - dRight) < c_dGRAPHICS_ERROR_MM;
 	}
 	bool CBaseItem::operator==(const CBaseItem& other)
 	{

DocxRenderer/src/logic/elements/BaseItem.h

@@ -50,6 +50,8 @@ namespace NSDocxRenderer
 		double m_dHeight {0.0};
 		double m_dWidth  {0.0};
 
+		size_t m_nOrder = 0;
+
 		CBaseItem();
 		CBaseItem(const CBaseItem& other);
 		CBaseItem(CBaseItem&& other);

DocxRenderer/src/logic/elements/ContText.cpp

@@ -73,11 +73,27 @@ namespace NSDocxRenderer
 		m_bPossibleHorSplit = rCont.m_bPossibleHorSplit;
 		m_bWriteStyleRaw = rCont.m_bWriteStyleRaw;
 
+		m_nOriginFontFaceIndex = rCont.m_nOriginFontFaceIndex;
+		m_wsOriginFontName = rCont.m_nOriginFontFaceIndex;
+
 		m_arSymWidths.clear();
 		m_arSymWidths.resize(rCont.m_arSymWidths.size());
 		for (size_t i = 0; i < rCont.m_arSymWidths.size(); ++i)
 			m_arSymWidths[i] = rCont.m_arSymWidths[i];
 
+		m_arGids.clear();
+		m_arGids.resize(rCont.m_arGids.size());
+		for (size_t i = 0; i < rCont.m_arGids.size(); ++i)
+			m_arGids[i] = rCont.m_arGids[i];
+
+		m_arOriginLefts.clear();
+		m_arOriginLefts.resize(rCont.m_arOriginLefts.size());
+		for (size_t i = 0; i < rCont.m_arOriginLefts.size(); ++i)
+			m_arOriginLefts[i] = rCont.m_arOriginLefts[i];
+
+		m_bFontSubstitution = rCont.m_bFontSubstitution;
+		m_dSpacing = rCont.m_dSpacing;
+
 		return *this;
 	}
 
@@ -85,7 +101,6 @@ namespace NSDocxRenderer
 	{
 		if (!m_pFontStyle->wsFontName.empty() && !m_oText.empty())
 		{
-			// нужно перемерять...
 			if (m_oSelectedFont.Path.empty())
 				m_pManager->LoadFontByName(m_oSelectedFont);
 			else
@@ -106,6 +121,7 @@ namespace NSDocxRenderer
 
 			m_oSelectedSizes.dWidth = dBoxWidth;
 			m_oSelectedSizes.dHeight = dBoxHeight;
+			m_dSpacing = (m_dWidth - m_oSelectedSizes.dWidth) / (m_oText.length());
 		}
 	}
 
@@ -128,13 +144,27 @@ namespace NSDocxRenderer
 		cont->m_dWidth = cont->m_dRight - cont->m_dLeft;
 
 		cont->m_arSymWidths.clear();
+		cont->m_arOriginLefts.clear();
+		cont->m_arGids.clear();
 		for (size_t i = index + 1; i < len; ++i)
+		{
 			cont->m_arSymWidths.push_back(m_arSymWidths[i]);
+			cont->m_arOriginLefts.push_back(m_arOriginLefts[i]);
+
+			if (!m_arGids.empty() && cont->m_bCollectMetaInfo)
+				cont->m_arGids.push_back(m_arGids[i]);
+		}
 
 		m_oText = m_oText.substr(0, index + 1);
 		m_dRight = cont->m_dLeft;
 		m_dWidth = m_dRight - m_dLeft;
+
 		m_arSymWidths.resize(index + 1);
+		m_arOriginLefts.resize(index + 1);
+
+		if (!m_arGids.empty())
+			m_arGids.resize(index + 1);
+
 		m_bPossibleHorSplit = false;
 
 		return cont;
@@ -178,34 +208,34 @@ namespace NSDocxRenderer
 			return eVerticalCrossingType::vctCurrentInsideNext;
 
 		else if (this_top < other_top && this_bot > other_bot)
-			return  eVerticalCrossingType::vctCurrentOutsideNext;
+			return eVerticalCrossingType::vctCurrentOutsideNext;
 
-		else if (this_top < other_top && this_bot < other_bot &&
-		         (this_bot >= other_top || fabs(this_bot - other_top) < c_dTHE_SAME_STRING_Y_PRECISION_MM))
-			return  eVerticalCrossingType::vctCurrentAboveNext;
+		else if (this_top < other_top && this_bot < other_bot && this_bot > other_top &&
+		    this_bot - other_top > c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctCurrentAboveNext;
 
-		else if (this_top > other_top && this_bot > other_bot &&
-		         (this_top <= other_bot || fabs(this_top - other_bot) < c_dTHE_SAME_STRING_Y_PRECISION_MM))
-			return  eVerticalCrossingType::vctCurrentBelowNext;
+		else if (this_top > other_top && this_bot > other_bot && this_top < other_bot &&
+		         other_bot - this_top > c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctCurrentBelowNext;
 
 		else if (this_top == other_top && this_bot == other_bot)
 			return  eVerticalCrossingType::vctDublicate;
 
 		else if (fabs(this_top - other_top) < c_dTHE_SAME_STRING_Y_PRECISION_MM &&
 		         fabs(this_bot - other_bot) < c_dTHE_SAME_STRING_Y_PRECISION_MM)
-			return  eVerticalCrossingType::vctTopAndBottomBordersMatch;
+			return eVerticalCrossingType::vctTopAndBottomBordersMatch;
 
 		else if (fabs(this_top - other_top) < c_dTHE_SAME_STRING_Y_PRECISION_MM)
-			return  eVerticalCrossingType::vctTopBorderMatch;
+			return eVerticalCrossingType::vctTopBorderMatch;
 
 		else if (fabs(this_bot - other_bot) < c_dTHE_SAME_STRING_Y_PRECISION_MM)
-			return  eVerticalCrossingType::vctBottomBorderMatch;
+			return eVerticalCrossingType::vctBottomBorderMatch;
 
-		else if (this_bot < other_top)
-			return  eVerticalCrossingType::vctNoCrossingCurrentAboveNext;
+		else if (other_top - this_bot > -c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctNoCrossingCurrentAboveNext;
 
-		else if (this_top > other_bot)
-			return  eVerticalCrossingType::vctNoCrossingCurrentBelowNext;
+		else if (this_top - other_bot > -c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctNoCrossingCurrentBelowNext;
 
 		else
 			return  eVerticalCrossingType::vctUnknown;
@@ -229,18 +259,11 @@ namespace NSDocxRenderer
 
 		LONG lCalculatedSpacing = 0;
 
+		// mm to points * 20
 		if (!m_oText.empty())
-		{
-			double dSpacing = (m_dWidth - m_oSelectedSizes.dWidth) / (m_oText.length());
-			dSpacing *= c_dMMToDx;
+			lCalculatedSpacing = static_cast<LONG>(m_dSpacing * c_dMMToDx);
 
-			//mm to points * 20
-			lCalculatedSpacing = static_cast<LONG>(dSpacing);
-		}
-
-		// принудительно уменьшаем spacing чтобы текстовые линии не выходили за правую границу
 		lCalculatedSpacing -= 1;
-
 		if (lCalculatedSpacing != 0)
 		{
 			oWriter.WriteString(L"<w:spacing w:val=\"");
@@ -367,14 +390,7 @@ namespace NSDocxRenderer
 
 		LONG lCalculatedSpacing = 0;
 		if (!m_oText.empty())
-		{
-			double dSpacing = (m_dWidth - m_oSelectedSizes.dWidth) / (m_oText.length());
-			dSpacing *= c_dMMToPt * 100;
-			lCalculatedSpacing = static_cast<LONG>(dSpacing);
-		}
-
-		// принудительно уменьшаем spacing чтобы текстовые линии не выходили за правую границу
-		lCalculatedSpacing -= 15;
+			lCalculatedSpacing = static_cast<LONG>(m_dSpacing * c_dMMToPt * 100);
 
 		oWriter.WriteString(L" spc=\"");
 		oWriter.AddInt(lCalculatedSpacing);
@@ -470,36 +486,49 @@ namespace NSDocxRenderer
 		oWriter.WriteString(L"</a:t>");
 		if (m_bIsAddBrEnd) oWriter.WriteString(L"<a:br/>");
 
+		std::wstring origin_gids{};
+		for (auto& gid : m_arGids)
+			origin_gids += std::to_wstring(gid) + L";";
+
+		// Origin width string
+		std::wstring origin_lefts{};
+		for (auto& l : m_arOriginLefts)
+			origin_lefts += std::to_wstring(static_cast<int>(l * c_dMMToEMU)) + L";";
+
 		// meta info for pdf-editor
 		oWriter.WriteString(L"<metaorigin:pos");
 		oWriter.WriteString(L" x=\"");
-		oWriter.AddDouble(m_dLeft, 4);
+		oWriter.AddInt(static_cast<int>(m_dLeft * c_dMMToEMU));
 		oWriter.WriteString(L"\" y=\"");
-		oWriter.AddDouble(m_dBot, 4);
-		oWriter.WriteString(L"\" widths=\"");
-		for (auto& w : m_arSymWidths)
-		{
-			oWriter.AddDouble(w, 4);
-			oWriter.WriteString(L",");
-		}
+		oWriter.AddInt(static_cast<int>(m_dBot * c_dMMToEMU));
 		oWriter.WriteString(L"\" />");
 
 		oWriter.WriteString(L"<metaorigin:font ");
-		oWriter.WriteString(L" font=\"");
+		oWriter.WriteString(L" name=\"");
 		oWriter.WriteString(m_wsOriginFontName);
+		oWriter.WriteString(L"\" faceindex=\"");
+		oWriter.AddInt(m_nOriginFontFaceIndex);
 		oWriter.WriteString(L"\" />");
+
+		oWriter.WriteString(L"<metaorigin:syminfo");
+		oWriter.WriteString(L" lefts=\"");
+		oWriter.WriteString(origin_lefts);
+		oWriter.WriteString(L"\" gids=\"");
+		oWriter.WriteString(origin_gids);
+		oWriter.WriteString(L"\" />");
+
+		oWriter.WriteString(L"<metaorigin:fontsubstitution");
+		oWriter.WriteString(L" value=\"");
+		oWriter.AddInt(m_bFontSubstitution);
+		oWriter.WriteString(L"\" />");
+
 		oWriter.WriteString(L"</a:r>");
 	}
 	void CContText::ToBin(NSWasm::CData& oWriter) const
 	{
 		int lCalculatedSpacing = 0;
 		if (!m_oText.empty())
-		{
-			double dSpacing = (m_dWidth - m_oSelectedSizes.dWidth) / (m_oText.length());
-			dSpacing *= c_dMMToPt * 100;
-			lCalculatedSpacing = static_cast<LONG>(dSpacing);
-		}
-		lCalculatedSpacing -= 15;
+			lCalculatedSpacing = static_cast<LONG>(m_dSpacing * c_dMMToPt * 100);
 
 		const BYTE kPARRUN_TYPE_RUN = 1;
 		oWriter.StartRecord(kPARRUN_TYPE_RUN);
@@ -508,6 +537,34 @@ namespace NSDocxRenderer
 		oWriter.WriteBYTE(0); oWriter.WriteStringUtf16(m_oText.ToStdWString());
 		oWriter.WriteBYTE(kBin_g_nodeAttributeEnd);
 
+		// Meta-info
+		oWriter.StartRecord(111);
+		oWriter.WriteBYTE(kBin_g_nodeAttributeStart);
+		oWriter.WriteBYTE(0); oWriter.WriteStringUtf16(m_wsOriginFontName); // Origin font name
+		oWriter.WriteBYTE(1); oWriter.AddInt(m_nOriginFontFaceIndex); // Origin face index
+		oWriter.WriteBYTE(2); oWriter.AddSInt(static_cast<int>(m_dLeft * c_dMMToEMU)); // Origin left
+		oWriter.WriteBYTE(3); oWriter.AddSInt(static_cast<int>(m_dBot * c_dMMToEMU)); // Origin bot
+
+		std::wstring origin_gids{};
+		for (auto& gid : m_arGids)
+			origin_gids += std::to_wstring(gid) + L";";
+
+		oWriter.WriteBYTE(4); oWriter.WriteStringUtf16(origin_gids); // Origin gids string
+
+		// Origin width string
+		std::wstring origin_lefts{};
+		for (auto& l : m_arOriginLefts)
+			origin_lefts += std::to_wstring(static_cast<int>(l * c_dMMToEMU)) + L";";
+		// add offset for last symbol
+		if (!m_arSymWidths.empty())
+			origin_lefts += std::to_wstring(static_cast<int>((m_arOriginLefts.back() + m_arSymWidths.back()) * c_dMMToEMU)) + L";";
+
+		oWriter.WriteBYTE(5); oWriter.WriteStringUtf16(origin_lefts); // Origin lefts
+		oWriter.WriteBYTE(6); oWriter.WriteBool(m_bFontSubstitution); // Font Substitution (just pass from pdf)
+
+		oWriter.WriteBYTE(kBin_g_nodeAttributeEnd);
+		oWriter.EndRecord();
+
 		// WriteRecord WriteRunProperties
 		[&oWriter, this, lCalculatedSpacing] () {
 			oWriter.StartRecord(0);
@@ -604,6 +661,7 @@ namespace NSDocxRenderer
 
 	bool CContText::IsEqual(const CContText *pCont) const noexcept
 	{
+		bool bIf0 = IsFontsEqual(m_oSelectedFont, pCont->m_oSelectedFont);
 		bool bIf1 = m_pFontStyle->wsFontStyleId == pCont->m_pFontStyle->wsFontStyleId;
 		bool bIf2 = m_bIsStrikeoutPresent == pCont->m_bIsStrikeoutPresent;
 		bool bIf3 = m_bIsDoubleStrikeout == pCont->m_bIsDoubleStrikeout;
@@ -620,7 +678,7 @@ namespace NSDocxRenderer
 		bool bIf14 = m_eVertAlignType == eVertAlignType::vatUnknown && pCont->m_eVertAlignType == eVertAlignType::vatBase;
 		bool bIf15 = m_eVertAlignType == eVertAlignType::vatBase && pCont->m_eVertAlignType == eVertAlignType::vatUnknown;
 
-		return (bIf1 && bIf2 && bIf3 && bIf4 && bIf5 && bIf6 && bIf7 &&
+		return (bIf0 && bIf1 && bIf2 && bIf3 && bIf4 && bIf5 && bIf6 && bIf7 &&
 		        bIf8 && bIf9 && bIf10 && bIf11 && bIf12 && (bIf13 || bIf14 || bIf15));
 	}
 
@@ -664,7 +722,10 @@ namespace NSDocxRenderer
 		return text.length() == 1 && CContText::IsUnicodeDiacriticalMark(text.at(0));
 	}
 
-	void CContText::AddTextBack(const NSStringUtils::CStringUTF32& oText, const std::vector<double>& arSymWidths)
+	void CContText::AddTextBack(const NSStringUtils::CStringUTF32& oText,
+	                             const std::vector<double>& arSymWidths,
+	                             const std::vector<unsigned int>& arGids,
+	                             const std::vector<double>& arOriginLefts)
 	{
 		bool is_space_twice = m_oText.at(m_oText.length() - 1) == c_SPACE_SYM &&
 		        oText.at(0) == c_SPACE_SYM;
@@ -679,22 +740,47 @@ namespace NSDocxRenderer
 				continue;
 			}
 			m_arSymWidths.push_back(w);
-			m_dWidth += w;
 			m_oText += oText.at(i);
+			m_arOriginLefts.push_back(arOriginLefts[i]);
+			m_dRight = arOriginLefts[i] + w;
+
+			if (!arGids.empty() && m_bCollectMetaInfo)
+				m_arGids.push_back(arGids[i]);
 		}
-		m_dRight = m_dLeft + m_dWidth;
+		m_dWidth = m_dRight - m_dLeft;
 	}
-	void CContText::AddTextFront(const NSStringUtils::CStringUTF32& oText, const std::vector<double>& arSymWidths)
+	void CContText::AddTextFront(const NSStringUtils::CStringUTF32& oText,
+	                             const std::vector<double>& arSymWidths,
+	                             const std::vector<unsigned int>& arGids,
+	                             const std::vector<double>& arOriginLefts)
 	{
 		m_oText = oText + m_oText;
 
 		auto ar_sym_w = m_arSymWidths;
 		m_arSymWidths = arSymWidths;
-
 		for (auto& w : ar_sym_w)
 			m_arSymWidths.push_back(w);
+
+		if (!arGids.empty() && m_bCollectMetaInfo)
+		{
+			auto ar_gids = m_arGids;
+			m_arGids = arGids;
+			for (auto& gid : ar_gids)
+				m_arGids.push_back(gid);
+		}
+
+		auto ar_lefts = m_arOriginLefts;
+		m_arOriginLefts = arOriginLefts;
+		for (auto& left : ar_lefts)
+			m_arOriginLefts.push_back(left);
+
+		m_dLeft = m_arOriginLefts.back();
+		m_dWidth = m_dRight - m_dLeft;
 	}
-	void CContText::SetText(const NSStringUtils::CStringUTF32& oText, const std::vector<double>& arSymWidths)
+	void CContText::SetText(const NSStringUtils::CStringUTF32& oText,
+	                        const std::vector<double>& arSymWidths,
+	                        std::vector<unsigned int>&& arGids,
+	                        std::vector<double>&& arOriginLefts)
 	{
 		m_oText = oText;
 		m_arSymWidths.clear();
@@ -705,32 +791,52 @@ namespace NSDocxRenderer
 			m_dWidth += w;
 		}
 		m_dRight = m_dLeft + m_dWidth;
+		m_arOriginLefts = std::move(arOriginLefts);
+
+		if (m_bCollectMetaInfo)
+			m_arGids = std::move(arGids);
 	}
 
-	void CContText::AddSymBack(uint32_t cSym, double dWidth)
+	void CContText::AddSymBack(uint32_t cSym, double dWidth, double dLeft, unsigned int nGid)
 	{
 		bool is_space_twice = m_oText.at(m_oText.length() - 1) == c_SPACE_SYM && cSym == c_SPACE_SYM;
 
 		if (is_space_twice)
+		{
 			m_arSymWidths.back() += dWidth;
+		}
 		else
 		{
 			m_arSymWidths.push_back(dWidth);
 			m_oText += cSym;
-		}
-		m_dWidth += dWidth;
-		m_dRight = m_dLeft + m_dWidth;
+			m_arOriginLefts.push_back(dLeft);
 
+			if (m_bCollectMetaInfo)
+			{
+				m_arGids.push_back(nGid);
+			}
+		}
+		m_dRight = dLeft + dWidth;
+		m_dWidth = m_dRight - m_dLeft;
 	}
-	void CContText::AddSymFront(uint32_t cSym, double dWidth)
+	void CContText::AddSymFront(uint32_t cSym, double dWidth, double dLeft, unsigned int nGid)
 	{
 		NSStringUtils::CStringUTF32 text;
 		text += cSym;
 		text += m_oText;
 		m_oText = text;
+
+		m_dLeft = dLeft;
+		m_dWidth = m_dRight - m_dLeft;
+
 		m_arSymWidths.insert(m_arSymWidths.begin(), dWidth);
+		m_arOriginLefts.insert(m_arOriginLefts.begin(), dLeft);
+		if (m_bCollectMetaInfo)
+		{
+			m_arGids.insert(m_arGids.begin(), nGid);
+		}
 	}
-	void CContText::SetSym(uint32_t cSym, double dWidth)
+	void CContText::SetSym(uint32_t cSym, double dWidth, double dLeft, unsigned int nGid)
 	{
 		m_oText = L"";
 		m_oText += cSym;
@@ -738,13 +844,34 @@ namespace NSDocxRenderer
 		m_arSymWidths.push_back(dWidth);
 		m_dWidth = dWidth;
 		m_dRight = m_dLeft + m_dWidth;
+
+		m_arSymWidths.clear();
+		m_arSymWidths.push_back(dWidth);
+
+		m_arOriginLefts.clear();
+		m_arOriginLefts.push_back(dLeft);
+
+		if (m_bCollectMetaInfo)
+		{
+			m_arGids.clear();
+			m_arGids.push_back(nGid);
+		}
 	}
 	void CContText::RemoveLastSym()
 	{
 		m_oText = m_oText.substr(0, m_oText.length() - 1);
-		m_dWidth -= m_arSymWidths[m_arSymWidths.size() - 1];
-		m_dRight = m_dLeft + m_dWidth;
 		m_arSymWidths.resize(m_arSymWidths.size() - 1);
+		m_arOriginLefts.resize(m_arOriginLefts.size() - 1);
+
+		if (!m_arOriginLefts.empty())
+			m_dRight = m_arOriginLefts.back() + m_arSymWidths.back();
+		else
+			m_dRight = m_dLeft;
+
+		m_dWidth = m_dRight - m_dLeft;
+
+		if (!m_arGids.empty() && m_bCollectMetaInfo)
+			m_arGids.resize(m_arGids.size() - 1);
 	}
 	uint32_t CContText::GetLastSym() const
 	{
@@ -759,16 +886,9 @@ namespace NSDocxRenderer
 	{
 		return m_arSymWidths;
 	}
-	const std::vector<double> CContText::GetSymLefts() const noexcept
+	const std::vector<double>& CContText::GetSymLefts() const noexcept
 	{
-		std::vector<double> lefts;
-		double left = m_dLeft;
-		for (auto& w : m_arSymWidths)
-		{
-			lefts.push_back(left);
-			left += w;
-		}
-		return lefts;
+		return m_arOriginLefts;
 	}
 
 	bool CContText::CheckFontEffects
@@ -778,12 +898,12 @@ namespace NSDocxRenderer
 	 eHorizontalCrossingType eHType)
 	{
 		//Условие пересечения по вертикали
-		bool bIf1 = eVType == eVerticalCrossingType::vctCurrentAboveNext; //текущий cont выше
-		bool bIf2 = eVType == eVerticalCrossingType::vctCurrentBelowNext; //текущий cont ниже
+		bool bIf1 = eVType == eVerticalCrossingType::vctCurrentAboveNext;
+		bool bIf2 = eVType == eVerticalCrossingType::vctCurrentBelowNext;
 
 		//Условие пересечения по горизонтали
-		bool bIf3 = eHType == eHorizontalCrossingType::hctCurrentLeftOfNext; //текущий cont левее
-		bool bIf4 = eHType == eHorizontalCrossingType::hctCurrentRightOfNext; //текущий cont правее
+		bool bIf3 = eHType == eHorizontalCrossingType::hctCurrentLeftOfNext;
+		bool bIf4 = eHType == eHorizontalCrossingType::hctCurrentRightOfNext;
 
 		//Размеры шрифта и текст должны бать одинаковыми
 		bool bIf5 = pFirstCont->m_pFontStyle->dFontSize == pSecondCont->m_pFontStyle->dFontSize;
@@ -799,9 +919,7 @@ namespace NSDocxRenderer
 		bool bIf11 = pFirstCont->m_pFontStyle->oBrush.Color1 == c_iGreyColor2;
 		bool bIf12 = pSecondCont->m_pFontStyle->oBrush.Color1 == c_iGreyColor2;
 
-		//note Каждый символ с Emboss или Engrave разбиваются на 3 символа с разными цветами
-		//note Логика подобрана для конкретного примера - возможно нужно будет ее обобщить.
-		//todo существует проблема неправильного определением FontEffects с физически пересекаемыми строчками - файл generaltest.pdf p.14
+		// каждый символ с Emboss или Engrave разбиваются на 3 символа с разными цветами
 		if (bIf5 && bIf6)
 		{
 			if (bIf12 && pFirstCont->m_bIsEmbossPresent)
@@ -861,8 +979,10 @@ namespace NSDocxRenderer
 	 eHorizontalCrossingType eHType)
 	{
 
+		double first_height = pFirstCont->m_dBotWithDescent - pFirstCont->m_dTopWithAscent;
 		bool bIf1 = eVType == eVerticalCrossingType::vctCurrentAboveNext ||
-		        eVType == eVerticalCrossingType::vctCurrentInsideNext;
+		        eVType == eVerticalCrossingType::vctCurrentInsideNext &&
+		        pSecondCont->m_dBot - pFirstCont->m_dBot > first_height * 0.2;
 
 		bool bIf2 = eVType == eVerticalCrossingType::vctCurrentBelowNext;
 
@@ -974,6 +1094,19 @@ namespace NSDocxRenderer
 	{
 		return 0x0300 <= cSym && 0x036F >= cSym;
 	}
+	bool CContText::IsFontsEqual(const NSStructures::CFont& oFont1, const NSStructures::CFont& oFont2)
+	{
+		bool res = oFont1.Name == oFont2.Name;
+		res = res && oFont1.Path == oFont2.Path;
+		res = res && oFont1.FaceIndex == oFont2.FaceIndex;
+		res = res && oFont1.StringGID == oFont2.StringGID;
+		res = res && oFont1.Size == oFont2.Size;
+		res = res && oFont1.Bold == oFont2.Bold;
+		res = res && oFont1.Italic == oFont2.Italic;
+		res = res && oFont1.Underline == oFont2.Underline;
+		res = res && oFont1.Strikeout == oFont2.Strikeout;
+		return res;
+	}
 
 	double CContText::CalculateSpace() const noexcept
 	{
@@ -1004,55 +1137,81 @@ namespace NSDocxRenderer
 	        const NSStructures::CBrush& oBrush,
 	        CFontManager* pFontManager,
 	        const NSStringUtils::CStringUTF32& oText,
+	        size_t nOrder,
+	        const PUINT pGids,
 	        bool bForcedBold,
 	        bool bUseDefaultFont,
-	        bool bWriteStyleRaw)
+	        bool bWriteStyleRaw,
+	        bool bCollectMetaInfo,
+	        bool bFontSubstitution)
 	{
 		double dWidth = dRight - dLeft;
 		double dHeight = dBot - dTop;
 
+		std::vector<unsigned int> gids;
+		if (bCollectMetaInfo)
+		{
+			for (size_t i = 0; i < oText.length(); ++i)
+				if (pGids)
+					gids.push_back(pGids[i]);
+				else
+					gids.push_back(0);
+		}
+
+		std::vector<double> origin_lefts;
+		double curr_origin_left = dLeft;
+		for (size_t i = 0; i < oText.length(); ++i)
+		{
+			origin_lefts.push_back(curr_origin_left);
+			curr_origin_left += dWidth / oText.length();
+		}
+
 		// if new text is close to current cont
 		if (m_pCurrCont != nullptr &&
 		        fabs(m_pCurrCont->m_dBot - dBot) < c_dTHE_SAME_STRING_Y_PRECISION_MM &&
 		        m_oPrevFont.IsEqual2(&oFont) &&
 		        m_oPrevBrush.IsEqual(&oBrush) && !(
-		            oText.length() == 1 && CContText::IsUnicodeDiacriticalMark(oText.at(0))))
+		            oText.length() == 1 && CContText::IsUnicodeDiacriticalMark(oText.at(0))) &&
+		        bFontSubstitution == m_pCurrCont->m_bFontSubstitution)
 		{
-
-			double avg_width = dWidth / oText.length();
-			for (size_t i = 0; i < oText.length(); ++i)
-				if (oText.at(i) == c_SPACE_SYM)
-					m_pCurrCont->m_pFontStyle->UpdateAvgSpaceWidth(avg_width);
-
 			double avg_space_width = m_pCurrCont->m_pFontStyle->GetAvgSpaceWidth();
 			double space_width =
 			        avg_space_width != 0.0 ?
 			            avg_space_width * c_dAVERAGE_SPACE_WIDTH_COEF :
 			            m_pCurrCont->CalculateSpace() * c_dSPACE_WIDTH_COEF;
 
+			double spacing = dLeft - m_dPrevRight;
 			bool is_added = false;
+			bool diff_spacing = false;
+
+			// set spacing at the second symbol
+			if (m_pCurrCont->GetLength() == 1)
+				m_pCurrCont->m_dSpacing = spacing;
+
+			if (fabs(spacing - m_pCurrCont->m_dSpacing) > c_dTHE_SAME_SPACING_ERROR)
+				diff_spacing = true;
 
 			// some_text+more_text
-			if (fabs(m_pCurrCont->m_dRight - dLeft) < space_width && dRight > m_pCurrCont->m_dRight)
+			if (!diff_spacing && fabs(m_pCurrCont->m_dRight - dLeft) < space_width && dRight > m_pCurrCont->m_dRight)
 			{
 				double left_avg_width = (dRight - m_pCurrCont->m_dRight) / oText.length();
 				std::vector<double> ar_widths;
 				for (size_t i = 0; i < oText.length(); ++i)
 					ar_widths.push_back(left_avg_width);
 
-				m_pCurrCont->AddTextBack(oText, ar_widths);
+				m_pCurrCont->AddTextBack(oText, ar_widths, gids, origin_lefts);
 				is_added = true;
 
 			}
 			// more_text+some_text
-			else if (fabs(m_pCurrCont->m_dLeft - dRight) < space_width && dLeft < m_pCurrCont->m_dLeft)
+			else if (diff_spacing && fabs(m_pCurrCont->m_dLeft - dRight) < space_width && dLeft < m_pCurrCont->m_dLeft)
 			{
 				double right_avg_width = (m_pCurrCont->m_dLeft - dLeft) / oText.length();
 				std::vector<double> ar_widths;
 				for (size_t i = 0; i < oText.length(); ++i)
 					ar_widths.push_back(right_avg_width);
 
-				m_pCurrCont->AddTextFront(oText, ar_widths);
+				m_pCurrCont->AddTextFront(oText, ar_widths, gids, origin_lefts);
 				is_added = true;
 			}
 
@@ -1062,6 +1221,8 @@ namespace NSDocxRenderer
 				m_pCurrCont->m_dBot = std::max(m_pCurrCont->m_dBot, dBot);
 				m_pCurrCont->m_dHeight = m_pCurrCont->m_dBot - m_pCurrCont->m_dTop;
 				m_pCurrCont->m_dWidth = m_pCurrCont->m_dRight - m_pCurrCont->m_dLeft;
+				m_pCurrCont->m_nOrder = nOrder;
+				m_dPrevRight = dRight;
 				return;
 			}
 		}
@@ -1085,29 +1246,31 @@ namespace NSDocxRenderer
 		            m_pFontSelector->IsSelectedItalic(),
 		            m_pFontSelector->IsSelectedBold() || bForcedBold);
 
-		// just in case if oText contains more than 1 symbol
-		std::vector<double> ar_widths;
-		double avg_width = abs(dRight - dLeft) / oText.length();
+		double avg_width = dWidth / oText.length();
 		for (size_t i = 0; i < oText.length(); ++i)
-		{
-			if (oText.at(i) == c_SPACE_SYM) pCont->m_pFontStyle->UpdateAvgSpaceWidth(avg_width);
-			ar_widths.push_back(avg_width);
-		}
+			if (oText.at(i) == c_SPACE_SYM)
+				pCont->m_pFontStyle->UpdateAvgSpaceWidth(avg_width);
 
-		pCont->SetText(oText, ar_widths);
+		std::vector<double> ar_widths;
+		for (size_t i = 0; i < oText.length(); ++i)
+			ar_widths.push_back(avg_width);
+
+		pCont->m_bCollectMetaInfo = bCollectMetaInfo;
+		pCont->SetText(oText, ar_widths, std::move(gids), std::move(origin_lefts));
 		pCont->m_bIsRtl = CContText::IsUnicodeRtl(oText.at(0));
 
 		pCont->m_dWidth = dWidth;
 		pCont->m_dRight = dRight;
 
-		double font_size = oFont.Size;
-		double em_height = oMetrics.dEmHeight;
-		double ratio = font_size / em_height * c_dPtToMM;
+		double ascent = pFontManager->GetFontAscent();
+		double descent = pFontManager->GetFontDescent();
 
-		pCont->m_dTopWithAscent = pCont->m_dBot - (oMetrics.dAscent * ratio) - oMetrics.dBaselineOffset;
-		pCont->m_dBotWithDescent = pCont->m_dBot + (oMetrics.dDescent * ratio) - oMetrics.dBaselineOffset;
+		pCont->m_dTopWithAscent = pCont->m_dBot - ascent;
+		pCont->m_dBotWithDescent = pCont->m_dBot + fabs(descent);
 		pCont->m_dSpaceWidthMM = pFontManager->GetSpaceWidthMM();
+
 		pCont->m_wsOriginFontName = oFont.Name;
+		pCont->m_nOriginFontFaceIndex = oFont.FaceIndex;
 
 		if (bUseDefaultFont)
 		{
@@ -1124,6 +1287,8 @@ namespace NSDocxRenderer
 			pCont->m_oSelectedFont.Italic = m_pFontSelector->IsSelectedItalic();
 		}
 		pCont->m_bWriteStyleRaw = bWriteStyleRaw;
+		pCont->m_bFontSubstitution = bFontSubstitution;
+		pCont->m_nOrder = nOrder;
 
 		if (pCont->IsDiacritical())
 		{
@@ -1137,6 +1302,7 @@ namespace NSDocxRenderer
 		m_pCurrCont = pCont;
 		m_oPrevFont = oFont;
 		m_oPrevBrush = oBrush;
+		m_dPrevRight = dRight;
 	}
 
 	void CContTextBuilder::NullCurrCont()

DocxRenderer/src/logic/elements/ContText.h

@@ -63,9 +63,11 @@ namespace NSDocxRenderer
 
 		// origin font
 		std::wstring m_wsOriginFontName{};
+		int m_nOriginFontFaceIndex{};
 
 		// sizes
 		double m_dSpaceWidthMM{0};
+		double m_dSpacing{0};
 		CSelectedSizes m_oSelectedSizes{};
 
 		double m_dTopWithAscent{0};
@@ -76,6 +78,11 @@ namespace NSDocxRenderer
 		bool m_bIsAddBrEnd{false};
 		bool m_bWriteStyleRaw{false};
 		bool m_bPossibleHorSplit{false};
+		bool m_bCollectMetaInfo{false};
+
+		std::vector<unsigned int> m_arGids{};
+		std::vector<double> m_arOriginLefts{};
+		bool m_bFontSubstitution = false;
 
 		CContText() = default;
 		CContText(CFontManager* pManager) : m_pManager(pManager) {}
@@ -92,20 +99,30 @@ namespace NSDocxRenderer
 		void CalcSelected();
 
 		size_t GetLength() const noexcept;
-		void AddTextBack(const NSStringUtils::CStringUTF32& oText, const std::vector<double>& arSymWidths);
-		void AddTextFront(const NSStringUtils::CStringUTF32& oText, const std::vector<double>& arSymWidths);
-		void SetText(const NSStringUtils::CStringUTF32& oText, const std::vector<double>& arSymWidths);
+		void AddTextBack(const NSStringUtils::CStringUTF32& oText,
+		                 const std::vector<double>& arSymWidths,
+		                 const std::vector<unsigned int>& arGids,
+		                 const std::vector<double>& arOriginLefts);
+		void AddTextFront(const NSStringUtils::CStringUTF32& oText,
+		                  const std::vector<double>& arSymWidths,
+		                  const std::vector<unsigned int>& arGids,
+		                  const std::vector<double>& arOriginLefts);
+		void SetText(const NSStringUtils::CStringUTF32& oText,
+		             const std::vector<double>& arSymWidths,
+		             std::vector<unsigned int>&& arGids,
+		             std::vector<double>&& arOriginLefts);
+
+		void AddSymBack(uint32_t cSym, double dWidth, double dLeft, unsigned int nGid = 0);
+		void AddSymFront(uint32_t cSym, double dWidth, double dLeft, unsigned int nGid = 0);
+		void SetSym(uint32_t cSym, double dWidth, double dLeft, unsigned int nGid = 0);
 
-		void AddSymBack(uint32_t cSym, double dWidth);
-		void AddSymFront(uint32_t cSym, double dWidth);
-		void SetSym(uint32_t cSym, double dWidth);
 		void RemoveLastSym();
 
 		uint32_t GetLastSym() const;
 
 		const NSStringUtils::CStringUTF32& GetText() const noexcept;
 		const std::vector<double>& GetSymWidths() const noexcept;
-		const std::vector<double> GetSymLefts() const noexcept;
+		const std::vector<double>& GetSymLefts() const noexcept;
 
 		std::shared_ptr<CContText> Split(size_t index);
 		std::shared_ptr<CContText> Split(double dLeft);
@@ -142,6 +159,8 @@ namespace NSDocxRenderer
 		static bool IsUnicodeSymbol(uint32_t symbol);
 		static bool IsUnicodeDiacriticalMark(uint32_t symbol);
 
+		static bool IsFontsEqual(const NSStructures::CFont& oFont1, const NSStructures::CFont& oFont2);
+
 	private:
 		NSStringUtils::CStringUTF32 m_oText{};
 		std::vector<double> m_arSymWidths{};
@@ -172,14 +191,18 @@ namespace NSDocxRenderer
 		        const NSStructures::CBrush& oBrush,
 		        CFontManager* pFontManager,
 		        const NSStringUtils::CStringUTF32& oText,
+		        size_t nOrder = 0,
+		        const PUINT pGids = nullptr,
 		        bool bForcedBold = false,
 		        bool bUseDefaultFont = false,
-		        bool bWriteStyleRaw = false);
+		        bool bWriteStyleRaw = false,
+		        bool bCollectMetaInfo = false,
+		        bool bFontSubstitution = false);
 
 		void NullCurrCont();
 		void Clear();
-
 	private:
+
 		std::vector<cont_ptr_t> m_arConts;
 		std::vector<cont_ptr_t> m_arDiacs;
 
@@ -190,5 +213,6 @@ namespace NSDocxRenderer
 
 		CFontStyleManager* m_pFontStyleManager {nullptr};
 		CFontSelector* m_pFontSelector {nullptr};
+		double m_dPrevRight = 0;
 	};
 }

DocxRenderer/src/logic/elements/Paragraph.cpp

@@ -313,7 +313,7 @@ namespace NSDocxRenderer
 			auto last_sym = text[text.length() - 1];
 
 			if (last_sym != c_SPACE_SYM && m_arTextLines.size() != 1)
-				pLastCont->AddSymBack(c_SPACE_SYM, 0);
+				pLastCont->AddSymBack(c_SPACE_SYM, 0, pLastCont->m_dRight, 0);
 		}
 	}
 }

DocxRenderer/src/logic/elements/Shape.cpp

@@ -1343,7 +1343,7 @@ namespace NSDocxRenderer
 			// WriteRecord WriteBodyPr
 			oWriter.StartRecord(0);
 			oWriter.WriteBYTE(kBin_g_nodeAttributeStart);
-			oWriter.WriteBYTE(1); oWriter.WriteBYTE(1);      // anchor
+			oWriter.WriteBYTE(1); oWriter.WriteBYTE(4);      // anchor
 			oWriter.WriteBYTE(2); oWriter.WriteBool(false);  // anchorCtr
 			oWriter.WriteBYTE(3); oWriter.AddInt(0);         // bIns
 			oWriter.WriteBYTE(4); oWriter.WriteBool(true);   // compatLnSpc

DocxRenderer/src/logic/elements/Shape.h

@@ -46,7 +46,6 @@ namespace NSDocxRenderer
 		std::wstring m_strDstMedia    {};
 
 		double m_dRotation {0.0};
-		size_t m_nOrder  {0};
 
 		bool m_bIsNoFill    {true};
 		bool m_bIsNoStroke  {true};

DocxRenderer/src/logic/elements/TextLine.cpp

@@ -21,6 +21,7 @@ namespace NSDocxRenderer
 	{
 		RecalcWithNewItem(oCont.get());
 		m_arConts.push_back(oCont);
+		m_nOrder = std::max(m_nOrder, oCont->m_nOrder);
 	}
 	void CTextLine::AddConts(const std::vector<std::shared_ptr<CContText>>& arConts)
 	{
@@ -65,6 +66,8 @@ namespace NSDocxRenderer
 		std::sort(m_arConts.begin(), m_arConts.end(), [] (const cont_ptr_t& a, const cont_ptr_t& b) {
 			if (!a) return false;
 			if (!b) return true;
+			if (fabs(a->m_dLeft - b->m_dLeft) < c_dTHE_SAME_STRING_X_PRECISION_MM)
+				return a->m_dRight < b->m_dRight;
 			return a->m_dLeft < b->m_dLeft;
 		});
 
@@ -112,7 +115,7 @@ namespace NSDocxRenderer
 
 					wide_space->m_dHeight = pCurrent->m_dHeight;
 
-					wide_space->SetSym(c_SPACE_SYM, wide_space->m_dRight - wide_space->m_dLeft);
+					wide_space->SetSym(c_SPACE_SYM, wide_space->m_dRight - wide_space->m_dLeft, wide_space->m_dLeft, 0);
 					wide_space->m_pFontStyle = pFirst->m_pFontStyle;
 					wide_space->m_pShape = nullptr;
 					wide_space->m_iNumDuplicates = 0;
@@ -146,12 +149,12 @@ namespace NSDocxRenderer
 			{
 				if (!bIsSpaceDelta)
 				{
-					pFirst->AddTextBack(pCurrent->GetText(), pCurrent->GetSymWidths());
+					pFirst->AddTextBack(pCurrent->GetText(), pCurrent->GetSymWidths(), pCurrent->m_arGids, pCurrent->m_arOriginLefts);
 				}
 				else
 				{
-					pFirst->AddSymBack(c_SPACE_SYM, pCurrent->m_dLeft - pFirst->m_dRight);
-					pFirst->AddTextBack(pCurrent->GetText(), pCurrent->GetSymWidths());
+					pFirst->AddSymBack(c_SPACE_SYM, pCurrent->m_dLeft - pFirst->m_dRight, pFirst->m_dRight, 0);
+					pFirst->AddTextBack(pCurrent->GetText(), pCurrent->GetSymWidths(), pCurrent->m_arGids, pCurrent->m_arOriginLefts);
 				}
 
 				if (pFirst->m_pCont.expired())
@@ -166,9 +169,9 @@ namespace NSDocxRenderer
 				if (bIsSpaceDelta)
 				{
 					if (pFirst->GetNumberOfFeatures() <= pCurrent->GetNumberOfFeatures())
-						pFirst->AddSymBack(c_SPACE_SYM, pCurrent->m_dLeft - pFirst->m_dRight);
+						pFirst->AddSymBack(c_SPACE_SYM, pCurrent->m_dLeft - pFirst->m_dRight, pFirst->m_dRight, 0);
 					else
-						pCurrent->AddSymFront(c_SPACE_SYM, pCurrent->m_dLeft - pFirst->m_dRight);
+						pCurrent->AddSymFront(c_SPACE_SYM, pCurrent->m_dLeft - pFirst->m_dRight, pFirst->m_dRight, 0);
 				}
 				pFirst = pCurrent;
 			}
@@ -193,16 +196,20 @@ namespace NSDocxRenderer
 				continue;
 
 			const auto& text = cont->GetText();
-			auto ar_widths = cont->GetSymWidths();
+			auto ar_lefts = cont->GetSymLefts();
+			auto ar_width = cont->GetSymWidths();
 			for (size_t i = 0; i < text.length(); ++i)
 			{
 				if (text.at(i) == c_SPACE_SYM)
 				{
-					m_dFirstWordWidth = width;
+					if (i == 0)
+						m_dFirstWordWidth = cont->m_dLeft - m_dLeft;
+					else
+						m_dFirstWordWidth = ar_lefts[i - 1] - m_dLeft + ar_width[i - 1];
 					is_done = true;
 					break;
 				}
-				width += ar_widths[i];
+
 			}
 			if (is_done)
 				break;
@@ -238,15 +245,15 @@ namespace NSDocxRenderer
 			return eVerticalCrossingType::vctCurrentInsideNext;
 
 		else if (this_top < other_top && this_bot > other_bot)
-			return  eVerticalCrossingType::vctCurrentOutsideNext;
+			return eVerticalCrossingType::vctCurrentOutsideNext;
 
-		else if (this_top < other_top && this_bot < other_bot &&
-		         (this_bot >= other_top || fabs(this_bot - other_top) < c_dTHE_SAME_STRING_Y_PRECISION_MM))
-			return  eVerticalCrossingType::vctCurrentAboveNext;
+		else if (this_top < other_top && this_bot < other_bot && this_bot > other_top &&
+		    this_bot - other_top > c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctCurrentAboveNext;
 
-		else if (this_top > other_top && this_bot > other_bot &&
-		         (this_top <= other_bot || fabs(this_top - other_bot) < c_dTHE_SAME_STRING_Y_PRECISION_MM))
-			return  eVerticalCrossingType::vctCurrentBelowNext;
+		else if (this_top > other_top && this_bot > other_bot && this_top < other_bot &&
+		         other_bot - this_top > c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctCurrentBelowNext;
 
 		else if (this_top == other_top && this_bot == other_bot &&
 		         m_dLeft == pLine->m_dLeft && m_dRight == pLine->m_dRight)
@@ -254,31 +261,33 @@ namespace NSDocxRenderer
 
 		else if (fabs(this_top - other_top) < c_dTHE_SAME_STRING_Y_PRECISION_MM &&
 		         fabs(this_bot - other_bot) < c_dTHE_SAME_STRING_Y_PRECISION_MM)
-			return  eVerticalCrossingType::vctTopAndBottomBordersMatch;
+			return eVerticalCrossingType::vctTopAndBottomBordersMatch;
 
 		else if (fabs(this_top - other_top) < c_dTHE_SAME_STRING_Y_PRECISION_MM)
-			return  eVerticalCrossingType::vctTopBorderMatch;
+			return eVerticalCrossingType::vctTopBorderMatch;
 
 		else if (fabs(this_bot - other_bot) < c_dTHE_SAME_STRING_Y_PRECISION_MM)
-			return  eVerticalCrossingType::vctBottomBorderMatch;
+			return eVerticalCrossingType::vctBottomBorderMatch;
 
-		else if (this_bot < other_top)
-			return  eVerticalCrossingType::vctNoCrossingCurrentAboveNext;
+		else if (other_top - this_bot > -c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctNoCrossingCurrentAboveNext;
 
-		else if (this_top > other_bot)
-			return  eVerticalCrossingType::vctNoCrossingCurrentBelowNext;
+		else if (this_top - other_bot > -c_dOVERLAP_TEXT_LINE_ERROR_MM)
+			return eVerticalCrossingType::vctNoCrossingCurrentBelowNext;
 
 		else
-			return  eVerticalCrossingType::vctUnknown;
+			return eVerticalCrossingType::vctUnknown;
 	}
 
 	void CTextLine::RecalcWithNewItem(const CContText* pCont)
 	{
 		CBaseItem::RecalcWithNewItem(pCont);
-		if (m_dTopWithMaxAscent == 0.0) m_dTopWithMaxAscent = pCont->m_dTopWithAscent;
-		else m_dTopWithMaxAscent = std::min(m_dTopWithMaxAscent, pCont->m_dTopWithAscent);
-
-		m_dBotWithMaxDescent = std::max(m_dBotWithMaxDescent, pCont->m_dBotWithDescent);
+		if (!pCont->IsOnlySpaces())
+		{
+			if (m_dTopWithMaxAscent == 0.0) m_dTopWithMaxAscent = pCont->m_dTopWithAscent;
+			else m_dTopWithMaxAscent = std::min(m_dTopWithMaxAscent, pCont->m_dTopWithAscent);
+			m_dBotWithMaxDescent = std::max(m_dBotWithMaxDescent, pCont->m_dBotWithDescent);
+		}
 	}
 
 	void CTextLine::SetVertAlignType(const eVertAlignType& oType)

DocxRenderer/src/logic/managers/FontManager.cpp

@@ -581,6 +581,16 @@ namespace NSDocxRenderer
 	{
 		return c_dPtToMM * (m_oFontMetrics.dLineSpacing * m_oFont.Size) / m_oFontMetrics.dEmHeight;
 	}
+	double CFontManager::GetFontAscent() const
+	{
+		//double tmp = m_oFontMetrics.dAscent;
+		double tmp = m_oFontMetrics.dLineSpacing - fabs(m_oFontMetrics.dDescent);
+		return c_dPtToMM * (tmp * m_oFont.Size) / m_oFontMetrics.dEmHeight;
+	}
+	double CFontManager::GetFontDescent() const
+	{
+		return c_dPtToMM * (m_oFontMetrics.dDescent * m_oFont.Size) / m_oFontMetrics.dEmHeight;
+	}
 	double CFontManager::GetSpaceWidthMM() const
 	{
 		double dSpaceWidthMM = 0.0;

DocxRenderer/src/logic/managers/FontManager.h

@@ -124,6 +124,9 @@ namespace NSDocxRenderer
 		const CFontMetrics& GetFontMetrics() const noexcept;
 
 		double GetFontHeight() const;
+		double GetFontAscent() const;
+		double GetFontDescent() const;
+
 		double GetSpaceWidthMM() const;
 
 		void SetStringGid(const LONG& lGid);

DocxRenderer/src/resources/Constants.h

@@ -24,9 +24,11 @@ constexpr double c_dPtToEMU       = 12700.0;
 constexpr double c_dDegreeToAngle = 60000.0;
 
 const double c_dSTANDART_STRING_HEIGHT_MM       = 4.2333333333333334;
-const double c_dTHE_SAME_STRING_Y_PRECISION_MM  = 0.02;
-const double c_dTHE_SAME_STRING_X_PRECISION_MM  = 0.02;
+const double c_dTHE_SAME_STRING_Y_PRECISION_MM  = 0.015;
+const double c_dTHE_SAME_STRING_X_PRECISION_MM  = 0.03;
+const double c_dTHE_SAME_SPACING_ERROR          = 0.1;
 const double c_dLINE_DISTANCE_ERROR_MM          = 0.3;
+const double c_dOVERLAP_TEXT_LINE_ERROR_MM      = 0.5;
 const double c_dERROR_OF_PARAGRAPH_BORDERS_MM   = 1.0;
 const double c_dCENTER_POSITION_ERROR_MM        = 1.5;
 const double c_dTHE_STRING_X_PRECISION_MM       = 0.5;