Fix for snapshots

Release/v8.2.0

Common/3dParty/boost/boost.pri

@@ -1,16 +1,18 @@
 INCLUDEPATH += $$PWD/build/$$CORE_BUILDS_PLATFORM_PREFIX/include
 CORE_BOOST_LIBS = $$PWD/build/$$CORE_BUILDS_PLATFORM_PREFIX/lib
 
+core_ios:CONFIG += disable_enum_constexpr_conversion
+core_android:CONFIG += disable_enum_constexpr_conversion
+core_mac:CONFIG += disable_enum_constexpr_conversion
+
 core_android {
     INCLUDEPATH += $$PWD/build/android/include
     CORE_BOOST_LIBS = $$PWD/build/android/lib/$$CORE_BUILDS_PLATFORM_PREFIX
 
     DEFINES += "_HAS_AUTO_PTR_ETC=0"
-    QMAKE_CFLAGS += -Wno-enum-constexpr-conversion
-    QMAKE_CXXFLAGS += -Wno-enum-constexpr-conversion
 }
 
-core_ios {
+disable_enum_constexpr_conversion {
     QMAKE_CFLAGS += -Wno-enum-constexpr-conversion
     QMAKE_CXXFLAGS += -Wno-enum-constexpr-conversion
 }

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

@@ -12,22 +12,20 @@
 #include "StaticFunctions.h"
 #include "ConstValues.h"
 
-#define DEFAULTFONTSIZE 28 // 14 * 2
+#define DEFAULT_FONT_SIZE 14
 
 namespace NSCSS
 {
 	typedef std::map<std::wstring, std::wstring>::const_iterator styles_iterator;
 
 	CCompiledStyle::CCompiledStyle() : m_nDpi(96), m_UnitMeasure(Point)
-	{
-		m_oFont.SetSize(std::to_wstring(DEFAULTFONTSIZE), 0, true);
-	}
+	{}
 
-	 CCompiledStyle::CCompiledStyle(const CCompiledStyle& oStyle) :
-	    m_arParentsStyles(oStyle.m_arParentsStyles), m_sId(oStyle.m_sId),
-	    m_nDpi(oStyle.m_nDpi), m_UnitMeasure(oStyle.m_UnitMeasure),
-	    m_oFont(oStyle.m_oFont), m_oMargin(oStyle.m_oMargin), m_oPadding(oStyle.m_oPadding), m_oBackground(oStyle.m_oBackground),
-	    m_oText(oStyle.m_oText), m_oBorder(oStyle.m_oBorder), m_oDisplay(oStyle.m_oDisplay){}
+	CCompiledStyle::CCompiledStyle(const CCompiledStyle& oStyle) :
+		m_arParentsStyles(oStyle.m_arParentsStyles), m_sId(oStyle.m_sId),
+		m_nDpi(oStyle.m_nDpi), m_UnitMeasure(oStyle.m_UnitMeasure),
+		m_oFont(oStyle.m_oFont), m_oMargin(oStyle.m_oMargin), m_oPadding(oStyle.m_oPadding), m_oBackground(oStyle.m_oBackground),
+		m_oText(oStyle.m_oText), m_oBorder(oStyle.m_oBorder), m_oDisplay(oStyle.m_oDisplay){}
 
 	CCompiledStyle::~CCompiledStyle()
 	{
@@ -36,6 +34,9 @@ namespace NSCSS
 
 	CCompiledStyle& CCompiledStyle::operator+= (const CCompiledStyle &oElement)
 	{
+		if (oElement.Empty())
+			return *this;
+
 		m_oBackground   += oElement.m_oBackground;
 		m_oBorder       += oElement.m_oBorder;
 		m_oFont         += oElement.m_oFont;
@@ -44,6 +45,9 @@ namespace NSCSS
 		m_oText         += oElement.m_oText;
 		m_oDisplay      += oElement.m_oDisplay;
 
+		if (!oElement.m_sId.empty())
+			m_sId += L'+' + oElement.m_sId;
+
 		return *this;
 	}
 
@@ -68,9 +72,7 @@ namespace NSCSS
 
 	bool CCompiledStyle::operator== (const CCompiledStyle& oStyle) const
 	{
-		return GetId()[0]        == oStyle.GetId()[0]        &&
-		       m_arParentsStyles == oStyle.m_arParentsStyles &&
-		       m_oBackground     == oStyle.m_oBackground     &&
+		return m_oBackground     == oStyle.m_oBackground     &&
 		       m_oBorder         == oStyle.m_oBorder         &&
 		       m_oFont           == oStyle.m_oFont           &&
 		       m_oMargin         == oStyle.m_oMargin         &&
@@ -100,16 +102,6 @@ namespace NSCSS
 		m_UnitMeasure = enUnitMeasure;
 	}
 
-	void CCompiledStyle::SetSizeSourceWindow(const CSizeWindow &oSizeWindow)
-	{
-		m_oSourceWindow = oSizeWindow;
-	}
-
-	void CCompiledStyle::SetSizeDeviceWindow(const CSizeWindow &oSizeWindow)
-	{
-		m_oDeviceWindow = oSizeWindow;
-	}
-
 	bool CCompiledStyle::Empty() const
 	{
 		return m_oBackground.Empty() && m_oBorder.Empty() && m_oFont.Empty() &&
@@ -124,8 +116,8 @@ namespace NSCSS
 	void CCompiledStyle::AddStyle(const std::map<std::wstring, std::wstring>& mStyle, const unsigned int unLevel, const bool& bHardMode)
 	{
 		const bool bIsThereBorder = (m_oBorder.Empty()) ? false : true;
-		const double dFontSize = m_oFont.GetSize().ToDouble(NSCSS::Twips);
-		
+		const double dFontSize = (!m_oFont.GetSize().Empty()) ? m_oFont.GetSize().ToDouble(NSCSS::Point) : DEFAULT_FONT_SIZE;
+
 		for (std::pair<std::wstring, std::wstring> pPropertie : mStyle)
 		{
 			std::transform(pPropertie.first.begin(), pPropertie.first.end(), pPropertie.first.begin(), tolower);
@@ -183,45 +175,48 @@ namespace NSCSS
 					if (bIsThereBorder)
 						break;
 
-					m_oMargin.AddValue(pPropertie.second, unLevel, bHardMode);
+					m_oMargin.SetValues(pPropertie.second, unLevel, bHardMode);
 					m_oMargin.UpdateAll(dFontSize);
 					break;
 				}
 				CASE(L"margin-top"):
+				CASE(L"topmargin"):
 				{
 					if (bIsThereBorder)
 						break;
 
-					m_oMargin.AddTop(pPropertie.second, unLevel, bHardMode);
-					m_oMargin.UpdateTop(dFontSize);
+					m_oMargin.SetTop(pPropertie.second, unLevel, bHardMode);
 					break;
 				}
 				CASE(L"margin-right"):
 				CASE(L"margin-block-end"):
+				CASE(L"rightmargin"):
 				{
 					if (bIsThereBorder)
 						break;
 
-					m_oMargin.AddRight(pPropertie.second, unLevel, bHardMode);
+					m_oMargin.SetRight(pPropertie.second, unLevel, bHardMode);
 					m_oMargin.UpdateRight(dFontSize);
 					break;
 				}
 				CASE(L"margin-bottom"):
+				CASE(L"bottommargin"):
 				{
 					if (bIsThereBorder)
 						break;
 
-					m_oMargin.AddBottom(pPropertie.second, unLevel, bHardMode);
+					m_oMargin.SetBottom(pPropertie.second, unLevel, bHardMode);
 					m_oMargin.UpdateBottom(dFontSize);
 					break;
 				}
 				CASE(L"margin-left"):
 				CASE(L"margin-block-start"):
+				CASE(L"leftmargin"):
 				{
 					if (bIsThereBorder)
 						break;
 
-					m_oMargin.AddLeft(pPropertie.second, unLevel, bHardMode);
+					m_oMargin.SetLeft(pPropertie.second, unLevel, bHardMode);
 					m_oMargin.UpdateLeft(dFontSize);
 					break;
 				}
@@ -229,35 +224,35 @@ namespace NSCSS
 				CASE(L"padding"):
 				CASE(L"mso-padding-alt"):
 				{
-					m_oPadding.AddValue(pPropertie.second, unLevel, bHardMode);
+					m_oPadding.SetValues(pPropertie.second, unLevel, bHardMode);
 					m_oPadding.UpdateAll(dFontSize);
 					break;
 				}
 				CASE(L"padding-top"):
 				CASE(L"mso-padding-top-alt"):
 				{
-					m_oPadding.AddTop(pPropertie.second, unLevel, bHardMode);
+					m_oPadding.SetTop(pPropertie.second, unLevel, bHardMode);
 					m_oPadding.UpdateTop(dFontSize);
 					break;
 				}
 				CASE(L"padding-right"):
 				CASE(L"mso-padding-right-alt"):
 				{
-					m_oPadding.AddRight(pPropertie.second, unLevel, bHardMode);
+					m_oPadding.SetRight(pPropertie.second, unLevel, bHardMode);
 					m_oPadding.UpdateRight(dFontSize);
 					break;
 				}
 				CASE(L"padding-bottom"):
 				CASE(L"mso-padding-bottom-alt"):
 				{
-					m_oPadding.AddBottom(pPropertie.second, unLevel, bHardMode);
+					m_oPadding.SetBottom(pPropertie.second, unLevel, bHardMode);
 					m_oPadding.UpdateBottom(dFontSize);
 					break;
 				}
 				CASE(L"padding-left"):
 				CASE(L"mso-padding-left-alt"):
 				{
-					m_oPadding.AddLeft(pPropertie.second, unLevel, bHardMode);
+					m_oPadding.SetLeft(pPropertie.second, unLevel, bHardMode);
 					m_oPadding.UpdateLeft(dFontSize);
 					break;
 				}
@@ -305,6 +300,11 @@ namespace NSCSS
 					m_oBorder.SetColor(pPropertie.second, unLevel, bHardMode);
 					break;
 				}
+				CASE(L"border-collapse"):
+				{
+					m_oBorder.SetCollapse(pPropertie.second, unLevel, bHardMode);
+					break;
+				}
 				//BORDER TOP
 				CASE(L"border-top"):
 				{
@@ -393,20 +393,12 @@ namespace NSCSS
 				CASE(L"background-color"):
 				{
 					m_oBackground.SetColor(pPropertie.second, unLevel, bHardMode);
-
-					if (bIsThereBorder)
-						m_oBackground.InBorder();
-
 					break;
 				}
 				CASE(L"background"):
 				CASE(L"bgcolor"):
 				{
 					m_oBackground.SetBackground(pPropertie.second, unLevel, bHardMode);
-
-					if (bIsThereBorder)
-						m_oBackground.InBorder();
-
 					break;
 				}
 				//DISPLAY
@@ -431,6 +423,7 @@ namespace NSCSS
 					break;
 				}
 				CASE(L"vertical-align"):
+				CASE(L"valign"):
 				{
 					m_oDisplay.SetVAlign(pPropertie.second, unLevel, bHardMode);
 					break;
@@ -501,6 +494,11 @@ namespace NSCSS
 		return arParentsName;
 	}
 
+	std::set<std::wstring> CCompiledStyle::GetParentsNamesSet() const
+	{
+		return m_arParentsStyles;
+	}
+
 	void CCompiledStyle::SetID(const std::wstring& sId)
 	{
 		m_sId = sId;
@@ -510,4 +508,9 @@ namespace NSCSS
 	{
 		return m_sId;
 	}
+	
+	bool CCompiledStyle::HaveThisParent(const std::wstring &wsParentName) const
+	{
+		return m_arParentsStyles.end() != m_arParentsStyles.find(wsParentName);
+	}
 }

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

@@ -22,9 +22,6 @@ namespace NSCSS
 		unsigned short int m_nDpi;
 		UnitMeasure m_UnitMeasure;
 
-		CSizeWindow m_oSourceWindow;
-		CSizeWindow m_oDeviceWindow;
-
 	public:
 		NSProperties::CFont       m_oFont;
 		NSProperties::CIndent     m_oMargin;
@@ -41,8 +38,6 @@ namespace NSCSS
 
 		void SetDpi(const unsigned short& uiDpi);
 		void SetUnitMeasure(const UnitMeasure& enUnitMeasure);
-		void SetSizeSourceWindow(const CSizeWindow& oSizeWindow);
-		void SetSizeDeviceWindow(const CSizeWindow& oSizeWindow);
 
 		bool Empty() const;
 
@@ -53,10 +48,13 @@ namespace NSCSS
 		void AddParent(const std::wstring& sParentName);
 
 		std::vector<std::wstring> GetParentsName() const;
+		std::set<std::wstring> GetParentsNamesSet() const;
 
 		void SetID(const std::wstring& sId);
 		std::wstring GetId() const;
 
+		bool HaveThisParent(const std::wstring& wsParentName) const;
+
 		CCompiledStyle& operator+= (const CCompiledStyle& oElement);
 		CCompiledStyle& operator=  (const CCompiledStyle& oElement);
 		bool operator==            (const CCompiledStyle& oElement) const;

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

@@ -1,7 +1,6 @@
 #include "CCssCalculator.h"
 #include "CCssCalculator_Private.h"
 
-
 namespace NSCSS
 {
 	CCssCalculator::CCssCalculator()
@@ -24,6 +23,16 @@ namespace NSCSS
 		return m_pInternal->GetCompiledStyle(oStyle, arSelectors, bIsSettings, unitMeasure);
 	}
 
+	std::wstring CCssCalculator::CalculateStyleId(const CNode& oNode)
+	{
+		return m_pInternal->CalculateStyleId(oNode);
+	}
+
+	bool CCssCalculator::CalculatePageStyle(NSProperties::CPage& oPageData, const std::vector<CNode> &arSelectors)
+	{
+		return m_pInternal->CalculatePageStyle(oPageData, arSelectors);
+	}
+
 	void CCssCalculator::AddStyles(const std::string &sStyle)
 	{
 		m_pInternal->AddStyles(sStyle);
@@ -54,26 +63,6 @@ namespace NSCSS
 		m_pInternal->SetBodyTree(oTree);
 	}
 
-	void CCssCalculator::SetSizeSourceWindow(const CSizeWindow &oSizeWindow)
-	{
-		m_pInternal->SetSizeSourceWindow(oSizeWindow);
-	}
-
-	void CCssCalculator::SetSizeDeviceWindow(const CSizeWindow &oSizeWindow)
-	{
-		m_pInternal->SetSizeDeviceWindow(oSizeWindow);
-	}
-
-	CSizeWindow CCssCalculator::GetSizeSourceWindow() const
-	{
-		return m_pInternal->GetSizeSourceWindow();
-	}
-
-	CSizeWindow CCssCalculator::GetSizeDeviceWindow() const
-	{
-		return m_pInternal->GetSizeDeviceWindow();
-	}
-
 	UnitMeasure CCssCalculator::GetUnitMeasure() const
 	{
 		return m_pInternal->GetUnitMeasure();

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

@@ -22,6 +22,9 @@ namespace NSCSS
 		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point) const;
 		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point) const;
 
+		std::wstring CalculateStyleId(const CNode& oNode);
+		bool CalculatePageStyle(NSProperties::CPage& oPageData, const std::vector<CNode> &arSelectors);
+
 		// void AddStyle(const std::vector<std::string>& sSelectors, const std::string& sStyle);
 		void AddStyles        (const std::string&  sStyle);
 		void AddStyles        (const std::wstring& wsStyle);
@@ -31,12 +34,6 @@ namespace NSCSS
 		void SetDpi(const unsigned short int& nValue);
 		void SetBodyTree(const CTree &oTree);
 
-		void SetSizeSourceWindow(const CSizeWindow& oSizeWindow);
-		void SetSizeDeviceWindow(const CSizeWindow& oSizeWindow);
-
-		CSizeWindow GetSizeSourceWindow() const;
-		CSizeWindow GetSizeDeviceWindow() const;
-
 		UnitMeasure GetUnitMeasure() const;
 		std::wstring GetEncoding()   const;
 		unsigned short int GetDpi()  const;

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

@@ -16,8 +16,9 @@
 
 #define MaxNumberRepetitions 6
 
-inline static std::wstring      StringifyValueList(const KatanaArray* oValues);
-inline static std::wstring      StringifyValue(const KatanaValue* oValue);
+inline static std::wstring StringifyValueList(const KatanaArray* oValues);
+inline static std::wstring StringifyValue(const KatanaValue* oValue);
+inline static bool         IsTableElement(const std::wstring& wsNameTag);
 
 bool operator<(const std::vector<NSCSS::CNode> &arLeftSelectors, const std::vector<NSCSS::CNode> &arRightSelectors)
 {
@@ -52,13 +53,6 @@ namespace NSCSS
 
 		m_mData.clear();
 
-		#ifdef CSS_CALCULATOR_WITH_XHTML
-		for (std::map<std::vector<CNode>, CCompiledStyle*>::iterator iter  = m_mUsedStyles.begin(); iter != m_mUsedStyles.end(); ++iter)
-			delete iter->second;
-
-		m_mUsedStyles.clear();
-		#endif
-
 		if (NULL != m_mStatictics)
 			delete m_mStatictics;
 	}
@@ -86,6 +80,182 @@ namespace NSCSS
 
 	}
 
+	#ifdef CSS_CALCULATOR_WITH_XHTML
+	std::map<std::wstring, std::wstring> CCssCalculator_Private::GetPageData(const std::wstring &wsPageName)
+	{
+		if (m_arPageDatas.empty())
+			return {};
+
+		for (const TPageData& oPageData : m_arPageDatas)
+		{
+			if (std::find(oPageData.m_wsNames.begin(), oPageData.m_wsNames.end(), wsPageName) != oPageData.m_wsNames.end())
+				return oPageData.m_mData;
+		}
+
+		return {};
+	}
+	
+	void CCssCalculator_Private::SetPageData(NSProperties::CPage &oPage, const std::map<std::wstring, std::wstring> &mData, unsigned int unLevel, bool bHardMode)
+	{
+		for (const std::pair<std::wstring, std::wstring> &oData : mData)
+		{
+			if (L"margin" == oData.first)
+				oPage.SetMargin(oData.second, unLevel, bHardMode);
+			else if (L"size" == oData.first)
+				oPage.SetSize(oData.second, unLevel, bHardMode);
+			else if (L"mso-header-margin" == oData.first)
+				oPage.SetHeader(oData.second, unLevel, bHardMode);
+			else if (L"mso-footer-margin" == oData.first)
+				oPage.SetFooter(oData.second, unLevel, bHardMode);
+		}
+	}
+
+	std::vector<std::wstring> CCssCalculator_Private::CalculateAllNodes(const std::vector<CNode> &arSelectors)
+	{
+		std::vector<std::wstring> arNodes;
+		
+		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin(); oNode != arSelectors.rend(); ++oNode)
+		{
+			if (!oNode->m_wsName.empty())
+				arNodes.push_back(oNode->m_wsName);
+
+			if (!oNode->m_wsClass.empty())
+			{
+				if (oNode->m_wsClass.find(L' ') != std::wstring::npos)
+				{
+					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false, L" ");
+
+					arNodes.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
+													  [](std::wstring sRes, const std::wstring& sClass)
+														{return sRes += L'.' + sClass + L' ';}));
+				}
+				else
+					arNodes.push_back(L'.' + oNode->m_wsClass);
+			}
+
+			if (!oNode->m_wsId.empty())
+				arNodes.push_back(L'#' + oNode->m_wsId);
+		}
+
+		return arNodes;
+	}
+
+	void CCssCalculator_Private::FindPrevAndKindElements(const CElement *pElement, const std::vector<std::wstring> &arNextNodes, std::vector<CElement*>& arFindedElements, const std::wstring &wsName, const std::vector<std::wstring> &arClasses)
+	{
+		if (arNextNodes.empty())
+			return;
+
+		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.crbegin() + 1, arNextNodes.crend());
+		const std::vector<CElement*> arTempKins = pElement->GetNextOfKin(wsName, arClasses);
+
+		if (!arTempPrev.empty())
+			arFindedElements.insert(arFindedElements.end(), arTempPrev.begin(), arTempPrev.end());
+
+		if (!arTempKins.empty())
+			arFindedElements.insert(arFindedElements.end(), arTempKins.begin(), arTempKins.end());
+	}
+
+	std::vector<CElement*> CCssCalculator_Private::FindElements(std::vector<std::wstring> &arNodes, std::vector<std::wstring> &arNextNodes, bool bIsSettings)
+	{
+		if (arNodes.empty())
+			return {};
+
+		std::vector<CElement*> arFindedElements;
+
+		std::wstring wsName, 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());
+			arNodes.pop_back();
+		}
+
+		if (!arNodes.empty())
+		{
+			wsName = arNodes.back();
+			arNodes.pop_back();
+			arNextNodes.push_back(wsName);
+		}
+
+		const std::map<std::wstring, CElement*>::const_iterator oFindName = m_mData.find(wsName);
+		std::map<std::wstring, CElement*>::const_iterator oFindId;
+
+		if (!wsId.empty())
+		{
+			oFindId = m_mData.find(wsId);
+
+			if (oFindId != m_mData.end() && NULL != m_mStatictics)
+			{
+				std::map<StatistickElement, unsigned int>::const_iterator oFindCountId = m_mStatictics->find(StatistickElement{StatistickElement::IsId, wsId});
+
+				if ((m_mStatictics->end() != oFindCountId) &&
+				   (((bIsSettings && oFindCountId->second < MaxNumberRepetitions) ||
+					 (!bIsSettings && oFindCountId->second >= MaxNumberRepetitions))))
+				{
+					if (!oFindId->second->Empty())
+						arFindedElements.push_back(oFindId->second);
+				}
+
+				FindPrevAndKindElements(oFindId->second, arNextNodes, arFindedElements, wsName);
+			}
+		}
+
+		if (!arClasses.empty())
+		{
+			if (!bIsSettings)
+			{
+				for (std::vector<std::wstring>::const_reverse_iterator iClass = arClasses.rbegin(); iClass != arClasses.rend(); ++iClass)
+				{
+					const std::map<std::wstring, CElement*>::const_iterator oFindClass = m_mData.find(*iClass);
+					if (oFindClass != m_mData.end())
+					{
+						if (!oFindClass->second->Empty())
+							arFindedElements.push_back(oFindClass->second);
+
+						FindPrevAndKindElements(oFindClass->second, arNextNodes, arFindedElements, wsName);
+					}
+				}
+			}
+		}
+
+		if (oFindName != m_mData.end())
+		{
+			if (!bIsSettings)
+			{
+				if (!oFindName->second->Empty())
+					arFindedElements.push_back(oFindName->second);
+
+				FindPrevAndKindElements(oFindName->second, arNextNodes, arFindedElements, wsName, arClasses);
+			}
+		}
+
+		if (arFindedElements.size() > 1)
+		{
+			std::sort(arFindedElements.rbegin(), arFindedElements.rend(),
+					  [](CElement* oFirstElement, CElement* oSecondElement)
+					  {
+						  return oFirstElement->GetWeight() > oSecondElement->GetWeight();
+					  });
+		}
+
+		return arFindedElements;
+	}
+	#endif
+
+	void CCssCalculator_Private::AddPageData(const std::wstring &wsPageNames, const std::wstring &wsStyles)
+	{
+		m_arPageDatas.push_back({NS_STATIC_FUNCTIONS::GetWordsW(wsPageNames), NS_STATIC_FUNCTIONS::GetRules(wsStyles)});
+	}
+	
 	inline void CCssCalculator_Private::GetStylesheet(const KatanaStylesheet *oStylesheet)
 	{
 		for (size_t i = 0; i < oStylesheet->imports.length; ++i)
@@ -308,231 +478,11 @@ namespace NSCSS
 		if (arSelectors.empty())
 			return CCompiledStyle();
 
-		SetUnitMeasure(unitMeasure);
+		CCompiledStyle oStyle;
 
-		if (!bIsSettings)
-		{
-			const std::map<std::vector<CNode>, CCompiledStyle*>::iterator oItem = m_mUsedStyles.find(arSelectors);
+		GetCompiledStyle(oStyle, arSelectors, bIsSettings, unitMeasure);
 
-			if (oItem != m_mUsedStyles.end())
-				return *oItem->second;
-		}
-		else if (NULL == m_mStatictics || m_mStatictics->empty())
-		{
-			CCompiledStyle oStyle;
-			oStyle.SetDpi(m_nDpi);
-			oStyle.SetUnitMeasure(m_UnitMeasure);
-			oStyle.SetID(arSelectors.back().m_wsName + ((!arSelectors.back().m_wsClass.empty()) ? L'.' + arSelectors.back().m_wsClass : L"") + ((arSelectors.back().m_wsId.empty()) ? L"" : L'#' + arSelectors.back().m_wsId) + L'-' + std::to_wstring(++m_nCountNodes));
-
-			oStyle.SetSizeDeviceWindow(m_oDeviceWindow);
-			oStyle.SetSizeSourceWindow(m_oSourceWindow);
-
-			return oStyle;
-		}
-
-		CCompiledStyle *pStyle = new CCompiledStyle();
-
-		pStyle->SetDpi(m_nDpi);
-		pStyle->SetUnitMeasure(m_UnitMeasure);
-
-		pStyle->SetSizeDeviceWindow(m_oDeviceWindow);
-		pStyle->SetSizeSourceWindow(m_oSourceWindow);
-
-		std::vector<std::wstring> arWords;
-		arWords.reserve(arSelectors.size() * 2);
-
-		std::vector<std::wstring> arNextNodes;
-		arNextNodes.reserve(arSelectors.size() * 2);
-
-		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin(); oNode != arSelectors.rend(); ++oNode)
-		{
-			arWords.push_back(oNode->m_wsName);
-
-			//TODO:: проверить данный момент
-//            if (oNode->m_sName == L"td")
-//				pStyle->m_oMargin.SetPermission(false);
-
-			if (oNode->m_wsName == L"table")
-				pStyle->m_oBorder.Block();
-
-			if (!oNode->m_wsClass.empty())
-			{
-				if (oNode->m_wsClass.find(L' ') != std::wstring::npos)
-				{
-					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false, L" ");
-
-					if (arClasses.size() > 1)
-						arClasses.resize(unique(arClasses.begin(),arClasses.end()) - arClasses.begin());
-					switch (arClasses.size())
-					{
-						case 1:
-						{
-							arWords.push_back(L'.' + arClasses[0]);
-							break;
-						}
-						case 2:
-						{
-							arWords.push_back(L'.' + arClasses[0] + L" ." + arClasses[1]);
-							break;
-						}
-						case 3:
-						{
-							arWords.push_back(L'.' + arClasses[0] + L" ." + arClasses[1] + L" ." + arClasses[2]);
-							break;
-						}
-						default:
-						{
-							arWords.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
-							                                  [](std::wstring sRes, const std::wstring& sClass)
-							                                    {return sRes += L'.' + sClass + L' ';}));
-							break;
-						}
-					}
-				}
-				else
-				arWords.push_back(L'.' + oNode->m_wsClass);
-			}
-			if (!oNode->m_wsId.empty())
-				arWords.push_back(L'#' + oNode->m_wsId);
-		}
-
-		std::vector<CElement*> arElements;
-
-		for (size_t i = 0; i < arSelectors.size(); ++i)
-		{
-			std::wstring sName, sId;
-			std::vector<std::wstring> arClasses;
-
-			if (arWords.back()[0] == L'#')
-			{
-				sId = arWords.back();
-				arWords.pop_back();
-				arNextNodes.push_back(sId);
-			}
-
-			if (arWords.back()[0] == L'.')
-			{
-				arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arWords.back(), false, L" ");
-				arNextNodes.push_back(arWords.back());
-				arWords.pop_back();
-			}
-
-			sName = arWords.back();
-			arWords.pop_back();
-			arNextNodes.push_back(sName);
-			pStyle->AddParent(sName);
-
-			const std::map<std::wstring, CElement*>::const_iterator oFindName = m_mData.find(sName);
-			std::map<std::wstring, CElement*>::const_iterator oFindId;
-			std::vector<CElement*> arFindElements;
-
-			if (!sId.empty())
-			{
-				oFindId = m_mData.find(sId);
-
-				if (oFindId != m_mData.end() && NULL != m_mStatictics)
-				{
-					std::map<StatistickElement, unsigned int>::const_iterator oFindCountId = m_mStatictics->find(StatistickElement{StatistickElement::IsId, sId});
-
-					if ((m_mStatictics->end() != oFindCountId) &&
-					   (((bIsSettings && oFindCountId->second < MaxNumberRepetitions) ||
-					     (!bIsSettings && oFindCountId->second >= MaxNumberRepetitions))))
-					{
-						if (!oFindId->second->Empty())
-							arFindElements.push_back(oFindId->second);
-					}
-
-					const std::vector<CElement*> arTempPrev = oFindId->second->GetPrevElements(arNextNodes.rbegin() + ((arClasses.empty()) ? 1 : 2), arNextNodes.rend());
-
-					if (!arTempPrev.empty())
-						arFindElements.insert(arFindElements.end(), arTempPrev.begin(), arTempPrev.end());
-				}
-			}
-
-			if (!arClasses.empty())
-			{
-				if (!bIsSettings)
-				{
-					for (std::vector<std::wstring>::const_reverse_iterator iClass = arClasses.rbegin(); iClass != arClasses.rend(); ++iClass)
-					{
-						const std::map<std::wstring, CElement*>::const_iterator oFindClass = m_mData.find(*iClass);
-						if (oFindClass != m_mData.end())
-						{
-							if (!oFindClass->second->Empty())
-								arFindElements.push_back(oFindClass->second);
-
-							const std::vector<CElement*> arTempPrev = oFindClass->second->GetPrevElements(arNextNodes.rbegin() + 2, arNextNodes.rend());
-							const std::vector<CElement*> arTempKins = oFindClass->second->GetNextOfKin(sName);
-
-							if (!arTempPrev.empty())
-								arFindElements.insert(arFindElements.end(), arTempPrev.begin(), arTempPrev.end());
-
-							if (!arTempKins.empty())
-								arFindElements.insert(arFindElements.end(), arTempKins.begin(), arTempKins.end());
-						}
-					}
-				}
-			}
-
-			if (oFindName != m_mData.end())
-			{
-				if (!bIsSettings)
-				{
-					if (!oFindName->second->Empty())
-						arFindElements.push_back(oFindName->second);
-
-					const std::vector<CElement*> arTempPrev = oFindName->second->GetPrevElements(arNextNodes.rbegin() + 1, arNextNodes.rend());
-					const std::vector<CElement*> arTempKins = oFindName->second->GetNextOfKin(sName, arClasses);
-
-					if (!arTempPrev.empty())
-						arFindElements.insert(arFindElements.end(), arTempPrev.begin(), arTempPrev.end());
-
-					if (!arTempKins.empty())
-						arFindElements.insert(arFindElements.end(), arTempKins.begin(), arTempKins.end());
-				}
-			}
-
-
-			if (arFindElements.size() > 1)
-			{
-				std::sort(arFindElements.rbegin(), arFindElements.rend(),
-				          [](CElement* oFirstElement, CElement* oSecondElement)
-				          {
-					          return oFirstElement->GetWeight() > oSecondElement->GetWeight();
-				          });
-			}
-
-			pStyle->AddStyle(arSelectors[i].m_mAttributes, i + 1);
-
-			for (const CElement* oElement : arFindElements)
-				pStyle->AddStyle(oElement->GetStyle(), i + 1);
-
-			if (NULL != m_mStatictics)
-			{
-				std::map<StatistickElement, unsigned int>::const_iterator oFindCountStyle = m_mStatictics->find(StatistickElement{StatistickElement::IsStyle, arSelectors[i].m_wsStyle});
-
-				if (oFindCountStyle != m_mStatictics->end())
-				{
-					if ((bIsSettings && oFindCountStyle->second <  MaxNumberRepetitions) ||
-					   (!bIsSettings && oFindCountStyle->second >= MaxNumberRepetitions))
-						pStyle->AddStyle(arSelectors[i].m_wsStyle, i + 1,  true);
-					else if (!bIsSettings)
-						pStyle->AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
-				}
-				else if (bIsSettings)
-					pStyle->AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
-			}
-			else
-				pStyle->AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
-		}
-
-		if (!bIsSettings)
-		{
-			pStyle->SetID(arSelectors.back().m_wsName + ((!arSelectors.back().m_wsClass.empty()) ? L'.' + arSelectors.back().m_wsClass : L"") + ((arSelectors.back().m_wsId.empty()) ? L"" : L'#' + arSelectors.back().m_wsId) + L'-' + std::to_wstring(++m_nCountNodes));
-			m_mUsedStyles[arSelectors] = pStyle;
-		}
-
-		return *pStyle;
+		return oStyle;
 	}
 
 	bool CCssCalculator_Private::GetCompiledStyle(CCompiledStyle &oStyle, const std::vector<CNode> &arSelectors, const bool &bIsSettings, const UnitMeasure &unitMeasure)
