DocumentServer/ActiveX/ASCOfficePPTXFile/ASCOfficeDrawingConverter.h

/*
 * (c) Copyright Ascensio System SIA 2010-2014
 *
 * This program is a free software product. You can redistribute it and/or 
 * modify it under the terms of the GNU Affero General Public License (AGPL) 
 * version 3 as published by the Free Software Foundation. In accordance with 
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect 
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied 
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For 
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
 * EU, LV-1021.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under 
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */
 
#pragma once
#include "stdafx.h"
#include "resource.h"       

#include "../Common/OfficeFileTemplate.h"
#include "./PPTXFormat/Logic/SpTreeElem.h"

#include "../Common/DocxFormat/Source/Common/SimpleTypes_Base.h"
#include "../ASCPresentationEditor/OfficeDrawing/Shapes/Shape.h"

#include "./PPTXFormat/Logic/Geometry.h"

namespace PPTX
{
	class CCSS
	{
	public:
		CAtlMap<CString, CString> m_mapSettings;
		CString m_strClassName;

	public:
		CCSS()
		{
			Clear();
		}
		~CCSS()
		{
		}
		AVSINLINE void Clear()
		{
			m_strClassName = _T("");
			m_mapSettings.RemoveAll();
		}

	public:
		void LoadFromString(CString& strParams)
		{
			Clear();

			
			TCHAR* pData	= strParams.GetBuffer();
			int nCount		= strParams.GetLength();

			int nPosition	= 0;
			TCHAR* pDataMem = pData;

			while ((nPosition < nCount) && ((TCHAR(' ') == *pDataMem) || (TCHAR('\n') == *pDataMem) || (TCHAR('.') == *pDataMem)))
			{
				++nPosition;
				++pDataMem;
			}

			int nPosNameStart = nPosition;
			while ((nPosition < nCount) && (TCHAR(' ') != *pDataMem) && (TCHAR('{') != *pDataMem))
			{
				++nPosition;
				++pDataMem;
			}
			m_strClassName = strParams.Mid(nPosNameStart, nPosition - nPosNameStart);

			while (true)
			{
				++nPosition;
				++pDataMem;
				
				
				while ((nPosition < nCount) && ((TCHAR(' ') == *pDataMem) || (TCHAR('{') == *pDataMem)))
				{
					++nPosition;
					++pDataMem;
				}

				int nPosOld = nPosition;

				
				while ((nPosition < nCount) && (TCHAR(':') != *pDataMem))
				{
					++nPosition;
					++pDataMem;
				}

				if (nPosOld == nPosition)
				{
					
					break;
				}
				CString strName = strParams.Mid(nPosOld, nPosition - nPosOld);

				
				++nPosition;
				++pDataMem;

				
				while ((nPosition < nCount) && (TCHAR(' ') == *pDataMem))
				{
					++nPosition;
					++pDataMem;
				}

				nPosOld = nPosition;

				
				while ((nPosition < nCount) && (TCHAR(';') != *pDataMem) && (TCHAR('}') != *pDataMem))
				{
					++nPosition;
					++pDataMem;
				}

				CString strValue = strParams.Mid(nPosOld, nPosition - nPosOld);

				m_mapSettings.SetAt(strName, strValue);
			}
		}

		void LoadFromString2(CString& strParams)
		{
			Clear();

			
			TCHAR* pData	= strParams.GetBuffer();
			int nCount		= strParams.GetLength();

			int nPosition	= 0;
			TCHAR* pDataMem = pData;

			m_strClassName = _T("");

			while (true)
			{
				
				while ((nPosition < nCount) && ((TCHAR(' ') == *pDataMem) || (TCHAR('{') == *pDataMem) || (TCHAR(';') == *pDataMem)))
				{
					++nPosition;
					++pDataMem;
				}

				int nPosOld = nPosition;

				
				while ((nPosition < nCount) && (TCHAR(':') != *pDataMem))
				{
					++nPosition;
					++pDataMem;
				}

				if (nPosOld == nPosition)
				{
					
					break;
				}
				CString strName = strParams.Mid(nPosOld, nPosition - nPosOld);

				
				++nPosition;
				++pDataMem;

				
				while ((nPosition < nCount) && (TCHAR(' ') == *pDataMem))
				{
					++nPosition;
					++pDataMem;
				}

				nPosOld = nPosition;

				
				while ((nPosition < nCount) && (TCHAR(';') != *pDataMem) && (TCHAR('}') != *pDataMem))
				{
					++nPosition;
					++pDataMem;
				}

				CString strValue = strParams.Mid(nPosOld, nPosition - nPosOld);

				if (pData[nPosOld] == WCHAR('.'))
					strValue = (_T("0") + strValue);

				m_mapSettings.SetAt(strName, strValue);
			}
		}

	};

