.

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

DesktopEditor/graphics/AlphaMask.cpp

@@ -1,5 +1,4 @@
-#include "AlphaMask.h"
-#include <string.h>
+#include "AlphaMask_p.h"
 
 namespace Aggplus
 {
@@ -33,7 +32,6 @@ namespace Aggplus
 		{
 		case EMaskDataType::ImageBuffer: return 4;
 		case EMaskDataType::AlphaBuffer: return 1;
-		case EMaskDataType::Alpha4Buffer: return 4;
 		}
 	}
 
@@ -65,130 +63,26 @@ namespace Aggplus
 		return Ok;
 	}
 
-
-
-	CSoftMask::CSoftMask() : m_unWidth(0), m_unHeight(0), m_pImageData(NULL), m_pAlphaBufferData(NULL) {}
-	CSoftMask::CSoftMask(BYTE* pBuffer, UINT unWidth, UINT unHeight, EMaskDataType enDataType, bool bExternalBuffer, bool bFlip) : m_pImageData(NULL), m_pAlphaBufferData(NULL)
+	CSoftMask::CSoftMask(BYTE* pBuffer, unsigned int unWidth, unsigned int unHeight, bool bFlip, bool bRGB, bool bAlpha)
 	{
-		LoadFromBuffer(pBuffer, unWidth, unHeight, enDataType, bExternalBuffer, bFlip);
+		if (bAlpha)
+			m_pInternal = new CSoftMaskAlpha(pBuffer, unWidth, unHeight, false, bFlip);
+		else
+		{
+			if (bRGB)
+				m_pInternal = new CSoftMaskBGRAgray(pBuffer, unWidth, unHeight, false, bFlip);
+			else
+				m_pInternal = new CSoftMaskRGBAgray(pBuffer, unWidth, unHeight, false, bFlip);
+		}
 	}
 	CSoftMask::~CSoftMask()
 	{
-		BYTE* pBuffer = m_oRenderingBuffer.buf();
-		if (NULL != pBuffer)
-		{
-			if (!m_bExternalBuffer)
-				RELEASEARRAYOBJECTS(pBuffer);
-
-			m_oRenderingBuffer.attach(NULL, 0, 0, 0);
-		}
-
-		RELEASEOBJECT(m_pImageData);
-		RELEASEOBJECT(m_pAlphaBufferData);
+		RELEASEOBJECT(m_pInternal);
 	}
 
-	EMaskDataType CSoftMask::GetDataType() const { return m_enDataType; }
-	unsigned int CSoftMask::GetStep() const
-	{
-		switch(m_enDataType)
-		{
-		case EMaskDataType::ImageBuffer: return 4;
-		case EMaskDataType::AlphaBuffer: return 1;
-		case EMaskDataType::Alpha4Buffer: return 4;
-		}
-	}
-	unsigned int CSoftMask::GetWidth() const { return m_unWidth; }
-	unsigned int CSoftMask::GetHeight() const { return m_unHeight; }
-
-	void CSoftMask::SetType(EMaskDataType enDataType)
-	{
-		m_enDataType = enDataType;
-
-		RELEASEOBJECT(m_pImageData);
-		RELEASEOBJECT(m_pAlphaBufferData);
-
-		switch (enDataType)
-		{
-		case EMaskDataType::ImageBuffer:
-		{
-			m_pImageData = new AMaskFromImage(m_oRenderingBuffer);
-			m_pImageData->m_oRendererBase.attach(m_pImageData->m_oPixfmt);
-			m_pImageData->m_oAlphaMask.attach(m_oRenderingBuffer);
-			break;
-		}
-		case EMaskDataType::Alpha4Buffer:
-		{
-			m_pAlphaBufferData = new AMaskFromABuffer(m_oRenderingBuffer);
-			m_pAlphaBufferData->m_oRendererBase.attach(m_pAlphaBufferData->m_oPixfmt);
-			m_pAlphaBufferData->m_oAlphaMask.attach(m_oRenderingBuffer);
-			break;
-		}
-		}
-	}
-
-	Status CSoftMask::Create(UINT unWidth, UINT unHeight, EMaskDataType enDataType)
-	{
-		if (0 == unWidth || 0 == unHeight)
-			return InvalidParameter;
-
-		m_bExternalBuffer = false;
-
-		UINT unSize = unWidth * unHeight * GetStep();
-		BYTE* pAlphaBufffer = new BYTE[unSize];
-		if (!pAlphaBufffer)
-			return OutOfMemory;
-
-		memset(pAlphaBufffer, 0x00, unSize);
-
-		Set(pAlphaBufffer, unWidth, unHeight, enDataType);
-
-		return Ok;
-	}
-
-	Status CSoftMask::LoadFromBuffer(BYTE *pBuffer, UINT unWidth, UINT unHeight, EMaskDataType enDataType, bool bExternalBuffer, bool bFlip)
-	{
-		if (NULL == pBuffer || 0 == unWidth || 0 == unHeight)
-			return InvalidParameter;
-
-		m_bExternalBuffer = bExternalBuffer;
-
-		Set(pBuffer, unWidth, unHeight, enDataType, bFlip);
-
-		return Ok;
-	}
-
-	RenBaseBGRA32& CSoftMask::GetRendererBaseImage()
-	{
-		return m_pImageData->m_oRendererBase;
-	}
-
-	ScanlineBGRA32Gray& CSoftMask::GetScanlineImage()
-	{
-		return m_pImageData->m_oScanLine;
-	}
-
-	ScanlineBGRA32A& CSoftMask::GetScanlineABuffer()
-	{
-		return m_pAlphaBufferData->m_oScanLine;
-	}
-
-	BYTE* CSoftMask::GetBuffer()
-	{
-		return m_oRenderingBuffer.buf();
-	}
-
-	agg::rendering_buffer& CSoftMask::GetRenderingBuffer()
-	{
-		return m_oRenderingBuffer;
-	}
-
-	void CSoftMask::Set(BYTE* pBuffer, UINT unWidth, UINT unHeight, EMaskDataType enDataType, bool bFlip)
-	{
-		m_enDataType = enDataType;
-		m_unWidth    = unWidth;
-		m_unHeight   = unHeight;
-		m_oRenderingBuffer.attach(pBuffer, unWidth, unHeight, (bFlip ? -1 : 1) * GetStep() * unWidth);
-
-		SetType(enDataType);
-	}
+	unsigned int CSoftMask::GetStep() const { return m_pInternal->GetStep(); }
+	unsigned int CSoftMask::GetWidth() const { return m_pInternal->GetWidth(); }
+	unsigned int CSoftMask::GetHeight() const { return m_pInternal->GetHeight(); }
+	BYTE* CSoftMask::GetBuffer() { return m_pInternal->GetBuffer(); }
+	ESoftMaskType CSoftMask::GetDataType() { return m_pInternal->GetDataType(); }
 }

DesktopEditor/graphics/AlphaMask.h

@@ -1,23 +1,16 @@
 #ifndef _BUILD_ALPHAMASK_H_
 #define _BUILD_ALPHAMASK_H_
 
-#include <string>
 #include "aggplustypes.h"
 #include "../common/IGrObject.h"
 #include "./config.h"
 