@@ -544,11 +494,11 @@ namespace NSCSS
 
 		if (!bIsSettings)
 		{
-			const std::map<std::vector<CNode>, CCompiledStyle*>::iterator oItem = m_mUsedStyles.find(arSelectors);
+			const std::map<std::vector<CNode>, CCompiledStyle>::iterator oItem = m_mUsedStyles.find(arSelectors);
 
 			if (oItem != m_mUsedStyles.end())
 			{
-				oStyle = *oItem->second;
+				oStyle = oItem->second;
 				return true;
 			}
 		}
@@ -558,180 +508,35 @@ namespace NSCSS
 			oStyle.SetUnitMeasure(m_UnitMeasure);
 			oStyle.SetID(arSelectors.back().m_wsName + ((!arSelectors.back().m_wsClass.empty()) ? L'.' + arSelectors.back().m_wsClass : L"") + ((arSelectors.back().m_wsId.empty()) ? L"" : L'#' + arSelectors.back().m_wsId) + L'-' + std::to_wstring(++m_nCountNodes));
 
-			oStyle.SetSizeDeviceWindow(m_oDeviceWindow);
-			oStyle.SetSizeSourceWindow(m_oSourceWindow);
-
 			return false;
 		}
 
 		oStyle.SetDpi(m_nDpi);
 		oStyle.SetUnitMeasure(m_UnitMeasure);
 
-		oStyle.SetSizeDeviceWindow(m_oDeviceWindow);
-		oStyle.SetSizeSourceWindow(m_oSourceWindow);
-
-		std::vector<std::wstring> arWords;
-		arWords.reserve(arSelectors.size() * 2);
-
-		std::vector<std::wstring> arNextNodes;
-		arNextNodes.reserve(arSelectors.size() * 2);
-
-		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin(); oNode != arSelectors.rend(); ++oNode)
-		{
-			arWords.push_back(oNode->m_wsName);
-
-//			if (oNode->m_sName == L"td")
-//				oStyle.m_pMargin.SetPermission(false);
-
-			if (oNode->m_wsName == L"table")
-				oStyle.m_oBorder.Block();
-
-			if (!oNode->m_wsClass.empty())
-			{
-				if (oNode->m_wsClass.find(L' ') != std::wstring::npos)
-				{
-					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false,  L" ");
-
-					if (arClasses.size() > 1)
-						arClasses.resize(unique(arClasses.begin(),arClasses.end()) - arClasses.begin());
-					switch (arClasses.size())
-					{
-						case 1:
-						{
-							arWords.push_back(L'.' + arClasses[0]);
-							break;
-						}
-						case 2:
-						{
-							arWords.push_back(L'.' + arClasses[0] + L" ." + arClasses[1]);
-							break;
-						}
-						case 3:
-						{
-							arWords.push_back(L'.' + arClasses[0] + L" ." + arClasses[1] + L" ." + arClasses[2]);
-							break;
-						}
-						default:
-						{
-							arWords.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
-							                                  [](std::wstring sRes, const std::wstring& sClass)
-							                                    {return sRes += L'.' + sClass + L' ';}));
-							break;
-						}
-					}
-				}
-				else
-				arWords.push_back(L'.' + oNode->m_wsClass);
-			}
-			if (!oNode->m_wsId.empty())
-				arWords.push_back(L'#' + oNode->m_wsId);
-		}
-
-		std::vector<CElement*> arElements;
-
+		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors);
+		std::vector<std::wstring> arPrevNodes;
+		bool bInTable = false;
+		
 		for (size_t i = 0; i < arSelectors.size(); ++i)
 		{
-			std::wstring sName, sId;
-			std::vector<std::wstring> arClasses;
+			oStyle.AddParent(arSelectors[i].m_wsName);
 
-			if (arWords.back()[0] == L'#')
+			if (!bInTable)
+				bInTable = IsTableElement(arSelectors[i].m_wsName);
+
+			if (bInTable)
 			{
-				sId = arWords.back();
-				arWords.pop_back();
-				arNextNodes.push_back(sId);
+				oStyle.m_oBackground.Clear();
+				oStyle.m_oBorder.Clear();
 			}
 
-			if (arWords.back()[0] == L'.')
-			{
-				arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arWords.back(), false,  L" ");
-				arNextNodes.push_back(arWords.back());
-				arWords.pop_back();
-			}
+			CCompiledStyle oTempStyle;
 
-			sName = arWords.back();
-			arWords.pop_back();
-			arNextNodes.push_back(sName);
-			oStyle.AddParent(sName);
+			oTempStyle.AddStyle(arSelectors[i].m_mAttributes, i + 1);
 
-			const std::map<std::wstring, CElement*>::const_iterator oFindName = m_mData.find(sName);
-			std::map<std::wstring, CElement*>::const_iterator oFindId;
-			std::vector<CElement*> arFindElements;
-
-			if (!sId.empty())
-			{
-				oFindId = m_mData.find(sId);
-
-				if (oFindId != m_mData.end() && NULL != m_mStatictics)
-				{
-					std::map<StatistickElement, unsigned int>::const_iterator oFindCountId = m_mStatictics->find(StatistickElement{StatistickElement::IsId, sId});
-
-					if ((m_mStatictics->end() != oFindCountId) &&
-					   (((bIsSettings && oFindCountId->second < MaxNumberRepetitions) ||
-					     (!bIsSettings && oFindCountId->second >= MaxNumberRepetitions))))
-					{
-						if (!oFindId->second->Empty())
-							arFindElements.push_back(oFindId->second);
-					}
-
-					const std::vector<CElement*> arTempPrev = oFindId->second->GetPrevElements(arNextNodes.rbegin() + ((arClasses.empty()) ? 1 : 2), arNextNodes.rend());
-
-					if (!arTempPrev.empty())
-						arFindElements.insert(arFindElements.end(), arTempPrev.begin(), arTempPrev.end());
-				}
-			}
-
-			if (!arClasses.empty())
-			{
-				if (!bIsSettings)
-				{
-					for (std::vector<std::wstring>::const_reverse_iterator iClass = arClasses.rbegin(); iClass != arClasses.rend(); ++iClass)
-					{
-						const std::map<std::wstring, CElement*>::const_iterator oFindClass = m_mData.find(*iClass);
-						if (oFindClass != m_mData.end())
-						{
-							if (!oFindClass->second->Empty())
-								arFindElements.push_back(oFindClass->second);
-
-							const std::vector<CElement*> arTempPrev = oFindClass->second->GetPrevElements(arNextNodes.rbegin() + 2, arNextNodes.rend());
-							const std::vector<CElement*> arTempKins = oFindClass->second->GetNextOfKin(sName);
-
-							if (!arTempPrev.empty())
-								arFindElements.insert(arFindElements.end(), arTempPrev.begin(), arTempPrev.end());
-
-							if (!arTempKins.empty())
-								arFindElements.insert(arFindElements.end(), arTempKins.begin(), arTempKins.end());
-						}
-					}
-				}
-			}
-
-			if (oFindName != m_mData.end())
-			{
-				if (!bIsSettings)
-				{
-					if (!oFindName->second->Empty())
-						arFindElements.push_back(oFindName->second);
-
-					const std::vector<CElement*> arTempPrev = oFindName->second->GetPrevElements(arNextNodes.rbegin() + 1, arNextNodes.rend());
-					const std::vector<CElement*> arTempKins = oFindName->second->GetNextOfKin(sName, arClasses);
-
-					if (!arTempPrev.empty())
-						arFindElements.insert(arFindElements.end(), arTempPrev.begin(), arTempPrev.end());
-
-					if (!arTempKins.empty())
-						arFindElements.insert(arFindElements.end(), arTempKins.begin(), arTempKins.end());
-				}
-			}
-
-
-			if (arFindElements.size() > 1)
-			{
-				std::sort(arFindElements.rbegin(), arFindElements.rend(),
-				          [](CElement* oFirstElement, CElement* oSecondElement)
-				          {
-					          return oFirstElement->GetWeight() > oSecondElement->GetWeight();
-				          });
-			}
+			for (const CElement* oElement : FindElements(arNodes, arPrevNodes, bIsSettings))
+				oTempStyle.AddStyle(oElement->GetStyle(), i + 1);
 
 			if (NULL != m_mStatictics)
 			{
@@ -741,31 +546,68 @@ namespace NSCSS
 				{
 					if ((bIsSettings && oFindCountStyle->second <  MaxNumberRepetitions) ||
 					   (!bIsSettings && oFindCountStyle->second >= MaxNumberRepetitions))
-						oStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1,  true);
+						oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1,  true);
 					else if (!bIsSettings)