	class CStylesCSS
	{
	public: 
		CAtlArray<CCSS> m_arStyles;

	public:
		CStylesCSS() : m_arStyles()
		{
		}
		~CStylesCSS()
		{
		}
		AVSINLINE void Clear()
		{
			m_arStyles.RemoveAll();
		}

	public:
		void LoadStyles(CString& strParams)
		{
			Clear();

			TCHAR* pData	= strParams.GetBuffer();
			int nCount		= strParams.GetLength();

			int nPosition	 = 0;
			int nPositionOld = 0;
			TCHAR* pDataMem = pData;

			while (nPosition < nCount)
			{
				if (*pDataMem == TCHAR('}'))
				{
					CString strTemp = strParams.Mid(nPositionOld, nPosition - nPositionOld + 1);
					m_arStyles.Add();
					m_arStyles[m_arStyles.GetCount() - 1].LoadFromString(strTemp);

					nPositionOld = nPosition + 1;
				}

				++nPosition;
				++pDataMem;
			}
		}
	};
}


[object, uuid("44B693E1-F4F9-4547-ACEF-0AE037C84485"), dual, pointer_default(unique)]
__interface IAVSODObjectProps : IDispatch
{
	[id(1)]			HRESULT GetProperty([in] LONG lId, [out, retval] VARIANT* pProp);
	[id(2)]			HRESULT SetProperty([in] LONG lId, [in] VARIANT prop);	
	
	[id(1000)]		HRESULT SetAdditionalParam([in] BSTR ParamName, [in] VARIANT ParamValue);
	[id(1001)]		HRESULT GetAdditionalParam([in] BSTR ParamName, [out, retval] VARIANT* ParamValue);
};


[object, uuid("8E0FBC40-9B34-40bf-B68A-0FA320E1B004"), dual, pointer_default(unique)]
__interface IAVSOfficeDrawingConverter : IDispatch
{
	[id(1)]				HRESULT SetMainDocument([in] IUnknown* pDocument);
	[id(2)]				HRESULT SetRelsPath([in] BSTR bsRelsPath);
	[id(3)]				HRESULT	SetMediaDstPath([in] BSTR bsMediaPath);
	
	[id(9)]				HRESULT AddShapeType([in] BSTR bsXml);
	[id(10)]			HRESULT AddObject([in] BSTR bsXml, [out] BSTR* pMainProps, [out, satype("BYTE")] SAFEARRAY** ppBinary);
	[id(11)]			HRESULT SaveObject([in, satype("BYTE")] SAFEARRAY* pBinaryObj, [in] LONG lStart, [in] LONG lLength, [in] BSTR bsMainProps, [out] BSTR* bsXml);
	[id(12)]			HRESULT SaveObjectEx([in, satype("BYTE")] SAFEARRAY* pBinaryObj, [in] LONG lStart, [in] LONG lLength, [in] BSTR bsMainProps, [in] LONG lDocType, [out] BSTR* bsXml);

	[id(13)]			HRESULT GetRecordBinary([in] LONG lRecordType, [in] BSTR bsXml, [out, satype("BYTE")] SAFEARRAY** ppBinary);
	[id(14)]			HRESULT GetRecordXml([in, satype("BYTE")] SAFEARRAY* pBinaryObj, [in] LONG lStart, [in] LONG lLength, [in] LONG lRecType, [in] LONG lDocType, [out] BSTR* bsXml);
		
	[id(20)]			HRESULT AddObject2([in] BSTR bsXml, [in, satype("BYTE")] SAFEARRAY* pBinaryObj, [out] BSTR* pXmlOutput);
	
	[id(30)]			HRESULT GetThemeBinary([in] BSTR bsThemeFilePath, [out, satype("BYTE")] SAFEARRAY** ppBinary);
	[id(31)]			HRESULT SaveThemeXml([in, satype("BYTE")] SAFEARRAY* pBinaryTheme, [in] LONG lStart, [in] LONG lLength, [in] BSTR bsThemePath);

	[id(40)]			HRESULT SetDstContentRels();
	[id(41)]			HRESULT SaveDstContentRels([in] BSTR bsRelsPath);
	[id(42)]			HRESULT WriteRels([in] BSTR bsType, [in] BSTR bsTarget, [in] BSTR bsTargetMode, [out] LONG* lId);

	[id(50)]			HRESULT LoadClrMap([in] BSTR bsXml);

	[id(60)]			HRESULT GetTxBodyBinary([in] BSTR bsXml, [out, satype("BYTE")] SAFEARRAY** ppBinary);
	[id(61)]			HRESULT GetTxBodyXml([in, satype("BYTE")] SAFEARRAY* pBinary, [in] LONG lStart, [in] LONG lLength, BSTR* pbstrXml);
	[id(62)]			HRESULT SetFontDir([in] BSTR bsFontDir);
	
	[id(1000)]			HRESULT SetAdditionalParam([in] BSTR ParamName, [in] VARIANT ParamValue);
	[id(1001)]			HRESULT GetAdditionalParam([in] BSTR ParamName, [out, retval] VARIANT* ParamValue);
};