-#include "../agg-2.4/include/agg_renderer_base.h"
-#include "../agg-2.4/include/agg_pixfmt_rgba.h"
-#include "../agg-2.4/include/agg_scanline_u.h"
-#include "../agg-2.4/include/agg_alpha_mask_u8.h"
-
 namespace Aggplus
 {
 	enum class EMaskDataType
 	{
 		ImageBuffer,
-		AlphaBuffer,
-		Alpha4Buffer
+		AlphaBuffer
 	};
 
 	class GRAPHICS_DECL CAlphaMask : public IGrObject
@@ -39,56 +32,30 @@ namespace Aggplus
 		bool          m_bExternalBuffer;
 	};
 
-	template <class PixelFormat, class AlphaMask>
-	struct TAlphaMaskData
+	enum class ESoftMaskType
 	{
-		TAlphaMaskData(agg::rendering_buffer& oRenderingBuffer) : m_oPixfmt(oRenderingBuffer), m_oScanLine(m_oAlphaMask) {};
-
-		PixelFormat                     m_oPixfmt;
-		agg::renderer_base<PixelFormat> m_oRendererBase;
-		AlphaMask                       m_oAlphaMask;
-		agg::scanline_u8_am<AlphaMask>  m_oScanLine;
+		RGBGrayBuffer,
+		BGRGrayBuffer,
+		Alpha4Buffer
 	};
 
-	typedef agg::renderer_base<agg::pixfmt_bgra32>          RenBaseBGRA32;
-	typedef agg::scanline_u8_am<agg::alpha_mask_bgra32gray> ScanlineBGRA32Gray;
-	typedef agg::scanline_u8_am<agg::alpha_mask_bgra32a>    ScanlineBGRA32A;
-
+	class CSoftMask_private;
 	class GRAPHICS_DECL CSoftMask : public IGrObject
 	{
 	public:
-		CSoftMask();
-		CSoftMask(BYTE* pBuffer, UINT unWidth, UINT unHeight, EMaskDataType enDataType, bool bExternalBuffer = true, bool bFlip = false);
-		virtual ~CSoftMask();
+		CSoftMask(BYTE* pBuffer, unsigned int unWidth, unsigned int unHeight, bool bFlip, bool bRGB, bool bAlpha);
+		~CSoftMask();
 
-		EMaskDataType GetDataType() const;
 		unsigned int GetStep() const;
 		unsigned int GetWidth() const;
 		unsigned int GetHeight() const;
+		BYTE* GetBuffer();
+		ESoftMaskType GetDataType();
 
-		void SetType(EMaskDataType enDataType);
-		Status Create(UINT unWidth, UINT unHeight, EMaskDataType enDataType);
-		Status LoadFromBuffer(BYTE* pBuffer, UINT unWidth, UINT unHeight, EMaskDataType enDataType, bool bExternalBuffer = true, bool bFlip = false);
-
-		agg::rendering_buffer& GetRenderingBuffer();
-		RenBaseBGRA32&         GetRendererBaseImage();
-		ScanlineBGRA32Gray&    GetScanlineImage();
-		ScanlineBGRA32A&       GetScanlineABuffer();
-		BYTE*                  GetBuffer();
 	private:
-		void Set(BYTE* pBuffer, UINT unWidth, UINT unHeight, EMaskDataType enDataType, bool bFlip = false);
+		CSoftMask_private* m_pInternal;
 
-		agg::rendering_buffer m_oRenderingBuffer;
-		EMaskDataType         m_enDataType;
-		bool                  m_bExternalBuffer;
-		unsigned int          m_unWidth;
-		unsigned int          m_unHeight;
-
-		typedef TAlphaMaskData<agg::pixfmt_bgra32, agg::alpha_mask_bgra32gray> AMaskFromImage;
-		typedef TAlphaMaskData<agg::pixfmt_bgra32, agg::alpha_mask_bgra32a>    AMaskFromABuffer;
-
-		AMaskFromImage*   m_pImageData;
-		AMaskFromABuffer* m_pAlphaBufferData;
+		friend class CGraphics;
 	};
 }
 

DesktopEditor/graphics/AlphaMask_p.h

@@ -0,0 +1,96 @@
+#ifndef _BUILD_ALPHAMASK_P_H_
+#define _BUILD_ALPHAMASK_P_H_
+
+#include "AlphaMask.h"
+#include <string>
+#include <string.h>
+
+#include "../agg-2.4/include/agg_rendering_buffer.h"
+#include "../agg-2.4/include/agg_scanline_u.h"
+#include "../agg-2.4/include/agg_alpha_mask_u8.h"
+
+namespace Aggplus
+{
+	class CSoftMask_private
+	{
+	public:
+		virtual ~CSoftMask_private()
+		{
+			BYTE* pBuffer = m_oRenderingBuffer.buf();
+			if (NULL != pBuffer)
+			{
+				if (!m_bExternalBuffer)
+					RELEASEARRAYOBJECTS(pBuffer);
+
+				m_oRenderingBuffer.attach(NULL, 0, 0, 0);
+			}
+		}
+
+		unsigned int GetStep() const { return 4; }
+		unsigned int GetWidth() const { return m_unWidth; }
+		unsigned int GetHeight() const { return m_unHeight; }
+		BYTE* GetBuffer() { return m_oRenderingBuffer.buf(); }
+
+		virtual ESoftMaskType GetDataType() const = 0;
+		virtual bool GetSwapRGB() const { return true; };
+
+	protected:
+		CSoftMask_private(BYTE* pBuffer, unsigned int unWidth, unsigned int unHeight, bool bExternalBuffer, bool bFlip)
+		{
+			m_bExternalBuffer = bExternalBuffer;
+			m_unWidth         = unWidth;
+			m_unHeight        = unHeight;
+			m_oRenderingBuffer.attach(pBuffer, unWidth, unHeight, (bFlip ? -1 : 1) * GetStep() * unWidth);
+		}
+
+		agg::rendering_buffer m_oRenderingBuffer;
+		bool                  m_bExternalBuffer;
+		unsigned int          m_unWidth;
+		unsigned int          m_unHeight;
+	};
+
+	class CSoftMaskBGRAgray : public CSoftMask_private
+	{
+	public:
+		CSoftMaskBGRAgray(BYTE* pBuffer, unsigned int unWidth, unsigned int unHeight, bool bExternalBuffer, bool bFlip)
+			: CSoftMask_private(pBuffer, unWidth, unHeight, bExternalBuffer, bFlip), m_oAlphaMask(m_oRenderingBuffer), m_oScanLine(m_oAlphaMask) {}
+
+		agg::scanline_u8_am<agg::alpha_mask_bgra32gray>& GetScanline() { return m_oScanLine; }
+		virtual ESoftMaskType GetDataType() const override { return ESoftMaskType::BGRGrayBuffer; }
+
+	private:
+		agg::alpha_mask_bgra32gray                      m_oAlphaMask;
+		agg::scanline_u8_am<agg::alpha_mask_bgra32gray> m_oScanLine;
+	};
+
+	class CSoftMaskRGBAgray : public CSoftMask_private
+	{
+	public:
+		CSoftMaskRGBAgray(BYTE* pBuffer, unsigned int unWidth, unsigned int unHeight, bool bExternalBuffer, bool bFlip)
+			: CSoftMask_private(pBuffer, unWidth, unHeight, bExternalBuffer, bFlip), m_oAlphaMask(m_oRenderingBuffer), m_oScanLine(m_oAlphaMask) {}
+
+		agg::scanline_u8_am<agg::alpha_mask_rgba32gray>& GetScanline() { return m_oScanLine; }
+		virtual bool GetSwapRGB() const override { return false; };
+		virtual ESoftMaskType GetDataType() const override { return ESoftMaskType::RGBGrayBuffer; }
+
+	private:
+		agg::alpha_mask_rgba32gray                      m_oAlphaMask;
+		agg::scanline_u8_am<agg::alpha_mask_rgba32gray> m_oScanLine;
+	};
+
+	class CSoftMaskAlpha : public CSoftMask_private
+	{
+	public:
+		CSoftMaskAlpha(BYTE* pBuffer, unsigned int unWidth, unsigned int unHeight, bool bExternalBuffer, bool bFlip)
+			: CSoftMask_private(pBuffer, unWidth, unHeight, bExternalBuffer, bFlip), m_oAlphaMask(m_oRenderingBuffer), m_oScanLine(m_oAlphaMask) {}
+
+		agg::scanline_u8_am<agg::alpha_mask_rgba32a>& GetScanline() { return m_oScanLine; }
+		virtual ESoftMaskType GetDataType() const override { return ESoftMaskType::Alpha4Buffer; }
+
+	private:
+		agg::alpha_mask_rgba32a                      m_oAlphaMask;
+		agg::scanline_u8_am<agg::alpha_mask_rgba32a> m_oScanLine;
+	};
+}
+
+#endif // _BUILD_ALPHAMASK_P_H_