-						oStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
+						oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
 				}
-				else if (bIsSettings)
-					oStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
+				else /*if (bIsSettings)*/
+					oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
 			}
 			else
-				oStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
+				oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
 
-			for (const CElement* oElement : arFindElements)
-				oStyle.AddStyle(oElement->GetStyle(), i + 1);
+			oStyle += oTempStyle;
 
-			oStyle.AddStyle(arSelectors[i].m_mAttributes, i + 1);
+			// Скидываем некоторые внешние стили, которые внутри таблицы переопределяются
+			if (bInTable && i < arSelectors.size() - 1)
+			{
+				oStyle.m_oFont.GetLineHeight().Clear();
+				oStyle.m_oPadding.Clear();
+				oStyle.m_oMargin.Clear();
+			}
 		}
 
-		if (!bIsSettings)
+		oStyle.SetID(CalculateStyleId(arSelectors.back()));
+
+		if (!bIsSettings && !oStyle.Empty())
+			m_mUsedStyles[arSelectors] = oStyle;
+
+		return true;
+	}
+
+	std::wstring CCssCalculator_Private::CalculateStyleId(const CNode& oNode)
+	{
+		return oNode.m_wsName + ((!oNode.m_wsClass.empty()) ? L'.' + oNode.m_wsClass : L"") + ((oNode.m_wsId.empty()) ? L"" : L'#' + oNode.m_wsId) + L'-' + std::to_wstring(++m_nCountNodes);
+	}
+
+	bool CCssCalculator_Private::CalculatePageStyle(NSProperties::CPage &oPageData, const std::vector<CNode> &arSelectors)
+	{
+		if (arSelectors.empty())
+			return false;
+
+		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors);
+		std::vector<std::wstring> arNextNodes;
+
+		for (size_t i = 0; i < arSelectors.size(); ++i)
 		{
-			oStyle.SetID(arSelectors.back().m_wsName + ((!arSelectors.back().m_wsClass.empty()) ? L'.' + arSelectors.back().m_wsClass : L"") + ((arSelectors.back().m_wsId.empty()) ? L"" : L'#' + arSelectors.back().m_wsId) + L'-' + std::to_wstring(++m_nCountNodes));
+			if (!arSelectors[i].m_wsStyle.empty() && std::wstring::npos != arSelectors[i].m_wsStyle.find(L"page"))
+			{
+				std::map<std::wstring, std::wstring> mRules = NS_STATIC_FUNCTIONS::GetRules(arSelectors[i].m_wsStyle);
+				if (mRules.end() != mRules.find(L"page"))
+					SetPageData(oPageData, GetPageData(mRules[L"page"]), i + 1, true);
+			}
 
-			CCompiledStyle *pTemp = new CCompiledStyle(oStyle);
+			for (const CElement* oElement : FindElements(arNodes, arNextNodes, false))
+			{
+				std::map<std::wstring, std::wstring> mRules = oElement->GetStyle();
+				if (mRules.end() != mRules.find(L"page"))
+					SetPageData(oPageData, GetPageData(mRules[L"page"]), i + 1, true);
+			}
 
-			m_mUsedStyles[arSelectors] = pTemp;
+			if (arSelectors[i].m_mAttributes.end() != arSelectors[i].m_mAttributes.find(L"page"))
+				SetPageData(oPageData, GetPageData(arSelectors[i].m_mAttributes.at(L"page")), i + 1, false);
 		}
-
+		
 		return true;
 	}
 	#endif
@@ -784,6 +626,16 @@ namespace NSCSS
 		if (wsStyle.empty())
 			return;
 
+		std::wregex oRegex(L"@page\\s*([^{]*)(\\{[^}]*\\})");
+		std::wsmatch oMatch;
+		std::wstring::const_iterator oSearchStart(wsStyle.cbegin());
+		
+		while (std::regex_search(oSearchStart, wsStyle.cend(), oMatch, oRegex))
+		{
+			AddPageData(oMatch[1].str(), oMatch[2].str());
+			oSearchStart = oMatch.suffix().first;
+		}
+
 		AddStyles(U_TO_UTF8(wsStyle));
 	}
 
@@ -810,26 +662,6 @@ namespace NSCSS
 		CTree::CountingNumberRepetitions(oTree, *m_mStatictics);
 	}
 
-	void CCssCalculator_Private::SetSizeSourceWindow(const CSizeWindow &oSizeWindow)
-	{
-		m_oSourceWindow = oSizeWindow;
-	}
-
-	void CCssCalculator_Private::SetSizeDeviceWindow(const CSizeWindow &oSizeWindow)
-	{
-		m_oDeviceWindow = oSizeWindow;
-	}
-
-	CSizeWindow CCssCalculator_Private::GetSizeSourceWindow() const
-	{
-		return m_oSourceWindow;
-	}
-
-	CSizeWindow CCssCalculator_Private::GetSizeDeviceWindow() const
-	{
-		return m_oDeviceWindow;
-	}
-
 	void CCssCalculator_Private::SetUnitMeasure(const UnitMeasure& nType)
 	{
 		m_UnitMeasure = nType;
@@ -863,9 +695,6 @@ namespace NSCSS
 
 		m_mData.clear();
 		m_arFiles.clear();
-
-		m_oDeviceWindow.Clear();
-		m_oSourceWindow.Clear();
 	}
 }
 inline static std::wstring StringifyValueList(const KatanaArray* oValues)
@@ -968,4 +797,11 @@ inline static std::wstring StringifyValue(const KatanaValue* oValue)
 	return str;
 }
 
+inline static bool IsTableElement(const std::wstring& wsNameTag)
+{
+	return  L"td" == wsNameTag || L"tr" == wsNameTag || L"table" == wsNameTag || 
+	        L"tbody" == wsNameTag || L"thead" == wsNameTag || L"tfoot" == wsNameTag ||
+	        L"th" == wsNameTag;
+}
+
 

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

@@ -26,16 +26,31 @@ namespace NSCSS
 
 		std::map<std::wstring, CElement*> m_mData;
 
+		typedef struct
+		{
+			std::vector<std::wstring>            m_wsNames;
+			std::map<std::wstring, std::wstring> m_mData;
+		} TPageData;
+
+		std::vector<TPageData> m_arPageDatas;
+
 		std::map<StatistickElement, unsigned int> *m_mStatictics; // Количество повторений свойств id и style у селекторов
 
 		#ifdef CSS_CALCULATOR_WITH_XHTML
-		std::map<std::vector<CNode>, CCompiledStyle*> m_mUsedStyles;
+		std::map<std::vector<CNode>, CCompiledStyle> m_mUsedStyles;
+		
+		std::map<std::wstring, std::wstring> GetPageData(const std::wstring& wsPageName);
+		void SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode = false);
+
+		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors);
+
+		void FindPrevAndKindElements(const CElement* pElement, const std::vector<std::wstring>& arNextNodes, std::vector<CElement*>& arFindedElements, const std::wstring& wsName, const std::vector<std::wstring>& arClasses = {});
+		std::vector<CElement*> FindElements(std::vector<std::wstring>& arNodes, std::vector<std::wstring>& arNextNodes, bool bIsSettings);
 		#endif
 
 		std::wstring m_sEncoding;
 
-		CSizeWindow m_oSourceWindow;
-		CSizeWindow m_oDeviceWindow;
+		void AddPageData(const std::wstring& wsPageName, const std::wstring& wsStyles);
 
 		void GetStylesheet(const KatanaStylesheet* oStylesheet);
 		void GetRule(const KatanaRule* oRule);
@@ -59,6 +74,9 @@ namespace NSCSS
 		#ifdef CSS_CALCULATOR_WITH_XHTML
 		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point);
 		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point);
+
+		std::wstring CalculateStyleId(const CNode& oNode);
+		bool CalculatePageStyle(NSProperties::CPage& oPageData, const std::vector<CNode> &arSelectors);
 		#endif
 
 		void AddStyles(const std::string& sStyle);
@@ -69,12 +87,6 @@ namespace NSCSS
 		void SetDpi(unsigned short int nValue);
 		void SetBodyTree(const CTree &oTree);
 
-		void SetSizeSourceWindow(const CSizeWindow& oSizeWindow);
-		void SetSizeDeviceWindow(const CSizeWindow& oSizeWindow);
-
-		CSizeWindow GetSizeSourceWindow() const;
-		CSizeWindow GetSizeDeviceWindow() const;
-
 		UnitMeasure GetUnitMeasure() const;
 		std::wstring GetEncoding() const;
 		unsigned short int GetDpi() const;

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

@@ -173,26 +173,26 @@ namespace NSCSS
 		return arElements;
 	}
 
-	std::vector<CElement *> CElement::GetPrevElements(const std::vector<std::wstring>::reverse_iterator &arNodesRBegin, const std::vector<std::wstring>::reverse_iterator &arNodesREnd) const
+	std::vector<CElement *> CElement::GetPrevElements(const std::vector<std::wstring>::const_reverse_iterator& oNodesRBegin, const std::vector<std::wstring>::const_reverse_iterator& oNodesREnd) const
 	{
-		if (arNodesRBegin >= arNodesREnd || m_arPrevElements.empty())
+		if (oNodesRBegin >= oNodesREnd || m_arPrevElements.empty())
 			return std::vector<CElement*>();
 
 		std::vector<CElement*> arElements;
 
-		for (std::vector<std::wstring>::reverse_iterator iWord = arNodesRBegin; iWord != arNodesREnd; ++iWord)
+		for (std::vector<std::wstring>::const_reverse_iterator iWord = oNodesRBegin; iWord != oNodesREnd; ++iWord)
 		{
 			if ((*iWord)[0] == L'.' && ((*iWord).find(L" ") != std::wstring::npos))
 			{
 				std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(*iWord, false, L" ");
-				for (std::wstring sClass : arClasses)
+				for (const std::wstring& wsClass : arClasses)
 				{
 					for (CElement* oPrevElement : m_arPrevElements)
 					{
-						if (oPrevElement->m_sSelector == sClass)
+						if (oPrevElement->m_sSelector == wsClass)
 						{
 							arElements.push_back(oPrevElement);
-							std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, arNodesREnd);
+							std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesREnd);
 							arElements.insert(arElements.end(), arTempElements.begin(), arTempElements.end());
 						}
 					}
@@ -205,7 +205,7 @@ namespace NSCSS
 					if (oPrevElement->m_sSelector == *iWord)
 					{
 						arElements.push_back(oPrevElement);
-						std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, arNodesREnd);
+						std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesREnd);
 						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>::reverse_iterator &arNodesRBegin, const std::vector<std::wstring>::reverse_iterator &arNodesREnd) 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::map<std::wstring, std::wstring> GetConvertStyle(const std::vector<CNode>& arNodes) const;
 
 		CElement *FindPrevElement(const std::wstring& sSelector) const;

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

@@ -5,7 +5,7 @@ namespace NSCSS
 	CNode::CNode()
 	{}
 
-	CNode::CNode(std::wstring wsName, std::wstring wsClass, std::wstring wsId)
+	CNode::CNode(const std::wstring& wsName, const std::wstring& wsClass, const std::wstring& wsId)
 		: m_wsName(wsName), m_wsClass(wsClass), m_wsId(wsId)
 	{}
 

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

@@ -18,7 +18,7 @@ namespace NSCSS
 
 	public:
 		CNode();
-		CNode(std::wstring wsName, std::wstring wsClass, std::wstring wsId);
+		CNode(const std::wstring& wsName, const std::wstring& wsClass, const std::wstring& wsId);
 
 		bool Empty() const;
 

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

@@ -14,23 +14,21 @@ namespace NSCSS
 	{
 		switch (enUnitMeasure)
 		{
-			case NSCSS::Pixel:
-				return dValue;
 			case NSCSS::Point:
-				return 72. / (double)ushDPI * dValue;
+				return dValue * 72. / (double)ushDPI;
 			case NSCSS::Cantimeter:
 				return dValue / (double)ushDPI * 2.54;
 			case NSCSS::Millimeter:
 				return dValue / (double)ushDPI * 25.4;
 			case NSCSS::Inch:
-				return 1. / (double)ushDPI * dValue;
+				return dValue / (double)ushDPI;
 			case NSCSS::Peak:
-				return 0.16667 / (double)ushDPI * dValue;
+				return dValue * 6. / (double)ushDPI; // 1 дюйм = 6 пик
 			case NSCSS::Twips:
-				return (dValue / (double)ushDPI) * 144.;
+				return dValue * 1440. / (double)ushDPI;
+			default:
+				return dValue;
 		}
-
-		return 0.;
 	}
 
 	double CUnitMeasureConverter::ConvertCm(double dValue, UnitMeasure enUnitMeasure, unsigned short ushDPI)
@@ -38,22 +36,20 @@ namespace NSCSS
 		switch (enUnitMeasure)
 		{
 			case NSCSS::Point:
-				return 28.35 * dValue;
+				return dValue * 28.3465 ; // 1 см = (2.54 / 72) пункта
 			case NSCSS::Pixel:
-				return (double)ushDPI / 2.54 * dValue;
-			case NSCSS::Cantimeter:
-				return dValue;
+				return dValue * (double)ushDPI / 2.54;
 			case NSCSS::Millimeter:
 				return dValue * 10.;
 			case NSCSS::Inch:
-				return dValue / 2.54f;
+				return dValue / 2.54; // 1 дюйм = 2.54 см
 			case NSCSS::Peak:
-				return 2.36 * dValue;
+				return dValue * 2.36; // 2.36 = 6 / 2.54
 			case NSCSS::Twips:
-				return (dValue) * 0.3937 * (double)ushDPI;
+				return dValue * 567.; // 1 см = (1440 / 2.54) твипов
+			default:
+				return dValue;
 		}
-
-		return 0.;
 	}
 
 	double CUnitMeasureConverter::ConvertMm(double dValue, NSCSS::UnitMeasure enUnitMeasure, unsigned short ushDPI)
@@ -61,22 +57,20 @@ namespace NSCSS
 		switch (enUnitMeasure)
 		{
 			case NSCSS::Point:
-				return 2.835 * dValue;
+				return dValue * 2.8346; // 1 мм = (25.4 / 72) пункта
 			case NSCSS::Pixel:
-				return (double)ushDPI / 25.4 * dValue;
+				return dValue * (double)ushDPI / 25.4;
 			case NSCSS::Cantimeter:
 				return dValue / 10.;
-			case NSCSS::Millimeter:
-				return dValue;
 			case NSCSS::Inch:
 				return dValue / 25.4;
 			case NSCSS::Peak:
-				return 0.236 * dValue;
+				return dValue * 0.236; // 0.236 = 6 / 25.4
 			case NSCSS::Twips:
-				return (dValue / 10.) * 0.3937 * (double)ushDPI;
+				return dValue * 56.7;
+			default:
+				return dValue;
 		}
-
-		return 0.;
 	}
 
 	double CUnitMeasureConverter::ConvertIn(double dValue, NSCSS::UnitMeasure enUnitMeasure, unsigned short ushDPI)
@@ -84,45 +78,41 @@ namespace NSCSS
 		switch (enUnitMeasure)
 		{
 			case NSCSS::Point:
-				return dValue / 6.;
+				return dValue / 72.;
 			case NSCSS::Pixel:
 				return dValue * (double)ushDPI;
 			case NSCSS::Cantimeter:
-				return dValue * 2.54;
+				return dValue * 2.54; // 1 дюйм = 2.54 см
 			case NSCSS::Millimeter:
 				return dValue * 25.4;
-			case NSCSS::Inch:
-				return dValue;
 			case NSCSS::Peak:
-				return dValue / 72.;
+				return dValue * 6.;
 			case NSCSS::Twips:
-				return dValue * 144.;
+				return dValue * 1440.;
+			default:
+				return dValue;
 		}
-
-		return 0.;
 	}
 
 	double CUnitMeasureConverter::ConvertPt(double dValue, NSCSS::UnitMeasure enUnitMeasure, unsigned short ushDPI)
 	{
 		switch (enUnitMeasure)
 		{
-			case NSCSS::Point:
-				return dValue;
 			case NSCSS::Pixel:
-				return (double)ushDPI / 72. * dValue;
+				return dValue * (double)ushDPI / 72.;
 			case NSCSS::Cantimeter:
-				return dValue * 0.03528;
+				return dValue * 0.03528; // 0.03528 = 2.54 / 72
 			case NSCSS::Millimeter:
 				return dValue * 0.3528;
 			case NSCSS::Inch:
-				return dValue / 72.;
+				return dValue / 72.; // 1 дюйм = 72 пункта
 			case NSCSS::Peak:
-				return dValue / 12.;
+				return dValue * 0.0833; // 0.0833 = 6 / 72 (1 пункт = 1/72 дюйма)
 			case NSCSS::Twips:
-				return (dValue / 72.) * 144.;
+				return dValue * 20.; // 20 = 1440 / 72
+			default:
+				return dValue;
 		}
-
-		return 0.;
 	}
 
 	double CUnitMeasureConverter::ConvertPc(double dValue, NSCSS::UnitMeasure enUnitMeasure, unsigned short ushDPI)