class CSpTreeElemProps
{
public:
	LONG X;
	LONG Y;
	LONG Width;
	LONG Height;

	bool IsTop;

public:
	CSpTreeElemProps()
	{
		X = 0;
		Y = 0;
		Width = 0;
		Height = 0;

		IsTop = true;
	}
};

class CElementProps
{
public:
	CAtlMap<LONG, VARIANT> m_Properties;

public:
	CElementProps() : m_Properties()
	{
	}

	~CElementProps()
	{
		FinalRelease();
	}

	void FinalRelease()
	{
		POSITION pos = m_Properties.GetStartPosition();
		while (pos != NULL)
		{
			CAtlMap<LONG, VARIANT>::CPair * pPair = m_Properties.GetNext(pos);
			if (NULL != pPair)
			{
				if (pPair->m_value.vt == VT_BSTR)
					SysFreeString(pPair->m_value.bstrVal);
			}
		}
		m_Properties.RemoveAll();
	}

public:
	STDMETHOD(GetProperty)(LONG lId, VARIANT* pProp)
	{
		if (NULL == pProp)
			return S_FALSE;

		CAtlMap<LONG, VARIANT>::CPair * pPair = m_Properties.Lookup(lId);
		if (NULL == pPair)
			return S_FALSE;

		bool bIsSupportProp = CopyProperty(*pProp, pPair->m_value);

		if (!bIsSupportProp)
		{
			return S_FALSE;
		}

		return S_OK;
	}
	STDMETHOD(SetProperty)(LONG lId, VARIANT prop)
	{
		VARIANT var;
		bool bIsSupportProp = CopyProperty(var, prop);
		if (!bIsSupportProp)
			return S_FALSE;

		CAtlMap<LONG, VARIANT>::CPair* pPair = m_Properties.Lookup(lId);
		if (NULL != pPair)
		{
			if (pPair->m_value.vt == VT_BSTR)
				SysFreeString(pPair->m_value.bstrVal);
		}

		m_Properties.SetAt(lId, var);
		return S_OK;
	}

public:
	static bool CopyProperty(VARIANT& oDst, const VARIANT& oSrc)
	{
		oDst.vt = oSrc.vt;
		switch (oDst.vt)
		{
		case VT_I4:
			{
				oDst.lVal = oSrc.lVal;
				break;
			}
		case VT_R8:
			{
				oDst.dblVal = oSrc.dblVal;
				break;
			}
		case VT_BSTR:
			{
				oDst.bstrVal = SysAllocString(oSrc.bstrVal);
				break;
			}
		default:
			return false;			
		}
		return true;
	}
};