DesktopEditor/graphics/BaseThreadMonitor.cpp

@@ -107,9 +107,14 @@ namespace NSThreads
 		{
 			if (i->ID == nThreadId)
 			{
+				CBaseThreadInfo last;
+				last.ID = i->ID;
+				last.Instance = i->Instance;
+
 				m_listThreads.erase(i);
-				m_listThreads.insert(m_listThreads.begin(), *i);
-				return i->Instance;
+				m_listThreads.insert(m_listThreads.begin(), last);
+				
+				return last.Instance;
 			}
 			i++;
 		}

DesktopEditor/graphics/Graphics.cpp

@@ -1297,7 +1297,9 @@ namespace Aggplus
 		RELEASEINTERFACE(pCurrentGraphicsLayer);
 		RELEASEINTERFACE(m_pSoftMask);
 
-		m_pSoftMask = new CSoftMask(pBuffer, m_frame_buffer.ren_buf().width(), m_frame_buffer.ren_buf().height(), bAlpha ? EMaskDataType::Alpha4Buffer : EMaskDataType::ImageBuffer, false, m_frame_buffer.ren_buf().stride() < 0);
+		unsigned int unWidth = m_frame_buffer.ren_buf().width(), unHeight = m_frame_buffer.ren_buf().height();
+		bool bFlip = m_frame_buffer.ren_buf().stride() < 0;
+		m_pSoftMask = new CSoftMask(pBuffer, unWidth, unHeight, bFlip, m_bSwapRGB, bAlpha);
 
 		pBuffer = m_arLayers.empty() ? m_pPixels : m_arLayers.top()->GetBuffer();
 		if (!pBuffer)
@@ -1306,7 +1308,7 @@ namespace Aggplus
 			return NULL;
 		}
 
-		m_frame_buffer.ren_buf().attach(pBuffer, m_frame_buffer.ren_buf().width(), m_frame_buffer.ren_buf().height(), m_frame_buffer.ren_buf().stride());
+		m_frame_buffer.ren_buf().attach(pBuffer, unWidth, unHeight, m_frame_buffer.ren_buf().stride());
 
 		return m_pSoftMask;
 	}
@@ -1401,19 +1403,13 @@ namespace Aggplus
 		}
 		else if (m_pSoftMask)
 		{
-			switch(m_pSoftMask->GetDataType())
-			{
-			case EMaskDataType::ImageBuffer:
-			{
+			ESoftMaskType nType = m_pSoftMask->GetDataType();
+			if (nType == ESoftMaskType::RGBGrayBuffer)
+				Aggplus::BlendTo<agg::rgb_to_gray_mask_u8<0, 1, 2>>(pCurrentGraphicsLayer, m_frame_buffer.pixfmt(), m_pSoftMask->GetBuffer(), m_pSoftMask->GetStep());
+			else if (nType == ESoftMaskType::BGRGrayBuffer)
 				Aggplus::BlendTo<agg::rgb_to_gray_mask_u8<2, 1, 0>>(pCurrentGraphicsLayer, m_frame_buffer.pixfmt(), m_pSoftMask->GetBuffer(), m_pSoftMask->GetStep());
-				break;
-			}
-			case EMaskDataType::Alpha4Buffer:
-			{
+			else if (nType == ESoftMaskType::Alpha4Buffer)
 				Aggplus::BlendTo<agg::one_component_mask_u8>(pCurrentGraphicsLayer, m_frame_buffer.pixfmt(), m_pSoftMask->GetBuffer() + 3, m_pSoftMask->GetStep());
-				break;
-			}
-			}
 		}
 		else
 		{
@@ -1549,10 +1545,13 @@ namespace Aggplus
 	{
 		if (m_pSoftMask)
 		{
-			if (m_pSoftMask->GetDataType() == EMaskDataType::ImageBuffer)
-				return render_scanlines_3(ras, ren, m_pSoftMask->GetScanlineImage());
-			if (m_pSoftMask->GetDataType() == EMaskDataType::Alpha4Buffer)
-				return render_scanlines_3(ras, ren, m_pSoftMask->GetScanlineABuffer());
+			ESoftMaskType nType = m_pSoftMask->GetDataType();
+			if (nType == ESoftMaskType::RGBGrayBuffer)
+				return render_scanlines_3(ras, ren, ((CSoftMaskRGBAgray*)m_pSoftMask->m_pInternal)->GetScanline());
+			if (nType == ESoftMaskType::BGRGrayBuffer)
+				return render_scanlines_3(ras, ren, ((CSoftMaskBGRAgray*)m_pSoftMask->m_pInternal)->GetScanline());
+			if (nType == ESoftMaskType::Alpha4Buffer)
+				return render_scanlines_3(ras, ren, ((CSoftMaskAlpha*)m_pSoftMask->m_pInternal)->GetScanline());
 		}
 		render_scanlines_3(ras, ren, m_rasterizer.get_scanline());
 	}

DesktopEditor/graphics/Graphics.h

@@ -66,7 +66,7 @@
 #include "Matrix.h"
 #include "GraphicsLayerBlend.h"
 #include "GraphicsPath.h"
-#include "AlphaMask.h"
+#include "AlphaMask_p.h"
 #include "Clip.h"
 #include "Brush.h"
 #include "Image.h"

DesktopEditor/graphics/GraphicsRenderer.cpp

@@ -955,61 +955,62 @@ HRESULT CGraphicsRenderer::DrawPath(const LONG& nType)
 				}
 
 				Aggplus::CBrushTexture* pTextureBrush = NULL;