@@ -130,27 +120,49 @@ namespace NSCSS
 		switch (enUnitMeasure)
 		{
 			case NSCSS::Point:
-				return dValue * 12.;
+				return dValue * 12.; // 12 = 72 / 6
 			case NSCSS::Pixel:
-				return (double)ushDPI / 6. * dValue;
+				return dValue * (double)ushDPI / 6.; // 1 дюйм = 6 пика
 			case NSCSS::Cantimeter:
-				return dValue * 0.423;
+				return dValue * 0.423; // 0.423 = 2.54 / 6
 			case NSCSS::Millimeter:
-				return dValue * 4.23;
+				return dValue * 4.233; // 4.23 = 25.4 / 6
 			case NSCSS::Inch:
 				return dValue / 6.;
-			case NSCSS::Peak:
-				return dValue;
 			case NSCSS::Twips:
-				return dValue * 24.;
+				return dValue * 3.333; // 3.333 = 20 / 6
+			default:
+				return dValue;
+		}
+	}
+	
+	double CUnitMeasureConverter::ConvertTw(double dValue, UnitMeasure enUnitMeasure, unsigned short ushDPI)
+	{
+		switch (enUnitMeasure)
+		{
+			case NSCSS::Point:
+				return dValue * 0.05; // 0.05 = 72. / 1440.
+			case NSCSS::Pixel:
+				return dValue * (double)ushDPI / 1440.; // 1 дюйм = 1440 твипов
+			case NSCSS::Cantimeter:
+				return dValue * 0.001764; // 0.001764 = 2.54 / 1440
+			case NSCSS::Millimeter:
+				return dValue * 0.01764;
+			case NSCSS::Inch:
+				return dValue * 1440.;
+			case NSCSS::Peak:
+				return dValue * 0.004167; // 0.004167 = 6 / 1440
+			default:
+				return dValue;
 		}
-
-		return 0.;
 	}
 
 	bool CUnitMeasureConverter::GetValue(const std::wstring &wsValue, double &dValue, UnitMeasure &enUnitMeasure)
 	{
-		std::wregex oRegex(LR"((-?\.\d+|-?\d+(\.\d+)?)\s*(px|pt|cm|mm|in|pc|%|em|rem)?)");
+		if (wsValue.empty() || wsValue.end() == std::find_if(wsValue.begin(), wsValue.end(), [](wchar_t wChar) { return iswdigit(wChar);}))
+			return false;
+
+		std::wregex oRegex(LR"((-?\.\d+|-?\d+(\.\d+)?)\s*(px|pt|cm|mm|in|pc|%|em|rem|tw)?)");
 		std::wsmatch oMatches;
 
 		if(!std::regex_search(wsValue, oMatches, oRegex))
@@ -176,6 +188,8 @@ namespace NSCSS
 			enUnitMeasure = Em;
 		else if (L"rem" == oMatches[3])
 			enUnitMeasure = Rem;
+		else if (L"tw" == oMatches[3])
+			enUnitMeasure = Twips;
 		else
 			enUnitMeasure = None;
 		

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

@@ -30,6 +30,7 @@ namespace NSCSS
 		static double ConvertIn(double dValue, UnitMeasure enUnitMeasure, unsigned short ushDPI);
 		static double ConvertPt(double dValue, UnitMeasure enUnitMeasure, unsigned short ushDPI);
 		static double ConvertPc(double dValue, UnitMeasure enUnitMeasure, unsigned short ushDPI);
+		static double ConvertTw(double dValue, UnitMeasure enUnitMeasure, unsigned short ushDPI);
 
 		static bool GetValue(const std::wstring& wsValue, double& dValue, UnitMeasure& enUnitMeasure);
 	};

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

@@ -2,34 +2,6 @@
 
 namespace NSCSS
 {
-	CSizeWindow::CSizeWindow()
-		: m_ushWidth(0), m_ushHeight(0)
-	{}
-
-	CSizeWindow::CSizeWindow(unsigned short unWidth, unsigned short unHeight)
-		: m_ushWidth(unWidth), m_ushHeight(unHeight)
-	{}
-
-	bool CSizeWindow::Empty() const
-	{
-		return ((0 == m_ushWidth) && (0 == m_ushHeight));
-	}
-
-	void CSizeWindow::Clear()
-	{
-		m_ushWidth = m_ushHeight = 0;
-	}
-
-	bool CSizeWindow::operator==(const CSizeWindow &oSizeWindow) const
-	{
-		return ((m_ushWidth == oSizeWindow.m_ushWidth) && (m_ushHeight == oSizeWindow.m_ushHeight));
-	}
-
-	bool CSizeWindow::operator!=(const CSizeWindow &oSizeWindow) const
-	{
-		return ((m_ushWidth != oSizeWindow.m_ushWidth) || (m_ushHeight != oSizeWindow.m_ushHeight));
-	}
-
 	bool StatistickElement::operator<(const StatistickElement &oStatistickElement) const
 	{
 		return sValue < oStatistickElement.sValue;
@@ -98,7 +70,7 @@ namespace NSCSS
 			{L"deepskyblue",        L"00BFFF"}, {L"dodgerblue",            L"1E90FF"}, {L"cornflowerblue",L"6495ED"},
 			{L"mediumdlateblue",    L"7B68EE"}, {L"royalblue",             L"4169E1"}, {L"blue",          L"0000FF"},                                                                   {L"LightCoral", L"#F08080"}, {L"LightCoral", L"#F08080"}, {L"LightCoral", L"#F08080"},
 			{L"mediumblue",         L"0000CD"}, {L"darkblue",              L"00008B"}, {L"navy",          L"000080"},
-			{L"midnightblue",       L"191970"},
+			{L"midnightblue",       L"191970"}, {L"navyblue",              L"A0B0E0"},
 			/* White tones */
 			{L"white",              L"FFFFFF"}, {L"snow",                  L"FFFAFA"}, {L"honeydew",      L"F0FFF0"},
 			{L"mintcream",          L"F5FFFA"}, {L"azure",                 L"F0FFFF"}, {L"aliceblue",     L"F0F8FF"},

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

@@ -16,21 +16,6 @@ namespace NSCSS
 		ScalingDirectionY = 2
 	} ScalingDirection;
 
-	struct CSizeWindow
-	{
-		unsigned short m_ushWidth;
-		unsigned short m_ushHeight;
-
-		CSizeWindow();
-		CSizeWindow(unsigned short unWidth, unsigned short unHeight);
-
-		bool Empty() const;
-		void Clear();
-
-		bool operator==(const CSizeWindow& oSizeWindow) const;
-		bool operator!=(const CSizeWindow& oSizeWindow) const;
-	};
-
 	struct StatistickElement
 	{
 		enum TypeElement
@@ -61,66 +46,69 @@ namespace NSCSS
 		{
 			typedef enum
 			{
-				B_CustomStyle = 0,
-				B_StyleId = 1,
-				B_Type = 2,
-				B_Default = 3,
+				B_CustomStyle,
+				B_StyleId,
+				B_Type,
+				B_Default,
 
-				B_Name = 4,
-				B_BasedOn = 5,
-				B_QFormat = 6,
-				B_Link = 7,
-				B_UnhideWhenUsed = 8,
-				B_UiPriority = 9,
+				B_Name,
+				B_BasedOn,
+				B_QFormat,
+				B_Link,
+				B_UnhideWhenUsed,
+				B_UiPriority,
+				B_SemiHidden
 			} BasicProperties;
 
 			typedef enum
 			{
-				P_Jc = 0,
-				P_Spacing = 1,
-				P_ContextualSpacing = 2,
-				P_Ind = 3,
-				P_OutlineLvl = 4,
-				P_Shd = 5,
+				P_Jc,
+				P_Spacing,
+				P_ContextualSpacing,
+				P_Ind,
+				P_OutlineLvl,
+				P_Shd,
 				// <pBdr>
-					P_TopBorder = 6,
-					P_LeftBorder = 7,
-					P_BottomBorder = 8,
-					P_RightBorder = 9,
+					P_TopBorder,
+					P_LeftBorder,
+					P_BottomBorder,
+					P_RightBorder,
 				// </pBdr>
-				P_KeepLines = 10,
-				P_KeepNext = 11,
+				P_KeepLines,
+				P_KeepNext,
 			} ParagraphProperties;
 
 			typedef enum
 			{
-				R_RFonts = 0,
-				R_Sz = 1,
-				R_B = 2,
-				R_I = 3,
-				R_Color = 4,
-				R_U = 5,
-				R_Highlight = 6,
-				R_SmallCaps = 7
+				R_RFonts ,
+				R_Sz,
+				R_B,
+				R_I,
+				R_Color,
+				R_U,
+				R_Highlight,
+				R_Shd,
+				R_SmallCaps,
+				R_Kern
 			} RunnerProperties;
 
 			typedef enum
 			{
-				T_TblInd = 0,
+				T_TblInd ,
 				// <tblCellMar>
-					T_CellTop = 1,
-					T_CellLeft = 2,
-					T_CellBottom = 3,
-					T_CellRight = 4,
+					T_CellTop,
+					T_CellLeft,
+					T_CellBottom,
+					T_CellRight,
 				// <tblCellMar>
 
 				// <tblBorders>
-					T_BorderTop = 5,
-					T_BorderLeft = 6,
-					T_BorderBottom = 7,
-					T_BorderRight = 8,
-					T_BorderInsideH = 9,
-					T_BorderInsideV = 10
+					T_BorderTop ,
+					T_BorderLeft,
+					T_BorderBottom,
+					T_BorderRight,
+					T_BorderInsideH,
+					T_BorderInsideV 
 				// </tblBorders>
 			} TableProperties;
 		}

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

@@ -80,6 +80,52 @@ namespace NS_STATIC_FUNCTIONS
 		return arValues;
 	}
 
+	std::vector<std::wstring> ParseCSSPropertie(const std::wstring& wsInput)
+	{
+		std::vector<std::wstring> arResult;
+		std::wstring wsCurrent;
+		bool bInQuotes = false;
+		bool bInFunction = false;
+		int nParenDepth = 0;
+
+		for (wchar_t c : wsInput)
+		{
+			if (c == ' ' && !bInQuotes && !bInFunction)
+			{
+				if (!wsCurrent.empty())
+				{
+					arResult.push_back(wsCurrent);
+					wsCurrent.clear();
+				}
+			}
+			else if (c == '"' || c == '\'')
+			{
+				bInQuotes = !bInQuotes;
+				wsCurrent += c;
+			}
+			else if (c == '(')
+			{
+				bInFunction = true;
+				nParenDepth++;
+				wsCurrent += c;
+			}
+			else if (c == ')')
+			{
+				nParenDepth--;
+				if (nParenDepth == 0)
+					bInFunction = false;
+				wsCurrent += c;
+			} 
+			else 
+				wsCurrent += c;
+		}
+
+		if (!wsCurrent.empty())
+			arResult.push_back(wsCurrent);
+
+		return arResult;
+	}
+
 	std::vector<std::wstring> GetWordsW(const std::wstring& wsLine, bool bWithSigns, const std::wstring& wsDelimiters)
 	{
 		if (wsLine.empty())
@@ -95,7 +141,9 @@ namespace NS_STATIC_FUNCTIONS
 
 		while (std::wstring::npos != unEnd)
 		{
-			arWords.emplace_back(wsLine.data() + unStart, unEnd - unStart + ((bWithSigns) ? 1 : 0));
+			if (unStart != unEnd)
+				arWords.emplace_back(wsLine.data() + unStart, unEnd - unStart + ((bWithSigns) ? 1 : 0));
+
 			unStart = wsLine.find_first_not_of(wsDelimiters, unEnd);
 			unEnd = wsLine.find_first_of(wsDelimiters, unStart);
 		}
@@ -141,30 +189,17 @@ namespace NS_STATIC_FUNCTIONS
 
 	std::map<std::wstring, std::wstring> GetRules(const std::wstring& wsStyles)
 	{
-		if (wsStyles.empty())
-				return {};
+		std::wregex oCssPropertyRegex(L"([a-zA-Z-]+)\\s*:\\s*([^;\t\n\r\f\v]+)");
+		std::wsmatch oMatch;
+
+		std::wstring::const_iterator oSearchStart(wsStyles.cbegin());
 
 		std::map<std::wstring, std::wstring> mRules;
 
-		std::wstring::const_iterator oStartProperty = std::find_if_not(wsStyles.begin(), wsStyles.end(), std::iswspace);
-		std::wstring::const_iterator oEndProperty, oStartValue, oEndValue;
-
-		while (wsStyles.end() != oStartProperty)
+		while (std::regex_search(oSearchStart, wsStyles.cend(), oMatch, oCssPropertyRegex))
 		{
-			oEndProperty = std::find_if(oStartProperty, wsStyles.end(), [](const wchar_t &wcChar){ return L':' == wcChar;});
-			oStartValue  = std::find_if_not(oEndProperty + 1, wsStyles.end(), std::iswspace);
-
-			if (wsStyles.end() == oEndProperty || wsStyles.end() == oStartValue)
-				break;
-
-			oEndValue    = std::find_if(oStartValue, wsStyles.end(), [](const wchar_t &wcChar){ return L';' == wcChar;});
-
-			mRules.insert({std::wstring(oStartProperty, oEndProperty), std::wstring(oStartValue, oEndValue)});
-
-			if (wsStyles.end() == oEndValue)
-				break;
-
-			oStartProperty = std::find_if_not(oEndValue + 1, wsStyles.end(), std::iswspace);
+			mRules.insert(std::make_pair<std::wstring, std::wstring>(oMatch[1], oMatch[2]));
+			oSearchStart = oMatch.suffix().first;
 		}
 
 		return mRules;

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

@@ -20,6 +20,7 @@ namespace NSCSS
 		double ReadDouble(const std::wstring& wsValue);
 		std::vector<double> ReadDoubleValues(const std::wstring& wsValue);
 
+		std::vector<std::wstring> ParseCSSPropertie(const std::wstring& wsInput);
 		std::vector<std::wstring> GetWordsW(const std::wstring& wsLine, bool bWithSigns = false, const std::wstring& wsDelimiters = L" \n\r\t\f\v:;,!");
 		std::vector<unsigned short int> GetWeightSelector(const std::wstring& sSelector);
 		std::map<std::wstring, std::wstring> GetRules(const std::wstring& wsStyles);

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

@@ -13,6 +13,8 @@ namespace NSCSS
 {
 	namespace NSProperties
 	{
+	#define NEXT_LEVEL UINT_MAX, true
+
 	template<typename T>
 	class CValue
 	{
@@ -21,6 +23,7 @@ namespace NSCSS
 		friend class CDigit;
 		friend class CColor;
 		friend class CEnum;
+		friend class CURL;
 
 		T            m_oValue;
 		unsigned int m_unLevel;
@@ -54,6 +57,11 @@ namespace NSCSS
 			}
 		}
 
+		static bool LevelIsSame(const CValue& oFirstValue, const CValue& 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; }
@@ -69,28 +77,33 @@ namespace NSCSS
 			return *this;
 		}
 
-		CValue& operator =(const T& oValue)
+		virtual CValue& operator =(const T& oValue)
 		{
 			//m_oValue = oValue.m_oValue;
 			return *this;
 		}
 
-		CValue& operator+=(const CValue& oValue)
+		virtual CValue& operator+=(const CValue& oValue)
 		{
 			if (m_unLevel > oValue.m_unLevel || (m_bImportant && !oValue.m_bImportant) || oValue.Empty())
 				return *this;
 
 			m_oValue     = oValue.m_oValue;
-			m_unLevel    = std::max(m_unLevel, oValue.m_unLevel);
-			m_bImportant = std::max(m_bImportant, oValue.m_bImportant);
+			m_unLevel    = oValue.m_unLevel;
+			m_bImportant = oValue.m_bImportant;
 
 			return *this;
 		}
 
-		bool operator==(const CValue& oValue) const
+		virtual bool operator==(const CValue& oValue) const
 		{
 			return m_oValue == oValue.m_oValue;
 		}
+
+		virtual bool operator!=(const CValue& oValue) const
+		{
+			return m_oValue != oValue.m_oValue;
+		}
 	};
 
 	class CString : public CValue<std::wstring>
@@ -124,13 +137,15 @@ namespace NSCSS
 		CDigit(double dValue, unsigned int unLevel, 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, unsigned int unLevel, bool bHardMode);
 
 		bool Empty() const override;
 		bool Zero() const;
 		void Clear() override;
 
 		void ConvertTo(UnitMeasure enUnitMeasure, double dPrevValue = 0.);
-		
+
 		int          ToInt()     const override;
 		double       ToDouble()  const override;
 		std::wstring ToWString() const override;
@@ -144,6 +159,9 @@ namespace NSCSS
 		bool operator==(const double& oValue) const;
 		bool operator==(const CDigit& oDigit) const;
 
+		bool operator!=(const double& oValue) const;
+		bool operator!=(const CDigit& oDigit) const;
+
 		CDigit operator+(const CDigit& oDigit) const;
 		CDigit operator-(const CDigit& oDigit) const;
 		CDigit operator*(const CDigit& oDigit) const;
@@ -169,8 +187,28 @@ namespace NSCSS
 		bool Empty() const;
 
 		bool operator==(const TRGB& oRGB) const;
+		bool operator!=(const TRGB& oRGB) const;
 	};
 
+	class CURL
+	{
+	public:
+		CURL();
+
+		bool Empty() const;
+		bool LinkToId() const;
+
+		void Clear();
+
+		bool SetValue(const std::wstring& wsValue);
+		std::wstring GetValue() const;
+
+		bool operator==(const CURL& oValue) const;
+		bool operator!=(const CURL& oValue) const;
+	private:
+		std::wstring m_wsValue;
+	};
+	
 	typedef enum
 	{
 		ColorEmpty,
@@ -180,39 +218,8 @@ namespace NSCSS
 		ColorUrl
 	} ColorType;
 
-	class Q_DECL_EXPORT CColorValue
+	class CColor : public CValue<void*>
 	{
-	public:
-		CColorValue();
-		CColorValue(const CColorValue& oColorValue);
-		~CColorValue();
-
-		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);
-		void SetNone();
-
-		void Clear();
-
-		bool Empty() const;
-
-		ColorType    m_enType;
-		void*        m_pColor = NULL;
-
-		std::wstring GetColor() const;
-
-		bool         operator==(const CColorValue& oColorValue) const;
-		CColorValue& operator= (const CColorValue& oColorValue);
-	};
-
-	class CColor : public CValue<CColorValue>
-	{
-		CDigit m_oOpacity;
-		static TRGB ConvertHEXtoRGB(const std::wstring& wsValue);
-		static std::wstring ConvertRGBtoHEX(const TRGB& oValue);
-		static std::wstring CutURL(const std::wstring& wsValue);
-		void SetEmpty(unsigned int unLevel = 0);
 	public:
 		CColor();
 
@@ -220,6 +227,8 @@ namespace NSCSS
 		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;
@@ -229,7 +238,27 @@ namespace NSCSS
 		int ToInt() const override;
 		double ToDouble() const override;
 		std::wstring ToWString() const override;
+		std::wstring EquateToColor(const std::vector<std::pair<TRGB, std::wstring>>& arColors) const;
 		TRGB ToRGB() const;
+
+		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);
+	private:
+		CDigit    m_oOpacity;
+		ColorType m_enType;
+
+		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);
+		void SetNone();
 	};
 
 	typedef enum
@@ -277,7 +306,7 @@ namespace NSCSS
 		CEnum();
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode) override;
-		void SetMapping(const std::map<std::wstring, int>& mMap);
+		void SetMapping(const std::map<std::wstring, int>& mMap, int nDefaulvalue = -1);
 
 		bool Empty() const override;
 		void Clear() override;
@@ -370,19 +399,18 @@ namespace NSCSS
 
 		bool SetColor     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetBackground(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		void InBorder();
 
 		const CColor& GetColor() const;
-		bool IsInBorder()        const;
 
-		bool Empty() const;
+		void Clear();
+		bool Empty()  const;
+		bool IsNone() const;
 
 		CBackground& operator =(const CBackground& oBackground);
 		CBackground& operator+=(const CBackground& oBackground);
 		bool         operator==(const CBackground& oBackground) const;
 	private:
 		CColor m_oColor;
-		bool   m_bInBorder;
 	};
 
 	class CTransform