[coclass, uuid("4AB04382-4B51-4674-A691-BE2691A5F387"), threading(apartment), vi_progid("AVSOfficePPTXFile.ODObjectProps"), progid("AVSOfficePPTXFile.ODObjectProps.1"), version(1.0), registration_script("control.rgs")]
class ATL_NO_VTABLE CAVSODObjectProps 
	:	public IAVSODObjectProps
{
private:
	CElementProps m_oProps;

public:

	CAVSODObjectProps() : m_oProps()
	{
	}

	~CAVSODObjectProps()
	{
	}

	DECLARE_PROTECT_FINAL_CONSTRUCT()

	HRESULT FinalConstruct()
	{
		return S_OK;
	}

	void FinalRelease()
	{
		m_oProps.FinalRelease();		
	}

public:
	STDMETHOD(GetProperty)(LONG lId, VARIANT* pProp)
	{
		return m_oProps.GetProperty(lId, pProp);
	}
	STDMETHOD(SetProperty)(LONG lId, VARIANT prop)
	{
		return m_oProps.SetProperty(lId, prop);
	}
	
	STDMETHOD(SetAdditionalParam)(BSTR ParamName, VARIANT ParamValue)
	{
		return S_OK;
	}
	STDMETHOD(GetAdditionalParam)(BSTR ParamName, VARIANT* ParamValue)
	{
		return S_OK;
	}
};