-				
-				if (NULL != m_pCache)
-				{
-                    pCacheImage = (CCacheImage*)m_pCache->Lock(m_oBrush.TexturePath);
 
-					pTextureBrush = new Aggplus::CBrushTexture(pCacheImage->GetImage(), oMode);
+				if (NULL != m_oBrush.Image)
+				{
+					pTextureBrush = new Aggplus::CBrushTexture(m_oBrush.Image, oMode);
+				}
+				else if (m_oBrush.TexturePath.find(L"data:") == 0)
+				{
+					bool bIsOnlyOfficeHatch = false;
+					if (m_oBrush.TexturePath.find(L"onlyoffice_hatch") != std::wstring::npos)
+					bIsOnlyOfficeHatch = true;
+
+					int countErase = (int)(m_oBrush.TexturePath.find(',') + 1);
+					int nInputSize = (int)(m_oBrush.TexturePath.length() - countErase);
+					const wchar_t* pInputSrc = m_oBrush.TexturePath.c_str() + countErase;
+
+					int nDecodeLen = NSBase64::Base64DecodeGetRequiredLength(nInputSize);
+					BYTE* pImageData = new BYTE[nDecodeLen];
+					if (TRUE == NSBase64::Base64Decode(pInputSrc, nInputSize, pImageData, &nDecodeLen))
+					{
+						CBgraFrame oFrame;
+						if (bIsOnlyOfficeHatch)
+						{
+							int nSize = (int)sqrt(nDecodeLen >> 2);
+							oFrame.put_IsRGBA(true);
+							oFrame.put_Data(pImageData);
+							oFrame.put_Width(nSize);
+							oFrame.put_Height(nSize);
+							oFrame.put_Stride(4 * nSize);
+						}
+						else
+						{
+							oFrame.put_IsRGBA(false);
+							oFrame.Decode(pImageData, nDecodeLen);
+							RELEASEARRAYOBJECTS(pImageData);
+						}
+						// pImage отдается pTextureBrush и освобождается вместе с pBrush
+						Aggplus::CImage* pImage = new Aggplus::CImage();
+						pImage->Create(oFrame.get_Data(), oFrame.get_Width(), oFrame.get_Height(), oFrame.get_Stride());
+						oFrame.ClearNoAttack();
+						pTextureBrush = new Aggplus::CBrushTexture(pImage, oMode);
+						pTextureBrush->m_bReleaseImage = TRUE;
+					}
+					else
+						RELEASEARRAYOBJECTS(pImageData);
 				}
 				else
 				{
-				#ifdef BUILDING_WASM_MODULE
-					if (NULL != m_oBrush.Image)
-						pTextureBrush = new Aggplus::CBrushTexture(m_oBrush.Image, oMode);
-					else if (m_oBrush.TexturePath.find(L"data:") == 0)
+					if (NULL != m_pCache)
 					{
-						bool bIsOnlyOfficeHatch = false;
-						if (m_oBrush.TexturePath.find(L"onlyoffice_hatch") != std::wstring::npos)
-							bIsOnlyOfficeHatch = true;
-						std::string sBase64MultyByte(m_oBrush.TexturePath.begin(), m_oBrush.TexturePath.end());
-						sBase64MultyByte.erase(0, sBase64MultyByte.find(',') + 1);
-						int nDecodeLen = NSBase64::Base64DecodeGetRequiredLength(sBase64MultyByte.length());
-						BYTE* pImageData = new BYTE[nDecodeLen + 64];
-						if (TRUE == NSBase64::Base64Decode(sBase64MultyByte.c_str(), sBase64MultyByte.length(), pImageData, &nDecodeLen))
-						{
-							CBgraFrame oFrame;
-							if (bIsOnlyOfficeHatch)
-							{
-								int nSize = (int)sqrt(nDecodeLen >> 2);
-								oFrame.put_IsRGBA(true);
-								oFrame.put_Data(pImageData);
-								oFrame.put_Width(nSize);
-								oFrame.put_Height(nSize);
-								oFrame.put_Stride(4 * nSize);
-							}
-							else
-							{
-								oFrame.put_IsRGBA(false);
-								oFrame.Decode(pImageData, nDecodeLen);
-								RELEASEARRAYOBJECTS(pImageData);
-							}
-							// pImage отдается pTextureBrush и освобождается вместе с pBrush
-							Aggplus::CImage* pImage = new Aggplus::CImage();
-							pImage->Create(oFrame.get_Data(), oFrame.get_Width(), oFrame.get_Height(), oFrame.get_Stride());
-							oFrame.ClearNoAttack();
-							pTextureBrush = new Aggplus::CBrushTexture(pImage, oMode);
-							pTextureBrush->m_bReleaseImage = TRUE;
-						}
-						else
-							RELEASEARRAYOBJECTS(pImageData);
+						pCacheImage = (CCacheImage*)m_pCache->Lock(m_oBrush.TexturePath);
+						pTextureBrush = new Aggplus::CBrushTexture(pCacheImage->GetImage(), oMode);
 					}
-				#else
-					if (NULL != m_oBrush.Image)
-						pTextureBrush = new Aggplus::CBrushTexture(m_oBrush.Image, oMode);
 					else
+					{
 						pTextureBrush = new Aggplus::CBrushTexture(m_oBrush.TexturePath, oMode);
-                #endif
+					}
 				}
 
 				if( pTextureBrush )

DesktopEditor/graphics/pro/graphics.pro

@@ -59,7 +59,8 @@ SOURCES += \
 
 # alpha mask
 HEADERS += \
-	./../AlphaMask.h
+	./../AlphaMask.h \
+	./../AlphaMask_p.h
 
 SOURCES += \
 	./../AlphaMask.cpp

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

@@ -126,6 +126,11 @@ CFile.prototype["loadFromDataWithPassword"] = function(password)
 	return error;
 };
 
+CFile.prototype["getType"] = function()
+{
+	return this.type;
+};
+
 CFile.prototype["close"] = function()
 {
 	this._closeFile();

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

@@ -144,7 +144,7 @@ CFile.prototype._getInteractiveFormsInfo = function()
 
 CFile.prototype._getAnnotationsInfo = function(pageIndex)
 {
-	g_module_pointer.ptr = g_native_drawing_file["GetAnnotationsInfo"](pageIndex);
+	g_module_pointer.ptr = g_native_drawing_file["GetAnnotationsInfo"](pageIndex === undefined ? -1 : pageIndex);
 	return g_module_pointer;
 };
 

DesktopEditor/xml/build/qt/libxml2.pri

@@ -74,6 +74,8 @@ SOURCES += \
     $$PWD/../../libxml2/valid.c \
      $$PWD/../../libxml2/parser.c
 }
+
+!core_only_libxml {
 SOURCES +=  \
     $$PWD/../../src/xmlwriter.cpp \
     $$PWD/../../src/xmllight.cpp \
@@ -85,3 +87,4 @@ HEADERS += \
 HEADERS += \
     $$PWD/../../include/xmlutils.h \
     $$PWD/../../include/xmlwriter.h
+}

OOXML/Binary/Document/BinReader/Readers.cpp

@@ -4979,6 +4979,18 @@ int Binary_DocumentTableReader::ReadDocumentContent(BYTE type, long length, void
 		m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::JsaProject.RelationType(), sJsaProject.GetPath(), L"", &lId);
 		m_oFileWriter.m_pDrawingConverter->m_pImageManager->m_pContentTypes->AddDefault(sJsaProject.GetExtention(false));
 	}
+	else if (c_oSerParType::PermStart == type)
+	{
+		OOX::Logic::CPermStart oPerm;
+		READ1_DEF(length, res, this->ReadPermStart, &oPerm);
+		m_oDocumentWriter.m_oContent.WriteString(oPerm.toXML());
+	}
+	else if (c_oSerParType::PermEnd == type)
+	{
+		OOX::Logic::CPermEnd oPerm;
+		READ1_DEF(length, res, this->ReadPermEnd, &oPerm);
+		m_oDocumentWriter.m_oContent.WriteString(oPerm.toXML());
+	}
 	else
 		res = c_oSerConstants::ReadUnknown;
 	return res;