@@ -397,6 +425,11 @@ namespace NSCSS
 		bool SetMatrix(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetMatrix(const Aggplus::CMatrix &oMatrix);
 
+		void Translate(double dOffsetX, double dOffsetY);
+		void Scale(double dScaleX, double dScaleY);
+		void Rotate(double dValue);
+		void RotateAt(double dValue, double dX, double dY);
+
 		const CMatrix& GetMatrix() const;
 
 		bool Empty() const;
@@ -411,14 +444,20 @@ namespace NSCSS
 	{
 	public:
 		CBorderSide();
+		CBorderSide(const CBorderSide& oBorderSide);
+
+		void Clear();
 
 		static void Equation(CBorderSide &oFirstBorderSide, CBorderSide &oSecondBorderSide);
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidth(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetWidth(const double& dValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetStyle(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColor(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
+		void SetNone(unsigned int unLevel, bool bHardMode);
+
 		void Block();
 		void Unblock();
 
@@ -429,9 +468,13 @@ namespace NSCSS
 		const CColor&  GetColor() const;
 
 		bool Empty() const;
+		bool Zero()  const;
+		bool Valid() const;
 
 		CBorderSide& operator+=(const CBorderSide& oBorderSide);
 		bool         operator==(const CBorderSide& oBorderSide) const;
+		bool         operator!=(const CBorderSide& oBorderSide) const;
+		CBorderSide& operator =(const CBorderSide& oBorderSide);
 	private:
 		CDigit  m_oWidth;
 		CString m_oStyle;
@@ -440,48 +483,71 @@ namespace NSCSS
 		bool    m_bBlock;
 	};
 
+	typedef enum
+	{
+		Collapse,
+		Separate
+	} BorderCollapse;
+	
 	class CBorder
 	{
 	public:
 		CBorder();
 
+		void Clear();
+		void ClearLeftSide();
+		void ClearTopSide();
+		void ClearRightSide();
+		void ClearBottomSide();
+
 		static void Equation(CBorder &oFirstBorder, CBorder &oSecondBorder);
 
-		bool SetSides(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetWidth(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetStyle(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetColor(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetSides(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
+		bool SetWidth(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
+		bool SetWidth(const double& dValue,           unsigned int unLevel, bool bHardMode = false);
+		bool SetStyle(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
+		bool SetColor(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
+		bool SetCollapse(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		//Left Side
 		bool SetLeftSide       (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthLeftSide  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthLeftSide  (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleLeftSide  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorLeftSide  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		//Top Side
 		bool SetTopSide        (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthTopSide   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthTopSide   (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleTopSide   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorTopSide   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		//Right Side
 		bool SetRightSide      (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthRightSide (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthRightSide (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleRightSide (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorRightSide (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		//Bottom Side
 		bool SetBottomSide     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthBottomSide(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthBottomSide(const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleBottomSide(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorBottomSide(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
+		void SetNone(unsigned int unLevel, bool bHardMode = false);
+
 		void Block();
 		void Unblock();
 
 		bool Empty() const;
+		bool Zero() const;
 		bool EqualSides() const;
 
+		const CEnum& GetCollapse() const;
+
 		const CBorderSide& GetLeftBorder()   const;
 		const CBorderSide& GetTopBorder()    const;
 		const CBorderSide& GetRightBorder()  const;
@@ -489,11 +555,15 @@ namespace NSCSS
 
 		CBorder& operator+=(const CBorder& oBorder);
 		bool     operator==(const CBorder& oBorder) const;
+		bool     operator!=(const CBorder& oBorder) const;
+		CBorder& operator =(const CBorder& oBorder);
 	private:
 		CBorderSide m_oLeft;
 		CBorderSide m_oTop;
 		CBorderSide m_oRight;
 		CBorderSide m_oBottom;
+		
+		CEnum m_enCollapse;
 	};
 
 	class CTextDecorationLine
@@ -513,6 +583,7 @@ namespace NSCSS
 		bool LineThrough() const;
 
 		CTextDecorationLine &operator+=(const CTextDecorationLine& oTextDecoration);
+		bool operator==(const CTextDecorationLine& oTextDecorationLine) const;
 	};
 
 	struct TTextDecoration
@@ -522,6 +593,7 @@ namespace NSCSS
 		CColor              m_oColor;
 
 		TTextDecoration& operator+=(const TTextDecoration& oTextDecoration);
+		bool operator==(const TTextDecoration& oTextDecoration) const;
 	};
 
 	class CText
@@ -535,11 +607,13 @@ namespace NSCSS
 		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);
 
 		const CDigit&          GetIndent()     const;
 		const CString&         GetAlign()      const;
 		const TTextDecoration& GetDecoration() const;
 		const CColor&          GetColor()      const;
+		const CColor&          GetHighlight()  const;
 
 		bool Empty() const;
 
@@ -554,6 +628,7 @@ namespace NSCSS
 		CDigit          m_oIndent;
 		CString         m_oAlign;
 		CColor          m_oColor;
+		CColor          m_oHighlight;
 	};
 
 	class CIndent
@@ -561,33 +636,44 @@ namespace NSCSS
 	public:
 		CIndent();
 
+		void Clear();
+
 		static void Equation(CIndent &oFirstMargin, CIndent &oSecondMargin);
 
+		bool Equals() const;
+
 		void SetPermisson(bool bPermission);
 
-		bool AddValue  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool AddLeft   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool AddTop    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool AddRight  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool AddBottom (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		
-		void UpdateAll(double dFontSize);
-		void UpdateLeft(double dFontSize);
-		void UpdateTop(double dFontSize);
-		void UpdateRight(double dFontSize);
-		void UpdateBottom(double dFontSize);
+		bool SetValues (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetTop    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetTop    (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetRight  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetRight  (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetBottom (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetBottom (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetLeft   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetLeft   (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+
+		void UpdateAll   (double dFontSize);
+		void UpdateTop   (double dFontSize);
+		void UpdateRight (double dFontSize);
+		void UpdateBottom(double dFontSize);
+		void UpdateLeft  (double dFontSize);
 
-		const CDigit& GetLeft  () const;
 		const CDigit& GetTop   () const;
 		const CDigit& GetRight () const;
 		const CDigit& GetBottom() const;
+		const CDigit& GetLeft  () const;
 
 		bool Empty() const;
+		bool Zero() const;
 
-		CIndent& operator+=(const CIndent& oMargin);
-		bool     operator==(const CIndent& oMargin) const;
+		CIndent& operator+=(const CIndent& oIndent);
+		bool     operator==(const CIndent& oIndent) const;
+		bool     operator!=(const CIndent& oIndent) const;
 	private:
-		bool AddValue(CDigit& oValue, const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetValues(const std::wstring& wsTopValue, const std::wstring& wsRightValue, const std::wstring& wsBottomValue, const std::wstring& wsLeftValue, unsigned int unLevel, bool bHardMode = false);
+		void UpdateSide(CDigit& oSide, double dFontSize);
 
 		CDigit m_oLeft;
 		CDigit m_oTop;
@@ -606,6 +692,7 @@ namespace NSCSS
 
 		bool SetValue         (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetSize          (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetSize          (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetLineHeight    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetFamily        (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetStretch       (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
@@ -623,6 +710,7 @@ namespace NSCSS
 
 		const CDigit&  GetSize()       const;
 		const CDigit&  GetLineHeight() const;
+		CDigit&  GetLineHeight();
 		const CString& GetFamily()     const;
 		const CString& GetStretch()    const;
 		const CString& GetStyle()      const;
@@ -642,8 +730,29 @@ namespace NSCSS
 		CString m_oStyle;
 		CString m_oVariant;
 		CString m_oWeight;
+	};
 
-		TTextDecoration m_oTextDecoration;
+	class CPage
+	{
+	public:
+		CPage();
+
+		bool SetMargin (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetSize   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetFooter (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetHeader (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+
+		const CDigit&  GetWidth()  const;
+		const CDigit&  GetHeight() const;
+		const CIndent& GetMargin() const;
+		const CDigit&  GetFooter() const;
+		const CDigit&  GetHeader() const;
+	private:
+		CDigit  m_oWidth;
+		CDigit  m_oHeight;
+		CIndent m_oMargin;
+		CDigit  m_oFooter;
+		CDigit  m_oHeader;
 	};
 	}
 }

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

@@ -1,19 +1,20 @@
 #include "CDocumentStyle.h"
 
 #include <iostream>
+#include <unordered_set>
 #include <wchar.h>
 #include <math.h>
+#include <cmath>
 #include <algorithm>
 #include <list>
 
+#define DEFAULT_LINEHEIGHT 240
 #define LINEHEIGHTSCALE 10 // Значение LineHeight в OOXML должно быть в 10 раз больше чем указано в стиле
-#define LINEHEIGHTCOEF  24 // Используется когда необходимо перевести в twips значение
-#define POINTCOEF       20 // Используется для конвертации в OOXML значение интервала между абзацами (Измерение в двадцатых долях от точки)
 
-#define PAGEWIDTH  (12240 / POINTCOEF)
-#define PAGEHEIGHT (15840 / POINTCOEF)
-
-#define DOUBLE_TO_INTW(dValue) std::to_wstring(static_cast<int>(dValue + 0.5))
+#define VALUE_TO_INT(value, unit_measure) \
+	(NSCSS::UnitMeasure::None != value.GetUnitMeasure()) ? \
+		value.ToInt(unit_measure) : \
+		static_cast<int>(NSCSS::CUnitMeasureConverter::ConvertPx(value.ToDouble(), unit_measure, 96) + 0.5)
 
 namespace NSCSS
 {
@@ -21,24 +22,55 @@ namespace NSCSS
 		: m_oStyle(oStyle), m_bIsPStyle(bIsPStyle)
 	{}
 
+	bool CheckArrays(const std::vector<std::wstring>& arInitial, const std::set<std::wstring>& arFirst, const std::set<std::wstring>& arSecond) 
+	{
+		std::unordered_set<std::wstring> arInitialSet(arInitial.begin(), arInitial.end());
+	
+		std::vector<std::wstring> arCommonElements1;
+		std::vector<std::wstring> arCommonElements2;
+
+		for (const std::wstring& wsValue : arFirst)
+		{
+			if (arInitialSet.count(wsValue) > 0)
+				arCommonElements1.push_back(wsValue);
+		}
+
+		for (const std::wstring& wsValue : arSecond)
+		{
+			if (arInitialSet.count(wsValue) > 0)
+				arCommonElements2.push_back(wsValue);
+		}
+
+		if (arCommonElements1.size() != arCommonElements2.size())
+			return false;
+
+		std::sort(arCommonElements1.begin(), arCommonElements1.end());
+		std::sort(arCommonElements2.begin(), arCommonElements2.end());
+
+		return arCommonElements1 == arCommonElements2;
+	}
+
 	bool CStyleUsed::operator==(const CStyleUsed &oUsedStyle) const
 	{
-		return (m_bIsPStyle == oUsedStyle.m_bIsPStyle) && (m_oStyle == oUsedStyle.m_oStyle);
+		return m_bIsPStyle == oUsedStyle.m_bIsPStyle &&
+		       CheckArrays(Names_Standard_Styles, m_oStyle.GetParentsNamesSet(), oUsedStyle.m_oStyle.GetParentsNamesSet()) &&
+		       m_oStyle == oUsedStyle.m_oStyle;
 	}
 
 	std::wstring CStyleUsed::getId()
 	{
-		return m_sId;
+		if (m_bIsPStyle)
+			return m_oStyle.GetId();
+
+		return m_oStyle.GetId() + L"-c";
 	}
 
-	void CStyleUsed::setId(const std::wstring &sId)
+	CDocumentStyle::CDocumentStyle() : m_arStandardStyles(Names_Standard_Styles)
 	{
-		m_sId = sId;
+		for (const std::wstring& oNameStandardStyle : Names_Standard_Styles)
+			m_arStandardStyles.push_back(oNameStandardStyle + L"-c");
 	}
 
-	CDocumentStyle::CDocumentStyle() : m_arStandardStyles({L"a", L"li", L"h1", L"h2", L"h3", L"h4", L"h5", L"h6", L"h1-c",
-	    L"h2-c", L"h3-c", L"h4-c", L"h5-c", L"h6-c", L"p-c", L"p", L"div-c", L"div", L"a-c"}) {}
-
 	CDocumentStyle::~CDocumentStyle()
 	{
 		m_arStandardStyles.    clear();
@@ -157,6 +189,7 @@ namespace NSCSS
 
 			if (!oParentStyle.Empty())
 			{
+				oParentStyle.AddBasicProperties(BProperties::B_BasedOn, L"normal");
 				oParentStyle.AddBasicProperties(BProperties::B_StyleId, L"(" + oParentStyle.GetStyleId() + L")");
 				if (!bIsPStyle)
 				{
@@ -271,250 +304,308 @@ namespace NSCSS
 		oElement.AddBasicProperties(BProperties::B_CustomStyle, L"1");
 	}
 
-	void CDocumentStyle::SetPStyle   (const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement)
+	void CDocumentStyle::SetPStyle   (const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite)
 	{
-		ConvertStyle(oStyle, oXmlElement, true);
-		if (oStyle.Empty() && oXmlElement.Empty())
+		if (!bIsLite)
+			ConvertStyle(oStyle, oXmlElement, true);
+
+		if (oStyle.Empty())
 			return;
-		
-		oXmlElement.AddPropertiesInP(PProperties::P_Jc, oStyle.m_oText.GetAlign().ToWString());
+
+		const bool bInTable{oStyle.HaveThisParent(L"table")};
+
+		std::wstring wsTextAlign{oStyle.m_oText.GetAlign().ToWString()};
+
+		if (wsTextAlign.empty() && bInTable)
+			wsTextAlign = oStyle.m_oDisplay.GetHAlign().ToWString();
+
+		oXmlElement.AddPropertiesInP(PProperties::P_Jc, wsTextAlign);
 
 		std::wstring sInfValue;
 		sInfValue.reserve(64);
 
-		//TODO:: проверить Permission в Margin
-		if (!oStyle.m_oMargin.Empty() || !oStyle.m_oPadding.Empty() /*&& oStyle.m_oMargin.GetPermission()*/)
-		{
-			const double dLeftSide  = oStyle.m_oMargin.GetLeft() .ToDouble(NSCSS::Twips) + oStyle.m_oPadding.GetLeft() .ToDouble(NSCSS::Twips);
-			const double dRightSide = oStyle.m_oMargin.GetRight().ToDouble(NSCSS::Twips) + oStyle.m_oPadding.GetRight().ToDouble(NSCSS::Twips);
+		if (!oStyle.m_oMargin.GetLeft().Empty() && !oStyle.m_oMargin.GetLeft().Zero())
+			sInfValue += L"w:left=\""   + std::to_wstring(oStyle.m_oMargin.GetLeft().ToInt(NSCSS::Twips)) + L"\" ";
 
-			sInfValue += L"w:left=\""  + DOUBLE_TO_INTW(dLeftSide  * POINTCOEF) + L"\" ";
-			sInfValue += L"w:right=\"" + DOUBLE_TO_INTW(dRightSide * POINTCOEF) + L"\" ";
-		}
+		if (!oStyle.m_oMargin.GetRight().Empty() && !oStyle.m_oMargin.GetRight().Zero())
+			sInfValue += L"w:right=\""  + std::to_wstring(oStyle.m_oMargin.GetRight().ToInt(NSCSS::Twips)) + L"\" ";
 
-		const double dIndent = oStyle.m_oText.GetIndent().ToDouble(NSCSS::Twips);
-		
-		if (0. != dIndent)
-			sInfValue += L"w:firstLine=\"" + DOUBLE_TO_INTW(dIndent) + L"\" ";
+		const int nIndent = oStyle.m_oText.GetIndent().ToInt(NSCSS::Twips);
+
+		if (0 != nIndent)
+			sInfValue += L"w:firstLine=\"" + std::to_wstring(nIndent) + L"\" ";
 
 		oXmlElement.AddPropertiesInP(PProperties::P_Ind, sInfValue);
 
 		std::wstring sSpacingValue;
 		sSpacingValue.reserve(128);
 
-		//TODO:: проверить Permission в Margin
-		if (!oStyle.m_oMargin.Empty() || !oStyle.m_oPadding.Empty()/*&& oStyle.m_oMargin.GetPermission()*/)
-		{
-			const double dSpacingBottom = oStyle.m_oMargin.GetBottom().ToDouble(NSCSS::Twips) + oStyle.m_oPadding.GetBottom().ToDouble(NSCSS::Twips);
-			const double dSpacingTop    = oStyle.m_oMargin.GetTop()   .ToDouble(NSCSS::Twips) + oStyle.m_oPadding.GetTop()   .ToDouble(NSCSS::Twips);;
-			
-			sSpacingValue += L" w:after=\""  + DOUBLE_TO_INTW(dSpacingBottom * POINTCOEF) + L"\" ";
-			sSpacingValue += L" w:before=\"" + DOUBLE_TO_INTW(dSpacingTop    * POINTCOEF) + L"\" ";
-		}
-		else/* if (!oStyle.m_pBorder.Empty() || !oStyle.m_oMargin.GetPermission())*/
-			sSpacingValue += L"w:after=\"0\" w:before=\"0\"";
+		if (!oStyle.m_oMargin.GetTop().Empty() && !oStyle.m_oMargin.GetTop().Zero())
+			sSpacingValue += L"w:before=\""  + std::to_wstring(VALUE_TO_INT(oStyle.m_oMargin.GetTop(), NSCSS::Twips))    + L"\" w:beforeAutospacing=\"0\"";
+		else if (oStyle.m_oMargin.GetBottom().Zero() || bInTable)
+			sSpacingValue += L"w:before=\"0\" w:beforeAutospacing=\"0\"";
 
-		std::wstring wsLineHeight;
-		
-		if (!oStyle.m_oFont.GetLineHeight().Empty())
-		{
-			double dLineHeight = oStyle.m_oFont.GetLineHeight().ToDouble(NSCSS::Twips, LINEHEIGHTCOEF) * LINEHEIGHTSCALE;
+		if (!oStyle.m_oMargin.GetBottom().Empty() && !oStyle.m_oMargin.GetBottom().Zero())
+			sSpacingValue += L" w:after=\""   + std::to_wstring(VALUE_TO_INT(oStyle.m_oMargin.GetBottom(), NSCSS::Twips)) + L"\" w:afterAutospacing=\"0\"";
+		else if (oStyle.m_oMargin.GetBottom().Zero() || bInTable)
+			sSpacingValue += L" w:after=\"0\" w:afterAutospacing=\"0\"";
 
-			if (NSCSS::None == oStyle.m_oFont.GetLineHeight().GetUnitMeasure())
-				dLineHeight *= LINEHEIGHTCOEF;
-			
-			if (0. != dLineHeight)
-				wsLineHeight = DOUBLE_TO_INTW(dLineHeight);
-		}
-		
-		if (!wsLineHeight.empty())
+		if (!oStyle.m_oFont.GetLineHeight().Empty() && !oStyle.m_oFont.GetLineHeight().Zero())
 		{
-			sSpacingValue += L" w:line=\"" + wsLineHeight + L"\" w:lineRule=\"auto\"";
+			const std::wstring wsLine{std::to_wstring(oStyle.m_oFont.GetLineHeight().ToInt(NSCSS::Twips, DEFAULT_LINEHEIGHT))};
+			const std::wstring wsLineRule{(NSCSS::Percent == oStyle.m_oFont.GetLineHeight().GetUnitMeasure() ? L"auto" : L"atLeast")};
+
+			sSpacingValue += L" w:line=\"" + wsLine + L"\" w:lineRule=\"" + wsLineRule + L"\"";
 		}
-//		else if (!oStyle.m_oBorder.Empty())
-//		{
-//			sSpacingValue += L" w:line=\"" + std::to_wstring(static_cast<short int>(oStyle.m_oFont.GetSize().ToDouble(NSCSS::Twips) * 2 * POINTCOEF + 0.5f)) + L"\" w:lineRule=\"auto\"";
-//		}
-		else if (!oStyle.m_oBorder.Empty())
-			sSpacingValue += L" w:line=\"240\" w:lineRule=\"auto\" ";
+		else if (oStyle.m_oFont.GetLineHeight().Zero() || bInTable)
+			sSpacingValue += L" w:lineRule=\"auto\" w:line=\"240\"";
 
 		if (!sSpacingValue.empty())
-		{
 			oXmlElement.AddPropertiesInP(PProperties::P_Spacing, sSpacingValue);
-			oXmlElement.AddPropertiesInP(PProperties::P_ContextualSpacing, L"true");
-		}
 
-		if (!oStyle.m_oBackground.Empty())
-		{
-			const std::wstring wsColor = oStyle.m_oBackground.GetColor().ToWString();
-			if (wsColor != L"ffffff")
-				oXmlElement.AddPropertiesInP(PProperties::P_Shd, wsColor);
-		}
+		if (!oStyle.m_oBackground.Empty() && !bInTable)
+			oXmlElement.AddPropertiesInP(PProperties::P_Shd, oStyle.m_oBackground.IsNone() ? L"auto" : oStyle.m_oBackground.GetColor().ToWString());
 
-		if (!oStyle.m_oBorder.Empty())
+		if (!oStyle.m_oBorder.Empty() && !bInTable)
 		{
 			if (oStyle.m_oBorder.EqualSides())
 			{
-				const std::wstring sBorderColor = oStyle.m_oBorder.GetLeftBorder().GetColor().ToWString();
-				const std::wstring sBorderStyle = oStyle.m_oBorder.GetLeftBorder().GetStyle().ToWString();
-				const std::wstring sBorderWidth = oStyle.m_oBorder.GetLeftBorder().GetWidth().ToWString();
-
-				const std::wstring sBorder = L" w:color=\"" + sBorderColor + L"\" w:space=\"0\" w:sz=\"" +
-				                                              sBorderWidth + L"\" w:val=\"" + sBorderStyle + L"\"";
-
-				oXmlElement.AddPropertiesInP(PProperties::P_TopBorder, sBorder);
-				oXmlElement.AddPropertiesInP(PProperties::P_LeftBorder, sBorder);
-				oXmlElement.AddPropertiesInP(PProperties::P_BottomBorder, sBorder);
-				oXmlElement.AddPropertiesInP(PProperties::P_RightBorder, sBorder);
+				SetBorderStyle(oStyle, oXmlElement, PProperties::P_TopBorder);
+				SetBorderStyle(oStyle, oXmlElement, PProperties::P_LeftBorder);
+				SetBorderStyle(oStyle, oXmlElement, PProperties::P_BottomBorder);
+				SetBorderStyle(oStyle, oXmlElement, PProperties::P_RightBorder);
 			}
 			else
 			{
 				if (!oStyle.m_oBorder.GetTopBorder().Empty())
-				{
-					const std::wstring sBorderColor = oStyle.m_oBorder.GetTopBorder().GetColor().ToWString();
-					const std::wstring sBorderStyle = oStyle.m_oBorder.GetTopBorder().GetStyle().ToWString();
-					const std::wstring sBorderWidth = oStyle.m_oBorder.GetTopBorder().GetWidth().ToWString();
-
-					const std::wstring sBorder = L" w:color=\"" + sBorderColor + L"\" w:space=\"4\" w:sz=\"" +
-					                                              sBorderWidth + L"\" w:val=\"" + sBorderStyle + L"\"";
-
-					oXmlElement.AddPropertiesInP(PProperties::P_TopBorder, sBorder);
-				}
+					SetBorderStyle(oStyle, oXmlElement, PProperties::P_TopBorder);
 
 				if (!oStyle.m_oBorder.GetRightBorder().Empty())
-				{
-					const std::wstring sBorderColor = oStyle.m_oBorder.GetRightBorder().GetColor().ToWString();
-					const std::wstring sBorderStyle = oStyle.m_oBorder.GetRightBorder().GetStyle().ToWString();
-					const std::wstring sBorderWidth = oStyle.m_oBorder.GetRightBorder().GetWidth().ToWString();
-
-					const std::wstring sBorder = L" w:color=\"" + sBorderColor + L"\" w:space=\"4\" w:sz=\"" +
-					                                              sBorderWidth + L"\" w:val=\"" + sBorderStyle + L"\"";
-
-					oXmlElement.AddPropertiesInP(PProperties::P_RightBorder, sBorder);
-				}
+					SetBorderStyle(oStyle, oXmlElement, PProperties::P_RightBorder);
 
 				if (!oStyle.m_oBorder.GetBottomBorder().Empty())
-				{
-					const std::wstring sBorderColor = oStyle.m_oBorder.GetBottomBorder().GetColor().ToWString();
-					const std::wstring sBorderStyle = oStyle.m_oBorder.GetBottomBorder().GetStyle().ToWString();
-					const std::wstring sBorderWidth = oStyle.m_oBorder.GetBottomBorder().GetWidth().ToWString();
-
-					const std::wstring sBorder = L" w:color=\"" + sBorderColor + L"\" w:space=\"4\" w:sz=\"" +
-					                                              sBorderWidth + L"\" w:val=\"" + sBorderStyle + L"\"";
-
-					oXmlElement.AddPropertiesInP(PProperties::P_BottomBorder, sBorder);
-				}
+					SetBorderStyle(oStyle, oXmlElement, PProperties::P_BottomBorder);
 
 				if (!oStyle.m_oBorder.GetLeftBorder().Empty())
-				{
-					const std::wstring sBorderColor = oStyle.m_oBorder.GetLeftBorder().GetColor().ToWString();
-					const std::wstring sBorderStyle = oStyle.m_oBorder.GetLeftBorder().GetStyle().ToWString();
-					const std::wstring sBorderWidth = oStyle.m_oBorder.GetLeftBorder().GetWidth().ToWString();
-
-					const std::wstring sBorder = L" w:color=\"" + sBorderColor + L"\" w:space=\"4\" w:sz=\"" +
-					                                              sBorderWidth + L"\" w:val=\"" + sBorderStyle + L"\"";
-
-					oXmlElement.AddPropertiesInP(PProperties::P_LeftBorder, sBorder);
-				}
+					SetBorderStyle(oStyle, oXmlElement, PProperties::P_LeftBorder);
 			}
 		}
 	}
 
-	void CDocumentStyle::SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement)
+	void CDocumentStyle::SetBorderStyle(const CCompiledStyle &oStyle, CXmlElement &oXmlElement, const PProperties &enBorderProperty)
 	{
-		ConvertStyle(oStyle, oXmlElement, false);
+		const NSCSS::NSProperties::CBorderSide* pBorder = NULL;
+		const NSCSS::NSProperties::CDigit* pPadding = NULL;
+
+		switch(enBorderProperty)
+		{
+			case PProperties::P_BottomBorder:
+			{
+				pBorder  = &oStyle.m_oBorder.GetBottomBorder();
+				pPadding = &oStyle.m_oPadding.GetBottom();
+				break;
+			}
+			case PProperties::P_LeftBorder:
+			{
+				pBorder = &oStyle.m_oBorder.GetLeftBorder();
+				pPadding = &oStyle.m_oPadding.GetLeft();
+				break;
+			}
+			case PProperties::P_RightBorder:
+			{
+				pBorder = &oStyle.m_oBorder.GetRightBorder();
+				pPadding = &oStyle.m_oPadding.GetRight();
+				break;
+			}
+			case PProperties::P_TopBorder:
+			{
+				pBorder = &oStyle.m_oBorder.GetTopBorder();
+				pPadding = &oStyle.m_oPadding.GetTop();
+				break;
+			}
+			default:
+				return;
+		}
+
+		oXmlElement.AddPropertiesInP(enBorderProperty, CalculateBorderStyle(*pBorder, pPadding));
+	}
+
+	std::wstring CDocumentStyle::CalculateBorderStyle(const NSProperties::CBorderSide &oBorder, const NSProperties::CDigit *pPadding)
+	{
+		if (oBorder.Empty())
+			return L"";
+
+		std::wstring wsColor = oBorder.GetColor().ToWString();
+		std::wstring wsStyle = oBorder.GetStyle().ToWString();
+
+		int nWidth = static_cast<int>(std::round(oBorder.GetWidth().ToDouble(Point) * 8.));
+
+		if (L"double" == wsStyle)
+			nWidth /= 3; // в ooxml double граница формируется из трёх линий
+
+		if (nWidth <= 3)
+			nWidth = 2;
+		else if (nWidth <= 5)
+			nWidth = 4;
+		else if (nWidth <= 7)
+			nWidth = 6;
+		else if (nWidth <= 9)
+			nWidth = 8;
+		else if (nWidth <= 15)
+			nWidth = 12;
+		else if (nWidth <= 21)
+			nWidth = 18;
+		else if (nWidth <= 29)
+			nWidth = 24;
+		else if (nWidth <= 41)
+			nWidth = 36;
+		else
+			nWidth = 48;
+
+		if (wsColor.empty())
+			wsColor = L"auto";
+
+		if (wsStyle.empty())
+			wsStyle = L"single";
+
+		int nSpace{0};
+
+		if (NULL != pPadding && !pPadding->Empty() && !pPadding->Zero())
+			nSpace = pPadding->ToInt(NSCSS::Point);
+
+		return  L"w:val=\"" + wsStyle + L"\" w:sz=\"" + std::to_wstring(nWidth) + + L"\" w:space=\"" + std::to_wstring(nSpace) + L"\" w:color=\"" + wsColor + L"\"";
+	}
+
+	void CDocumentStyle::SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite)
+	{
+		if (!bIsLite)
+			ConvertStyle(oStyle, oXmlElement, false);
+
 		if (oStyle.Empty() && oXmlElement.Empty())
 			return;
 
 		if (!oStyle.m_oFont.GetSize().Empty())
-			oXmlElement.AddPropertiesInR(RProperties::R_Sz, DOUBLE_TO_INTW(oStyle.m_oFont.GetSize().ToDouble(NSCSS::Twips))); 
+			oXmlElement.AddPropertiesInR(RProperties::R_Sz, std::to_wstring(static_cast<int>(oStyle.m_oFont.GetSize().ToDouble(NSCSS::Point) * 2. + 0.5))); // Значения шрифта увеличивает на 2
+
+		if (oStyle.m_oText.GetDecoration().m_oLine.Underline())
+			oXmlElement.AddPropertiesInR(RProperties::R_U, (!oStyle.m_oText.GetDecoration().m_oStyle.Empty()) ? oStyle.m_oText.GetDecoration().m_oStyle.ToWString() : L"single");
+
+		if (!oStyle.m_oBackground.GetColor().Empty() && !oStyle.m_oBackground.GetColor().None() && !oStyle.m_oBackground.GetColor().Url())
+			oXmlElement.AddPropertiesInR(RProperties::R_Shd, oStyle.m_oBackground.GetColor().ToWString());
+
+		const std::wstring wsHighlight{oStyle.m_oText.GetHighlight().EquateToColor({{{0,   0,   0},   L"black"},    {{0,   0,   255}, L"blue"},      {{0,   255, 255}, L"cyan"},
+		                                                                            {{0,   255, 0},   L"green"},    {{255, 0,   255}, L"magenta"},   {{255, 0,   0},   L"red"},
+		                                                                            {{255, 255, 0},   L"yellow"},   {{255, 255, 255}, L"white"},     {{0,   0,   139}, L"darkBlue"},
+		                                                                            {{0,   139, 139}, L"darkCyan"}, {{0,   100, 0},   L"darkGreen"}, {{139, 0,   139}, L"darkMagenta"},
+		                                                                            {{139, 0,   0},   L"darkRed"},  {{128, 128, 0},   L"darkYellow"},{{169, 169, 169}, L"darkGray"},
+		                                                                            {{211, 211, 211}, L"lightGray"}})};
+
+		if (L"none" != wsHighlight)
+			oXmlElement.AddPropertiesInR(RProperties::R_Highlight, wsHighlight);
 
-		oXmlElement.AddPropertiesInR(RProperties::R_Highlight, oStyle.m_oBackground.GetColor().ToWString());
 		oXmlElement.AddPropertiesInR(RProperties::R_Color, oStyle.m_oText.GetColor().ToWString());
-		oXmlElement.AddPropertiesInR(RProperties::R_U, (oStyle.m_oText.GetDecoration().m_oLine.Underline()) ? L"underline" : L"");
+
+		std::wstring wsFontFamily{oStyle.m_oFont.GetFamily().ToWString()};
+
+		if (L"sans-serif" == wsFontFamily)
+			wsFontFamily = L"Arial";
+		else if (L"serif" == wsFontFamily)
+			wsFontFamily = L"Times New Roman";
+
 		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());
 		oXmlElement.AddPropertiesInR(RProperties::R_SmallCaps, oStyle.m_oFont.GetVariant().ToWString());
 	}
 
-	void CDocumentStyle::WriteRStyle (const NSCSS::CCompiledStyle& oStyle)
+	bool CDocumentStyle::WriteRStyle(const NSCSS::CCompiledStyle& oStyle)
 	{
+		Clear();
+
 		if(oStyle.GetId().empty())
-		{
-			m_sId = L"normal";
-			return;
-		}
+			return false;
 
 		CStyleUsed structStyle(oStyle, false);
 
-		std::list<CStyleUsed>::iterator oItem = std::find(m_arStyleUsed.begin(), m_arStyleUsed.end(), structStyle);
+		std::vector<CStyleUsed>::iterator oItem = std::find(m_arStyleUsed.begin(), m_arStyleUsed.end(), structStyle);
 
 		if (oItem != m_arStyleUsed.end())
 		{
 			m_sId = (*oItem).getId();
-			return;
+			return true;
 		}
-		CXmlElement oXmlElement;
-		SetRStyle(oStyle, oXmlElement);
-
-		if (!oStyle.Empty() || !oXmlElement.Empty())
-		{
-			structStyle.setId(oXmlElement.GetStyleId());
-			m_arStyleUsed.push_back(structStyle);
-			m_sStyle += oXmlElement.GetRStyle();
-		}
-	}
-
-	void CDocumentStyle::WriteLitePStyle(const CCompiledStyle &oStyle)
-	{
-		if (oStyle.Empty())
-			return;
-
-		CXmlElement oXmlElement;
-		SetPStyle(oStyle, oXmlElement);
-
-		if (!oXmlElement.Empty())
-			m_sStyle += oXmlElement.GetPStyle(true);
-	}
-
-	void CDocumentStyle::WriteLiteRStyle(const CCompiledStyle &oStyle)
-	{
-		if (oStyle.Empty())
-			return;
 
 		CXmlElement oXmlElement;
 		SetRStyle(oStyle, oXmlElement);
 
-		if (!oXmlElement.Empty())
-			m_sStyle += oXmlElement.GetRStyle(true);
+		if (oXmlElement.Empty())
+			return false;
+
+		m_arStyleUsed.push_back(structStyle);
+		m_sStyle += oXmlElement.GetRStyle();
+
+		return true;
 	}
 
-	void CDocumentStyle::WritePStyle (const NSCSS::CCompiledStyle& oStyle)
+	bool CDocumentStyle::WriteLitePStyle(const CCompiledStyle &oStyle)
 	{
+		Clear();
+
+		if (oStyle.Empty())
+			return false;
+
+		CXmlElement oXmlElement;
+		SetPStyle(oStyle, oXmlElement, true);
+
+		if (oXmlElement.Empty())
+			return false;
+		
+		m_sStyle += oXmlElement.GetPStyle(true);
+		return true;
+	}
+
+	bool CDocumentStyle::WriteLiteRStyle(const CCompiledStyle &oStyle)
+	{
+		Clear();
+
+		if (oStyle.Empty())
+			return false;
+
+		CXmlElement oXmlElement;
+		SetRStyle(oStyle, oXmlElement, true);
+
+		if (oXmlElement.Empty())
+			return false;
+
+		m_sStyle += oXmlElement.GetRStyle(true);
+		return true;
+	}
+
+	bool CDocumentStyle::WritePStyle(const NSCSS::CCompiledStyle& oStyle)
+	{
+		Clear();
+
 		if(oStyle.GetId().empty())
-		{
-			m_sId = L"normal";
-			return;
-		}
+			return false;
 
 		CStyleUsed structStyle(oStyle, true);
-		std::list<CStyleUsed>::iterator oItem = std::find(m_arStyleUsed.begin(), m_arStyleUsed.end(), structStyle);
+		std::vector<CStyleUsed>::iterator oItem = std::find(m_arStyleUsed.begin(), m_arStyleUsed.end(), structStyle);
 
 		if (oItem != m_arStyleUsed.end())
 		{
 			m_sId = (*oItem).getId();
-			return;
+			return true;
 		}
 
 		CXmlElement oXmlElement;
 		SetPStyle(oStyle, oXmlElement);
 
-		if (!oStyle.Empty() || !oXmlElement.Empty())
-		{
-			structStyle.setId(oXmlElement.GetStyleId());
-			m_arStyleUsed.push_back(structStyle);
-			m_sStyle += oXmlElement.GetPStyle();
-		}
+		if (oXmlElement.Empty())
+			return false;
+
+		m_arStyleUsed.push_back(structStyle);
+		m_sStyle += oXmlElement.GetPStyle();
+
+		return true;
 	}
 }

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

@@ -12,7 +12,6 @@ namespace NSCSS
 	{
 		CCompiledStyle m_oStyle;
 		bool m_bIsPStyle;
-		std::wstring m_sId;
 
 	public:
 		CStyleUsed(const CCompiledStyle& oStyle, bool bIsPStyle);
@@ -20,18 +19,19 @@ namespace NSCSS
 		bool operator==(const CStyleUsed& oUsedStyle) const;
 
 		std::wstring getId();
-		void setId(const std::wstring& sId);
 	};
 
+	static const std::vector<std::wstring> Names_Standard_Styles = {L"a", L"li", L"h1", L"h2", L"h3", L"h4", L"h5", L"h6",L"p", L"div"};
+
 	class CSSCALCULATOR_EXPORT CDocumentStyle
 	{
 		typedef NSConstValues::NSProperties::BasicProperties     BProperties;
 		typedef NSConstValues::NSProperties::ParagraphProperties PProperties;
 		typedef NSConstValues::NSProperties::RunnerProperties    RProperties;
 	
-		std::list<std::wstring> m_arStandardStylesUsed;
-		std::list<std::wstring> m_arStandardStyles;
-		std::list<CStyleUsed>   m_arStyleUsed;
+		std::vector<std::wstring> m_arStandardStylesUsed;
+		std::vector<std::wstring> m_arStandardStyles;
+		std::vector<CStyleUsed>   m_arStyleUsed;
 
 		std::wstring m_sStyle;
 		std::wstring m_sId;
@@ -40,17 +40,18 @@ namespace NSCSS
 		void CreateStandardStyle  (const std::wstring& sNameStyle, CXmlElement& oElement);
 		void ConvertStyle         (const NSCSS::CCompiledStyle& oStyle, CXmlElement& oElement, bool bIsPStyle);
 
-		void SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement);
-		void SetPStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement);
+		void SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite = false);
+		void SetPStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite = false);
 
+		void SetBorderStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, const PProperties& enBorderProperty);
 	public:
 		CDocumentStyle();
 		~CDocumentStyle();
 
-		void WritePStyle(const NSCSS::CCompiledStyle& oStyle);
-		void WriteRStyle(const NSCSS::CCompiledStyle& oStyle);
-		void WriteLitePStyle(const NSCSS::CCompiledStyle& oStyle);
-		void WriteLiteRStyle(const NSCSS::CCompiledStyle& oStyle);
+		bool WritePStyle(const NSCSS::CCompiledStyle& oStyle);
+		bool WriteRStyle(const NSCSS::CCompiledStyle& oStyle);
+		bool WriteLitePStyle(const NSCSS::CCompiledStyle& oStyle);
+		bool WriteLiteRStyle(const NSCSS::CCompiledStyle& oStyle);
 
 		void SetStyle(const std::wstring& sStyle);
 		void SetId   (const std::wstring& sId);
@@ -59,6 +60,8 @@ namespace NSCSS
 		std::wstring GetIdAndClear();
 
 		void Clear();
+
+		static std::wstring CalculateBorderStyle(const NSCSS::NSProperties::CBorderSide& oBorder, const NSCSS::NSProperties::CDigit* pPadding = NULL);
 	};
 }
 #endif // CDOCUMENTSTYLE_H

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

@@ -27,7 +27,7 @@ CXmlElement::CXmlElement(const std::wstring& sNameDefaultElement)
 
 bool CXmlElement::Empty() const
 {
-	return m_mBasicValues.empty() && m_mPStyleValues.empty() && m_mRStyleValues.empty();
+	return m_mPStyleValues.empty() && m_mRStyleValues.empty() && GetBasedOn().empty();
 }
 
 void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
@@ -35,7 +35,19 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 	if (!Empty())
 		Clear();
 
-	if (sNameDefaultElement == L"li")
+/*	if (sNameDefaultElement == L"p")
+	{
+		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"paragraph");
+		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"p");
+		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Normal (Web)");
+		AddBasicProperties(CSSProperties::BasicProperties::B_BasedOn, L"normal");
+		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"99");
+		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
+		AddBasicProperties(CSSProperties::BasicProperties::B_SemiHidden, L"true");
+
+//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
+	}
+	else */if (sNameDefaultElement == L"li")
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"paragraph");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"li");
@@ -55,7 +67,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h1-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"0");
-		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:after=\"0\" w:before=\"480\"");
+//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h2")
 	{
@@ -66,7 +78,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h2-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"1");
-		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:after=\"0\" w:before=\"400\"");
+//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h3")
 	{
@@ -77,7 +89,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h3-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"2");
-		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:after=\"0\" w:before=\"360\"");
+//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h4")
 	{
@@ -88,7 +100,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h4-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"3");
-		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:after=\"0\" w:before=\"320\"");
+//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h5")
 	{
@@ -99,7 +111,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h5-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"4");
-		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:after=\"0\" w:before=\"280\"");
+//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 
 	}
 	else if (sNameDefaultElement == L"h6")
@@ -111,7 +123,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h6-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"5");
-		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:after=\"0\" w:before=\"280\"");
+//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h1-c")
 	{
@@ -122,9 +134,9 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"9");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h1");
 
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_B, L"bold");
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"44");
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"48");
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_Kern, L"36");
 	}
 	else if (sNameDefaultElement == L"h2-c")
 	{
@@ -136,9 +148,8 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h2");
 
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_B, L"bold");
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"33");
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"36");
 	}
 	else if (sNameDefaultElement == L"h3-c")
 	{
@@ -150,9 +161,8 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h3");
 
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_B, L"bold");
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"26");
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"27");
 	}
 	else if (sNameDefaultElement == L"h4-c")
 	{
@@ -164,9 +174,8 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h4");
 
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"24");
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_B, L"bold");
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"22");
 	}
 	else if (sNameDefaultElement == L"h5-c")
 	{
@@ -178,9 +187,8 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h5");
 
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"20");
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_B, L"bold");
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"18");
 	}
 	else if (sNameDefaultElement == L"h6-c")
 	{
@@ -192,38 +200,16 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h6");
 
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_B, L"bold");
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"15");
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_B, L"bold");
 	}