[coclass, uuid("BA240E3F-CFE4-45d7-96BB-97CDD73F63C3"), event_source(com), threading(apartment), vi_progid("AVSOfficePPTXFile.ODConverter"), progid("AVSOfficePPTXFile.ODConverter.1"), version(1.0), registration_script("control.rgs")]
class ATL_NO_VTABLE CAVSOfficeDrawingConverter 
	:	public IAVSOfficeDrawingConverter
{
public:
	class CElement
	{
	public:
		PPTX::WrapperWritingElement*	m_pElement;
		CElementProps*					m_pProps;

	public:
		CElement()
		{
			m_pElement	= NULL;
			m_pProps	= NULL;
		}
		~CElement()
		{
			RELEASEOBJECT(m_pElement);
			RELEASEOBJECT(m_pProps);
		}

		CElement& operator=(const CElement& oSrc)
		{
			m_pElement	= oSrc.m_pElement;
			m_pProps	= oSrc.m_pProps;
			return *this;
		}
		CElement(const CElement& oSrc)
		{
			*this = oSrc;
		}
	};

	
	CAtlMap<CString, CShape*>				m_mapShapeTypes;
	CAtlMap<CString, smart_ptr<PPTX::CCommonRels>>	m_mapRels;
	CString									m_strCurrentRelsPath;
	
	NSBinPptxRW::CBinaryFileWriter			m_oBinaryWriter;
	int										m_lNextId;

	int										m_lCurrentObjectTop;

	NSBinPptxRW::CBinaryFileReader			m_oReader;
	NSBinPptxRW::CImageManager2				m_oImageManager;
	NSBinPptxRW::CXmlWriter					m_oXmlWriter;
	int										m_nCurrentIndexObject;

	IASCRenderer*							m_pOOXToVMLRenderer;
	BOOL									m_bIsUseConvertion2007;

	NSCommon::smart_ptr<PPTX::WrapperFile>				m_oTheme;
	NSCommon::smart_ptr<PPTX::WrapperWritingElement>	m_oClrMap;

	CString									m_strFontDirectory;

public:

	__event __interface _IAVSOfficeFileTemplateEvents2;

	CAVSOfficeDrawingConverter()
	{
		m_nCurrentIndexObject = 0;
		m_strFontDirectory = _T("");
	}

	~CAVSOfficeDrawingConverter()
	{
	}

	DECLARE_PROTECT_FINAL_CONSTRUCT()

	HRESULT FinalConstruct()
	{
		m_strCurrentRelsPath = _T("");
		m_lNextId = 1;
		m_lCurrentObjectTop = 0;

		m_pOOXToVMLRenderer = NULL;
		m_bIsUseConvertion2007 = TRUE;
		return S_OK;
	}

	void FinalRelease()
	{
		Clear();
		RELEASEINTERFACE(m_pOOXToVMLRenderer);
	}

public:
	STDMETHOD(SetMainDocument)(IUnknown* pDocument)
	{
		m_oBinaryWriter.ClearNoAttack();
		m_oBinaryWriter.m_oCommon.m_oImageManager.NewDocument();
		m_oBinaryWriter.SetMainDocument(pDocument);
		m_oReader.SetMainDocument(pDocument);
		m_lNextId = 1;
		return S_OK;
	}
	STDMETHOD(SetRelsPath)(BSTR bsRelsPath)
	{
		
		m_strCurrentRelsPath = bsRelsPath;
		return SetCurrentRelsPath();
	}
	STDMETHOD(SetMediaDstPath)(BSTR bsMediaPath)
	{
		m_oBinaryWriter.m_oCommon.m_oImageManager.m_strDstMedia = (CString)bsMediaPath;
		m_oImageManager.SetDstMedia(m_oBinaryWriter.m_oCommon.m_oImageManager.m_strDstMedia);

		CreateDirectory(bsMediaPath, NULL);
		return S_OK;
	}
	
	STDMETHOD(AddShapeType)(BSTR bsXml)
	{
		CString strXml = _T("<main ");

		strXml += _T("\
xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" \
xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" \
xmlns:v=\"urn:schemas-microsoft-com:vml\" \
xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" \
xmlns:w10=\"urn:schemas-microsoft-com:office:word\" \
xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" \
xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" \
xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" \
xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" \
xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" \
xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" \
xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" \
xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\"");

		strXml += _T(">");

		strXml += (CString)bsXml;

		strXml += _T("</main>");

		XmlUtils::CXmlNode oNode;
		oNode.FromXmlString(strXml);

		if (oNode.IsValid())
		{
			CPPTShape* pShape = new CPPTShape();
			pShape->m_bIsShapeType = true;
			
			XmlUtils::CXmlNode oNodeST = oNode.ReadNodeNoNS(_T("shapetype"));

			CString strId = oNodeST.GetAttribute(_T("id"));
			pShape->LoadFromXMLShapeType(oNodeST);

			CShape* pS = new CShape(NSBaseShape::unknown, 0);
			pS->m_pShape = pShape;
			LoadCoordSize(oNodeST, pS);

			m_mapShapeTypes.SetAt(strId, pS);			
		}

		return S_OK;
	}

	STDMETHOD(AddObject)(BSTR bsXml, BSTR* pMainProps, SAFEARRAY** ppBinary)
	{
		CString strXml = _T("<main ");

		strXml += _T("\
xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" \
xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" \
xmlns:v=\"urn:schemas-microsoft-com:vml\" \
xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" \
xmlns:w10=\"urn:schemas-microsoft-com:office:word\" \
xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" \
xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" \
xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" \
xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" \
xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" \
xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" \
xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" \
xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\" \
xmlns:xdr=\"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing\"");

		strXml += _T(">");

		strXml += (CString)bsXml;

		strXml += _T("</main>");

		m_oBinaryWriter.m_oCommon.CheckFontPicker();

		++m_lCurrentObjectTop;
		bool bResult = ParceObject(strXml, pMainProps, ppBinary);
		--m_lCurrentObjectTop;

		if (0 == m_lCurrentObjectTop)
		{
			m_oBinaryWriter.ClearNoAttack();
		}

		return bResult ? S_OK : S_FALSE;
	}

	STDMETHOD(AddObject2)(BSTR bsXml, SAFEARRAY* pBinaryObj, BSTR* pXmlOutput)
	{
		return S_OK;
	}

	STDMETHOD(GetThemeBinary)(BSTR bsThemeFilePath, SAFEARRAY** ppBinary);

	STDMETHOD(SaveThemeXml)(SAFEARRAY* pBinaryTheme, LONG lStart, LONG lLength, BSTR bsThemePath);
	STDMETHOD(SaveObject)(SAFEARRAY* pBinaryObj, LONG lStart, LONG lLength, BSTR bsMainProps, BSTR* bsXml);
	STDMETHOD(SaveObjectEx)(SAFEARRAY* pBinaryObj, LONG lStart, LONG lLength, BSTR bsMainProps, LONG lDocType, BSTR* bsXml);

	STDMETHOD(GetRecordBinary)(LONG lRecordType, BSTR bsXml, SAFEARRAY** ppBinary);
	STDMETHOD(GetRecordXml)(SAFEARRAY* pBinaryObj, LONG lStart, LONG lLength, LONG lRecType, LONG lDocType, BSTR* bsXml);

	STDMETHOD(SetDstContentRels)()
	{
		m_oReader.m_oRels.Clear();
		m_oReader.m_oRels.StartRels();
		return S_OK;
	}
	STDMETHOD(SaveDstContentRels)(BSTR bsRelsPath)
	{
		m_oReader.m_oRels.CloseRels();
		m_oReader.m_oRels.SaveRels((CString)bsRelsPath);
		return S_OK;
	}
	STDMETHOD(WriteRels)(BSTR bsType, BSTR bsTarget, BSTR bsTargetMode, LONG* lId)
	{
		if (NULL == lId)
			return S_FALSE;

		*lId = m_oReader.m_oRels.WriteRels(bsType, bsTarget, bsTargetMode);
		return S_OK;
	}

	STDMETHOD(LoadClrMap)(BSTR bsXml);

	STDMETHOD(GetTxBodyBinary)(BSTR bsXml, SAFEARRAY** ppBinary);
	STDMETHOD(GetTxBodyXml)(SAFEARRAY* pBinary, LONG lStart, LONG lLength, BSTR *pbstrXml);
	STDMETHOD(SetFontDir)(BSTR bsFontDir);
		
	STDMETHOD(SetAdditionalParam)(BSTR ParamName, VARIANT ParamValue)
	{
		CString name = (CString)ParamName;
		if (name == _T("SourceFileDir"))
		{
			m_oReader.m_oRels.m_pManager = &m_oImageManager;
			m_oImageManager.m_bIsWord = TRUE;
			m_oReader.m_strFolder = CString(ParamValue.bstrVal);
		}
		else if (name == _T("UseConvertion2007"))
		{
			m_bIsUseConvertion2007 = (ParamValue.boolVal == VARIANT_TRUE) ? true : false;
		}
		else if (name == _T("SerializeImageManager"))
		{
			NSBinPptxRW::CBinaryFileReader oReader;
			oReader.Deserialize(&m_oBinaryWriter.m_oCommon.m_oImageManager, ParamValue.parray);
		}
		else if (name == _T("SerializeImageManager2"))
		{
			NSBinPptxRW::CBinaryFileReader oReader;
			oReader.Deserialize(&m_oImageManager, ParamValue.parray);
		}
		else if (name == _T("FontPicker") && ParamValue.vt == VT_UNKNOWN && NULL != ParamValue.punkVal)
		{
			IOfficeFontPicker* pFontPicker = NULL;
			ParamValue.punkVal->QueryInterface(__uuidof(IOfficeFontPicker), (void**)&pFontPicker);
			
			m_oBinaryWriter.m_oCommon.CreateFontPicker(pFontPicker);
			RELEASEINTERFACE(pFontPicker);
		}
		else if (name == _T("DocumentChartsCount") && ParamValue.vt == VT_I4)
		{
			m_oReader.m_lChartNumber = ParamValue.lVal + 1;
		}		
		return S_OK;
	}
	STDMETHOD(GetAdditionalParam)(BSTR ParamName, VARIANT* ParamValue)
	{
		CString name = (CString)ParamName;
		if (name == _T("SerializeImageManager"))
		{
			NSBinPptxRW::CBinaryFileWriter oWriter;

			ParamValue->vt = VT_ARRAY;
			ParamValue->parray = oWriter.Serialize(&m_oBinaryWriter.m_oCommon.m_oImageManager);
		}
		else if (name == _T("SerializeImageManager2"))
		{
			NSBinPptxRW::CBinaryFileWriter oWriter;

			ParamValue->vt = VT_ARRAY;
			ParamValue->parray = oWriter.Serialize(&m_oImageManager);
		}
		else if (name == _T("FontPicker"))
		{
			ParamValue->vt = VT_UNKNOWN;
			ParamValue->punkVal = NULL;

			if (NULL != m_oBinaryWriter.m_oCommon.m_pFontPicker)
				m_oBinaryWriter.m_oCommon.m_pFontPicker->QueryInterface(IID_IUnknown, (void**)&(ParamValue->punkVal));
		}
		else if (name == _T("DocumentChartsCount"))
		{
			ParamValue->vt = VT_I4;
			ParamValue->lVal = m_oReader.m_lChartNumber;
		}
		else if (name == _T("ContentTypes"))
		{
			ParamValue->vt = VT_BSTR;
			ParamValue->bstrVal = m_oReader.m_strContentTypes.AllocSysString();
		}
		return S_OK;
	}

protected:
	bool ParceObject(CString& strXml, BSTR* pMainProps, SAFEARRAY** ppBinary);
	void SendMainProps(CString& strMainProps, BSTR*& pMainProps);

	PPTX::Logic::SpTreeElem doc_LoadShape(XmlUtils::CXmlNode& oNode, BSTR*& pMainProps, bool bIsTop = true);
	PPTX::Logic::SpTreeElem doc_LoadGroup(XmlUtils::CXmlNode& oNode, BSTR*& pMainProps, bool bIsTop = true);

	CString GetVMLShapeXml(CPPTShape* pPPTShape);
	CString GetVMLShapeXml(PPTX::Logic::SpTreeElem& oElem);

	void CheckBrushShape(PPTX::Logic::SpTreeElem& oElem, XmlUtils::CXmlNode& oNode, PPTShapes::ShapeType eType, CPPTShape* pPPTShape);
	void CheckPenShape(PPTX::Logic::SpTreeElem& oElem, XmlUtils::CXmlNode& oNode, PPTShapes::ShapeType eType, CPPTShape* pPPTShape);
		
	void LoadCoordSize(XmlUtils::CXmlNode& oNode, CShape* pShape);
	CString GetDrawingMainProps(XmlUtils::CXmlNode& oNode, PPTX::CCSS& oCssStyles, CSpTreeElemProps& oProps);

	void ConvertMainPropsToVML(BSTR bsMainProps, NSBinPptxRW::CXmlWriter& oWriter, PPTX::Logic::SpTreeElem& oElem);
	void ConvertShapeVML(PPTX::Logic::SpTreeElem& oShape, BSTR bsMainProps, NSBinPptxRW::CXmlWriter& oWriter);
	void ConvertGroupVML(PPTX::Logic::SpTreeElem& oGroup, BSTR bsMainProps, NSBinPptxRW::CXmlWriter& oWriter);

	void Clear()
	{
		POSITION pos = m_mapShapeTypes.GetStartPosition();
		while (NULL != pos)
		{
			CShape* pMem = m_mapShapeTypes.GetNextValue(pos);
			RELEASEOBJECT(pMem);
		}
		m_mapShapeTypes.RemoveAll();
		m_mapRels.RemoveAll();
	}

	HRESULT SetCurrentRelsPath()
	{
		CAtlMap<CString, smart_ptr<PPTX::CCommonRels>>::CPair* pPair = m_mapRels.Lookup(m_strCurrentRelsPath);

		if (NULL == pPair)
		{
			smart_ptr<PPTX::CCommonRels> pCR = new PPTX::CCommonRels();
			m_mapRels.SetAt(m_strCurrentRelsPath, pCR);

			pPair = m_mapRels.Lookup(m_strCurrentRelsPath);
			OOX::CPath filename = m_strCurrentRelsPath;
			pPair->m_value->_read(filename);
		}

		m_oBinaryWriter.m_pCommonRels = pPair->m_value.smart_dynamic_cast<PPTX::FileContainer>();
		return S_OK;
	}
};