@@ -5755,8 +5767,8 @@ int Binary_DocumentTableReader::ReadPermStart(BYTE type, long length, void* poRe
 	}
 	else if (c_oSerPermission::Ed == type)
 	{
-		pPerm->m_sId.Init();
-		*pPerm->m_sId = m_oBufferedStream.GetString3(length);
+		pPerm->m_sEd.Init();
+		*pPerm->m_sEd = m_oBufferedStream.GetString3(length);
 	}
 	else if (c_oSerPermission::EdGroup == type)
 	{
@@ -6034,6 +6046,18 @@ int Binary_DocumentTableReader::ReadMathArg(BYTE type, long length, void* poResu
 		READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd);
 		GetRunStringWriter().WriteString(oMoveToRangeEnd.toXML());
 	}	
+	else if (c_oSer_OMathContentType::PermStart == type)
+	{
+		OOX::Logic::CPermStart oPerm;
+		READ1_DEF(length, res, this->ReadPermStart, &oPerm);
+		GetRunStringWriter().WriteString(oPerm.toXML());
+	}
+	else if (c_oSer_OMathContentType::PermEnd == type)
+	{
+		OOX::Logic::CPermEnd oPerm;
+		READ1_DEF(length, res, this->ReadPermEnd, &oPerm);
+		GetRunStringWriter().WriteString(oPerm.toXML());
+	}
 	else
 		res = c_oSerConstants::ReadUnknown;
 	return res;
@@ -8653,6 +8677,18 @@ int Binary_DocumentTableReader::Read_TableContent(BYTE type, long length, void*
 		READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd);
 		pCStringWriter->WriteString(oMoveToRangeEnd.toXML());
 	}
+	else if (c_oSerDocTableType::PermStart == type)
+	{
+		OOX::Logic::CPermStart oPerm;
+		READ1_DEF(length, res, this->ReadPermStart, &oPerm);
+		pCStringWriter->WriteString(oPerm.toXML());
+	}
+	else if (c_oSerDocTableType::PermEnd == type)
+	{
+		OOX::Logic::CPermEnd oPerm;
+		READ1_DEF(length, res, this->ReadPermEnd, &oPerm);
+		pCStringWriter->WriteString(oPerm.toXML());
+	}
 	else
 		res = c_oSerConstants::ReadUnknown;
 	return res;
@@ -8726,6 +8762,18 @@ int Binary_DocumentTableReader::ReadRowContent(BYTE type, long length, void* poR
 		READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd);
 		pCStringWriter->WriteString(oMoveToRangeEnd.toXML());
 	}
+	else if (c_oSerDocTableType::PermStart == type)
+	{
+		OOX::Logic::CPermStart oPerm;
+		READ1_DEF(length, res, this->ReadPermStart, &oPerm);
+		pCStringWriter->WriteString(oPerm.toXML());
+	}
+	else if (c_oSerDocTableType::PermEnd == type)
+	{
+		OOX::Logic::CPermEnd oPerm;
+		READ1_DEF(length, res, this->ReadPermEnd, &oPerm);
+		pCStringWriter->WriteString(oPerm.toXML());
+	}
 	else
 		res = c_oSerConstants::ReadUnknown;
 	return res;

OOXML/Binary/Document/BinWriter/BinReaderWriterDefines.h

@@ -572,7 +572,9 @@ extern int g_nCurFormatVersion;
 		MoveFromRangeStart = 14,
 		MoveFromRangeEnd = 15,
 		MoveToRangeStart = 16,
-		MoveToRangeEnd = 17
+		MoveToRangeEnd = 17,
+		PermStart = 18,
+		PermEnd = 19
 	};}
 	namespace c_oSerRunType{enum c_oSerRunType
 	{
@@ -1075,7 +1077,9 @@ extern int g_nCurFormatVersion;
 		NoBreakHyphen = 81,
 		SoftHyphen = 82,
 		Sym = 83,
-		Tab = 84
+		Tab = 84,
+		PermStart =85,
+		PermEnd = 86
 	};}
 	namespace c_oSer_FramePrType{ enum c_oSer_FramePrType
 	{		

OOXML/Binary/Document/BinWriter/BinWriters.cpp

@@ -3606,7 +3606,17 @@ void BinaryDocumentTableWriter::WriteDocumentContent(const std::vector<OOX::Writ
 				Write(static_cast<OOX::Logic::CDocParts*>(item));
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}break;
-		default:
+			case OOX::et_w_permStart:
+			{
+				OOX::Logic::CPermStart* pPermStart = static_cast<OOX::Logic::CPermStart*>(item);
+				WritePermission(c_oSerParType::PermStart, pPermStart);
+			}break;
+			case OOX::et_w_permEnd:
+			{
+				OOX::Logic::CPermEnd* pPermEnd = static_cast<OOX::Logic::CPermEnd*>(item);
+				WritePermission(c_oSerParType::PermEnd, pPermEnd);
+			}break;
+			default:
 			break;
 		}
 	}