-	else if (sNameDefaultElement == L"p-c")
-	{
-		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
-		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"p-c");
-		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Paragraph character");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"p");
-
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
-	}
-	else if (sNameDefaultElement == L"p")
-	{
-		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"paragraph");
-		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"p");
-		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Paragraph");
-		AddBasicProperties(CSSProperties::BasicProperties::B_BasedOn, L"normal");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"p-c");
-	}
-	else if (sNameDefaultElement == L"div-c")
+	/*else if (sNameDefaultElement == L"div-c")
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"div-c");
 		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Div character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"div");
-
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
 	}
 	else if (sNameDefaultElement == L"div")
 	{
@@ -233,7 +219,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Div paragraph");
 		AddBasicProperties(CSSProperties::BasicProperties::B_BasedOn, L"normal");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"div-c");
-	}
+	}*/
 	else if (sNameDefaultElement == L"a-c")
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
@@ -242,9 +228,9 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"99");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
 
+		AddPropertiesInR(CSSProperties::RunnerProperties::R_Sz, L"24");
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_Color, L"0000FF");
 		AddPropertiesInR(CSSProperties::RunnerProperties::R_U, L"single");
-		AddPropertiesInR(CSSProperties::RunnerProperties::R_RFonts, DEFAULTFONTNAME);
 	}
 	else if (sNameDefaultElement == L"a")
 	{
@@ -312,7 +298,7 @@ CXmlElement& CXmlElement::operator=(const CXmlElement& oElement)
 	return *this;
 }
 