@@ -3896,12 +3906,12 @@ void BinaryDocumentTableWriter::WriteParagraphContent(const std::vector<OOX::Wri
 			case OOX::et_w_permStart:
 			{
 				OOX::Logic::CPermStart* pPermStart = static_cast<OOX::Logic::CPermStart*>(item);
-				WritePermission(pPermStart);
+				WritePermission(c_oSerParType::PermStart, pPermStart);
 			}break;
 			case OOX::et_w_permEnd:
 			{
 				OOX::Logic::CPermEnd* pPermEnd = static_cast<OOX::Logic::CPermEnd*>(item);
-				WritePermission(pPermEnd);
+				WritePermission(c_oSerParType::PermEnd, pPermEnd);
 			}break;
 			case OOX::et_w_fldSimple:
 			{
@@ -4197,11 +4207,11 @@ void BinaryDocumentTableWriter::WriteComment(OOX::EElementType eType, nullable<S
 		m_oBcw.WriteItemEnd(nCurPos);
 	}
 }
-void BinaryDocumentTableWriter::WritePermission(OOX::Logic::CPermStart* pPerm)
+void BinaryDocumentTableWriter::WritePermission(unsigned char type, OOX::Logic::CPermStart* pPerm)
 {
 	if (!pPerm) return;
 
-	int nCurPos2 = m_oBcw.WriteItemStart(c_oSerParType::PermStart);
+	int nCurPos2 = m_oBcw.WriteItemStart(type);
 
 	if (pPerm->m_sId.IsInit())
 	{
@@ -4241,11 +4251,11 @@ void BinaryDocumentTableWriter::WritePermission(OOX::Logic::CPermStart* pPerm)
 	}
 	m_oBcw.WriteItemWithLengthEnd(nCurPos2);
 }
-void BinaryDocumentTableWriter::WritePermission(OOX::Logic::CPermEnd* pPerm)
+void BinaryDocumentTableWriter::WritePermission(unsigned char type, OOX::Logic::CPermEnd* pPerm)
 {
 	if (!pPerm) return;
 	
-	int nCurPos2 = m_oBcw.WriteItemStart(c_oSerParType::PermEnd);
+	int nCurPos2 = m_oBcw.WriteItemStart(type);
 	if (pPerm->m_sId.IsInit())
 	{
 		int nCurPos = m_oBcw.WriteItemStart(c_oSerPermission::Id);
@@ -4688,184 +4698,170 @@ void BinaryDocumentTableWriter::WriteMathArgNodes(const std::vector<OOX::Writing
 		int nCurPos = 0;
 		switch(eType)
 		{
-		case OOX::et_m_acc:
+			case OOX::et_m_acc:
 			{
 				OOX::Logic::CAcc* pAcc = static_cast<OOX::Logic::CAcc*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Acc);
 
-				if ( pAcc->m_oAccPr.IsInit() )
+				if (pAcc->m_oAccPr.IsInit())
 					WriteMathAccPr(pAcc->m_oAccPr.get());
-				if ( pAcc->m_oElement.IsInit() )
+				if (pAcc->m_oElement.IsInit())
 					WriteMathElement(pAcc->m_oElement.get());
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_argPr:
+			}break;
+			case OOX::et_m_argPr:
 			{
 				OOX::Logic::CArgPr* pArgPr = static_cast<OOX::Logic::CArgPr*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::ArgPr);
 
-				if ( pArgPr->m_oArgSz.IsInit() )
+				if (pArgPr->m_oArgSz.IsInit())
 					WriteMathArgSz(pArgPr->m_oArgSz.get());
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_bar:
+			}break;
+			case OOX::et_m_bar:
 			{
 				OOX::Logic::CBar* pBar = static_cast<OOX::Logic::CBar*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Bar);
 
-				if ( pBar->m_oBarPr.IsInit() )
+				if (pBar->m_oBarPr.IsInit())
 					WriteMathBarPr(pBar->m_oBarPr.get());
-				if ( pBar->m_oElement.IsInit() )
+				if (pBar->m_oElement.IsInit())
 					WriteMathElement(pBar->m_oElement.get());
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_borderBox:
+			}break;
+			case OOX::et_m_borderBox:
 			{
 				OOX::Logic::CBorderBox* pBorderBox = static_cast<OOX::Logic::CBorderBox*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::BorderBox);
 
-				if ( pBorderBox->m_oBorderBoxPr.IsInit() )
+				if (pBorderBox->m_oBorderBoxPr.IsInit())
 					WriteMathBorderBoxPr(pBorderBox->m_oBorderBoxPr.get());
-				if ( pBorderBox->m_oElement.IsInit() )
+				if (pBorderBox->m_oElement.IsInit())
 					WriteMathElement(pBorderBox->m_oElement.get());
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_box:
+			}break;
+			case OOX::et_m_box:
 			{
 				OOX::Logic::CBox* pBox = static_cast<OOX::Logic::CBox*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Box);
 
-				if ( pBox->m_oBoxPr.IsInit() )
+				if (pBox->m_oBoxPr.IsInit())
 					WriteMathBoxPr(pBox->m_oBoxPr.get());
-				if ( pBox->m_oElement.IsInit() )
+				if (pBox->m_oElement.IsInit())
 					WriteMathElement(pBox->m_oElement.get());
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_ctrlPr:
+			}break;
+			case OOX::et_m_ctrlPr:
 			{
 				OOX::Logic::CCtrlPr* pCtrlPr = static_cast<OOX::Logic::CCtrlPr*>(item);
 				WriteMathCtrlPr(*pCtrlPr, c_oSer_OMathContentType::CtrlPr);
 				break;
 			}
-		case OOX::et_m_d:
+			case OOX::et_m_d:
 			{
 				OOX::Logic::CDelimiter* pDelimiter = static_cast<OOX::Logic::CDelimiter*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Delimiter);
 
 				WriteMathDelimiter(pDelimiter->m_arrItems, pDelimiter->m_lColumn);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_del:
+			}break;
+			case OOX::et_w_del:
 			{
 				OOX::Logic::CDel* pDel = static_cast<OOX::Logic::CDel*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Del);
 				WriteDel(*pDel);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_eqArr:
+			}break;
+			case OOX::et_m_eqArr:
 			{
 				OOX::Logic::CEqArr* pEqArr = static_cast<OOX::Logic::CEqArr*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::EqArr);
 
 				WriteMathEqArr(pEqArr->m_arrItems, pEqArr->m_lRow);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_f:
+			}break;
+			case OOX::et_m_f:
 			{
 				OOX::Logic::CFraction* pFraction = static_cast<OOX::Logic::CFraction*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Fraction);
 
-				if ( pFraction->m_oFPr.IsInit() )
+				if (pFraction->m_oFPr.IsInit())
 					WriteMathFPr(pFraction->m_oFPr.get());
-				if ( pFraction->m_oDen.IsInit() )
+				if (pFraction->m_oDen.IsInit())
 					WriteMathDen(pFraction->m_oDen.get());
-				if ( pFraction->m_oNum.IsInit() )
+				if (pFraction->m_oNum.IsInit())
 					WriteMathNum(pFraction->m_oNum.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_func:
+			}break;
+			case OOX::et_m_func:
 			{
 				OOX::Logic::CFunc* pFunc = static_cast<OOX::Logic::CFunc*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Func);
 
-				if ( pFunc->m_oFuncPr.IsInit() )
+				if (pFunc->m_oFuncPr.IsInit())
 					WriteMathFuncPr(pFunc->m_oFuncPr.get());
-				if ( pFunc->m_oElement.IsInit() )
+				if (pFunc->m_oElement.IsInit())
 					WriteMathElement(pFunc->m_oElement.get());
-				if ( pFunc->m_oFName.IsInit() )
+				if (pFunc->m_oFName.IsInit())
 					WriteMathFName(pFunc->m_oFName.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_groupChr:
+			}break;
+			case OOX::et_m_groupChr:
 			{
 				OOX::Logic::CGroupChr* pGroupChr = static_cast<OOX::Logic::CGroupChr*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::GroupChr);
 
-				if ( pGroupChr->m_oGroupChrPr.IsInit() )
+				if (pGroupChr->m_oGroupChrPr.IsInit())
 					WriteMathGroupChrPr(pGroupChr->m_oGroupChrPr.get());
-				if ( pGroupChr->m_oElement.IsInit() )
+				if (pGroupChr->m_oElement.IsInit())
 					WriteMathElement(pGroupChr->m_oElement.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_ins:
+			}break;
+			case OOX::et_w_ins:
 			{
 				OOX::Logic::CIns* pIns = static_cast<OOX::Logic::CIns*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Ins);
 				WriteIns(*pIns);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_limLow:
+			}break;
+			case OOX::et_m_limLow:
 			{
 				OOX::Logic::CLimLow* pLimLow = static_cast<OOX::Logic::CLimLow*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::LimLow);
 
-				if ( pLimLow->m_oLimLowPr.IsInit() )
+				if (pLimLow->m_oLimLowPr.IsInit())
 					WriteMathLimLowPr(pLimLow->m_oLimLowPr.get());
-				if ( pLimLow->m_oElement.IsInit() )
+				if (pLimLow->m_oElement.IsInit())
 					WriteMathElement(pLimLow->m_oElement.get());
-				if ( pLimLow->m_oLim.IsInit() )
+				if (pLimLow->m_oLim.IsInit())
 					WriteMathLim(pLimLow->m_oLim.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_limUpp:
+			}break;
+			case OOX::et_m_limUpp:
 			{
 				OOX::Logic::CLimUpp* pLimUpp = static_cast<OOX::Logic::CLimUpp*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::LimUpp);
 
-				if ( pLimUpp->m_oLimUppPr.IsInit() )
+				if (pLimUpp->m_oLimUppPr.IsInit())
 					WriteMathLimUppPr(pLimUpp->m_oLimUppPr.get());
-				if ( pLimUpp->m_oElement.IsInit() )
+				if (pLimUpp->m_oElement.IsInit())
 					WriteMathElement(pLimUpp->m_oElement.get());
-				if ( pLimUpp->m_oLim.IsInit() )
+				if (pLimUpp->m_oLim.IsInit())
 					WriteMathLim(pLimUpp->m_oLim.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_m:
+			}break;
+			case OOX::et_m_m:
 			{
 				OOX::Logic::CMatrix* pMatrix = static_cast<OOX::Logic::CMatrix*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Matrix);
 
 				LONG lCol = 0;
-//TODO убрать, тк при отсутствии m:mcs, к-во столбцов должно разруливаться динамически в скрипте
+				//TODO убрать, тк при отсутствии m:mcs, к-во столбцов должно разруливаться динамически в скрипте
 				for (std::vector<OOX::WritingElement*>::iterator jt = pMatrix->m_arrItems.begin(); jt != pMatrix->m_arrItems.end(); jt++)
 				{
 					OOX::WritingElement* item = *jt;
@@ -4878,35 +4874,32 @@ void BinaryDocumentTableWriter::WriteMathArgNodes(const std::vector<OOX::Writing
 				}
 				WriteMathMatrix(pMatrix->m_arrItems, pMatrix->m_lRow, lCol);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_nary:
+			}break;
+			case OOX::et_m_nary:
 			{
 				OOX::Logic::CNary* pNary = static_cast<OOX::Logic::CNary*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Nary);
 
-				if ( pNary->m_oNaryPr.IsInit() )
+				if (pNary->m_oNaryPr.IsInit())
 					WriteMathNaryPr(pNary->m_oNaryPr.get());
-				if ( pNary->m_oSub.IsInit() )
+				if (pNary->m_oSub.IsInit())
 					WriteMathSub(pNary->m_oSub.get());
-				if ( pNary->m_oSup.IsInit() )
+				if (pNary->m_oSup.IsInit())
 					WriteMathSup(pNary->m_oSup.get());
-				if ( pNary->m_oElement.IsInit() )
+				if (pNary->m_oElement.IsInit())
 					WriteMathElement(pNary->m_oElement.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_oMath:
+			}break;
+			case OOX::et_m_oMath:
 			{
 				OOX::Logic::COMath* pOMath = static_cast<OOX::Logic::COMath*>(item);
 
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::OMath);
-					WriteMathArgNodes(pOMath->m_arrItems);
+				WriteMathArgNodes(pOMath->m_arrItems);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_oMathPara:
+			}break;
+			case OOX::et_m_oMathPara:
 			{
 				OOX::Logic::COMathPara* pOMathPara = static_cast<OOX::Logic::COMathPara*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::OMathPara);
@@ -4914,158 +4907,154 @@ void BinaryDocumentTableWriter::WriteMathArgNodes(const std::vector<OOX::Writing
 				WriteMathOMathPara(pOMathPara->m_arrItems);
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_phant:
+			}break;
+			case OOX::et_m_phant:
 			{
 				OOX::Logic::CPhant* pPhant = static_cast<OOX::Logic::CPhant*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Phant);
 
-				if ( pPhant->m_oPhantPr.IsInit() )
+				if (pPhant->m_oPhantPr.IsInit())
 					WriteMathPhantPr(pPhant->m_oPhantPr.get());
-				if ( pPhant->m_oElement.IsInit() )
+				if (pPhant->m_oElement.IsInit())
 					WriteMathElement(pPhant->m_oElement.get());
 
-				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_r:
+				m_oBcw.WriteItemEnd(nCurPos);			
+			}break;
+			case OOX::et_m_r:
 			{
 				OOX::Logic::CMRun* pMRun = static_cast<OOX::Logic::CMRun*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::MRun);
 				WriteMathRunContent(pMRun);
-				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_rad:
+				m_oBcw.WriteItemEnd(nCurPos);			
+			}break;
+			case OOX::et_m_rad:
 			{
 				OOX::Logic::CRad* pRad = static_cast<OOX::Logic::CRad*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::Rad);
 
-				if ( pRad->m_oRadPr.IsInit() )
+				if (pRad->m_oRadPr.IsInit())
 					WriteMathRadPr(pRad->m_oRadPr.get());
-				if ( pRad->m_oDeg.IsInit() )
+				if (pRad->m_oDeg.IsInit())
 					WriteMathDeg(pRad->m_oDeg.get());
-				if ( pRad->m_oElement.IsInit() )
+				if (pRad->m_oElement.IsInit())
 					WriteMathElement(pRad->m_oElement.get());
 
-				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_sPre:
+				m_oBcw.WriteItemEnd(nCurPos);			
+			}break;
+			case OOX::et_m_sPre:
 			{
 				OOX::Logic::CSPre* pSPre = static_cast<OOX::Logic::CSPre*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::SPre);
 
-				if ( pSPre->m_oSPrePr.IsInit() )
+				if (pSPre->m_oSPrePr.IsInit())
 					WriteMathSPrePr(pSPre->m_oSPrePr.get());
-				if ( pSPre->m_oSub.IsInit() )
+				if (pSPre->m_oSub.IsInit())
 					WriteMathSub(pSPre->m_oSub.get());
-				if ( pSPre->m_oSup.IsInit() )
+				if (pSPre->m_oSup.IsInit())
 					WriteMathSup(pSPre->m_oSup.get());
-				if ( pSPre->m_oElement.IsInit() )
+				if (pSPre->m_oElement.IsInit())
 					WriteMathElement(pSPre->m_oElement.get());
 
-				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_sSub:
+				m_oBcw.WriteItemEnd(nCurPos);			
+			}break;
+			case OOX::et_m_sSub:
 			{
 				OOX::Logic::CSSub* pSSub = static_cast<OOX::Logic::CSSub*>(item);
 				int nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::SSub);
 
-				if ( pSSub->m_oSSubPr.IsInit() )
+				if (pSSub->m_oSSubPr.IsInit())
 					WriteMathSSubPr(pSSub->m_oSSubPr.get());
-				if ( pSSub->m_oElement.IsInit() )
+				if (pSSub->m_oElement.IsInit())
 					WriteMathElement(pSSub->m_oElement.get());
-				if ( pSSub->m_oSub.IsInit() )
+				if (pSSub->m_oSub.IsInit())
 					WriteMathSub(pSSub->m_oSub.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_sSubSup:
+			}break;
+			case OOX::et_m_sSubSup:
 			{
 				OOX::Logic::CSSubSup* pSSubSup = static_cast<OOX::Logic::CSSubSup*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::SSubSup);
 
-				if ( pSSubSup->m_oSSubSupPr.IsInit() )
+				if (pSSubSup->m_oSSubSupPr.IsInit())
 					WriteMathSSubSupPr(pSSubSup->m_oSSubSupPr.get());
-				if ( pSSubSup->m_oElement.IsInit() )
+				if (pSSubSup->m_oElement.IsInit())
 					WriteMathElement(pSSubSup->m_oElement.get());
-				if ( pSSubSup->m_oSub.IsInit() )
+				if (pSSubSup->m_oSub.IsInit())
 					WriteMathSub(pSSubSup->m_oSub.get());
-				if ( pSSubSup->m_oSup.IsInit() )
+				if (pSSubSup->m_oSup.IsInit())
 					WriteMathSup(pSSubSup->m_oSup.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_m_sSup:
+			}break;
+			case OOX::et_m_sSup:
 			{
 				OOX::Logic::CSSup* pSSup = static_cast<OOX::Logic::CSSup*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::SSup);
 