-bool CXmlElement::operator==(const CXmlElement &oElement)
+bool CXmlElement::operator==(const CXmlElement &oElement) const
 {
 	return m_mBasicValues == oElement.m_mBasicValues &&
 	       m_mPStyleValues == oElement.m_mPStyleValues &&
@@ -364,22 +350,22 @@ std::wstring CXmlElement::ConvertPStyle(bool bIsLite) const
 
 			case CSSProperties::ParagraphProperties::P_TopBorder:
 			{
-				sPBdr += L"<w:top" + oItem.second + L"/>";
+				sPBdr += L"<w:top " + oItem.second + L"/>";
 				break;
 			}
 			case CSSProperties::ParagraphProperties::P_LeftBorder:
 			{
-				sPBdr += L"<w:left" + oItem.second + L"/>";
+				sPBdr += L"<w:left " + oItem.second + L"/>";
 				break;
 			}
 			case CSSProperties::ParagraphProperties::P_BottomBorder:
 			{
-				sPBdr += L"<w:bottom" + oItem.second + L"/>";
+				sPBdr += L"<w:bottom " + oItem.second + L"/>";
 				break;
 			}
 			case CSSProperties::ParagraphProperties::P_RightBorder:
 			{
-				sPBdr += L"<w:right" + oItem.second + L"/>";
+				sPBdr += L"<w:right " + oItem.second + L"/>";
 				break;
 			}
 			case CSSProperties::ParagraphProperties::P_KeepLines:
@@ -429,8 +415,8 @@ std::wstring CXmlElement::ConvertRStyle(bool bIsLite) const
 			}
 			case CSSProperties::RunnerProperties::R_Sz:
 			{
-				sRStyle += L"<w:sz w:val=\"" + oItem.second +
-				           L"\"/>" + L"<w:szCs w:val=\"" + oItem.second + L"\"/>";
+				sRStyle += L"<w:sz w:val=\""   + oItem.second + L"\"/>" + 
+				           L"<w:szCs w:val=\"" + oItem.second + L"\"/>";
 				break;
 			}
 			case CSSProperties::RunnerProperties::R_B:
@@ -462,11 +448,18 @@ std::wstring CXmlElement::ConvertRStyle(bool bIsLite) const
 					sRStyle += L"<w:u w:val=\"" + oItem.second + L"\"/>";
 				break;
 			}
-//			case CSSProperties::RunnerProperties::R_Highlight:
-//			{
-//				sRStyle += L"<w:highlight w:val=\"" + oItem.second + L"\"/>";
-//				break;
-//			}
+			case CSSProperties::RunnerProperties::R_Highlight:
+			{
+				if (!oItem.second.empty())
+					sRStyle += L"<w:highlight w:val=\"" + oItem.second + L"\"/>";
+				break;
+			}
+			case CSSProperties::RunnerProperties::R_Shd:
+			{
+				if (!oItem.second.empty())
+					sRStyle += L"<w:shd w:val=\"clear\" w:color=\"auto\" w:fill=\"" + oItem.second + L"\"/>";
+				break;
+			}
 			case CSSProperties::RunnerProperties::R_SmallCaps:
 			{
 				if (oItem.second == L"smallCaps")
@@ -475,6 +468,11 @@ std::wstring CXmlElement::ConvertRStyle(bool bIsLite) const
 					sRStyle += L"<w:smallCaps w:val=\"false\"/>";
 				break;
 			}
+			case CSSProperties::RunnerProperties::R_Kern:
+			{
+				sRStyle += L"<w:kern w:val=\"" + oItem.second + L"\"/>";
+				break;
+			}
 			default:
 				break;
 		}
@@ -519,7 +517,8 @@ std::wstring CXmlElement::ConvertBasicInfoStyle() const
 			}
 			case CSSProperties::BasicProperties::B_UnhideWhenUsed:
 			{
-				sBasicInfo += L"<w:unhideWhenUsed/>";
+				if (L"true" == oItem.second)
+					sBasicInfo += L"<w:unhideWhenUsed/>";
 				break;
 			}
 			case CSSProperties::BasicProperties::B_UiPriority:
@@ -527,6 +526,12 @@ std::wstring CXmlElement::ConvertBasicInfoStyle() const
 				sBasicInfo += L"<w:uiPriority w:val=\"" + oItem.second + L"\"/>";
 				break;
 			}
+			case CSSProperties::BasicProperties::B_SemiHidden:
+			{
+				if (L"true" == oItem.second)
+					sBasicInfo += L"<w:semiHidden/>";
+				break;
+			}
 			default:
 				break;
 		}
@@ -598,7 +603,7 @@ std::wstring CXmlElement::GetPStyle(bool bIsLite) const
 {
 	if (bIsLite)
 		return ConvertPStyle(true);
-		
+
 	return GetStyle(true, true, false);
 }
 
@@ -606,7 +611,7 @@ std::wstring CXmlElement::GetRStyle(bool bIsLite) const
 {
 	if (bIsLite)
 		return ConvertRStyle(true);
-		
+
 	return GetStyle(true, false, true);
 }
 

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

@@ -47,7 +47,7 @@ public:
 
 	CXmlElement& operator+=(const CXmlElement& oElement);
 	CXmlElement& operator= (const CXmlElement& oelement);
-	bool        operator== (const CXmlElement& oElement);
+	bool        operator== (const CXmlElement& oElement) const;
 };
 
 #endif // CXMLELEMENT_H

Common/3dParty/html/fetch.py

@@ -5,7 +5,6 @@ sys.path.append('../../../../build_tools/scripts')
 import config
 import base
 import os
-import build
 
 base_directory = os.getcwd()
 

Common/3dParty/html/htmltoxhtml.h

@@ -11,7 +11,9 @@
 #include "../../../DesktopEditor/common/File.h"
 #include "../../../DesktopEditor/common/Directory.h"
 #include "../../../DesktopEditor/common/StringBuilder.h"
+#include "../../../DesktopEditor/xml/include/xmlutils.h"
 #include "../../../UnicodeConverter/UnicodeConverter.h"
+#include "../../../HtmlFile2/src/StringFinder.h"
 
 static std::string nonbreaking_inline  = "|a|abbr|acronym|b|bdo|big|cite|code|dfn|em|font|i|img|kbd|nobr|s|small|span|strike|strong|sub|sup|tt|";
 static std::string empty_tags          = "|area|base|basefont|bgsound|br|command|col|embed|event-source|frame|hr|image|img|input|keygen|link|menuitem|meta|param|source|spacer|track|wbr|";
@@ -20,8 +22,27 @@ static std::string special_handling    = "|html|body|";
 static std::string no_entity_sub       = ""; //"|style|";
 static std::string treat_like_inline   = "|p|";
 
-static void prettyprint(GumboNode*, NSStringUtils::CStringBuilderA& oBuilder);
-static std::string mhtTohtml(std::string& sFileContent);
+static std::vector<std::string> html_tags = {"div","span","a","img","p","h1","h2","h3","h4","h5","h6",
+                                             "ul", "ol", "li","td","tr","table","thead","tbody","tfoot","th",
+                                             "br","form","input","button","section","nav","header","footer",
+                                             "main","figure","figcaption","strong","em","i", "b", "u","pre",
+                                             "code","blockquote","hr","script","link","meta","style","title",
+                                             "head","body","html","legend","optgroup","option","select","dl",
+                                             "dt","dd","time","data","abbr","address","area","base","bdi",
+                                             "bdo","cite","col","iframe","video","source","track","textarea",
+                                             "label","fieldset","colgroup","del","ins","details","summary",
+                                             "dialog","embed","kbd","map","mark","menu","meter","object",
+                                             "output","param","progress","q","samp","small","sub","sup","var",
+                                             "wbr","acronym","applet","article","aside","audio","basefont",
+                                             "bgsound","big","blink","canvas","caption","center","command",
+                                             "comment","datalist","dfn","dir","font","frame","frameset",
+                                             "hgroup","isindex","keygen","marquee","nobr","noembed","noframes",
+                                             "noscript","plaintext","rp","rt","ruby","s","strike","tt","xmp"};
+
+static std::vector<std::string> unchecked_nodes_new = {"svg"};
+
+static void prettyprint(GumboNode*, NSStringUtils::CStringBuilderA& oBuilder, bool bCheckValidNode = true);
+static std::string mhtTohtml(const std::string &sFileContent);
 
 // Заменяет в строке s все символы s1 на s2
 static void replace_all(std::string& s, const std::string& s1, const std::string& s2)
@@ -34,70 +55,40 @@ static void replace_all(std::string& s, const std::string& s1, const std::string
 	}
 }
 