-				if ( pSSup->m_oSSupPr.IsInit() )
+				if (pSSup->m_oSSupPr.IsInit())
 					WriteMathSSupPr(pSSup->m_oSSupPr.get());
-				if ( pSSup->m_oElement.IsInit() )
+				if (pSSup->m_oElement.IsInit())
 					WriteMathElement(pSSup->m_oElement.get());
-				if ( pSSup->m_oSup.IsInit() )
+				if (pSSup->m_oSup.IsInit())
 					WriteMathSup(pSSup->m_oSup.get());
 
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_bookmarkStart:
+			}break;
+			case OOX::et_w_bookmarkStart:
 			{
 				OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast<OOX::Logic::CBookmarkStart*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::BookmarkStart);
 				WriteBookmarkStart(*pBookmarkStart);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_bookmarkEnd:
+			}break;
+			case OOX::et_w_bookmarkEnd:
 			{
 				OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast<OOX::Logic::CBookmarkEnd*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::BookmarkEnd);
 				WriteBookmarkEnd(*pBookmarkEnd);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_moveFromRangeStart:
+			}break;
+			case OOX::et_w_moveFromRangeStart:
 			{
 				OOX::Logic::CMoveFromRangeStart* pMoveFromRangeStart = static_cast<OOX::Logic::CMoveFromRangeStart*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::MoveFromRangeStart);
 				WriteMoveRangeStart(*pMoveFromRangeStart);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_moveFromRangeEnd:
+			}break;
+			case OOX::et_w_moveFromRangeEnd:
 			{
 				OOX::Logic::CMoveFromRangeEnd* pMoveFromRangeEnd = static_cast<OOX::Logic::CMoveFromRangeEnd*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::MoveFromRangeEnd);
 				WriteMoveRangeEnd(*pMoveFromRangeEnd);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_moveToRangeStart:
+			}break;
+			case OOX::et_w_moveToRangeStart:
 			{
 				OOX::Logic::CMoveToRangeStart* pMoveToRangeStart = static_cast<OOX::Logic::CMoveToRangeStart*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::MoveToRangeStart);
 				WriteMoveRangeStart(*pMoveToRangeStart);
 				m_oBcw.WriteItemEnd(nCurPos);
-				break;
-			}
-		case OOX::et_w_moveToRangeEnd:
+			}break;
+			case OOX::et_w_moveToRangeEnd:
 			{
 				OOX::Logic::CMoveToRangeEnd* pMoveToRangeEnd = static_cast<OOX::Logic::CMoveToRangeEnd*>(item);
 				nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::MoveToRangeEnd);
 				WriteMoveRangeEnd(*pMoveToRangeEnd);
 				m_oBcw.WriteItemEnd(nCurPos);
+			}break;
+			case OOX::et_w_permStart:
+			{
+				OOX::Logic::CPermStart* pPermStart = static_cast<OOX::Logic::CPermStart*>(item);
+				WritePermission(c_oSer_OMathContentType::PermStart, pPermStart);
+			}break;
+			case OOX::et_w_permEnd:
+			{
+				OOX::Logic::CPermEnd* pPermEnd = static_cast<OOX::Logic::CPermEnd*>(item);
+				WritePermission(c_oSer_OMathContentType::PermEnd, pPermEnd);
+			}break;
+			default:
 				break;
-			}
-		default:
-			break;
 		}
 	}
 }
@@ -7668,7 +7657,7 @@ void BinaryDocumentTableWriter::WriteTableContent(std::vector<OOX::WritingElemen
 	int nCurPos			= 0;
 	int nCurRowIndex	= 0;
 
-	for(size_t i = 0; i < content.size(); ++i)
+	for (size_t i = 0; i < content.size(); ++i)
 	{
 		OOX::WritingElement* item = content[i];
 
@@ -7743,6 +7732,17 @@ void BinaryDocumentTableWriter::WriteTableContent(std::vector<OOX::WritingElemen
 			WriteMoveRangeEnd(*pMoveToRangeEnd);
 			m_oBcw.WriteItemEnd(nCurPos);
 		}
+		else if (OOX::et_w_permStart == item->getType())
+		{
+			OOX::Logic::CPermStart* pPermStart = static_cast<OOX::Logic::CPermStart*>(item);
+			WritePermission(c_oSerDocTableType::PermStart, pPermStart);
+		}
+		else if (OOX::et_w_permEnd == item->getType())
+		{
+			OOX::Logic::CPermEnd* pPermEnd = static_cast<OOX::Logic::CPermEnd*>(item);
+			WritePermission(c_oSerDocTableType::PermEnd, pPermEnd);
+		}
+
 	}
 }
 void BinaryDocumentTableWriter::WriteRow(const OOX::Logic::CTr& Row, OOX::Logic::CTableProperty* pTblPr, int nCurRowIndex)
@@ -7845,6 +7845,16 @@ void BinaryDocumentTableWriter::WriteRowContent(const std::vector<OOX::WritingEl
 			WriteMoveRangeEnd(*pMoveToRangeEnd);
 			m_oBcw.WriteItemEnd(nCurPos);
 		}
+		else if (OOX::et_w_permStart == item->getType())
+		{
+			OOX::Logic::CPermStart* pPermStart = static_cast<OOX::Logic::CPermStart*>(item);
+			WritePermission(c_oSerDocTableType::PermStart, pPermStart);
+		}
+		else if (OOX::et_w_permEnd == item->getType())
+		{
+			OOX::Logic::CPermEnd* pPermEnd = static_cast<OOX::Logic::CPermEnd*>(item);
+			WritePermission(c_oSerDocTableType::PermEnd, pPermEnd);
+		}
 	}
 }
 void BinaryDocumentTableWriter::WriteCell(OOX::Logic::CTc& tc, OOX::Logic::CTableProperty* pTblPr, int nCurRowIndex, int nCurColIndex)

OOXML/Binary/Document/BinWriter/BinWriters.h

@@ -343,8 +343,8 @@ namespace BinDocxRW
 		template<typename T> void WriteMoveRangeEnd(const T& elem);
 		void WriteComment(OOX::EElementType eType, nullable<SimpleTypes::CDecimalNumber>& oId);
 		void WriteFldChar(OOX::Logic::CFldChar* pFldChar);
-		void WritePermission(OOX::Logic::CPermStart* pPerm);
-		void WritePermission(OOX::Logic::CPermEnd* pPerm);
+		void WritePermission(unsigned char type, OOX::Logic::CPermStart* pPerm);
+		void WritePermission(unsigned char type, OOX::Logic::CPermEnd* pPerm);
 		void WriteFldSimple(OOX::Logic::CFldSimple* pFldSimple);
 		void WriteFldSimpleContent(OOX::Logic::CFldSimple* pFldSimple);
 		void WriteFFData(const OOX::Logic::CFFData& oFFData);

PdfFile/SrcReader/RendererOutputDev.cpp

@@ -3407,8 +3407,8 @@ namespace PdfReader
 				}
 			}
 
-			if (!bAlpha) // pTransferFunc преобразовала результат luminosity маски в alpha маску
-				m_pSoftMask->SetType(Aggplus::EMaskDataType::Alpha4Buffer);
+			// if (!bAlpha) // pTransferFunc преобразовала результат luminosity маски в alpha маску
+			// 	m_pSoftMask->SetType(Aggplus::EMaskDataType::Alpha4Buffer);
 		}
 
 		m_sCS.pop_back();