+static bool IsUnckeckedNodes(const std::string& sValue)
+{
+	return unchecked_nodes_new.end() != std::find(unchecked_nodes_new.begin(), unchecked_nodes_new.end(), sValue);
+}
+
 static std::wstring htmlToXhtml(std::string& sFileContent, bool bNeedConvert)
 {
-	// Распознование кодировки
 	if (bNeedConvert)
-	{
-		size_t posEncoding = sFileContent.find("charset=");
-		if (posEncoding == std::string::npos)
-			posEncoding = sFileContent.find("encoding=");
-		if (posEncoding != std::string::npos)
-		{
-			posEncoding = sFileContent.find("=", posEncoding) + 1;
-			char quoteSymbol = '\"';
-			if(sFileContent[posEncoding] == '\"' || sFileContent[posEncoding] == '\'')
-			{
-				quoteSymbol = sFileContent[posEncoding];
-				posEncoding += 1;
-			}
+	{ // Определение кодировки
+		std::string sEncoding = NSStringFinder::FindPropety(sFileContent, "charset", {"="}, {";", "\\n", "\\r", " ", "\""}).m_sValue;
 
-			size_t posEnd = sFileContent.find(quoteSymbol, posEncoding);
-			if (std::string::npos != posEnd)
-			{
-				std::string sEncoding = sFileContent.substr(posEncoding, posEnd - posEncoding);
-				if (sEncoding != "utf-8" && sEncoding != "UTF-8")
-				{
-					NSUnicodeConverter::CUnicodeConverter oConverter;
-					sFileContent = U_TO_UTF8(oConverter.toUnicode(sFileContent, sEncoding.c_str()));
-				}
-			}
+		if (sEncoding.empty())
+			sEncoding = NSStringFinder::FindPropety(sFileContent, "encoding", {"="}, {";", "\\n", "\\r", " "}).m_sValue;
+
+		if (!sEncoding.empty() && !NSStringFinder::Equals("utf-8", sEncoding))
+		{
+			NSUnicodeConverter::CUnicodeConverter oConverter;
+			sFileContent = U_TO_UTF8(oConverter.toUnicode(sFileContent, sEncoding.c_str()));
 		}
 	}
 
-	// Избавление от <a/>
-	size_t posA = sFileContent.find("<a ");
-	while(posA != std::string::npos)
-	{
-		size_t nBegin = sFileContent.find('<',  posA + 1);
-		size_t nEnd   = sFileContent.find("/>", posA);
-		if(nEnd < nBegin)
-			sFileContent.replace(nEnd, 2, "></a>");
-		posA = sFileContent.find("<a ", nBegin);
-	}
-	// Избавление от <title/>
-	posA = sFileContent.find("<title/>");
-	while (posA != std::string::npos)
-	{
-		sFileContent.replace(posA, 8, "<title></title>");
-		posA = sFileContent.find("<title/>", posA);
-	}
-	// Избавление от <script/>
-	posA = sFileContent.find("<script");
-	while (posA != std::string::npos)
-	{
-		size_t nEnd = 0;
-		size_t nEnd1 = sFileContent.find("/>", posA);
-		size_t nEnd2 = sFileContent.find("</script>", posA);
-		if (nEnd1 != std::string::npos)
-			nEnd = nEnd1 + 2;
-		if (nEnd2 != std::string::npos && (nEnd == 0 || (nEnd > 0 && nEnd2 < nEnd)))
-			nEnd = nEnd2 + 9;
+	// Избавляемся от лишних символов до <...
+	boost::regex oRegex("<[a-zA-Z]");
+	boost::match_results<typename std::string::const_iterator> oResult;
 
-		sFileContent.erase(posA, nEnd - posA);
+	if (boost::regex_search(sFileContent, oResult, oRegex))
+		sFileContent.erase(0, oResult.position());
 
-		posA = sFileContent.find("<script", posA);
-	}
+	//Избавление от <a ... />
+	while (NSStringFinder::RemoveEmptyTag(sFileContent, "a"));
+	//Избавление от <title ... />
+	while (NSStringFinder::RemoveEmptyTag(sFileContent, "title"));
+	//Избавление от <script ... />
+	while (NSStringFinder::RemoveEmptyTag(sFileContent, "script"));
 
 	// Gumbo
 	GumboOptions options = kGumboDefaultOptions;
@@ -120,7 +111,7 @@ static std::string Base64ToString(const std::string& sContent, const std::string
 	if (TRUE == NSBase64::Base64Decode(sContent.c_str(), nSrcLen, pData, &nDecodeLen))
 	{
 		std::wstring sConvert;
-		if(!sCharset.empty() && sCharset != "utf-8" && sCharset != "UTF-8")
+		if(!sCharset.empty() && NSStringFinder::Equals<std::string>("utf-8", sCharset))
 		{
 			NSUnicodeConverter::CUnicodeConverter oConverter;
 			sConvert = oConverter.toUnicode(reinterpret_cast<char *>(pData), (unsigned)nDecodeLen, sCharset.data());
@@ -208,174 +199,125 @@ static std::string QuotedPrintableDecode(const std::string& sContent, std::strin
 	return sRes.GetData();
 }
 
-static void ReadMht(std::string& sFileContent, size_t& nFound, size_t& nNextFound, const std::string& sBoundary,
-					std::map<std::string, std::string>& sRes, NSStringUtils::CStringBuilderA& oRes)
+static void ReadMht(const std::string& sMhtContent, std::map<std::string, std::string>& sRes, NSStringUtils::CStringBuilderA& oRes)
 {
-	// Content
-	size_t nContentTag = sFileContent.find("\n\n", nFound);
-	if(nContentTag == std::string::npos || nContentTag > nNextFound)
-	{
-		nContentTag = sFileContent.find("\r\r", nFound);
-		if(nContentTag == std::string::npos || nContentTag > nNextFound)
-		{
-			nContentTag = sFileContent.find("\r\n\r\n", nFound);
-			if(nContentTag == std::string::npos || nContentTag > nNextFound)
-			{
-				nFound = nNextFound;
-				return;
-			}
-			else
-				nContentTag += 4;
-		}
-		else
-			nContentTag += 2;
-	}
-	else
-		nContentTag += 2;
+	size_t unContentPosition = 0, unCharsetBegin = 0, unCharsetEnd = std::string::npos;
 
+	NSStringFinder::TFoundedData<char> oData;
+	
 	// Content-Type
-	size_t nTag = sFileContent.find("Content-Type: ", nFound);
-	if(nTag == std::string::npos || nTag > nContentTag)
+	oData =  NSStringFinder::FindPropety(sMhtContent, "content-type", {":"}, {";", "\\n", "\\r"});
+	const std::string sContentType{oData.m_sValue};
+
+	if (sContentType.empty())
+		return;
+	
+	if (NSStringFinder::Equals(sContentType, "multipart/alternative"))
 	{
-		nFound = nNextFound;
+		oRes.WriteString(mhtTohtml(sMhtContent.substr(oData.m_unEndPosition, sMhtContent.length() - oData.m_unEndPosition)));
 		return;
 	}
-	size_t nTagEnd = sFileContent.find_first_of(";\n\r", nTag);
-	nTag += 14;
-	if(nTagEnd == std::string::npos || nTagEnd > nContentTag)
-	{
-		nFound = nNextFound;
-		return;
-	}
-	std::string sContentType = sFileContent.substr(nTag, nTagEnd - nTag);
-	if(sContentType == "multipart/alternative")
-		nContentTag = nFound;
+
+	unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+	unCharsetBegin = oData.m_unEndPosition;
 
 	// name
-	std::string sName;
-	nTag = sFileContent.find(" name=", nFound);
-	if(nTag != std::string::npos && nTag < nContentTag)
+//	std::string sName = NSStringFinder::FindPropety(sMhtContent, "name", {"="}, {";", "\\n", "\\r"}, 0, unLastPosition);
+//	unContentPosition = std::max(unContentPosition, unLastPosition);
+
+	// Content-Location
+	oData = NSStringFinder::FindPropety(sMhtContent, "content-location", {":"}, {";", "\\n", "\\r"});
+	std::string sContentLocation{oData.m_sValue};
+
+	if (!oData.Empty())
+		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+
+	// Content-ID
+	oData = NSStringFinder::FindPropety(sMhtContent, "content-id", {":"}, {";", "\\n", "\\r"});
+	std::string sContentID{oData.m_sValue};
+
+	if (!oData.Empty())
 	{
-		nTagEnd = sFileContent.find_first_of(";\n\r", nTag);
-		nTag += 6;
-		if(nTagEnd != std::string::npos && nTagEnd < nContentTag)
-			sName = sFileContent.substr(nTag, nTagEnd - nTag);
+		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+		unCharsetEnd = std::min(unCharsetEnd, oData.m_unBeginPosition);
+		NSStringFinder::CutInside<std::string>(sContentID, "<", ">");
+	}
+
+	if (sContentLocation.empty() && !sContentID.empty())
+		sContentLocation = "cid:" + sContentID;
+
+	// Content-Transfer-Encoding
+	oData = NSStringFinder::FindPropety(sMhtContent, "content-transfer-encoding", {":"}, {";", "\\n", "\\r"});
+	const std::string sContentEncoding{oData.m_sValue};
+
+	if (!oData.Empty())
+	{
+		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+		unCharsetEnd = std::min(unCharsetEnd, oData.m_unBeginPosition);
 	}
 
 	// charset
-	std::string sCharset;
-	nTag = sFileContent.find("charset=", nFound);
-	if(nTag != std::string::npos && nTag < nContentTag)
-	{
-		nTagEnd = sFileContent.find_first_of(";\n\r", nTag);
-		nTag += 8;
-		if(nTagEnd != std::string::npos && nTagEnd < nContentTag)
-		{
-			if(sFileContent[nTag] == '\"')
-			{
-				nTag++;
-				nTagEnd--;
-			}
-			sCharset = sFileContent.substr(nTag, nTagEnd - nTag);
-		}
-	}
+	std::string sCharset = "utf-8";
 
-	// Content-Location
-	std::string sContentLocation;
-	nTag = sFileContent.find("Content-Location: ", nFound);
-	if(nTag != std::string::npos && nTag < nContentTag)
+	if (std::string::npos != unCharsetEnd && unCharsetBegin < unCharsetEnd)
 	{
-		nTagEnd = sFileContent.find_first_of(";\n\r", nTag);
-		nTag += 18;
-		if(nTagEnd != std::string::npos && nTagEnd < nContentTag)
-			sContentLocation = sFileContent.substr(nTag, nTagEnd - nTag);
-	}
-
-	if (sContentLocation.empty())
-	{
-		// Content-ID
-		std::string sContentID;
-		nTag = sFileContent.find("Content-ID: <", nFound);
-		if(nTag != std::string::npos && nTag < nContentTag)
-		{
-			nTagEnd = sFileContent.find_first_of(">", nTag);
-			nTag += 13;
-			if(nTagEnd != std::string::npos && nTagEnd < nContentTag)
-				sContentID = sFileContent.substr(nTag, nTagEnd - nTag);
-		}
-
-		if (!sContentID.empty())
-			sContentLocation = "cid:" + sContentID;
-	}
-
-	// Content-Transfer-Encoding
-	std::string sContentEncoding;
-	nTag = sFileContent.find("Content-Transfer-Encoding: ", nFound);
-	if(nTag != std::string::npos && nTag < nContentTag)
-	{
-		nTagEnd = sFileContent.find_first_of(";\n\r", nTag);
-		nTag += 27;
-		if(nTagEnd != std::string::npos && nTagEnd < nContentTag)
-			sContentEncoding = sFileContent.substr(nTag, nTagEnd - nTag);
+		sCharset = NSStringFinder::FindPropety(sMhtContent.substr(unCharsetBegin, unCharsetEnd - unCharsetBegin), "charset", {"="}, {";", "\\n", "\\r"}).m_sValue;
+		NSStringFinder::CutInside<std::string>(sCharset, "\"");
 	}
 
 	// Content
-	nTagEnd = nNextFound - 2;
-	if(nTagEnd == std::string::npos || nTagEnd < nContentTag)
-	{
-		nFound = nNextFound;
-		return;
-	}
-	std::string sContent = sFileContent.substr(nContentTag, nTagEnd - nContentTag);
+	std::string sContent = sMhtContent.substr(unContentPosition, sMhtContent.length() - unContentPosition);
 
-	// Удаляем лишнее
-	sFileContent.erase(0, nNextFound);
-	nFound = sFileContent.find(sBoundary);
-
-	std::wstring sExtention = NSFile::GetFileExtention(UTF8_TO_U(sName));
-	std::transform(sExtention.begin(), sExtention.end(), sExtention.begin(), tolower);
+//	std::wstring sExtention = NSFile::GetFileExtention(UTF8_TO_U(sName));
+//	std::transform(sExtention.begin(), sExtention.end(), sExtention.begin(), tolower);
 	// Основной документ
-	if(sContentType == "multipart/alternative")
+	if (NSStringFinder::Equals(sContentType, "multipart/alternative"))
 		oRes.WriteString(mhtTohtml(sContent));
-	else if((sContentType.find("text") != std::string::npos && (sExtention.empty() || sExtention == L"htm" || sExtention == L"html" || sExtention
-																== L"xhtml" || sExtention == L"css")) || (sContentType == "application/octet-stream" && (sContentLocation.find("css") !=
-																																						 std::string::npos)))
+	else if ((NSStringFinder::Find(sContentType, "text") /*&& (sExtention.empty() || NSStringFinder::EqualOf(sExtention, {L"htm", L"html", L"xhtml", L"css"}))*/) 
+	          || (NSStringFinder::Equals(sContentType, "application/octet-stream") && NSStringFinder::Find(sContentLocation, "css")))
 	{
 		// Стили заключаются в тэг <style>
-		if(sContentType == "text/css" || sExtention == L"css" || sContentLocation.find("css") != std::string::npos)
+		const bool bAddTagStyle = NSStringFinder::Equals(sContentType, "text/css") /*|| NSStringFinder::Equals(sExtention, L"css")*/ || NSStringFinder::Find(sContentLocation, "css");
+
+		if (bAddTagStyle)
 			oRes.WriteString("<style>");
-		if(sContentEncoding == "Base64" || sContentEncoding == "base64")
-			oRes.WriteString(Base64ToString(sContent, sCharset));
-		else if(sContentEncoding == "8bit" || sContentEncoding == "7bit" || sContentEncoding.empty())
+
+		if (NSStringFinder::Equals(sContentEncoding, "base64"))
+			sContent = Base64ToString(sContent, sCharset);
+		else if (NSStringFinder::EqualOf(sContentEncoding, {"8bit", "7bit"}) || sContentEncoding.empty())
 		{
-			if (sCharset != "utf-8" && sCharset != "UTF-8" && !sCharset.empty())
+			if (!NSStringFinder::Equals(sCharset, "utf-8") && !sCharset.empty())
 			{
 				NSUnicodeConverter::CUnicodeConverter oConverter;
 				sContent = U_TO_UTF8(oConverter.toUnicode(sContent, sCharset.data()));
 			}
-			oRes.WriteString(sContent);
 		}
-		else if(sContentEncoding == "quoted-printable" || sContentEncoding == "Quoted-Printable")
+		else if (NSStringFinder::Equals(sContentEncoding, "quoted-printable"))
 		{
 			sContent = QuotedPrintableDecode(sContent, sCharset);
-			if (sCharset != "utf-8" && sCharset != "UTF-8" && !sCharset.empty())
+			if (!NSStringFinder::Equals(sCharset, "utf-8") && !sCharset.empty())
 			{
 				NSUnicodeConverter::CUnicodeConverter oConverter;
 				sContent = U_TO_UTF8(oConverter.toUnicode(sContent, sCharset.data()));
 			}
-			oRes.WriteString(sContent);
 		}
-		if(sContentType == "text/css" || sExtention == L"css" || sContentLocation.find("css") != std::string::npos)
+
+		if (NSStringFinder::Equals(sContentType, "text/html"))
+			sContent = U_TO_UTF8(htmlToXhtml(sContent, false));
+
+		oRes.WriteString(sContent);
+
+		if(bAddTagStyle)
 			oRes.WriteString("</style>");
 	}
 	// Картинки
-	else if((sContentType.find("image") != std::string::npos || sExtention == L"gif" || sContentType == "application/octet-stream") &&
-			(sContentEncoding == "Base64" || sContentEncoding == "base64"))
+	else if ((NSStringFinder::Find(sContentType, "image") /*|| NSStringFinder::Equals(sExtention, L"gif")*/ || NSStringFinder::Equals(sContentType, "application/octet-stream")) && 
+			  NSStringFinder::Equals(sContentEncoding, "base64"))
 	{
-		if(sExtention == L"ico" || sContentType.find("ico") != std::string::npos)
-			sContentType = "image/jpg";
-		else if(sExtention == L"gif")
-			sContentType = "image/gif";
+//		if (NSStringFinder::Equals(sExtention, L"ico") || NSStringFinder::Find(sContentType, "ico"))
+//			sContentType = "image/jpg";
+//		else if(NSStringFinder::Equals(sExtention, L"gif"))
+//			sContentType = "image/gif";
 		int nSrcLen = (int)sContent.length();
 		int nDecodeLen = NSBase64::Base64DecodeGetRequiredLength(nSrcLen);
 		BYTE* pData = new BYTE[nDecodeLen];
@@ -385,50 +327,46 @@ static void ReadMht(std::string& sFileContent, size_t& nFound, size_t& nNextFoun
 	}
 }
 
-static std::string mhtTohtml(std::string& sFileContent)
+static std::string mhtTohtml(const std::string& sFileContent)
 {
 	std::map<std::string, std::string> sRes;
 	NSStringUtils::CStringBuilderA oRes;
 
 	// Поиск boundary
-	size_t nFound = sFileContent.find("boundary=");
-	if(nFound == std::string::npos)
+	NSStringFinder::TFoundedData<char> oData{NSStringFinder::FindPropety(sFileContent, "boundary", {"="}, {"\\r", "\\n", "\""})};
+
+	size_t nFound{oData.m_unEndPosition};
+	std::string sBoundary{oData.m_sValue};
+
+	if (sBoundary.empty())
 	{
 		size_t nFoundEnd = sFileContent.length();
 		nFound = 0;
-		ReadMht(sFileContent, nFound, nFoundEnd, "no", sRes, oRes);
+		ReadMht(sFileContent.substr(nFound, nFoundEnd), sRes, oRes);
 		return oRes.GetData();
 	}
-	size_t nFoundEnd = sFileContent.find_first_of(";\n\r", nFound);
-	if(nFoundEnd == std::string::npos)
-		return "";
-	nFound += 9;
-	if(sFileContent[nFound] == '\"')
-	{
-		nFound++;
-		nFoundEnd--;
-	}
-	if(nFound > nFoundEnd)
-		return "";
-	std::string sBoundary = sFileContent.substr(nFound, nFoundEnd - nFound);
+
+	NSStringFinder::CutInside<std::string>(sBoundary, "\"");
+
+	size_t nFoundEnd{nFound};
+
+	sBoundary = "--" + sBoundary;
 	size_t nBoundaryLength = sBoundary.length();
 
-	// Удаляем лишнее
-	nFound = sFileContent.find(sBoundary, nFoundEnd);
-	sFileContent.erase(0, nFound);
+	nFound = sFileContent.find(sBoundary, nFound) + nBoundaryLength;
 
 	// Цикл по boundary
-	nFound = 0;
 	while(nFound != std::string::npos)
 	{
-		// Выход по --boundary--
-		if(sFileContent[nFound + nBoundaryLength + 1] == '-')
-			break;
 		nFoundEnd = sFileContent.find(sBoundary, nFound + nBoundaryLength);
 		if(nFoundEnd == std::string::npos)
 			break;
-		ReadMht(sFileContent, nFound, nFoundEnd, sBoundary, sRes, oRes);
+
+		ReadMht(sFileContent.substr(nFound, nFoundEnd - nFound), sRes, oRes);
+
+		nFound = sFileContent.find(sBoundary, nFoundEnd);
 	}
+
 	std::string sFile = oRes.GetData();
 	for(const std::pair<std::string, std::string>& item : sRes)
 	{
@@ -440,10 +378,18 @@ static std::string mhtTohtml(std::string& sFileContent)
 		while(found != std::string::npos)
 		{
 			size_t fq = sFile.find_last_of("\"\'>=", found);
+
+			if (std::string::npos == fq)
+				break;
+
 			char ch = sFile[fq];
 			if(ch != '\"' && ch != '\'')
 				fq++;
 			size_t tq = sFile.find_first_of("\"\'<> ", found) + 1;
+
+			if (std::string::npos == tq)
+				break;
+
 			if(sFile[tq] != '\"' && sFile[tq] != '\'')
 				tq--;
 			if(ch != '>')
@@ -456,6 +402,7 @@ static std::string mhtTohtml(std::string& sFileContent)
 				found = sFile.find(sName, tq);
 		}
 	}
+
 	return sFile;
 }
 
@@ -587,7 +534,7 @@ static void build_attributes(const GumboVector* attribs, bool no_entities, NSStr
 	}
 }
 
-static void prettyprint_contents(GumboNode* node, NSStringUtils::CStringBuilderA& contents)
+static void prettyprint_contents(GumboNode* node, NSStringUtils::CStringBuilderA& contents, bool bCheckValidNode)
 {
 	std::string key             = "|" + get_tag_name(node) + "|";
 	bool no_entity_substitution = no_entity_sub.find(key) != std::string::npos;
@@ -618,7 +565,7 @@ static void prettyprint_contents(GumboNode* node, NSStringUtils::CStringBuilderA
 			contents.WriteString(val);
 		}
 		else if ((child->type == GUMBO_NODE_ELEMENT) || (child->type == GUMBO_NODE_TEMPLATE))
-			prettyprint(child, contents);
+			prettyprint(child, contents, bCheckValidNode);
 		else if (child->type == GUMBO_NODE_WHITESPACE)
 		{
 			if (keep_whitespace || is_inline || is_like_inline)
@@ -633,23 +580,33 @@ static void prettyprint_contents(GumboNode* node, NSStringUtils::CStringBuilderA
 	}
 }
 
-static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilder)
+static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilder, bool bCheckValidNode)
 {
 	// special case the document node
 	if (node->type == GUMBO_NODE_DOCUMENT)
 	{
 		build_doctype(node, oBuilder);
-		prettyprint_contents(node, oBuilder);
+		prettyprint_contents(node, oBuilder, bCheckValidNode);
+		return;
+	}
+
+	std::string tagname            = get_tag_name(node);
+
+	if (bCheckValidNode)
+		bCheckValidNode = !IsUnckeckedNodes(tagname);
+
+	if (bCheckValidNode && html_tags.end() == std::find(html_tags.begin(), html_tags.end(), tagname))
+	{
+		prettyprint_contents(node, oBuilder, bCheckValidNode);
 		return;
 	}
 
 	std::string close              = "";
 	std::string closeTag           = "";
-	std::string tagname            = get_tag_name(node);
 	std::string key                = "|" + tagname + "|";
 	bool is_empty_tag              = empty_tags.find(key) != std::string::npos;
 	bool no_entity_substitution    = no_entity_sub.find(key) != std::string::npos;
-
+	
 	// determine closing tag type
 	if (is_empty_tag)
 		close = "/";
@@ -665,7 +622,7 @@ static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilde
 	oBuilder.WriteString(close + ">");
 
 	// prettyprint your contents
-	prettyprint_contents(node, oBuilder);
+	prettyprint_contents(node, oBuilder, bCheckValidNode);
 	oBuilder.WriteString(closeTag);
 }
 

Common/3dParty/hunspell/test/main.cpp

@@ -33,6 +33,7 @@
 #include "../../../../Common/3dParty/hunspell/hunspell/src/hunspell/hunspell.h"
 #include "../../../../DesktopEditor/common/StringExt.h"
 #include "../../../../DesktopEditor/common/Directory.h"
+#include <iostream>
 
 bool CheckCaret(std::vector<std::wstring>& words)
 {
@@ -85,11 +86,36 @@ std::wstring CheckWord(Hunhandle* pDic, const std::wstring& sWord, const bool& b
 	return sResult;
 }
 
+#if defined(_WIN32) || defined(_WIN64)
+#define USE_WCHAR_ARGC
+#endif
+
+#ifdef USE_WCHAR_ARGC
+std::wstring GetParam(wchar_t* arg)
+{
+	return std::wstring(arg);
+}
+#else
+std::wstring GetParam(char* arg)
+{
+	return NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE *)arg, (LONG)strlen(arg));
+}
+#endif
+
+#ifdef USE_WCHAR_ARGC
+int wmain(int argc, wchar_t *argv[])
+#else
 int main(int argc, char *argv[])
+#endif
 {
 	std::wstring sSrcDir = NSFile::GetProcessDirectory() + L"/../src";
 	std::wstring sDstDir = NSFile::GetProcessDirectory() + L"/../dst";
 	std::wstring sDictionariesDir = NSFile::GetProcessDirectory() + L"/../../../../../../dictionaries";
+
+	if (argc > 1) sSrcDir = GetParam(argv[1]);
+	if (argc > 2) sDstDir = GetParam(argv[2]);
+	if (argc > 3) sDictionariesDir = GetParam(argv[3]);
+
 	std::vector<std::wstring> arSrcFiles = NSDirectory::GetFiles(sSrcDir);
 
 	for (int i = 0, len = (int)arSrcFiles.size(); i < len; ++i)
@@ -125,6 +151,8 @@ int main(int argc, char *argv[])
 		Hunspell_destroy(pDictionary);
 
 		NSFile::CFileBinary::SaveToFile(sFileDst, sResult, true);
+
+		std::cout << "[" << (i + 1) << " of " << (int)arSrcFiles.size() << "] " << U_TO_UTF8(sName) << std::endl;
 	}
 
 	return 0;

Common/3dParty/hunspell/test/test.pro

@@ -6,7 +6,7 @@
 
 QT -= core gui
 
-TARGET = test
+TARGET = dictionariestester
 CONFIG += console
 CONFIG -= app_bundle
 
@@ -22,8 +22,7 @@ include($$CORE_ROOT_DIR/Common/3dParty/icu/icu.pri)
 ADD_DEPENDENCY(UnicodeConverter kernel hunspell)
 
 core_windows:LIBS += -lgdi32 -ladvapi32 -luser32 -lshell32
-core_linux:LIBS += -lz
 
 SOURCES += main.cpp
 
-DESTDIR = $$PWD/build
+DESTDIR = $$CORE_BUILDS_BINARY_PATH