DocxRenderer (not worked)

DocxRenderer/DocxRenderer.cpp

+/*
+ * (c) Copyright Ascensio System SIA 2010-2016
+ *
+ * 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
+ *
+ */
+
+//----------------------------------------------------------------------------------------
+//
+// CDocxRenderer
+//
+//----------------------------------------------------------------------------------------
+CPdfRenderer::CPdfRenderer(CApplicationFonts* pAppFonts) : m_oCommandManager(this)
+{
+	m_pAppFonts = pAppFonts;
+
+	// Создаем менеджер шрифтов с собственным кэшем
+	m_pFontManager = pAppFonts->GenerateFontManager();
+	CFontsCache* pMeasurerCache = new CFontsCache();
+	pMeasurerCache->SetStreams(pAppFonts->GetStreams());
+	m_pFontManager->SetOwnerCache(pMeasurerCache);
+
+	m_pDocument = new CDocument();
+	if (!m_pDocument || !m_pDocument->CreateNew())
+	{
+		SetError();
+		return;
+	}
+
+    m_pDocument->SetCompressionMode(COMP_ALL);
+
+	m_bValid      = true;
+	m_dPageHeight = 297;
+	m_dPageWidth  = 210;
+	m_pPage       = NULL;
+	m_pFont       = NULL;
+
+	m_nCounter = 0;
+	m_nPagesCount = 0;
+
+	m_bNeedUpdateTextFont      = true;
+	m_bNeedUpdateTextColor     = true;
+	m_bNeedUpdateTextAlpha     = true;
+	m_bNeedUpdateTextCharSpace = true;
+	m_bNeedUpdateTextSize      = true;
+
+	m_wsTempFolder = L"";
+	SetTempFolder(NSFile::CFileBinary::GetTempPath());
+}
+CPdfRenderer::~CPdfRenderer()
+{
+	RELEASEOBJECT(m_pDocument);
+	RELEASEINTERFACE(m_pFontManager);
+
+	if (L"" != m_wsTempFolder)
+		NSDirectory::DeleteDirectory(m_wsTempFolder);
+}
+void CPdfRenderer::SaveToFile(const std::wstring& wsPath)
+{
+	if (!IsValid())
+		return;
+
+	m_oCommandManager.Flush();
+
+	m_pDocument->SaveToFile(wsPath);
+}
+void CPdfRenderer::SetTempFolder(const std::wstring& wsPath)
+{
+	if (L"" != m_wsTempFolder)
+		NSDirectory::DeleteDirectory(m_wsTempFolder);
+	
+	int nCounter = 0;
+    m_wsTempFolder = wsPath;
+    int nPathLen = (int)m_wsTempFolder.length();
+    if (nPathLen > 0)
+    {
+        const wchar_t* pData = m_wsTempFolder.c_str();
+        if ((pData[nPathLen - 1] != '/') && (pData[nPathLen - 1] != '\\'))
+            m_wsTempFolder += L"/";
+
+        m_wsTempFolder += L"PDF";
+    }
+
+    std::wstring sTest = m_wsTempFolder;
+	while (NSDirectory::Exists(m_wsTempFolder))
+	{
+        m_wsTempFolder = sTest + L"/PDF_" + std::to_wstring(nCounter);
+		nCounter++;
+	}
+	NSDirectory::CreateDirectory(m_wsTempFolder);
+}
+std::wstring CPdfRenderer::GetTempFile()
+{
+	return NSFile::CFileBinary::CreateTempFileWithUniqueName(m_wsTempFolder, L"PDF");
+}
+void         CPdfRenderer::SetThemesPlace(const std::wstring& wsThemesPlace)
+{
+	m_wsThemesPlace = wsThemesPlace;
+}
+std::wstring CPdfRenderer::GetThemesPlace()
+{
+	return m_wsThemesPlace;
+}
+//----------------------------------------------------------------------------------------
+// Тип рендерера
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::get_Type(LONG* lType)
+{
+	*lType = c_nPDFWriter;
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Функции для работы со страницей
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::NewPage()
+{
+	m_oCommandManager.Flush();
+
+	if (!IsValid())
+		return S_FALSE;
+
+	m_pPage = m_pDocument->AddPage();
+
+	if (!m_pPage)
+	{
+		SetError();
+		return S_FALSE;
+	}
+
+	m_pPage->SetWidth(m_dPageWidth);
+	m_pPage->SetHeight(m_dPageHeight);
+
+	m_oPen.Reset();
+	m_oBrush.Reset();
+	m_oFont.Reset();
+	m_oPath.Clear();
+
+	m_lClipDepth = 0;
+
+    m_nPagesCount++;//printf("Page %d\n", m_nPagesCount++);
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_Height(double* dHeight)
+{
+	*dHeight = m_dPageHeight;
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_Height(const double& dHeight)
+{
+	if (!IsValid() || !m_pPage)
+		return S_FALSE;
+
+	m_dPageHeight = dHeight;
+	m_pPage->SetHeight(MM_2_PT(dHeight));
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_Width(double* dWidth)
+{
+	*dWidth = m_dPageWidth;
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_Width(const double& dWidth)
+{
+	if (!IsValid() || !m_pPage)
+		return S_FALSE;
+
+	m_dPageWidth = dWidth;
+	m_pPage->SetWidth(MM_2_PT(dWidth));
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_DpiX(double* dDpiX)
+{
+	*dDpiX = 72;
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_DpiY(double* dDpiY)
+{
+	*dDpiY = 72;
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Функции для работы с Pen
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::get_PenColor(LONG* lColor)
+{
+	*lColor = m_oPen.GetColor();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenColor(const LONG& lColor)
+{
+	m_oPen.SetColor(lColor);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenAlpha(LONG* lAlpha)
+{
+	*lAlpha = m_oPen.GetAlpha();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenAlpha(const LONG& lAlpha)
+{
+	m_oPen.SetAlpha(lAlpha);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenSize(double* dSize)
+{
+	*dSize = m_oPen.GetSize();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenSize(const double& dSize)
+{
+	m_oPen.SetSize(dSize);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenDashStyle(BYTE* nDashStyle)
+{
+	*nDashStyle = m_oPen.GetDashStyle();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenDashStyle(const BYTE& nDashStyle)
+{
+	m_oPen.SetDashStyle(nDashStyle);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenLineStartCap(BYTE* nCapStyle)
+{
+	*nCapStyle = m_oPen.GetStartCapStyle();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenLineStartCap(const BYTE& nCapStyle)
+{
+	m_oPen.SetStartCapStyle(nCapStyle);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenLineEndCap(BYTE* nCapStyle)
+{
+	*nCapStyle = m_oPen.GetEndCapStyle();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenLineEndCap(const BYTE& nCapStyle)
+{
+	m_oPen.SetEndCapStyle(nCapStyle);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenLineJoin(BYTE* nJoinStyle)
+{
+	*nJoinStyle = m_oPen.GetJoinStyle();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenLineJoin(const BYTE& nJoinStyle)
+{
+	m_oPen.SetJoinStyle(nJoinStyle);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenDashOffset(double* dOffset)
+{
+	*dOffset = m_oPen.GetDashOffset();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenDashOffset(const double& dOffset)
+{
+	m_oPen.SetDashOffset(dOffset);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenAlign(LONG* lAlign)
+{
+	*lAlign = m_oPen.GetAlign();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenAlign(const LONG& lAlign)
+{
+	m_oPen.SetAlign(lAlign);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_PenMiterLimit(double* dMiter)
+{
+	*dMiter = m_oPen.GetMiter();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_PenMiterLimit(const double& dMiter)
+{
+	m_oPen.SetMiter(dMiter);
+	return S_OK;
+}
+HRESULT CPdfRenderer::PenDashPattern(double* pPattern, LONG lCount)
+{
+	m_oPen.SetDashPattern(pPattern, lCount);
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Функции для работы с Brush
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::get_BrushType(LONG* lType)
+{
+	*lType = m_oBrush.GetType();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushType(const LONG& lType)
+{
+	m_oBrush.SetType(lType);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushColor1(LONG* lColor)
+{
+	*lColor = m_oBrush.GetColor1();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushColor1(const LONG& lColor)
+{
+	if (lColor != m_oBrush.GetColor1())
+	{
+		m_oBrush.SetColor1(lColor);
+		m_bNeedUpdateTextColor = true;
+	}
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushAlpha1(LONG* lAlpha)
+{
+	*lAlpha = m_oBrush.GetAlpha1();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushAlpha1(const LONG& lAlpha)
+{
+	if (lAlpha != m_oBrush.GetAlpha1())
+	{
+		m_oBrush.SetAlpha1(lAlpha);
+		m_bNeedUpdateTextAlpha = true;
+	}
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushColor2(LONG* lColor)
+{
+	*lColor = m_oBrush.GetColor2();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushColor2(const LONG& lColor)
+{
+	m_oBrush.SetColor2(lColor);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushAlpha2(LONG* lAlpha)
+{
+	*lAlpha = m_oBrush.GetAlpha2();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushAlpha2(const LONG& lAlpha)
+{
+	m_oBrush.SetAlpha2(lAlpha);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushTexturePath(std::wstring* wsPath)
+{
+	*wsPath = m_oBrush.GetTexturePath();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushTexturePath(const std::wstring& wsPath)
+{
+	m_oBrush.SetTexturePath(wsPath);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushTextureMode(LONG* lMode)
+{
+	*lMode = m_oBrush.GetTextureMode();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushTextureMode(const LONG& lMode)
+{
+	m_oBrush.SetTextureMode(lMode);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushTextureAlpha(LONG* lAlpha)
+{
+	*lAlpha = m_oBrush.GetTextureAlpha();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushTextureAlpha(const LONG& lAlpha)
+{
+	m_oBrush.SetTextureAlpha(lAlpha);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_BrushLinearAngle(double* dAngle)
+{
+	*dAngle = m_oBrush.GetLinearAngle();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushLinearAngle(const double& dAngle)
+{
+	m_oBrush.SetLinearAngle(dAngle);
+	return S_OK;
+}
+HRESULT CPdfRenderer::BrushRect(const INT& nVal, const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight)
+{
+	// Данными параметрами пользуемся, только если пришла команда EnableBrushRect, если команда не пришла, тогда
+	// ориентируемся на границы пата.
+	m_oBrush.SetBrushRect(nVal, dLeft, dTop, dWidth, dHeight);
+	return S_OK;
+}
+HRESULT CPdfRenderer::BrushBounds(const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight)
+{
+	// TODO: Пока определяется все по границам пата
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG lCount)
+{
+	m_oBrush.SetGradientColors(lColors, pPositions, lCount);
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Функции для работы со шрифтами
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::get_FontName(std::wstring* wsName)
+{
+	*wsName = m_oFont.GetName();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_FontName(const std::wstring& wsName)
+{
+	if (wsName != m_oFont.GetName())
+	{
+		m_oFont.SetName(wsName);
+		m_bNeedUpdateTextFont = true;
+	}
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_FontPath(std::wstring* wsPath)
+{
+	*wsPath = m_oFont.GetPath();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_FontPath(const std::wstring& wsPath)
+{
+	if (wsPath != m_oFont.GetPath())
+	{
+		m_oFont.SetPath(wsPath);
+		m_bNeedUpdateTextFont = true;
+	}
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_FontSize(double* dSize)
+{
+	*dSize = m_oFont.GetSize();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_FontSize(const double& dSize)
+{
+	if (fabs(dSize - m_oFont.GetSize()) > 0.001)
+	{
+		m_oFont.SetSize(dSize);
+		m_bNeedUpdateTextSize = true;
+	}
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_FontStyle(LONG* lStyle)
+{
+	*lStyle = m_oFont.GetStyle();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_FontStyle(const LONG& lStyle)
+{
+	if (lStyle != m_oFont.GetStyle())
+	{
+		m_oFont.SetStyle(lStyle);
+		m_bNeedUpdateTextFont = true;
+	}
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_FontStringGID(INT* bGid)
+{
+	*bGid = m_oFont.GetGid() ? 1 : 0;
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_FontStringGID(const INT& bGid)
+{
+	m_oFont.SetGid(bGid ? true : false);
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_FontCharSpace(double* dSpace)
+{
+	*dSpace = m_oFont.GetCharSpace();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_FontCharSpace(const double& dSpace)
+{
+	if (fabs(dSpace - m_oFont.GetCharSpace()) > 0.001)
+	{
+		m_oFont.SetCharSpace(dSpace);
+		m_bNeedUpdateTextCharSpace = true;
+	}
+	return S_OK;
+}
+HRESULT CPdfRenderer::get_FontFaceIndex(int* nFaceIndex)
+{
+	*nFaceIndex = (int)m_oFont.GetFaceIndex();
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_FontFaceIndex(const int& nFaceIndex)
+{
+	if (nFaceIndex != m_oFont.GetFaceIndex())
+	{
+		m_oFont.SetFaceIndex(nFaceIndex);
+		m_bNeedUpdateTextFont = true;
+	}
+
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Функции для вывода текста
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::CommandDrawTextCHAR(const LONG& lUnicode, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	if (!IsPageValid())
+		return S_FALSE;
+
+	unsigned int unUnicode = lUnicode;
+	bool bRes = DrawText(&unUnicode, 1, dX, dY, NULL);
+	return bRes ? S_OK : S_FALSE;
+}
+HRESULT CPdfRenderer::CommandDrawText(const std::wstring& wsUnicodeText, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	if (!IsPageValid() || !wsUnicodeText.size())
+		return S_FALSE;
+
+	unsigned int unLen;
+	unsigned int* pUnicodes = WStringToUtf32(wsUnicodeText, unLen);
+	if (!pUnicodes)
+		return S_FALSE;
+
+	// Специальный случай для текста из Djvu, нам не нужно, чтобы он рисовался
+	if (L"" == m_oFont.GetPath() && L"DjvuEmptyFont" == m_oFont.GetName())
+	{
+		if (m_bNeedUpdateTextFont)
+		{
+			m_oFont.SetName(L"Arial");
+			UpdateFont();
+			m_oFont.SetName(L"DjvuEmptyFont");
+			if (!m_pFont)
+				return S_FALSE;
+		}
+
+		double dFontSize = MM_2_PT(dH);
+		unsigned char* pCodes = m_pFont->EncodeString(pUnicodes, unLen);
+		delete[] pUnicodes;
+
+		double dStringWidth = 0;
+		for (unsigned int unIndex = 0; unIndex < unLen; unIndex++)
+		{
+			unsigned short ushCode = (pCodes[2 * unIndex] << 8) + pCodes[2 * unIndex + 1];
+			dStringWidth += m_pFont->GetWidth(ushCode) * dFontSize / 1000.0;
+		}
+
+		double dResultWidth = MM_2_PT(dW);
+
+		CTransform& t = m_oTransform;
+		m_oCommandManager.SetTransform(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
+
+		CRendererTextCommand* pText = m_oCommandManager.AddText(pCodes, unLen * 2, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH));
+		pText->SetFont(m_pFont);
+		pText->SetSize(dFontSize);
+		pText->SetMode(textrenderingmode_Invisible);
+		if (fabs(dStringWidth) > 0.001)
+			pText->SetHorScaling(dResultWidth / dStringWidth * 100);
+
+		return S_OK;
+	}
+
+	bool bRes = DrawText(pUnicodes, unLen, dX, dY, NULL);
+	delete[] pUnicodes;
+
+	return bRes ? S_OK : S_FALSE;
+}
+HRESULT CPdfRenderer::CommandDrawTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	if (!IsPageValid())
+		return S_FALSE;
+
+	unsigned int unUnicode = lUnicode;
+	unsigned int unGid     = lGid;
+	bool bRes = DrawText(&unUnicode, 1, dX, dY, &unGid);
+	return bRes ? S_OK : S_FALSE;
+}
+HRESULT CPdfRenderer::CommandDrawTextEx(const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int unGidsCount, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	if (!IsPageValid() || (!wsUnicodeText.size() && (!pGids || !unGidsCount)))
+		return S_FALSE;
+
+	unsigned int unLen = 0;
+	unsigned int* pUnicodes = NULL;
+	if (pGids && unGidsCount)
+	{
+		unLen = unGidsCount;
+		if (wsUnicodeText.size())
+		{
+			unsigned int unUnicodeLen;
+			pUnicodes = WStringToUtf32(wsUnicodeText, unUnicodeLen);
+			if (!pUnicodes || unUnicodeLen != unLen)
+				RELEASEARRAYOBJECTS(pUnicodes);
+		}
+
+		if (!pUnicodes)
+		{
+			pUnicodes = new unsigned int[unLen];
+			if (!pUnicodes)
+				return S_FALSE;
+
+			for (unsigned int unIndex = 0; unIndex < unLen; unIndex++)
+				pUnicodes[unIndex] = pGids[unIndex];
+		}
+	}
+	else
+	{
+		pUnicodes = WStringToUtf32(wsUnicodeText, unLen);
+		if (!pUnicodes)
+			return S_FALSE;
+	}
+
+	bool bRes = DrawText(pUnicodes, unLen, dX, dY, pGids);
+	RELEASEARRAYOBJECTS(pUnicodes);
+
+	return bRes ? S_OK : S_FALSE;
+}
+//----------------------------------------------------------------------------------------
+// Маркеры команд
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::BeginCommand(const DWORD& dwType)
+{
+	// Здесь мы ничего не делаем
+	return S_OK;
+}
+HRESULT CPdfRenderer::EndCommand(const DWORD& dwType)
+{
+	if (!IsPageValid())
+		return S_FALSE;
+
+	// Здесь мы различаем лишь 2 команды: присоединить текущий пат к клипу и отменить клип
+	if (c_nClipType == dwType)
+	{
+		m_oCommandManager.Flush();
+		m_pPage->GrSave();
+		m_lClipDepth++;
+		UpdateTransform();
+
+		if (c_nClipRegionTypeEvenOdd & m_lClipMode)
+			m_oPath.Clip(m_pPage, true);
+		else
+			m_oPath.Clip(m_pPage, false);
+	}
+	else if (c_nResetClipType == dwType)
+	{
+		m_oCommandManager.Flush();
+		while (m_lClipDepth)
+		{
+			m_pPage->GrRestore();
+			m_lClipDepth--;
+		}
+	}
+
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Функции для работы с патом
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::PathCommandStart()
+{
+	m_oPath.Clear();
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandEnd()
+{
+	m_oPath.Clear();
+	return S_OK;
+}
+HRESULT CPdfRenderer::DrawPath(const LONG& lType)
+{
+	m_oCommandManager.Flush();
+
+	if (!IsPageValid())
+		return S_FALSE;
+
+	bool bStroke = LONG_2_BOOL(lType & c_nStroke);
+	bool bFill   = LONG_2_BOOL(lType & c_nWindingFillMode);
+	bool bEoFill = LONG_2_BOOL(lType & c_nEvenOddFillMode);
+
+	m_pPage->GrSave();
+	UpdateTransform();
+
+	if (bStroke)
+		UpdatePen();
+
+	if (bFill || bEoFill)
+		UpdateBrush();
+
+	if (!m_pShading)
+	{
+		m_oPath.Draw(m_pPage, bStroke, bFill, bEoFill);
+	}
+	else
+	{
+		if (bFill || bEoFill)
+		{
+			m_pPage->GrSave();
+			m_oPath.Clip(m_pPage, bEoFill);
+
+			if (NULL != m_pShadingExtGrState)
+				m_pPage->SetExtGrState(m_pShadingExtGrState);
+
+			m_pPage->DrawShading(m_pShading);
+			m_pPage->GrRestore();
+		}
+
+		if (bStroke)
+			m_oPath.Draw(m_pPage, bStroke, false, false);
+	}
+
+	m_pPage->GrRestore();
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandMoveTo(const double& dX, const double& dY)
+{
+	m_oPath.MoveTo(MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY));
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandLineTo(const double& dX, const double& dY)
+{
+	m_oPath.LineTo(MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY));
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandLinesTo(double* pPoints, const int& nCount)
+{
+	if (nCount < 4 || !pPoints)
+		return S_OK;
+
+	if (!m_oPath.IsMoveTo())
+		m_oPath.MoveTo(MM_2_PT(pPoints[0]), MM_2_PT(m_dPageHeight - pPoints[1]));
+
+	int nPointsCount = (nCount / 2) - 1;
+	for (int nIndex = 1; nIndex <= nPointsCount; ++nIndex)
+	{
+		m_oPath.LineTo(MM_2_PT(pPoints[nIndex * 2]), MM_2_PT(m_dPageHeight - pPoints[nIndex * 2 + 1]));
+	}
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandCurveTo(const double& dX1, const double& dY1, const double& dX2, const double& dY2, const double& dXe, const double& dYe)
+{
+	m_oPath.CurveTo(MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), MM_2_PT(dX2), MM_2_PT(m_dPageHeight - dY2), MM_2_PT(dXe), MM_2_PT(m_dPageHeight - dYe));
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandCurvesTo(double* pPoints, const int& nCount)
+{
+	if (nCount < 8 || !pPoints)
+		return S_OK;
+
+	if (!m_oPath.IsMoveTo())
+		m_oPath.MoveTo(MM_2_PT(pPoints[0]), MM_2_PT(m_dPageHeight - pPoints[1]));
+
+	int nPointsCount = (nCount - 2) / 6;
+	double* pCur = pPoints + 2;
+	for (int nIndex = 0; nIndex <= nPointsCount; ++nIndex, pCur += 6)
+	{
+		m_oPath.CurveTo(MM_2_PT(pCur[0]), MM_2_PT(m_dPageHeight - pCur[1]), MM_2_PT(pCur[2]), MM_2_PT(m_dPageHeight - pCur[3]), MM_2_PT(pCur[4]), MM_2_PT(m_dPageHeight - pCur[5]));
+	}
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandArcTo(const double& dX, const double& dY, const double& dW, const double& dH, const double& dStartAngle, const double& dSweepAngle)
+{
+	m_oPath.ArcTo(MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH), dStartAngle, dSweepAngle);
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandClose()
+{
+	m_oPath.Close();
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandGetCurrentPoint(double* dX, double* dY)
+{
+	m_oPath.GetLastPoint(*dX, *dY);
+	*dX = PT_2_MM(*dX);
+	*dY = PT_2_MM(*dY);
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandTextCHAR(const LONG& lUnicode, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	unsigned int unUnicode = lUnicode;
+	bool bRes = PathCommandDrawText(&unUnicode, 1, dX, dY, NULL);
+	return bRes ? S_OK : S_FALSE;
+}
+HRESULT CPdfRenderer::PathCommandText(const std::wstring& wsUnicodeText, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	unsigned int unLen;
+	unsigned int* pUnicodes = WStringToUtf32(wsUnicodeText, unLen);
+	if (!pUnicodes)
+		return S_FALSE;
+
+	PathCommandDrawText(pUnicodes, unLen, dX, dY, NULL);
+	delete[] pUnicodes;
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	unsigned int unUnicode = lUnicode;
+	unsigned int unGid     = lGid;
+	bool bRes = PathCommandDrawText(&unUnicode, 1, dX, dY, &unGid);
+	return bRes ? S_OK : S_FALSE;
+}
+HRESULT CPdfRenderer::PathCommandTextEx(const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int unGidsCount, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	if (!IsPageValid() || (!wsUnicodeText.size() && (!pGids || !unGidsCount)))
+		return S_FALSE;
+
+	unsigned int unLen = 0;
+	unsigned int* pUnicodes = NULL;
+	if (pGids && unGidsCount)
+	{
+		unLen = unGidsCount;
+		if (wsUnicodeText.size())
+		{
+			unsigned int unUnicodeLen;
+			pUnicodes = WStringToUtf32(wsUnicodeText, unUnicodeLen);
+			if (!pUnicodes || unUnicodeLen != unLen)
+				RELEASEARRAYOBJECTS(pUnicodes);
+		}
+
+		if (!pUnicodes)
+		{
+			pUnicodes = new unsigned int[unLen];
+			if (!pUnicodes)
+				return S_FALSE;
+
+			for (unsigned int unIndex = 0; unIndex < unLen; unIndex++)
+				pUnicodes[unIndex] = pGids[unIndex];
+		}
+	}
+	else
+	{
+		pUnicodes = WStringToUtf32(wsUnicodeText, unLen);
+		if (!pUnicodes)
+			return S_FALSE;
+	}
+
+	bool bRes = PathCommandDrawText(pUnicodes, unLen, dX, dY, pGids);
+	RELEASEARRAYOBJECTS(pUnicodes);
+
+	return bRes ? S_OK : S_FALSE;
+}
+//----------------------------------------------------------------------------------------
+// Функции для вывода изображений
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::DrawImage(IGrObject* pImage, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	m_oCommandManager.Flush();
+
+	if (!IsPageValid() || !pImage)
+		return S_OK;
+
+	if (!DrawImage((Aggplus::CImage*)pImage, dX, dY, dW, dH, 255))
+		return S_FALSE;
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::DrawImageFromFile(const std::wstring& wsImagePath, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha)
+{
+	m_oCommandManager.Flush();
+
+	if (!IsPageValid())
+		return S_OK;
+
+	Aggplus::CImage* pAggImage = NULL;
+
+	CImageFileFormatChecker oImageFormat(wsImagePath);
+	if (_CXIMAGE_FORMAT_WMF == oImageFormat.eFileType || _CXIMAGE_FORMAT_EMF == oImageFormat.eFileType || _CXIMAGE_FORMAT_SVM == oImageFormat.eFileType)
+	{
+		// TODO: Реализовать отрисовку метафайлов по-нормальному
+		MetaFile::CMetaFile oMeta(m_pAppFonts);
+		oMeta.LoadFromFile(wsImagePath.c_str());
+
+		double dNewW = std::max(10.0, dW) / 25.4 * 300;
+		std::wstring wsTempFile = GetTempFile();
+		oMeta.ConvertToRaster(wsTempFile.c_str(), _CXIMAGE_FORMAT_PNG, dNewW);
+
+		pAggImage = new Aggplus::CImage(wsTempFile);
+	}
+	else
+	{
+		pAggImage = new Aggplus::CImage(wsImagePath);
+	}
+
+	if (!pAggImage)
+		return S_FALSE;
+
+	if (!DrawImage(pAggImage, dX, dY, dW, dH, nAlpha))
+	{
+		delete pAggImage;
+		return S_FALSE;
+	}
+
+	delete pAggImage;
+
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Функции для выставления преобразования
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::SetTransform(const double& dM11, const double& dM12, const double& dM21, const double& dM22, const double& dX, const double& dY)
+{
+	m_oCommandManager.Flush();
+	m_oTransform.Set(dM11, dM12, dM21, dM22, dX, dY);
+	return S_OK;
+}
+HRESULT CPdfRenderer::GetTransform(double* dM11, double* dM12, double* dM21, double* dM22, double* dX, double* dY)
+{
+	*dM11 = m_oTransform.m11;
+	*dM12 = m_oTransform.m12;
+	*dM21 = m_oTransform.m21;
+	*dM22 = m_oTransform.m22;
+	*dX   = m_oTransform.dx;
+	*dY   = m_oTransform.dy;
+	return S_OK;
+}
+HRESULT CPdfRenderer::ResetTransform()
+{
+	m_oCommandManager.Flush();
+	m_oTransform.Reset();
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Тип клипа
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::get_ClipMode(LONG* lMode)
+{
+	*lMode = m_lClipMode;
+	return S_OK;
+}
+HRESULT CPdfRenderer::put_ClipMode(const LONG& lMode)
+{
+	m_lClipMode = lMode;
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Дополнительные функции
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::CommandLong(const LONG& lType, const LONG& lCommand)
+{
+	return S_OK;
+}
+HRESULT CPdfRenderer::CommandDouble(const LONG& lType, const double& dCommand)
+{
+	return S_OK;
+}
+HRESULT CPdfRenderer::CommandString(const LONG& lType, const std::wstring& sCommand)
+{
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Дополнительные функции Pdf рендерера
+//----------------------------------------------------------------------------------------
+HRESULT CPdfRenderer::CommandDrawTextPdf(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int unGidsCount, const std::wstring& bsSrcCodeText, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	return S_OK;
+}
+HRESULT CPdfRenderer::PathCommandTextPdf(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int unGidsCount, const std::wstring& bsSrcCodeText, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	return S_OK;
+}
+HRESULT CPdfRenderer::DrawImage1bpp(Pix* pImageBuffer, const unsigned int& unWidth, const unsigned int& unHeight, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	m_oCommandManager.Flush();
+
+	if (!IsPageValid() || !pImageBuffer)
+		return S_OK;
+
+	m_pPage->GrSave();
+	UpdateTransform();
+	
+	CImageDict* pPdfImage = m_pDocument->CreateImage();
+	pPdfImage->LoadBW(pImageBuffer, unWidth, unHeight);
+	m_pPage->DrawImage(pPdfImage, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH));
+
+	m_pPage->GrRestore();
+	return S_OK;
+}
+HRESULT CPdfRenderer::EnableBrushRect(const LONG& lEnable)
+{
+	m_oBrush.EnableBrushRect(LONG_2_BOOL(lEnable));
+	return S_OK;
+}
+HRESULT CPdfRenderer::SetLinearGradient(const double& dX0, const double& dY0, const double& dX1, const double& dY1)
+{
+	m_oBrush.SetType(c_BrushTypeLinearGradient);
+	m_oBrush.SetLinearGradientPattern(dX0, dY0, dX1, dY1);
+	return S_OK;
+}
+HRESULT CPdfRenderer::SetRadialGradient(const double& dX0, const double& dY0, const double& dR0, const double& dX1, const double& dY1, const double& dR1)
+{
+	m_oBrush.SetType(c_BrushTypeRadialGradient);
+	m_oBrush.SetRadialGradientPattern(dX0, dY0, dR0, dX1, dY1, dR1);
+	return S_OK;
+}
+HRESULT CPdfRenderer::DrawImageWith1bppMask(IGrObject* pImage, Pix* pMaskBuffer, const unsigned int& unMaskWidth, const unsigned int& unMaskHeight, const double& dX, const double& dY, const double& dW, const double& dH)
+{
+	m_oCommandManager.Flush();
+
+	if (!IsPageValid() || !pMaskBuffer || !pImage)
+		return S_OK;
+
+	m_pPage->GrSave();
+	UpdateTransform();
+	CImageDict* pPdfImage = LoadImage((Aggplus::CImage*)pImage, 255);
+	pPdfImage->LoadMask(pMaskBuffer, unMaskWidth, unMaskHeight);
+	m_pPage->DrawImage(pPdfImage, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH));
+	m_pPage->GrRestore();
+	return S_OK;
+}
+//----------------------------------------------------------------------------------------
+// Внутренние функции
+//----------------------------------------------------------------------------------------
+PdfWriter::CImageDict* CPdfRenderer::LoadImage(Aggplus::CImage* pImage, const BYTE& nAlpha)
+{
+	int nImageW = abs((int)pImage->GetWidth());
+	int nImageH = abs((int)pImage->GetHeight());
+	BYTE* pData = pImage->GetData();
+	int nStride = 4 * nImageW;
+
+	// Картинки совсем маленьких размеров нельзя делать Jpeg2000
+	bool bJpeg = false;
+	if (nImageH < 100 || nImageW < 100)
+		bJpeg = true;
+
+	// TODO: Пока не разберемся как в CxImage управлять параметрами кодирования нельзя писать в Jpeg2000,
+	//       т.к. файлы получаются гораздо больше и конвертация идет намного дольше.
+	bJpeg = true;
+
+	// Пробегаемся по картинке и определяем есть ли у нас альфа-канал
+	bool bAlpha = false;
+	for (int nIndex = 0, nSize = nImageW * nImageH; nIndex < nSize; nIndex++)
+	{
+		if (pData[4 * nIndex + 3] < 255)
+		{
+			bAlpha = true;
+			break;
+		}
+	}
+
+	CxImage oCxImage;
+	if (!oCxImage.CreateFromArray(pData, nImageW, nImageH, 32, nStride, (pImage->GetStride() >= 0) ? true : false))
+		return NULL;
+
+	oCxImage.SetJpegQualityF(85.0f);
+
+	BYTE* pBuffer = NULL;
+	int nBufferSize = 0;
+	if (!oCxImage.Encode(pBuffer, nBufferSize, bJpeg ? CXIMAGE_FORMAT_JPG : CXIMAGE_FORMAT_JP2))
+		return NULL;
+
+	if (!pBuffer || !nBufferSize)
+		return NULL;
+
+	CImageDict* pPdfImage = m_pDocument->CreateImage();
+	if (bAlpha || nAlpha < 255)
+		pPdfImage->LoadSMask(pData, nImageW, nImageH, nAlpha, (pImage->GetStride() >= 0) ? false : true);
+
+	if (bJpeg)
+        pPdfImage->LoadJpeg(pBuffer, nBufferSize, nImageW, nImageH);
+	else
+		pPdfImage->LoadJpx(pBuffer, nBufferSize, nImageW, nImageH);
+
+	free(pBuffer);
+
+	return pPdfImage;
+}
+bool CPdfRenderer::DrawImage(Aggplus::CImage* pImage, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha)
+{
+	CImageDict* pPdfImage = LoadImage(pImage, nAlpha);
+	if (!pPdfImage)
+		return false;
+
+	m_pPage->GrSave();
+	UpdateTransform();
+	m_pPage->DrawImage(pPdfImage, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH));
+	m_pPage->GrRestore();
+	
+	return true;
+}
+bool CPdfRenderer::DrawText(unsigned int* pUnicodes, unsigned int unLen, const double& dX, const double& dY, const unsigned int* pGids)
+{
+	if (m_bNeedUpdateTextFont)
+		UpdateFont();
+
+	if (!m_pFont)
+		return false;
+
+	unsigned char* pCodes = m_pFont->EncodeString(pUnicodes, unLen, pGids);
+
+	CTransform& t = m_oTransform;
+	m_oCommandManager.SetTransform(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
+
+	CRendererTextCommand* pText = m_oCommandManager.AddText(pCodes, unLen * 2, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY));
+	pText->SetFont(m_pFont);
+	pText->SetSize(m_oFont.GetSize());
+	pText->SetColor(m_oBrush.GetColor1());
+	pText->SetAlpha((BYTE)m_oBrush.GetAlpha1());
+	pText->SetCharSpace(MM_2_PT(m_oFont.GetCharSpace()));
+
+	return true;
+}
+bool CPdfRenderer::PathCommandDrawText(unsigned int* pUnicodes, unsigned int unLen, const double& dX, const double& dY, const unsigned int* pGids)
+{
+	if (m_bNeedUpdateTextFont)
+		UpdateFont();
+
+	if (!m_pFont)
+		return false;
+
+	unsigned char* pCodes = m_pFont->EncodeString(pUnicodes, unLen, pGids);
+	m_oPath.AddText(m_pFont, pCodes, unLen * 2, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY), m_oFont.GetSize(), MM_2_PT(m_oFont.GetCharSpace()));
+	return true;
+}
+void CPdfRenderer::UpdateFont()
+{
+	m_bNeedUpdateTextFont = false;
+    std::wstring wsFontPath = m_oFont.GetPath();
+	LONG lFaceIndex = m_oFont.GetFaceIndex();
+	if (L"" == wsFontPath)
+	{
+        std::wstring wsFontName = m_oFont.GetName();
+		bool bBold   = m_oFont.IsBold();
+		bool bItalic = m_oFont.IsItalic();
+		bool bFind = false;
+		for (int nIndex = 0, nCount = m_vFonts.size(); nIndex < nCount; nIndex++)
+		{
+			TFontInfo& oInfo = m_vFonts.at(nIndex);
+			if (oInfo.wsFontName == wsFontName && oInfo.bBold == bBold && oInfo.bItalic == bItalic)
+			{
+				wsFontPath = oInfo.wsFontPath;
+				lFaceIndex = oInfo.lFaceIndex;
+				bFind = true;
+				break;
+			}
+		}
+
+		if (!bFind)
+		{
+			CFontSelectFormat oFontSelect;
+			oFontSelect.wsName = new std::wstring(m_oFont.GetName());
+			oFontSelect.bItalic = new INT(m_oFont.IsItalic() ? 1 : 0);
+			oFontSelect.bBold   = new INT(m_oFont.IsBold() ? 1 : 0);
+			CFontInfo* pFontInfo = m_pFontManager->GetFontInfoByParams(oFontSelect, false);
+
+			wsFontPath = pFontInfo->m_wsFontPath;
+			lFaceIndex = pFontInfo->m_lIndex;
+
+			m_vFonts.push_back(TFontInfo(wsFontName, bBold, bItalic, wsFontPath, lFaceIndex));
+		}
+	}
+
+	m_pFont = NULL;
+	if (L"" != wsFontPath)
+	{
+		// TODO: Пока мы здесь предполагаем, что шрифты только либо TrueType, либо OpenType
+		m_pFontManager->LoadFontFromFile(wsFontPath, lFaceIndex, 10, 72, 72);
+		std::wstring wsFontType = m_pFontManager->GetFontType();
+		if (L"TrueType" == wsFontType || L"OpenType" == wsFontType || L"CFF" == wsFontType)
+			m_pFont = m_pDocument->CreateTrueTypeFont(wsFontPath, lFaceIndex);
+	}
+}
+void CPdfRenderer::UpdateTransform()
+{
+	CTransform& t = m_oTransform;
+	m_pPage->SetTransform(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
+}
+void CPdfRenderer::UpdatePen()
+{
+    TColor oColor = m_oPen.GetTColor();
+	m_pPage->SetStrokeColor(oColor.r, oColor.g, oColor.b);
+	m_pPage->SetStrokeAlpha((unsigned char)m_oPen.GetAlpha());
+	m_pPage->SetLineWidth(MM_2_PT(m_oPen.GetSize()));
+	
+	LONG lDashCount = 0;
+	double* pDashPattern = NULL;
+	
+	LONG lDashStyle = m_oPen.GetDashStyle();
+	if (Aggplus::DashStyleSolid == lDashStyle)
+	{
+		// Ничего не делаем
+	}
+	else if (Aggplus::DashStyleCustom == lDashStyle)
+	{
+		double *pDashPatternMM = m_oPen.GetDashPattern(lDashCount);
+		if (pDashPatternMM && lDashCount)
+		{
+			pDashPattern = new double[lDashCount];
+			if (pDashPattern)
+			{
+				for (LONG lIndex = 0; lIndex < lDashCount; lIndex++)
+				{
+					pDashPattern[lIndex] = MM_2_PT(pDashPatternMM[lIndex]);
+				}
+			}
+		}
+	}
+	else
+	{
+		// TODO: Реализовать другие типы пунктирных линий
+	}
+
+	if (pDashPattern && lDashCount)
+	{
+		m_pPage->SetDash(pDashPattern, lDashCount, MM_2_PT(m_oPen.GetDashOffset()));
+		delete[] pDashPattern;
+	}
+
+	LONG lCapStyle = m_oPen.GetStartCapStyle();
+	if (Aggplus::LineCapRound == lCapStyle)
+		m_pPage->SetLineCap(linecap_Round);
+	else if (Aggplus::LineCapSquare == lCapStyle)
+		m_pPage->SetLineCap(linecap_ProjectingSquare);
+	else
+		m_pPage->SetLineCap(linecap_Butt);
+
+	LONG lJoinStyle = m_oPen.GetJoinStyle();
+	if (Aggplus::LineJoinBevel == lJoinStyle)
+		m_pPage->SetLineJoin(linejoin_Bevel);
+	else if (Aggplus::LineJoinMiter == lJoinStyle)
+	{
+		m_pPage->SetLineJoin(linejoin_Miter);
+		m_pPage->SetMiterLimit(MM_2_PT(m_oPen.GetMiter()));
+	}
+	else
+		m_pPage->SetLineJoin(linejoin_Round);
+}
+void CPdfRenderer::UpdateBrush()
+{
+	m_pShading = NULL;
+	m_pShadingExtGrState = NULL;
+
+	LONG lBrushType = m_oBrush.GetType();
+	if (c_BrushTypeTexture == lBrushType)
+	{
+        std::wstring wsTexturePath = m_oBrush.GetTexturePath();
+		CImageFileFormatChecker oImageFormat(wsTexturePath);
+
+		CImageDict* pImage = NULL;
+		int nImageW = 0;
+		int nImageH = 0;
+		if (_CXIMAGE_FORMAT_JPG == oImageFormat.eFileType || _CXIMAGE_FORMAT_JP2 == oImageFormat.eFileType)
+		{
+			pImage = m_pDocument->CreateImage();
+			CBgraFrame oFrame;
+			oFrame.OpenFile(wsTexturePath);
+			nImageH = oFrame.get_Height();
+			nImageW = oFrame.get_Width();
+
+			if (pImage)
+			{
+				if (_CXIMAGE_FORMAT_JPG == oImageFormat.eFileType)
+                    pImage->LoadJpeg(wsTexturePath.c_str(), nImageW, nImageH, oFrame.IsGrayScale());
+				else
+					pImage->LoadJpx(wsTexturePath.c_str(), nImageW, nImageH);
+			}
+		}
+		else if (_CXIMAGE_FORMAT_WMF == oImageFormat.eFileType || _CXIMAGE_FORMAT_EMF == oImageFormat.eFileType || _CXIMAGE_FORMAT_SVM == oImageFormat.eFileType)
+		{
+			// TODO: Реализовать отрисовку метафайлов по-нормальному
+			MetaFile::CMetaFile oMeta(m_pAppFonts);
+			oMeta.LoadFromFile(wsTexturePath.c_str());
+
+			double dL, dR, dT, dB;
+			m_oPath.GetBounds(dL, dT, dR, dB);
+
+			double dNewW = std::max(10.0, dR - dL) / 72 * 300;
+
+			std::wstring wsTempFile = GetTempFile();
+			oMeta.ConvertToRaster(wsTempFile.c_str(), _CXIMAGE_FORMAT_PNG, dNewW);
+
+			Aggplus::CImage oImage(wsTempFile);
+			nImageW = abs((int)oImage.GetWidth());
+			nImageH = abs((int)oImage.GetHeight());
+			pImage = LoadImage(&oImage, 255);
+		}
+		else
+		{
+			Aggplus::CImage oImage(wsTexturePath);
+			nImageW = abs((int)oImage.GetWidth());
+			nImageH = abs((int)oImage.GetHeight());
+			pImage = LoadImage(&oImage, 255);
+		}
+
+		if (pImage)
+		{		
+			LONG lTextureMode = m_oBrush.GetTextureMode();
+
+			double dW = 10;
+			double dH = 10;
+
+			double dL, dR, dT, dB;
+			m_oPath.GetBounds(dL, dT, dR, dB);
+
+			if (c_BrushTextureModeStretch == lTextureMode)
+			{
+				// Чтобы избавиться от погрешностей из-за которых могут возникать полоски, немного увеличим границы пата.
+				dL -= 1;
+				dT -= 1;
+				dB += 1;
+				dR += 1;
+
+				// Растягиваем картинку по размерам пата
+                dW = std::max(10.0, dR - dL);
+                dH = std::max(10.0, dB - dT);
+			}
+			else
+			{
+				// Размеры картинки заданы в пикселях. Размеры тайла - это размеры картинки в пунктах.
+				dW = nImageW * 72 / 96;
+				dH = nImageH * 72 / 96;
+			}			
+
+			// Нам нужно, чтобы левый нижний угол границ нашего пата являлся точкой переноса для матрицы преобразования.
+			CMatrix* pMatrix = m_pPage->GetTransform();
+			pMatrix->Apply(dL, dB);
+			CMatrix oPatternMatrix = *pMatrix;
+			oPatternMatrix.x = dL;
+			oPatternMatrix.y = dB;
+			m_pPage->SetPatternColorSpace(m_pDocument->CreateImageTilePattern(dW, dH, pImage, &oPatternMatrix));
+		}
+	}
+	else if (c_BrushTypeHatch1 == lBrushType)
+	{
+        std::wstring wsHatchType = m_oBrush.GetTexturePath();
+
+		double dW = 8 * 72 / 96;
+		double dH = 8 * 72 / 96;
+
+        TColor oColor1 = m_oBrush.GetTColor1();
+        TColor oColor2 = m_oBrush.GetTColor2();
+		BYTE nAlpha1 = (BYTE)m_oBrush.GetAlpha1();
+		BYTE nAlpha2 = (BYTE)m_oBrush.GetAlpha2();
+
+		m_pPage->SetPatternColorSpace(m_pDocument->CreateHatchPattern(dW, dH, oColor1.r, oColor1.g, oColor1.b, nAlpha1, oColor2.r, oColor2.g, oColor2.b, nAlpha2, wsHatchType));
+	}
+	else if (c_BrushTypeRadialGradient == lBrushType || c_BrushTypeLinearGradient == lBrushType)
+	{
+		TColor* pGradientColors;
+		double* pPoints;
+		LONG lCount;
+
+		m_oBrush.GetGradientColors(pGradientColors, pPoints, lCount);
+
+		if (lCount > 0)
+		{
+			unsigned char* pColors = new unsigned char[3 * lCount];
+			unsigned char* pAlphas = new unsigned char[lCount];
+			if (pColors)
+			{
+				for (LONG lIndex = 0; lIndex < lCount; lIndex++)
+				{
+					pColors[3 * lIndex + 0] = pGradientColors[lIndex].r;
+					pColors[3 * lIndex + 1] = pGradientColors[lIndex].g;
+					pColors[3 * lIndex + 2] = pGradientColors[lIndex].b;
+					pAlphas[lIndex]         = pGradientColors[lIndex].a;
+				}
+
+				if (c_BrushTypeLinearGradient == lBrushType)
+				{
+					double dX0, dY0, dX1, dY1;
+					m_oBrush.GetLinearGradientPattern(dX0, dY0, dX1, dY1);
+					m_pShading = m_pDocument->CreateAxialShading(m_pPage, MM_2_PT(dX0), MM_2_PT(m_dPageHeight - dY0), MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), pColors, pAlphas, pPoints, lCount, m_pShadingExtGrState);
+				}
+				else //if (c_BrushTypeRadialGradient == lBrushType)
+				{
+					double dX0, dY0, dR0, dX1, dY1, dR1;
+					m_oBrush.GetRadialGradientPattern(dX0, dY0, dR0, dX1, dY1, dR1);
+					m_pShading = m_pDocument->CreateRadialShading(m_pPage, MM_2_PT(dX0), MM_2_PT(m_dPageHeight - dY0), MM_2_PT(dR0), MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), MM_2_PT(dR1), pColors, pAlphas, pPoints, lCount, m_pShadingExtGrState);
+				}
+				delete[] pColors;
+				delete[] pAlphas;
+			}
+		}
+	}
+	else// if (c_BrushTypeSolid == lBrushType)
+	{
+        TColor oColor1 = m_oBrush.GetTColor1();
+		m_pPage->SetFillColor(oColor1.r, oColor1.g, oColor1.b);
+		m_pPage->SetFillAlpha((unsigned char)m_oBrush.GetAlpha1());
+	}
+}
+HRESULT CPdfRenderer::OnlineWordToPdf          (const std::wstring& wsSrcFile, const std::wstring& wsDstFile)
+{
+	if (!NSOnlineOfficeBinToPdf::ConvertBinToPdf(this, wsSrcFile, wsDstFile, false))
+		return S_FALSE;
+
+	return S_OK;
+}
+HRESULT CPdfRenderer::OnlineWordToPdfFromBinary(const std::wstring& wsSrcFile, const std::wstring& wsDstFile)
+{
+	if (!NSOnlineOfficeBinToPdf::ConvertBinToPdf(this, wsSrcFile, wsDstFile, true))
+		return S_FALSE;
+
+	return S_OK;
+}
+
+static inline void UpdateMaxMinPoints(double& dMinX, double& dMinY, double& dMaxX, double& dMaxY, const double& dX, const double& dY)
+{
+	if (dX < dMinX)
+		dMinX = dX;
+
+	if (dX > dMaxX)
+		dMaxX = dX;
+
+	if (dY < dMinY)
+		dMinY = dY;
+
+	if (dY > dMaxY)
+		dMaxY = dY;
+}
+void CPdfRenderer::CPath::Draw(PdfWriter::CPage* pPage, bool bStroke, bool bFill, bool bEoFill)
+{
+	for (int nIndex = 0, nCount = m_vCommands.size(); nIndex < nCount; nIndex++)
+	{
+		CPathCommandBase* pCommand = m_vCommands.at(nIndex);
+		pCommand->Draw(pPage);
+	}
+
+	if (bStroke && !bFill && !bEoFill)
+		pPage->Stroke();
+	else if (bStroke && bFill)
+		pPage->FillStroke();
+	else if (bStroke && bEoFill)
+		pPage->EoFillStroke();
+	else if (bFill)
+		pPage->Fill();
+	else if (bEoFill)
+		pPage->EoFill();
+	else
+		pPage->EndPath();
+}
+void CPdfRenderer::CPath::Clip(PdfWriter::CPage* pPage, bool bEvenOdd)
+{
+	for (int nIndex = 0, nCount = m_vCommands.size(); nIndex < nCount; nIndex++)
+	{
+		CPathCommandBase* pCommand = m_vCommands.at(nIndex);
+		pCommand->Draw(pPage);
+	}
+
+	if (bEvenOdd)
+		pPage->Eoclip();
+	else
+		pPage->Clip();
+
+	pPage->EndPath();
+}
+void CPdfRenderer::CPath::GetLastPoint(double& dX, double& dY)
+{
+	dX = 0;
+	dY = 0;
+
+	bool bFindMoveTo = false;
+	for (int nIndex = m_vCommands.size() - 1; nIndex >= 0; nIndex--)
+	{
+		CPathCommandBase* pCommand = m_vCommands.at(nIndex);
+		if (rendererpathcommand_Close == pCommand->GetType())
+		{
+			bFindMoveTo = true;
+			continue;
+		}
+		else
+		{
+			pCommand->GetLastPoint(dX, dY);
+			if (!bFindMoveTo || rendererpathcommand_MoveTo == pCommand->GetType())
+				break;
+		}
+	}
+}
+void CPdfRenderer::CPath::GetBounds(double& dL, double& dT, double& dR, double& dB)
+{
+	GetLastPoint(dL, dT);
+	dR = dL;
+	dB = dT;
+
+	for (int nIndex = 0, nCount = m_vCommands.size(); nIndex < nCount; nIndex++)
+	{
+		CPathCommandBase* pCommand = m_vCommands.at(nIndex);
+		pCommand->UpdateBounds(dL, dT, dR, dB);
+	}
+}
+void CPdfRenderer::CPath::CPathMoveTo::Draw(PdfWriter::CPage* pPage)
+{
+	pPage->MoveTo(x, y);
+}
+void CPdfRenderer::CPath::CPathMoveTo::UpdateBounds(double& dL, double& dT, double& dR, double& dB)
+{
+	UpdateMaxMinPoints(dL, dT, dR, dB, x, y);
+}
+void CPdfRenderer::CPath::CPathLineTo::Draw(PdfWriter::CPage* pPage)
+{
+	pPage->LineTo(x, y);
+}
+void CPdfRenderer::CPath::CPathLineTo::UpdateBounds(double& dL, double& dT, double& dR, double& dB)
+{
+	UpdateMaxMinPoints(dL, dT, dR, dB, x, y);
+}
+void CPdfRenderer::CPath::CPathCurveTo::Draw(PdfWriter::CPage* pPage)
+{
+	pPage->CurveTo(x1, y1, x2, y2, xe, ye);
+}
+void CPdfRenderer::CPath::CPathCurveTo::UpdateBounds(double& dL, double& dT, double& dR, double& dB)
+{
+	UpdateMaxMinPoints(dL, dT, dR, dB, x1, y1);
+	UpdateMaxMinPoints(dL, dT, dR, dB, x2, y2);
+	UpdateMaxMinPoints(dL, dT, dR, dB, xe, ye);
+}
+void CPdfRenderer::CPath::CPathArcTo::Draw(PdfWriter::CPage* pPage)
+{
+	if (sweepAngle >= 360 - 0.001)
+		pPage->Ellipse(x + w / 2, y + h / 2, w / 2, h / 2);
+	else
+		pPage->EllipseArcTo(x + w / 2, y + h / 2, w / 2, h / 2, 360 - startAngle, 360 - (startAngle + sweepAngle), sweepAngle > 0 ? true : false);
+}
+void CPdfRenderer::CPath::CPathArcTo::UpdateBounds(double& dL, double& dT, double& dR, double& dB)
+{
+	UpdateMaxMinPoints(dL, dT, dR, dB, x, y);
+	UpdateMaxMinPoints(dL, dT, dR, dB, x + w, y + h);
+}
+void CPdfRenderer::CPath::CPathClose::Draw(PdfWriter::CPage* pPage)
+{
+	pPage->ClosePath();
+}
+void CPdfRenderer::CPath::CPathClose::UpdateBounds(double& dL, double& dT, double& dR, double& dB)
+{
+}
+void CPdfRenderer::CPath::CPathText::Draw(PdfWriter::CPage* pPage)
+{
+	// TODO: Если данная команда будет часто вызываться, тогда ее нужно будет оптимизировать, точно также как это делается в обычном тексте
+	pPage->BeginText();
+	pPage->SetFontAndSize(font, fontSize);
+	pPage->SetCharSpace(charSpace);
+	pPage->SetTextRenderingMode(textrenderingmode_Stroke);
+	pPage->DrawText(x, y, codes, codesCount);
+	pPage->EndText();
+}
+void CPdfRenderer::CPath::CPathText::UpdateBounds(double& dL, double& dT, double& dR, double& dB)
+{
+	UpdateMaxMinPoints(dL, dT, dR, dB, x, y);
+}
+void CPdfRenderer::CBrushState::Reset()
+{
+	m_lType = c_BrushTypeSolid;
+	m_oColor1.Set(0);
+	m_oColor2.Set(0);
+	m_nAlpha1 = 255;
+	m_nAlpha2 = 255;
+	m_wsTexturePath = L"";
+	m_lTextureMode  = c_BrushTextureModeStretch;
+	m_nTextureAlpha = 255;
+	m_dLinearAngle  = 0;
+	m_oRect.Reset();
+
+	if (m_pShadingColors)
+		delete[] m_pShadingColors;
+
+	if (m_pShadingPoints)
+		delete[] m_pShadingPoints;
+
+	m_pShadingColors      = NULL;
+	m_pShadingPoints      = NULL;
+	m_lShadingPointsCount = 0;
+}

DocxRenderer/DocxRenderer.h

+/*
+ * (c) Copyright Ascensio System SIA 2010-2016
+ *
+ * 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
+ *
+ */
+#ifndef _PDF_WRITER_PDFRENDERER_H
+#define _PDF_WRITER_PDFRENDERER_H
+
+#include "../DesktopEditor/graphics/IRenderer.h"
+#include <string>
+#include <vector>
+#include <algorithm>
+
+#ifndef DOCXRENDERER_USE_DYNAMIC_LIBRARY
+#define DOCXRENDERER_DECL_EXPORT
+#else
+#include "../DesktopEditor/common/base_export.h"
+#define DOCXRENDERER_DECL_EXPORT Q_DECL_EXPORT
+#endif
+
+class CFontManager;
+class CApplicationFonts;
+
+namespace NSDocxRenderer
+{
+    enum TextAssociationType
+    {
+        TextAssociationTypeDefault	= 0,
+        TextAssociationTypeLine		= 1,
+        TextAssociationTypeNoFrames	= 2,
+        TextAssociationTypeBlock	= 3
+    };
+}
+
+class DOCXRENDERER_DECL_EXPORT CDocxRenderer : public IRenderer
+{
+public:
+    CDocxRenderer(CApplicationFonts* pAppFonts);
+    ~CDocxRenderer();
+
+    void         CreateFile(const std::wstring& wsPath);
+    void         Close();
+
+    void         SetTextAssociationType(const NSDocxRenderer::TextAssociationType& eType);
+
+	void         SetTempFolder(const std::wstring& wsPath);
+	//----------------------------------------------------------------------------------------
+	// Тип рендерера
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_Type(LONG* lType);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы со страницей
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT NewPage();
+	virtual HRESULT get_Height(double* dHeight);
+	virtual HRESULT put_Height(const double& dHeight);
+	virtual HRESULT get_Width(double* dWidth);
+	virtual HRESULT put_Width(const double& dWidth);
+	virtual HRESULT get_DpiX(double* dDpiX);
+	virtual HRESULT get_DpiY(double* dDpiY);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы с Pen
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_PenColor(LONG* lColor);
+	virtual HRESULT put_PenColor(const LONG& lColor);
+	virtual HRESULT get_PenAlpha(LONG* lAlpha);
+	virtual HRESULT put_PenAlpha(const LONG& lAlpha);
+	virtual HRESULT get_PenSize(double* dSize);
+	virtual HRESULT put_PenSize(const double& dSize);
+	virtual HRESULT get_PenDashStyle(BYTE* nDashStyle);
+	virtual HRESULT put_PenDashStyle(const BYTE& nDashStyle);
+	virtual HRESULT get_PenLineStartCap(BYTE* nCapStyle);
+	virtual HRESULT put_PenLineStartCap(const BYTE& nCapStyle);
+	virtual HRESULT get_PenLineEndCap(BYTE* nCapStyle);
+	virtual HRESULT put_PenLineEndCap(const BYTE& nCapStyle);
+	virtual HRESULT get_PenLineJoin(BYTE* nJoinStyle);
+	virtual HRESULT put_PenLineJoin(const BYTE& nJoinStyle);
+	virtual HRESULT get_PenDashOffset(double* dOffset);
+	virtual HRESULT put_PenDashOffset(const double& dOffset);
+	virtual HRESULT get_PenAlign(LONG* lAlign);
+	virtual HRESULT put_PenAlign(const LONG& lAlign);
+	virtual HRESULT get_PenMiterLimit(double* dMiter);
+	virtual HRESULT put_PenMiterLimit(const double& dMiter);
+	virtual HRESULT PenDashPattern(double* pPattern, LONG lCount);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы с Brush
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_BrushType(LONG* lType);
+	virtual HRESULT put_BrushType(const LONG& lType);
+	virtual HRESULT get_BrushColor1(LONG* lColor);
+	virtual HRESULT put_BrushColor1(const LONG& lColor);
+	virtual HRESULT get_BrushAlpha1(LONG* lAlpha);
+	virtual HRESULT put_BrushAlpha1(const LONG& lAlpha);
+	virtual HRESULT get_BrushColor2(LONG* lColor);
+	virtual HRESULT put_BrushColor2(const LONG& lColor);
+	virtual HRESULT get_BrushAlpha2(LONG* lAlpha);
+	virtual HRESULT put_BrushAlpha2(const LONG& lAlpha);
+	virtual HRESULT get_BrushTexturePath(std::wstring* wsPath);
+	virtual HRESULT put_BrushTexturePath(const std::wstring& wsPath);
+	virtual HRESULT get_BrushTextureMode(LONG* lMode);
+	virtual HRESULT put_BrushTextureMode(const LONG& lMode);
+	virtual HRESULT get_BrushTextureAlpha(LONG* lAlpha);
+	virtual HRESULT put_BrushTextureAlpha(const LONG& lAlpha);
+	virtual HRESULT get_BrushLinearAngle(double* dAngle);
+	virtual HRESULT put_BrushLinearAngle(const double& dAngle);
+	virtual HRESULT BrushRect(const INT& nVal, const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight);
+	virtual HRESULT BrushBounds(const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight);
+	virtual HRESULT put_BrushGradientColors(LONG* pColors, double* pPositions, LONG lCount);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы со шрифтами
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_FontName(std::wstring* wsName);
+	virtual HRESULT put_FontName(const std::wstring& wsName);
+	virtual HRESULT get_FontPath(std::wstring* wsPath);
+	virtual HRESULT put_FontPath(const std::wstring& wsPath);
+	virtual HRESULT get_FontSize(double* dSize);
+	virtual HRESULT put_FontSize(const double& dSize);
+	virtual HRESULT get_FontStyle(LONG* lStyle);
+	virtual HRESULT put_FontStyle(const LONG& lStyle);
+	virtual HRESULT get_FontStringGID(INT* bGid);
+	virtual HRESULT put_FontStringGID(const INT& bGid);
+	virtual HRESULT get_FontCharSpace(double* dSpace);
+	virtual HRESULT put_FontCharSpace(const double& dSpace);
+	virtual HRESULT get_FontFaceIndex(int* lFaceIndex);
+	virtual HRESULT put_FontFaceIndex(const int& lFaceIndex);
+	//----------------------------------------------------------------------------------------
+	// Функции для вывода текста
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT CommandDrawTextCHAR  (const LONG& lUnicode,                   const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT CommandDrawTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT CommandDrawText      (const std::wstring& wsUnicodeText,                                                           const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT CommandDrawTextEx    (const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& dX, const double& dY, const double& dW, const double& dH);
+	//----------------------------------------------------------------------------------------
+	// Маркеры команд
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT BeginCommand(const DWORD& lType);
+	virtual HRESULT EndCommand(const DWORD& lType);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы с патом
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT PathCommandMoveTo(const double& dX, const double& dY);
+	virtual HRESULT PathCommandLineTo(const double& dX, const double& dY);
+	virtual HRESULT PathCommandLinesTo(double* pPoints, const int& nCount);
+	virtual HRESULT PathCommandCurveTo(const double& dX1, const double& dY1, const double& dX2, const double& dY2, const double& dXe, const double& dYe);
+	virtual HRESULT PathCommandCurvesTo(double* pPoints, const int& nCount);
+	virtual HRESULT PathCommandArcTo(const double& dX, const double& dY, const double& dW, const double& dH, const double& dStartAngle, const double& dSweepAngle);
+	virtual HRESULT PathCommandClose();
+	virtual HRESULT PathCommandEnd();
+	virtual HRESULT DrawPath(const LONG& lType);
+	virtual HRESULT PathCommandStart();
+	virtual HRESULT PathCommandGetCurrentPoint(double* dX, double* dY);
+	virtual HRESULT PathCommandTextCHAR  (const LONG& lUnicode,                   const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT PathCommandTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT PathCommandText      (const std::wstring& wsUnicodeText,                                                           const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT PathCommandTextEx    (const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& dX, const double& dY, const double& dW, const double& dH);
+	//----------------------------------------------------------------------------------------
+	// Функции для вывода изображений
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT DrawImage(IGrObject* pImage, const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT DrawImageFromFile(const std::wstring& wsImagePath, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha = 255);
+	//----------------------------------------------------------------------------------------
+	// Функции для выставления преобразования
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT SetTransform(const double& dM11, const double& dM12, const double& dM21, const double& dM22, const double& dX, const double& dY);
+	virtual HRESULT GetTransform(double* dM11, double* dM12, double* dM21, double* dM22, double* dX, double* dY);
+	virtual HRESULT ResetTransform();
+	//----------------------------------------------------------------------------------------
+	// Тип клипа
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_ClipMode(LONG* lMode);
+	virtual HRESULT put_ClipMode(const LONG& lMode);
+	//----------------------------------------------------------------------------------------
+	// Дополнительные функции
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT CommandLong(const LONG& lType, const LONG& lCommand);
+	virtual HRESULT CommandDouble(const LONG& lType, const double& dCommand);
+	virtual HRESULT CommandString(const LONG& lType, const std::wstring& sCommand);
+
+private:
+    CDocxRenderer_Private* m_pInternal;
+};
+
+#endif // _PDF_WRITER_PDFRENDERER_H

DocxRenderer/DocxRenderer.pro

+QT       -= core gui
+
+VERSION = 1.0.0.4
+TARGET = DocxRenderer
+TEMPLATE = lib
+
+CONFIG += shared
+CONFIG += plugin
+
+CONFIG += core_static_link_libstd
+
+CORE_ROOT_DIR = $$PWD/..
+PWD_ROOT_DIR = $$PWD
+include(../Common/base.pri)
+
+DEFINES += DOCXRENDERER_USE_DYNAMIC_LIBRARY
+
+CONFIG += build_all_zlib build_zlib_as_sources
+include(../OfficeUtils/OfficeUtils.pri)
+
+CONFIG += build_cximage_zlib_disable
+include(../DesktopEditor/Qt_build/graphics/project/graphics.pri)
+include(../DesktopEditor/xml/build/qt/libxml2.pri)
+
+#UnicodeConverter
+LIBS += -L$$CORE_BUILDS_LIBRARIES_PATH -lUnicodeConverter
+
+core_windows {
+
+LIBS += -lgdi32 \
+        -ladvapi32 \
+        -luser32 \
+        -lshell32
+}
+
+HEADERS += \
+    src/resources/resources.h
+
+HEADERS += \
+    src/logic/Common.h \
+    src/logic/Document.h \
+    src/logic/ElementImage.h \
+    src/logic/ElementParagraph.h \
+    src/logic/ElementShape.h \
+    src/logic/FontManager.h \
+    src/logic/FontManagerBase.h \
+    src/logic/Page.h
+
+HEADERS += \
+    DocxRenderer.h
+
+SOURCES += \
+    DocxRenderer.cpp

DocxRenderer/src/logic/Common.h

+#pragma once
+
+#ifndef AVSINLINE
+#if defined(_MSC_VER)
+#define AVSINLINE __forceinline
+#else
+#define AVSINLINE inline
+#endif
+#endif
+
+#include "../../Common/TemporaryCS.h"
+#include "../Graphics/Matrix.h"
+#include "../Graphics/Structures.h"
+#include "StringWriter.h"
+#include "CalculatorCRC32.h"
+
+namespace NSDocxRenderer
+{
+	AVSINLINE LONG ConvertColor(LONG lBGR)
+	{
+		return (0x00FFFFFF & (((lBGR & 0xFF) << 16) | (lBGR & 0x0000FF00) | ((lBGR >> 16) & 0xFF)));
+	} 
+
+	AVSINLINE void CorrectString(CString& strValue)
+	{
+		strValue.Replace(_T("&"),	_T("&amp;"));			
+		strValue.Replace(_T("'"),	_T("&apos;"));
+		strValue.Replace(_T("<"),	_T("&lt;"));
+		strValue.Replace(_T(">"),	_T("&gt;"));
+		strValue.Replace(_T("\""),	_T("&quot;"));
+	}
+
+	class CBaseItem
+	{
+	public:
+		enum ElemType
+		{
+			etParagraph	= 0,
+			etImage		= 1,
+			etShape		= 2
+		};
+
+		ElemType m_eType;
+
+		CBaseItem()
+		{
+			m_eType = etShape;
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter) = 0;
+	};
+
+	class CImageManager
+	{
+	public:
+		CAtlMap<CString, CImageInfo>	m_mapImagesFile;
+		CAtlMap<DWORD, CImageInfo>		m_mapImageData;
+
+		CString							m_strDstMedia;
+
+		LONG							m_lMaxSizeImage;
+		LONG							m_lNextIDImage;
+
+		CCalculatorCRC32				m_oCRC;
+
+	public:
+
+		CImageManager()
+		{
+			m_strDstMedia	= _T("");
+			m_lMaxSizeImage = 800;
+			m_lNextIDImage	= 0;
+		}
+
+		AVSINLINE void NewDocument()
+		{
+			m_strDstMedia	= _T("");
+			m_lMaxSizeImage = 800;
+			m_lNextIDImage	= 0;
+
+			m_mapImageData.RemoveAll();
+			m_mapImagesFile.RemoveAll();
+		}
+
+	public:
+		CImageInfo WriteImage(IUnknown* punkImage, double& x, double& y, double& width, double& height)
+		{
+			if (height < 0)
+			{
+				FlipY(punkImage);
+				height = -height;
+				y -= height;
+			}
+			
+			return GenerateImageID(punkImage);
+		}
+		CImageInfo WriteImage(CString& strFile, double& x, double& y, double& width, double& height)
+		{
+			return GenerateImageID(strFile);
+		}
+	
+	protected:
+		inline void CopyFile(CString& strFileSrc, CString& strFileDst)
+		{
+			CDirectory::CopyFile(strFileSrc, strFileDst, NULL, NULL);
+		}
+		void SaveImage(CString& strFileSrc, CImageInfo& oInfo)
+		{
+			CString strLoadXml = _T("<transforms><ImageFile-LoadImage sourcepath=\"") + strFileSrc + _T("\"/></transforms>");
+
+			ImageStudio::IImageTransforms* pTransform = NULL;
+			CoCreateInstance(ImageStudio::CLSID_ImageTransforms, NULL, CLSCTX_INPROC_SERVER, ImageStudio::IID_IImageTransforms, (void**)&pTransform);
+
+			VARIANT_BOOL vbRes = VARIANT_FALSE;
+			BSTR bsLoad = strLoadXml.AllocSysString();
+			pTransform->SetXml(bsLoad, &vbRes);
+			SysFreeString(bsLoad);
+
+			pTransform->Transform(&vbRes);
+
+			VARIANT var;
+			var.punkVal = NULL;
+			pTransform->GetResult(0, &var);
+
+			if (NULL == var.punkVal)
+			{
+				RELEASEINTERFACE(pTransform);
+				return;
+			}
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			var.punkVal->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			RELEASEINTERFACE((var.punkVal));
+
+			if (NULL == pFrame)
+			{
+				RELEASEINTERFACE(pTransform);
+				return;
+			}
+
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+
+			oInfo.m_eType = GetImageType(pFrame);
+
+			RELEASEINTERFACE(pFrame);
+
+			CString strSaveItem = _T("");
+			strSaveItem.Format(_T("\\image%d."), oInfo.m_lID);
+			if (itJPG == oInfo.m_eType)
+			{
+				strSaveItem = _T("<ImageFile-SaveAsJpeg destinationpath=\"") + m_strDstMedia + strSaveItem + _T("jpg\" format=\"888\"/>");
+			}
+			else
+			{
+				strSaveItem = _T("<ImageFile-SaveAsPng destinationpath=\"") + m_strDstMedia + strSaveItem + _T("png\" format=\"888\"/>");
+			}
+
+			CString strXml = _T("");
+
+			if ((lWidth <= m_lMaxSizeImage) && (lHeight <= m_lMaxSizeImage))
+			{
+				strXml = _T("<transforms>") + strSaveItem + _T("</transforms>");
+			}
+			else
+			{
+				LONG lW = 0;
+				LONG lH = 0;
+				double dAspect = (double)lWidth / lHeight;
+
+				if (lWidth >= lHeight)
+				{
+					lW = m_lMaxSizeImage;
+					lH = (LONG)((double)lW / dAspect);
+				}
+				else
+				{
+					lH = m_lMaxSizeImage;
+					lW = (LONG)(dAspect * lH);
+				}
+
+				CString strResize = _T("");
+				strResize.Format(_T("<ImageTransform-TransformResize width=\"%d\" height=\"%d\"/>"), lW, lH);
+
+				strXml = _T("<transforms>") + strResize + strSaveItem + _T("</transforms>");
+			}
+			
+			VARIANT_BOOL vbSuccess = VARIANT_FALSE;
+			BSTR bsXml = strXml.AllocSysString();
+			pTransform->SetXml(bsXml, &vbSuccess);
+			SysFreeString(bsXml);
+
+			pTransform->Transform(&vbSuccess);
+
+			RELEASEINTERFACE(pTransform);
+		}
+		void SaveImage(IUnknown* punkImage, CImageInfo& oInfo)
+		{
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkImage->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			if (NULL == pFrame)
+				return;
+
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+
+			oInfo.m_eType = GetImageType(pFrame);
+
+			RELEASEINTERFACE(pFrame);
+			
+			ImageStudio::IImageTransforms* pTransform = NULL;
+			CoCreateInstance(ImageStudio::CLSID_ImageTransforms, NULL ,CLSCTX_INPROC_SERVER, ImageStudio::IID_IImageTransforms, (void**)&pTransform);
+
+			VARIANT var;
+			var.vt = VT_UNKNOWN;
+			var.punkVal = punkImage;
+			pTransform->SetSource(0, var);
+
+			CString strSaveItem = _T("");
+			strSaveItem.Format(_T("\\image%d."), oInfo.m_lID);
+			if (itJPG == oInfo.m_eType)
+			{
+				strSaveItem = _T("<ImageFile-SaveAsJpeg destinationpath=\"") + m_strDstMedia + strSaveItem + _T("jpg\" format=\"888\"/>");
+			}
+			else
+			{
+				strSaveItem = _T("<ImageFile-SaveAsPng destinationpath=\"") + m_strDstMedia + strSaveItem + _T("png\" format=\"888\"/>");
+			}
+
+			CString strXml = _T("");
+			if ((lWidth <= m_lMaxSizeImage) && (lHeight <= m_lMaxSizeImage))
+			{
+				strXml = _T("<transforms>") + strSaveItem + _T("</transforms>");
+			}
+			else
+			{
+				LONG lW = 0;
+				LONG lH = 0;
+				double dAspect = (double)lWidth / lHeight;
+
+				if (lWidth >= lHeight)
+				{
+					lW = m_lMaxSizeImage;
+					lH = (LONG)((double)lW / dAspect);
+				}
+				else
+				{
+					lH = m_lMaxSizeImage;
+					lW = (LONG)(dAspect * lH);
+				}
+
+				CString strResize = _T("");
+				strResize.Format(_T("<ImageTransform-TransformResize width=\"%d\" height=\"%d\"/>"), lW, lH);
+
+				strXml = _T("<transforms>") + strResize + strSaveItem + _T("</transforms>");
+			}
+			
+			VARIANT_BOOL vbSuccess = VARIANT_FALSE;
+			BSTR bsXml = strXml.AllocSysString();
+			pTransform->SetXml(bsXml, &vbSuccess);
+			SysFreeString(bsXml);
+
+			pTransform->Transform(&vbSuccess);
+
+			RELEASEINTERFACE(pTransform);
+		}
+
+		CImageInfo GenerateImageID(IUnknown* punkData)
+		{
+			CImageInfo oInfo;
+
+			if (NULL == punkData)
+				return oInfo;
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkData->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			BYTE* pBuffer = NULL;
+			LONG lLen = 0;
+
+			pFrame->get_Buffer(&pBuffer);
+			pFrame->get_BufferSize(&lLen);
+
+			DWORD dwSum = m_oCRC.Calc(pBuffer, lLen);
+
+			CAtlMap<DWORD, CImageInfo>::CPair* pPair = m_mapImageData.Lookup(dwSum);
+			if (NULL == pPair)
+			{
+				//  
+				++m_lNextIDImage;
+				
+				oInfo.m_lID = m_lNextIDImage;
+				SaveImage(punkData, oInfo);
+				m_mapImageData.SetAt(dwSum, oInfo);
+			}
+			else
+			{
+				oInfo = pPair->m_value;
+			}
+
+			RELEASEINTERFACE(pFrame);
+
+			return oInfo;
+		}
+
+		CImageInfo GenerateImageID(CString& strFileName)
+		{
+			CImageInfo oInfo;
+			CAtlMap<CString, CImageInfo>::CPair* pPair = m_mapImagesFile.Lookup(strFileName);
+
+			if (NULL == pPair)
+			{
+				//  
+				++m_lNextIDImage;
+				
+				oInfo.m_lID = m_lNextIDImage;
+				SaveImage(strFileName, oInfo);
+				m_mapImagesFile.SetAt(strFileName, oInfo);
+			}
+			else
+			{
+				oInfo = pPair->m_value;
+			}
+
+			return oInfo;
+		}
+
+		ImageType GetImageType(MediaCore::IAVSUncompressedVideoFrame* pFrame)
+		{
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			BYTE* pBuffer	= NULL;
+
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+			pFrame->get_Buffer(&pBuffer);
+
+			BYTE* pBufferMem = pBuffer + 3;
+			LONG lCountPix = lWidth * lHeight;
+
+			for (LONG i = 0; i < lCountPix; ++i, pBufferMem += 4)
+			{
+				if (255 != *pBufferMem)
+					return itPNG;
+			}
+			return itJPG;
+		}
+
+		void FlipY(IUnknown* punkImage)
+		{
+			if (NULL == punkImage)
+				return;
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkImage->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			if (NULL == pFrame)
+				return;
+
+			BYTE* pBuffer	= NULL;
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			LONG lStride	= 0;
+
+			pFrame->get_Buffer(&pBuffer);
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+			pFrame->get_Stride(0, &lStride);
+
+			if (lStride < 0)
+				lStride = -lStride;
+			
+			if ((lWidth * 4) != lStride)
+			{
+				RELEASEINTERFACE(pFrame);
+				return;
+			}
+
+			BYTE* pBufferMem = new BYTE[lStride];
+
+			BYTE* pBufferEnd = pBuffer + lStride * (lHeight - 1);
+
+			LONG lCountV = lHeight / 2;
+
+			for (LONG lIndexV = 0; lIndexV < lCountV; ++lIndexV)
+			{
+				memcpy(pBufferMem, pBuffer, lStride);
+				memcpy(pBuffer, pBufferEnd, lStride);
+				memcpy(pBufferEnd, pBufferMem, lStride);
+				
+				pBuffer		+= lStride;
+				pBufferEnd	-= lStride;
+			}
+
+			RELEASEARRAYOBJECTS(pBufferMem);
+			RELEASEINTERFACE(pFrame);
+		}
+
+		void FlipX(IUnknown* punkImage)
+		{
+			if (NULL == punkImage)
+				return;
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkImage->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			if (NULL == pFrame)
+				return;
+
+			BYTE* pBuffer	= NULL;
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			LONG lStride	= 0;
+
+			pFrame->get_Buffer(&pBuffer);
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+			pFrame->get_Stride(0, &lStride);
+
+			if (lStride < 0)
+				lStride = -lStride;
+			
+			if ((lWidth * 4) != lStride)
+			{
+				RELEASEINTERFACE(pFrame);
+				return;
+			}
+
+			DWORD* pBufferDWORD	= (DWORD*)pBuffer;
+
+			LONG lW2 = lWidth / 2;
+			for (LONG lIndexV = 0; lIndexV < lHeight; ++lIndexV)
+			{
+				DWORD* pMem1 = pBufferDWORD;
+				DWORD* pMem2 = pBufferDWORD + lWidth - 1;
+				
+				LONG lI = 0;
+				while (lI < lW2)
+				{
+					DWORD dwMem = *pMem1;
+					*pMem1++ = *pMem2;
+					*pMem2-- = dwMem;
+				}
+			}
+
+			RELEASEINTERFACE(pFrame);
+		}
+
+	};
+}
+
+namespace NSDocxRenderer
+{
+	// 2-byte number
+    inline short little_endian_2_big_endian( short s )
+    {
+		return ( ( s >> 8) & 0xff ) + ( ( s << 8 ) & 0xff00 );
+    }
+
+    /*========================================================================================================*/
+
+    // 4-byte number
+    inline int little_endian_2_big_endian( int i )
+    {
+		return ( ( i & 0xff ) << 24 ) + ( ( i & 0xff00 ) << 8 ) + ( ( i & 0xff0000 ) >> 8 ) + ( ( i >> 24 ) & 0xff );
+    }
+
+	AVSINLINE CString ToHexString( unsigned int ui )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%08X"), ui);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+
+    AVSINLINE CString ToHexString( short s )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%04X"), s);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+	
+	AVSINLINE CString ToHexString( unsigned short us )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%04X"), us);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+
+    AVSINLINE CString ToHexString( char c )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%02X"), c);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+	
+	AVSINLINE CString ToHexString( BYTE uc )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%02X"), uc);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+}
\ No newline at end of file

DocxRenderer/src/logic/Document.h

+#pragma once
+#include "Page.h"
+
+namespace NSDocxRenderer
+{
+	static CString g_string_imageRID_png = _T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image\" Target=\"media/image%d.png\"/>");
+	static CString g_string_imageRID_jpg = _T("<Relationship Id=\"rId%d\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image\" Target=\"media/image%d.jpg\"/>");
+
+	static _bstr_t g_bstr_FontNameStart		= L"<w:font w:name=\"";
+	static _bstr_t g_bstr_FontPanoseStart	= L"<w:panose1 w:val=\"";
+	static _bstr_t g_bstr_FontCharsetStart	= L"<w:charset w:val=\"";
+	static _bstr_t g_bstr_FontFamilyStart	= L"<w:family w:val=\"";
+	static _bstr_t g_bstr_FontPitchTrue		= L"<w:pitch w:val=\"fixed\" />";
+	static _bstr_t g_bstr_FontPitchFalse	= L"<w:pitch w:val=\"variable\" />";
+
+	static CString g_string_SIG				= _T("<w:sig w:usb0=\"%08x\" w:usb1=\"%08x\" w:usb2=\"%08x\" w:usb3=\"%08x\" w:csb0=\"%08x\" w:csb1=\"%08x\"/>");
+	static _bstr_t g_bstr_end				= L"\"/>";
+	static _bstr_t g_bstr_end2				= L"\">";
+	static _bstr_t g_bstr_FontNameEnd		= L"</w:font>";
+
+	static CString g_string_DocumentStart	= L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
+<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
+xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
+xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
+xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\" \
+xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
+xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
+xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\">\
+<w:body>";
+
+	static CString g_string_DocumentEnd		= L"</w:body></w:document>";
+
+	class CDocument
+	{
+	public:
+		NSStructures::CPen				m_oPen;
+		NSStructures::CBrush			m_oBrush;
+		NSStructures::CFont				m_oFont;
+		NSStructures::CShadow			m_oShadow;
+		NSStructures::CEdgeText			m_oEdge;
+
+		NSStructures::CFont				m_oInstalledFont;
+
+		AVSGraphics::IASCGraphicSimpleComverter*	m_pSimpleGraphicsConverter;
+		AVSGraphics::IASCFontManager*				m_pFontManager;
+
+		NSDocxRenderer::CMatrix						m_oTransform;
+
+		LONG							m_lCurrentCommandType;
+
+		LONG							m_lClipMode;
+		CPage							m_oCurrentPage;
+
+		IUnknown*						m_punkRenderer;
+
+		CImageManager					m_oManager;
+
+		double							m_dWidth;
+		double							m_dHeight;
+
+		double							m_dDpiX;
+		double							m_dDpiY;
+
+		CString							m_strTempDirectory;
+
+		CFile							m_oDocumentStream;
+		LONG							m_lPagesCount;
+
+		NSDocxRenderer::CStringWriter	m_oWriter;
+		bool							m_bIsNeedPDFTextAnalyzer;
+
+	public:
+		CDocument() : m_oWriter()
+		{
+			m_pSimpleGraphicsConverter  = NULL;
+			m_lCurrentCommandType		= 0;
+
+			m_pFontManager				= NULL;
+			m_punkRenderer				= NULL;
+
+			m_dWidth	= 0;
+			m_dHeight	= 0;
+
+			m_dDpiX		= 72;
+			m_dDpiY		= 72;
+
+			m_strTempDirectory			= _T("");
+			m_lPagesCount				= 0;
+
+			m_bIsNeedPDFTextAnalyzer	= false;
+		}
+		AVSINLINE void Clear()
+		{
+			m_lClipMode = 0;
+			RELEASEINTERFACE(m_punkRenderer);
+			RELEASEINTERFACE(m_pSimpleGraphicsConverter);
+			RELEASEINTERFACE(m_pFontManager);
+		}
+
+		~CDocument()
+		{
+			m_lClipMode = 0;
+			RELEASEINTERFACE(m_pSimpleGraphicsConverter);
+			RELEASEINTERFACE(m_pFontManager);
+		}
+
+	public:
+
+		AVSINLINE HRESULT NewPage()
+		{
+			if (0 != m_lPagesCount)
+			{
+				m_oCurrentPage.WriteSectionToFile(false, m_oWriter);
+				m_oDocumentStream.WriteStringUTF8(m_oWriter.GetData());
+				m_oWriter.ClearNoAttack();
+			}
+			
+			m_oPen.SetDefaultParams();
+			m_oBrush.SetDefaultParams();
+			m_oFont.SetDefaultParams();
+			m_oShadow.SetDefaultParams();
+			m_oEdge.SetDefaultParams();
+
+			m_oTransform.Reset();
+
+			++m_lPagesCount;
+			m_oCurrentPage.Clear();
+			
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_Height(double* dHeight)
+		{
+			*dHeight = m_dHeight;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_Height(double dHeight)
+		{
+			m_dHeight					= dHeight;
+			m_oCurrentPage.m_dHeight	= dHeight;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_Width(double* dWidth)
+		{
+			*dWidth = m_dWidth;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_Width(double dWidth)
+		{
+			m_dWidth					= dWidth;
+			m_oCurrentPage.m_dWidth		= dWidth;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_DpiX(double* dDpiX)
+		{
+			*dDpiX = m_dDpiX;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_DpiY(double* dDpiY)
+		{
+			*dDpiY = m_dDpiY;
+			return S_OK;
+		}
+		//--------      ----------------------------------------------
+		// pen --------------------------------------------------------------------------------------
+		AVSINLINE HRESULT SetPen(BSTR bsXML)
+		{
+			m_oPen.FromXmlString((CString)bsXML);
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenColor(LONG* lColor)
+		{
+			*lColor = m_oPen.Color;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenColor(LONG lColor)
+		{
+			m_oPen.Color = lColor;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenAlpha(LONG* lAlpha)
+		{
+			*lAlpha = m_oPen.Alpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenAlpha(LONG lAlpha)
+		{
+			m_oPen.Alpha = lAlpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenSize(double* dSize)
+		{
+			*dSize = m_oPen.Size;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenSize(double dSize)
+		{
+			m_oPen.Size = dSize;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenDashStyle(BYTE* val)
+		{
+			*val = m_oPen.DashStyle;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenDashStyle(BYTE val)
+		{
+			m_oPen.DashStyle = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenLineStartCap(BYTE* val)
+		{
+			*val = m_oPen.LineStartCap;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenLineStartCap(BYTE val)
+		{
+			m_oPen.LineStartCap = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenLineEndCap(BYTE* val)
+		{
+			*val = m_oPen.LineEndCap;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenLineEndCap(BYTE val)
+		{
+			m_oPen.LineEndCap = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenLineJoin(BYTE* val)
+		{
+			*val = m_oPen.LineJoin;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenLineJoin(BYTE val)
+		{
+			m_oPen.LineJoin = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenDashOffset(double* val)
+		{
+			*val = m_oPen.DashOffset;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenDashOffset(double val)
+		{
+			m_oPen.DashOffset = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenAlign(LONG* val)
+		{
+			*val = m_oPen.Align;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenAlign(LONG val)
+		{
+			m_oPen.Align = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_PenMiterLimit(double* val)
+		{
+			*val = m_oPen.MiterLimit;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_PenMiterLimit(double val)
+		{
+			m_oPen.MiterLimit = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT PenDashPattern(SAFEARRAY* pPattern)
+		{
+			if (NULL != pPattern)
+			{
+				m_oPen.SetDashPattern((double*)pPattern->pvData, pPattern->rgsabound[0].cElements);
+			}
+
+			return S_OK;
+		}
+		// brush ------------------------------------------------------------------------------------
+		AVSINLINE HRESULT SetBrush(BSTR bsXML)
+		{
+			m_oBrush.FromXmlString((CString)bsXML);
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushType(LONG* lType)
+		{
+			*lType = m_oBrush.Type;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushType(LONG lType)
+		{
+			m_oBrush.Type = lType;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushColor1(LONG* lColor)
+		{
+			*lColor = m_oBrush.Color1;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushColor1(LONG lColor)
+		{
+			m_oBrush.Color1 = lColor;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushAlpha1(LONG* lAlpha)
+		{
+			*lAlpha = m_oBrush.Alpha1;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushAlpha1(LONG lAlpha)
+		{
+			m_oBrush.Alpha1 = lAlpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushColor2(LONG* lColor)
+		{
+			*lColor = m_oBrush.Color2;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushColor2(LONG lColor)
+		{
+			m_oBrush.Color2 = lColor;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushAlpha2(LONG* lAlpha)
+		{
+			*lAlpha = m_oBrush.Alpha2;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushAlpha2(LONG lAlpha)
+		{
+			m_oBrush.Alpha2 = lAlpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushTexturePath(BSTR* bsPath)
+		{
+			*bsPath = m_oBrush.TexturePath.AllocSysString();
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushTexturePath(BSTR bsPath)
+		{
+			m_oBrush.TexturePath = (CString)bsPath;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushTextureMode(LONG* lMode)
+		{
+			*lMode = m_oBrush.TextureMode;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushTextureMode(LONG lMode)
+		{
+			m_oBrush.TextureMode = lMode;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushTextureAlpha(LONG* lTxAlpha)
+		{
+			*lTxAlpha = m_oBrush.TextureAlpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushTextureAlpha(LONG lTxAlpha)
+		{
+			m_oBrush.TextureAlpha = lTxAlpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_BrushLinearAngle(double* dAngle)
+		{
+			*dAngle = m_oBrush.LinearAngle;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_BrushLinearAngle(double dAngle)
+		{
+			m_oBrush.LinearAngle = dAngle;
+			return S_OK;
+		}
+		AVSINLINE HRESULT BrushRect(BOOL val, double left, double top, double width, double height)
+		{
+			m_oBrush.Rectable = val;
+			m_oBrush.Rect.X = (float)left;
+			m_oBrush.Rect.Y = (float)top;
+			m_oBrush.Rect.Width  = (float)width;
+			m_oBrush.Rect.Height = (float)height;	
+
+			return S_OK;
+		}
+		// font -------------------------------------------------------------------------------------
+		AVSINLINE HRESULT SetFont(BSTR bsXML)
+		{
+			m_oFont.FromXmlString((CString)bsXML);
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_FontName(BSTR* bsName)
+		{
+			*bsName = m_oFont.Name.AllocSysString();
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_FontName(BSTR bsName)
+		{
+			m_oFont.Name = (CString)bsName;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_FontPath(BSTR* bsName)
+		{
+			*bsName = m_oFont.Path.AllocSysString();
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_FontPath(BSTR bsName)
+		{
+			m_oFont.Path = bsName;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_FontSize(double* dSize)
+		{
+			*dSize = m_oFont.Size;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_FontSize(double dSize)
+		{
+			m_oFont.Size = dSize;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_FontStyle(LONG* lStyle)
+		{
+			*lStyle = m_oFont.GetStyle();
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_FontStyle(LONG lStyle)
+		{
+			m_oFont.SetStyle(lStyle);
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_FontStringGID(BOOL* bGID)
+		{
+			*bGID = m_oFont.StringGID;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_FontStringGID(BOOL bGID)
+		{
+			m_oFont.StringGID = bGID;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_FontCharSpace(double* dSpace)
+		{
+			*dSpace = m_oFont.CharSpace;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_FontCharSpace(double dSpace)
+		{
+			m_oFont.CharSpace = dSpace;
+			return S_OK;
+		}
+		// shadow -----------------------------------------------------------------------------------
+		AVSINLINE HRESULT SetShadow(BSTR bsXML)
+		{
+			m_oShadow.FromXmlString((CString)bsXML);
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_ShadowDistanceX(double* val)
+		{
+			*val = m_oShadow.DistanceX;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_ShadowDistanceX(double val)
+		{
+			m_oShadow.DistanceX = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_ShadowDistanceY(double* val)
+		{
+			*val = m_oShadow.DistanceY;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_ShadowDistanceY(double val)
+		{
+			m_oShadow.DistanceY = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_ShadowBlurSize(double* val)
+		{
+			*val = m_oShadow.BlurSize;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_ShadowBlurSize(double val)
+		{
+			m_oShadow.BlurSize = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_ShadowColor(LONG* val)
+		{
+			*val = m_oShadow.Color;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_ShadowColor(LONG val)
+		{
+			m_oShadow.Color = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_ShadowAlpha(LONG* val)
+		{
+			*val = m_oShadow.Alpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_ShadowAlpha(LONG val)
+		{
+			m_oShadow.Alpha = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_ShadowVisible(BOOL* val)
+		{
+			*val = m_oShadow.Visible;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_ShadowVisible(BOOL val)
+		{
+			m_oShadow.Visible = val;
+			return S_OK;
+		}
+		// edge -------------------------------------------------------------------------------------
+		AVSINLINE HRESULT SetEdgeText(BSTR bsXML)
+		{
+			m_oEdge.FromXmlString((CString)bsXML);
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_EdgeVisible(LONG* val)
+		{
+			*val = m_oEdge.Visible;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_EdgeVisible(LONG val)
+		{
+			m_oEdge.Visible = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_EdgeColor(LONG* val)
+		{
+			*val = m_oEdge.Color;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_EdgeColor(LONG val)
+		{
+			m_oEdge.Color = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_EdgeAlpha(LONG* val)
+		{
+			*val = m_oEdge.Alpha;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_EdgeAlpha(LONG val)
+		{
+			m_oEdge.Alpha = val;
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_EdgeDist(double* val)
+		{
+			*val = m_oEdge.Dist;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_EdgeDist(double val)
+		{
+			m_oEdge.Dist = val;
+			return S_OK;
+		}
+
+		//--------     --------------------------------------------------------
+		AVSINLINE HRESULT CommandDrawText(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset)
+		{
+			double dAngleMatrix = m_oTransform.z_Rotation();
+			if (abs(dAngleMatrix) > 1)
+			{
+				PathCommandEnd();
+				BeginCommand(c_nPathType);
+				PathCommandText(bsText, fX, fY, fWidth, fHeight, fBaseLineOffset);
+				DrawPath(c_nWindingFillMode);
+				EndCommand(c_nPathType);
+				PathCommandEnd();
+				return S_OK;
+			}
+
+			m_oCurrentPage.WriteText(bsText, NULL, fX, fY, fWidth, fHeight, fBaseLineOffset, m_bIsNeedPDFTextAnalyzer);
+			return S_OK;
+		}
+		AVSINLINE HRESULT CommandDrawTextEx(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags)
+		{
+			double dAngleMatrix = m_oTransform.z_Rotation();
+			if (abs(dAngleMatrix) > 1)
+			{
+				PathCommandEnd();
+				BeginCommand(c_nPathType);
+				PathCommandTextEx(bsUnicodeText, bsGidText, bsSourceCodeText, fX, fY, fWidth, fHeight, fBaseLineOffset, lFlags);
+				DrawPath(c_nWindingFillMode);
+				EndCommand(c_nPathType);
+				PathCommandEnd();
+				return S_OK;
+			}
+
+			m_oCurrentPage.WriteText(bsUnicodeText, bsGidText, fX, fY, fWidth, fHeight, fBaseLineOffset, m_bIsNeedPDFTextAnalyzer);
+			return S_OK;
+		}
+		//--------    ---------------------------------------------------------------
+		AVSINLINE HRESULT BeginCommand(DWORD lType)
+		{
+			m_lCurrentCommandType = (LONG)lType;
+			m_oCurrentPage.m_lCurrentCommand	= m_lCurrentCommandType;
+
+			return S_OK;
+		}
+		AVSINLINE HRESULT EndCommand(DWORD lType)
+		{
+			m_lCurrentCommandType				= -1;
+			m_oCurrentPage.m_lCurrentCommand	= m_lCurrentCommandType;
+
+			if (c_nPageType == lType)
+			{
+				//     
+				m_oCurrentPage.Build();
+				m_oCurrentPage.Write(m_oWriter);
+			}
+			else if (c_nPathType == lType)
+			{
+				m_oCurrentPage.End();
+			}
+
+			return S_OK;
+		}
+		//--------     Graphics Path -----------------------------------------------
+		AVSINLINE HRESULT PathCommandMoveTo(double fX, double fY)
+		{
+			if (c_nSimpleGraphicType == m_lCurrentCommandType)
+			{
+				m_oCurrentPage.MoveTo(fX, fY);
+			}
+			else
+			{
+				m_pSimpleGraphicsConverter->PathCommandMoveTo(fX, fY);
+			}
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandLineTo(double fX, double fY)
+		{
+			if (c_nSimpleGraphicType == m_lCurrentCommandType)
+			{
+				m_oCurrentPage.LineTo(fX, fY);
+			}
+			else
+			{
+				m_pSimpleGraphicsConverter->PathCommandLineTo(fX, fY);
+			}
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandLinesTo(SAFEARRAY* pPoints)
+		{
+			m_pSimpleGraphicsConverter->PathCommandLinesTo(pPoints);
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandCurveTo(double fX1, double fY1, double fX2, double fY2, double fX3, double fY3)
+		{
+			if (c_nSimpleGraphicType == m_lCurrentCommandType)
+			{
+				m_oCurrentPage.CurveTo(fX1, fY1, fX2, fY2, fX3, fY3);
+			}
+			else
+			{
+				m_pSimpleGraphicsConverter->PathCommandCurveTo(fX1, fY1, fX2, fY2, fX3, fY3);
+			}
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandCurvesTo(SAFEARRAY* pPoints)
+		{
+			m_pSimpleGraphicsConverter->PathCommandCurvesTo(pPoints);
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandArcTo(double fX, double fY, double fWidth, double fHeight, double fStartAngle, double fSweepAngle)
+		{
+			m_pSimpleGraphicsConverter->PathCommandArcTo(fX, fY, fWidth, fHeight, fStartAngle, fSweepAngle);
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandClose()
+		{
+			if (c_nSimpleGraphicType == m_lCurrentCommandType)
+			{
+				m_oCurrentPage.Close();
+			}
+			else
+			{
+				m_pSimpleGraphicsConverter->PathCommandClose();
+			}
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandEnd()
+		{
+			if (c_nSimpleGraphicType == m_lCurrentCommandType)
+			{
+				m_oCurrentPage.End();
+			}
+			else
+			{
+				m_pSimpleGraphicsConverter->PathCommandEnd();
+			}
+			return S_OK;
+		}
+		AVSINLINE HRESULT DrawPath(long nType)
+		{
+			LONG lTxId = -1;
+			if ((nType > 0xFF) && (c_BrushTypeTexture == m_oBrush.Type))
+			{
+				double x = 0;
+				double y = 0;
+				double w = 0;
+				double h = 0;
+				CImageInfo oInfo = m_oManager.WriteImage(m_oBrush.TexturePath, x, y, w, h);
+				lTxId = oInfo.m_lID;
+			}
+
+			m_oCurrentPage.DrawPath(nType, lTxId);
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandStart()
+		{
+			if (c_nSimpleGraphicType == m_lCurrentCommandType)
+			{
+				m_oCurrentPage.Start();
+			}
+			else
+			{
+				m_pSimpleGraphicsConverter->PathCommandStart();
+			}
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandGetCurrentPoint(double* fX, double* fY)
+		{
+			m_pSimpleGraphicsConverter->PathCommandGetCurrentPoint(fX, fY);	
+			return S_OK;
+		}
+
+		AVSINLINE HRESULT PathCommandText(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset)
+		{
+			_SetFont();
+			m_pSimpleGraphicsConverter->PathCommandText(bsText, m_pFontManager, fX, fY, fWidth, fHeight, fBaseLineOffset);
+			return S_OK;
+		}
+		AVSINLINE HRESULT PathCommandTextEx(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags)
+		{
+			if (NULL != bsGidText)
+			{
+				m_oFont.StringGID = TRUE;
+				return PathCommandText(bsGidText, fX, fY, fWidth, fHeight, fBaseLineOffset);
+			}
+			
+			m_oFont.StringGID = FALSE;
+			return PathCommandText(bsUnicodeText, fX, fY, fWidth, fHeight, fBaseLineOffset);
+		}
+		
+		AVSINLINE HRESULT GetCommandParams(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags)
+		{
+			return S_OK;
+		}
+		AVSINLINE HRESULT SetCommandParams(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags)
+		{
+			ApplyTransform2(dAngle, dLeft, dTop, dWidth, dHeight, lFlags);
+			return S_OK;
+		}
+		//--------     --------------------------------------------------
+		AVSINLINE HRESULT DrawImage(IUnknown* pInterface, double fX, double fY, double fWidth, double fHeight)
+		{
+			CImageInfo oInfo = m_oManager.WriteImage(pInterface, fX, fY, fWidth, fHeight);
+			m_oCurrentPage.WriteImage(oInfo, fX, fY, fWidth, fHeight);
+			return S_OK;
+		}
+		AVSINLINE HRESULT DrawImageFromFile(BSTR bstrVal, double fX, double fY, double fWidth, double fHeight)
+		{
+			CImageInfo oInfo = m_oManager.WriteImage((CString)bstrVal, fX, fY, fWidth, fHeight);
+			m_oCurrentPage.WriteImage(oInfo, fX, fY, fWidth, fHeight);
+			return S_OK;
+		}
+		//------------------------------------------------------------------------------------------
+		AVSINLINE HRESULT SetAdditionalParam(BSTR ParamName, VARIANT ParamValue)
+		{
+			return S_OK;
+		}
+		AVSINLINE HRESULT GetAdditionalParam(BSTR ParamName, VARIANT* ParamValue)
+		{
+			return S_OK;
+		}
+
+		AVSINLINE HRESULT SetTransform(double dA, double dB, double dC, double dD, double dE, double dF)
+		{
+			ApplyTransform(dA, dB, dC, dD, dE, dF);
+			return S_OK;
+		}
+		AVSINLINE HRESULT GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
+		{
+			return S_OK;
+		}
+		AVSINLINE HRESULT ResetTransform(void)
+		{
+			m_oTransform.Reset();
+			return S_OK;
+		}
+		AVSINLINE HRESULT get_ClipMode(LONG* plMode)
+		{
+			*plMode = m_lClipMode;
+			return S_OK;
+		}
+		AVSINLINE HRESULT put_ClipMode(LONG lMode)
+		{
+			m_lClipMode = lMode;
+			return S_OK;
+		}
+
+	protected:
+		AVSINLINE void ApplyTransform(double d1, double d2, double d3, double d4, double d5, double d6)
+		{
+			m_oTransform.SetElements(d1, d2, d3, d4, d5, d6);
+		}
+
+		void ApplyTransform2(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags)
+		{
+			if ((dWidth <= 1) || (dHeight <= 1))
+				lFlags = 0;
+
+			BOOL bFlipX = (0 != (c_nParamFlipX & lFlags));
+			BOOL bFlipY = (0 != (c_nParamFlipY & lFlags));
+			
+			double m11 = bFlipX ? -1.0 : 1.0;
+			double m22 = bFlipY ? -1.0 : 1.0;
+			
+			NSDocxRenderer::CMatrix oMatrix(1, 0, 0, 1, 0, 0);
+
+			if ((0 != dAngle) || (0 != lFlags))
+			{
+				double dCentreX = (dLeft + dWidth / 2.0);
+				double dCentreY = (dTop + dHeight / 2.0);
+				
+				oMatrix.Translate(-dCentreX, -dCentreY	, Aggplus::MatrixOrderAppend);
+				
+				oMatrix.Rotate(dAngle			, Aggplus::MatrixOrderAppend);
+				oMatrix.Scale(m11, m22					, Aggplus::MatrixOrderAppend);
+				
+				oMatrix.Translate(dCentreX, dCentreY	, Aggplus::MatrixOrderAppend);
+			}
+
+			m_oTransform = oMatrix;
+		}
+
+		void _SetFont()
+		{
+			if (NULL == m_pFontManager)
+			{
+				CoCreateInstance(__uuidof(AVSGraphics::CASCFontManager), NULL, CLSCTX_ALL, __uuidof(AVSGraphics::IASCFontManager), (void**)&m_pFontManager);
+				m_pFontManager->Initialize(L"");
+			}
+
+			double dPix = m_oFont.CharSpace * m_dDpiX / 25.4;
+			
+			if (m_oInstalledFont.IsEqual(&m_oFont))
+			{
+				if (1 < m_dWidth)
+				{
+					m_pFontManager->SetCharSpacing(dPix);
+				}
+				return;
+			}
+
+			m_pFontManager->SetStringGID(m_oFont.StringGID);
+			if (1 < m_dWidth)
+			{
+				m_pFontManager->SetCharSpacing(dPix);
+			}
+
+			if (_T("") == m_oFont.Path)
+			{
+				BSTR bsName = m_oFont.Name.AllocSysString();
+				m_pFontManager->LoadFontByName(bsName, (float)m_oFont.Size, m_oFont.GetStyle(), m_dDpiX, m_dDpiY);
+				SysFreeString(bsName);
+			}
+			else
+			{
+				BSTR bsName = m_oFont.Path.AllocSysString();
+				m_pFontManager->LoadFontFromFile(bsName, (float)m_oFont.Size, m_dDpiX, m_dDpiY, 0);
+				SysFreeString(bsName);
+			}
+
+			m_oInstalledFont = m_oFont;
+		}
+
+	public:
+		
+		bool CreateDocument(IUnknown* pRenderer, CString strTempDirectory)
+		{
+			HINSTANCE hInst = _AtlBaseModule.GetModuleInstance();
+			m_strTempDirectory = strTempDirectory;
+
+			// rels
+			CString strRels = strTempDirectory + _T("\\_rels");
+			CDirectory::CreateDirectory(strRels);
+			
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_RELS), _T("DOCXREND"), strRels + _T("\\.rels"));
+
+			// docProps
+			CString strDocProps = strTempDirectory + _T("\\docProps");
+			CDirectory::CreateDirectory(strDocProps);
+
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_APP),  _T("DOCXREND"), strDocProps + _T("\\app.xml"));
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_CORE), _T("DOCXREND"), strDocProps + _T("\\core.xml"));
+
+			// contentTypes
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_CONTENT_TYPES), _T("DOCXREND"), strTempDirectory + _T("\\[Content_Types].xml"));
+
+			// word
+			CString strWord = strTempDirectory + _T("\\word");
+			CDirectory::CreateDirectory(strWord);
+
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_SETTINGS),		_T("DOCXREND"), strWord + _T("\\settings.xml"));
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_STYLES),		_T("DOCXREND"), strWord + _T("\\styles.xml"));
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_WEBSETTINGS),	_T("DOCXREND"), strWord + _T("\\webSettings.xml"));
+
+			// theme
+			CString strTheme = strWord + _T("\\theme");
+			CDirectory::CreateDirectory(strTheme);
+			LoadResourceFile(hInst, MAKEINTRESOURCE(IDB_DEFAULT_DOC_THEME),	_T("DOCXREND"), strTheme + _T("\\theme.xml"));
+
+			// documentRels
+			CDirectory::CreateDirectory(strWord + _T("\\_rels"));
+
+			// Init
+			Clear();
+
+			CoCreateInstance(__uuidof(AVSGraphics::CASCGraphicSimpleComverter), NULL, CLSCTX_ALL, 
+				__uuidof(AVSGraphics::IASCGraphicSimpleComverter), (void**)&m_pSimpleGraphicsConverter);
+
+			m_punkRenderer = pRenderer;
+			ADDREFINTERFACE(m_punkRenderer);
+			m_pSimpleGraphicsConverter->put_Renderer(m_punkRenderer);
+			m_lCurrentCommandType = 0;
+
+			m_oCurrentPage.Init(&m_oFont, &m_oPen, &m_oBrush, &m_oShadow, &m_oEdge, &m_oTransform, m_pSimpleGraphicsConverter);
+
+			m_oManager.NewDocument();
+			// media
+			m_oManager.m_strDstMedia = strWord + _T("\\media");
+			CDirectory::CreateDirectory(m_oManager.m_strDstMedia);
+
+			m_oCurrentPage.m_oManager.m_oFontTable.m_mapTable.RemoveAll();
+
+			m_oDocumentStream.CloseFile();
+			m_oDocumentStream.CreateFile(strWord + _T("\\document.xml"));
+			m_oDocumentStream.WriteStringUTF8(g_string_DocumentStart);
+
+			m_lPagesCount				= 0;
+			m_oWriter.Clear();
+			m_oWriter.AddSize(10000);
+
+			return true;
+		}
+
+		void Close()
+		{
+			//  rels (images & docs)
+			CFile oFile;
+			oFile.CreateFile(m_strTempDirectory + _T("\\word\\_rels\\document.xml.rels"));
+
+			NSDocxRenderer::CStringWriter oWriter;
+
+			CString strStart = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
+<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
+<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>\
+<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings\" Target=\"settings.xml\"/>\
+<Relationship Id=\"rId3\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings\" Target=\"webSettings.xml\"/>\
+<Relationship Id=\"rId4\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable\" Target=\"fontTable.xml\"/>\
+<Relationship Id=\"rId5\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"theme/theme.xml\"/>");
+
+			oWriter.WriteString(strStart);
+
+			POSITION pos = m_oManager.m_mapImageData.GetStartPosition();
+			while (NULL != pos)
+			{
+				CAtlMap<DWORD, CImageInfo>::CPair* pPair = m_oManager.m_mapImageData.GetNext(pos);
+
+				LONG lId = pPair->m_value.m_lID;
+				if (pPair->m_value.m_eType == itPNG)
+				{
+					CString strImage = _T("");
+					strImage.Format(g_string_imageRID_png, 10 + lId, lId);
+					oWriter.WriteString(strImage);
+				}
+				else
+				{
+					CString strImage = _T("");
+					strImage.Format(g_string_imageRID_jpg, 10 + lId, lId);
+					oWriter.WriteString(strImage);
+				}
+			}
+
+			pos = m_oManager.m_mapImagesFile.GetStartPosition();
+			while (NULL != pos)
+			{
+				CAtlMap<CString, CImageInfo>::CPair* pPair = m_oManager.m_mapImagesFile.GetNext(pos);
+
+				LONG lId = pPair->m_value.m_lID;
+				if (pPair->m_value.m_eType == itPNG)
+				{
+					CString strImage = _T("");
+					strImage.Format(g_string_imageRID_png, 10 + lId, lId);
+					oWriter.WriteString(strImage);
+				}
+				else
+				{
+					CString strImage = _T("");
+					strImage.Format(g_string_imageRID_jpg, 10 + lId, lId);
+					oWriter.WriteString(strImage);
+				}
+			}
+
+			CString strEnd = _T("</Relationships>"); 
+			oWriter.WriteString(strEnd);
+
+			oFile.WriteStringUTF8(oWriter.GetData());
+			oFile.CloseFile();
+
+			//  fontTable
+			CFile oFileFontTable;
+			oFileFontTable.CreateFile(m_strTempDirectory + _T("\\word\\fontTable.xml"));
+
+			oWriter.ClearNoAttack();
+
+			strStart = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
+<w:fonts xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">");
+
+			oWriter.WriteString(strStart);
+
+			CFontTable* pFontTable = &m_oCurrentPage.m_oManager.m_oFontTable;
+
+			pos = pFontTable->m_mapTable.GetStartPosition();
+			while (NULL != pos)
+			{
+				CAtlMap<CString, CFontTableEntry>::CPair* pPair = pFontTable->m_mapTable.GetNext(pos);
+
+				oWriter.WriteString(g_bstr_FontNameStart);
+				oWriter.WriteString((CString)pPair->m_value.m_strFamilyName);
+				oWriter.WriteString(g_bstr_end2);
+
+				oWriter.WriteString(g_bstr_FontPanoseStart);
+				oWriter.WriteString(pPair->m_value.m_strPANOSE);
+				oWriter.WriteString(g_bstr_end);
+
+				oWriter.WriteString(g_bstr_FontCharsetStart);
+				oWriter.WriteString((CString)_T("00"));
+				oWriter.WriteString(g_bstr_end);
+
+				//oWriter.WriteString(g_bstr_FontFamilyStart);
+				//oWriter.WriteString((CString)_T("roman"));
+				//oWriter.WriteString(g_bstr_end);
+
+				if (pPair->m_value.m_bIsFixedWidth)
+				{
+					oWriter.WriteString(g_bstr_FontPitchTrue);
+				}
+				else
+				{
+					oWriter.WriteString(g_bstr_FontPitchFalse);
+				}
+
+				CString strSig = _T("");
+				strSig.Format(g_string_SIG, pPair->m_value.m_arSignature[0], pPair->m_value.m_arSignature[1], pPair->m_value.m_arSignature[2], 
+					pPair->m_value.m_arSignature[3], pPair->m_value.m_arSignature[4], pPair->m_value.m_arSignature[5]);
+
+				oWriter.WriteString(strSig);
+
+				oWriter.WriteString(g_bstr_FontNameEnd);		
+			}
+
+			strEnd = _T("</w:fonts>");
+			oWriter.WriteString(strEnd);
+
+			oFileFontTable.WriteStringUTF8(oWriter.GetData());
+			oFileFontTable.CloseFile();
+
+			// document
+			m_oCurrentPage.WriteSectionToFile(true, m_oWriter);
+			m_oWriter.WriteString(g_string_DocumentEnd);
+			m_oDocumentStream.WriteStringUTF8(m_oWriter.GetData());
+			m_oWriter.ClearNoAttack();
+
+			m_oDocumentStream.CloseFile();
+		}
+
+	protected:
+
+		void LoadResourceFile(HINSTANCE hInst, LPCTSTR sResName, LPCTSTR sResType, const CString& strDstFile)
+		{
+			HRSRC hrRes = FindResource(hInst, sResName, sResType);
+			if (!hrRes)
+				return;
+
+			HGLOBAL hGlobal = LoadResource(hInst, hrRes);
+			DWORD sz = SizeofResource(hInst, hrRes);
+			void* ptrRes = LockResource(hGlobal);
+			
+			CFile oFile;
+			oFile.CreateFile(strDstFile);
+			oFile.WriteFile(ptrRes, sz);
+
+			UnlockResource(hGlobal);
+			FreeResource(hGlobal);
+		}			
+	};
+}
\ No newline at end of file

DocxRenderer/src/logic/ElementImage.h

+#pragma once
+#include "Common.h"
+
+namespace NSDocxRenderer
+{
+	static _bstr_t g_bstr_image_1			= L"<w:r><w:pict><v:shape id=\"\" type=\"\" style=\"position:absolute;";
+	static _bstr_t g_bstr_image_2			= L"z-index:-1;mso-position-horizontal-relative:page;mso-position-vertical-relative:page\" filled=\"f\">";
+	static _bstr_t g_bstr_image_3			= L"</v:shape></w:pict></w:r>";
+
+	static CString g_string_image_position			= _T("margin-left:%.2lfmm;margin-top:%.2lfmm;width:%.2lfmm;height:%.2lfmm;");
+	static CString g_string_image_position_rotate	= _T("margin-left:%.2lfmm;margin-top:%.2lfmm;width:%.2lfmm;height:%.2lfmm;rotation:%d;");
+	static CString g_string_image_rid				= _T("<v:imagedata r:id=\"rId%d\" o:title=\"\"/>");
+
+	class CImage : public CBaseItem
+	{
+	public:
+		CString m_strPath;
+		LONG	m_lID;
+
+		double m_dLeft;
+		double m_dTop;
+		double m_dWidth;
+		double m_dHeight;
+
+		double m_dRotate;
+
+	public:
+		CImage()
+		{
+			m_eType		= etImage;
+			m_strPath	= _T("");
+			m_lID		= -1;
+		}
+		CImage(const CImage& oSrc)
+		{
+			*this = oSrc;
+		}
+		CImage(const CImageInfo& oInfo, const CString& strDstMedia)
+		{
+			m_eType		= etImage;
+			m_strPath	= strDstMedia;
+			m_lID		= oInfo.m_lID;
+		}
+		CImage& operator=(const CImage& oSrc)
+		{
+			m_eType		= etImage;
+			m_strPath	= oSrc.m_strPath;
+			m_lID		= oSrc.m_lID;
+
+			m_dLeft		= oSrc.m_dLeft;
+			m_dTop		= oSrc.m_dTop;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_dRotate	= oSrc.m_dRotate;
+
+			return *this;
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			oWriter.WriteString(g_bstr_image_1);
+
+			if (0.0 == m_dRotate)
+			{
+				CString strPosition = _T("");
+				strPosition.Format(g_string_image_position, m_dLeft, m_dTop, m_dWidth, m_dHeight);
+				oWriter.WriteString(strPosition);
+			}
+			else
+			{
+				CString strPosition = _T("");
+				strPosition.Format(g_string_image_position_rotate, m_dLeft, m_dTop, m_dWidth, m_dHeight, (int)m_dRotate);
+				oWriter.WriteString(strPosition);
+			}
+
+			oWriter.WriteString(g_bstr_image_2);
+
+			CString strRid = _T("");
+			strRid.Format(g_string_image_rid, 10 + m_lID);
+
+			oWriter.WriteString(strRid);
+
+			oWriter.WriteString(g_bstr_image_3);
+		}
+	};
+}
\ No newline at end of file

DocxRenderer/src/logic/ElementParagraph.h

+#pragma once
+#include "Common.h"
+
+//#include "../../Common/DocxFormat/Source/DocxFormat/Logic/Paragraph.h"
+#include "FontManager.h"
+
+namespace NSDocxRenderer
+{
+	const double c_dMMToDx	 = 72 * 20 / 25.4;
+
+	//   T    IsBigger, IsBiggerOrEqual
+	template<typename T> 
+	void SortElements(CAtlArray<T*>& oArray)
+	{
+		int nSize = (int)oArray.GetCount();
+
+		// handle 0, 1 and 2 elements
+		if (nSize <= 1)
+			return;
+		if (nSize == 2)
+		{
+			if (oArray[0]->IsBigger(oArray[1]))
+			{
+				T* pTemp	= oArray[0];
+				oArray[0]	= oArray[1];
+				oArray[1]	= pTemp;
+			}
+			return;
+		}
+
+		T* tTemp;
+
+		// arrange elements as tree with greater elements appearing first
+		int nIndex = (nSize >> 1) - 1, nCurr = 0, nNext = 0;
+		int nLast = nSize - 1;
+		int nHalf = nSize >> 1;
+		do
+		{
+			// save element at start of chain
+			tTemp = oArray[nIndex];
+
+			nCurr = nIndex;
+			while (nCurr < nHalf)
+			{
+				nNext = (nCurr << 1) + 1;
+				if (nNext < nLast && (oArray[nNext + 1]->IsBigger(oArray[nNext])))
+					nNext++;
+				if (tTemp->IsBiggerOrEqual(oArray[nNext]))
+					break;
+
+				// promote element in chain
+				oArray[nCurr] = oArray[nNext];
+				nCurr = nNext;
+			}
+
+			// restore element at end of chain
+			oArray[nCurr] = tTemp;
+		}
+		while (nIndex--);
+
+		// sequentially reduce tree size by removing maximum element and rebalancing
+		nIndex = nSize;
+		while (--nIndex)
+		{
+			// save element at start of chain
+			tTemp = oArray[nIndex];
+			oArray[nIndex] = oArray[0];
+
+			nCurr = 0;
+			nLast = nIndex - 1;
+			nHalf = nIndex >> 1;
+			while (nCurr < nHalf)
+			{
+				nNext = (nCurr << 1) + 1;
+				if (nNext < nLast && (oArray[nNext + 1]->IsBigger(oArray[nNext])))
+					nNext++;
+				if (tTemp->IsBiggerOrEqual(oArray[nNext]))
+					break;
+
+				// promote element in chain
+				oArray[nCurr] = oArray[nNext];
+				nCurr = nNext;
+			}
+
+			// restore element at end of chain
+			oArray[nCurr] = tTemp;
+		}
+	}
+
+	static _bstr_t g_bstr_text_run_Start				= L"<w:r><w:rPr>";
+	static _bstr_t g_bstr_text_run_PropEnd				= L"</w:rPr>";
+	static _bstr_t g_bstr_text_run_End					= L"</w:r>";
+
+	static _bstr_t g_bstr_text_run_text1				= L"<w:t xml:space=\"preserve\">";
+	static _bstr_t g_bstr_text_run_text2				= L"</w:t>";
+
+	static _bstr_t g_bstr_text_bold_true				= L"<w:b w:val=\"true\"/>";
+	static _bstr_t g_bstr_text_italic_true				= L"<w:i w:val=\"true\"/>";
+
+	static CString g_string_text_font_size				= _T("<w:sz w:val=\"%d\"/><w:szCs w:val=\"%d\"/>");
+	static CString g_string_text_font_name				= _T("<w:rFonts w:ascii=\"%s\" w:hAnsi=\"%s\" w:cs=\"%s\"/>");
+
+	static CString g_string_text_color					= _T("<w:color w:val=\"%06x\"/>");
+
+	static CString g_string_text_paragraph_noframes		= _T("<w:pPr><w:spacing w:before=\"%d\" w:line=\"%d\" w:lineRule=\"exact\"/><w:ind w:left=\"%d\"/></w:pPr>");
+	static _bstr_t g_bstr_text_par_start				= L"<w:p>";
+	static _bstr_t g_bstr_text_par_end					= L"</w:p>";
+
+	static CString g_string_spacing_character			= _T("<w:spacing w:val=\"%d\"/>");
+	static CString g_string_spacing_character2			= _T("<w:spacing w:val=\"%.3lfpt\"/>");
+
+	static CString g_string_par_props_mode2				= _T("<w:pPr><w:framePr w:hAnchor=\"page\" w:vAnchor=\"page\" w:x=\"%d\" w:y=\"%d\"/></w:pPr>");
+
+	AVSINLINE void DeleteSpaces(CString& strText)
+	{
+		int nLen   = strText.GetLength();
+		int nStart = 0;
+
+		while ((nStart < nLen) && (TCHAR(' ') == strText[nStart]))
+			++nStart;
+
+		if (nStart == nLen)
+		{
+			strText = _T("");
+			return;
+		}
+		
+		int nEnd = nLen - 1;
+		while ((nEnd > nStart) && (TCHAR(' ') == strText[nEnd]))
+			--nEnd;
+
+		strText = strText.Mid(nStart, nEnd - nStart + 1);
+	}
+
+	class CContText
+	{
+	public:
+		NSStructures::CFont		m_oFont;
+		NSStructures::CBrush	m_oBrush;
+
+		CString m_strPickFontName;
+		LONG	m_lPickFontStyle;
+
+		CString m_strText;
+		CString m_strGidText;
+
+		double m_dX;
+		double m_dY;
+		double m_dWidth;
+		double m_dHeight;
+
+		double m_dWidthWithoutSpaces;
+		double m_dLeftWithoutSpaces;
+
+		double m_dPosition;
+		double m_dSpaceWidthMM;
+
+		double m_dCalculateWidth;
+
+	public:
+		CContText()
+		{
+			m_strText		= _T("");
+			m_strGidText	= _T("");
+
+			m_strPickFontName	= _T("");
+			m_lPickFontStyle	= 0;
+
+			m_dX			= 0;
+			m_dY			= 0;
+			m_dWidth		= 0;
+			m_dHeight		= 0;
+
+			m_dWidthWithoutSpaces	= 0;
+			m_dLeftWithoutSpaces	= 0;
+
+			m_dPosition		= 0;
+			m_dSpaceWidthMM	= 0;
+
+			m_dCalculateWidth = 0;
+		}
+		~CContText()
+		{
+		}
+
+		AVSINLINE void Clear()
+		{
+		}
+
+		CContText(const CContText& oSrc)
+		{
+			*this = oSrc;
+		}
+		CContText& operator=(const CContText& oSrc)
+		{
+			m_oFont		= oSrc.m_oFont;
+			m_oBrush	= oSrc.m_oBrush;
+
+			m_strText	 = oSrc.m_strText;
+			m_strGidText = oSrc.m_strGidText;
+
+			m_strPickFontName	= oSrc.m_strPickFontName;
+			m_lPickFontStyle	= oSrc.m_lPickFontStyle;
+
+			m_dX		= oSrc.m_dX;
+			m_dY		= oSrc.m_dY;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_dWidthWithoutSpaces	= oSrc.m_dWidthWithoutSpaces;
+			m_dLeftWithoutSpaces	= oSrc.m_dLeftWithoutSpaces;
+
+			m_dPosition = oSrc.m_dPosition;
+			m_dSpaceWidthMM = oSrc.m_dSpaceWidthMM;
+
+			m_dCalculateWidth = oSrc.m_dCalculateWidth;
+
+			return *this;
+		}
+
+		AVSINLINE bool IsBigger(const CContText* oSrc)
+		{
+			return (m_dX > oSrc->m_dX) ? true : false;
+		}
+		AVSINLINE bool IsBiggerOrEqual(const CContText* oSrc)
+		{
+			return (m_dX >= oSrc->m_dX) ? true : false;
+		}
+
+		AVSINLINE void Write(NSDocxRenderer::CStringWriter& oWriter, CFontManagerLight* pManagerLight, bool bIsAddSpace = false)
+		{
+			oWriter.WriteString(g_bstr_text_run_Start);
+
+			if (m_dWidth != m_dWidthWithoutSpaces)
+			{
+				DeleteSpaces(m_strText);
+				m_dWidth = m_dWidthWithoutSpaces;
+			}
+			
+			if (_T("") == m_strPickFontName)
+			{
+				if (m_oFont.Bold)
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (m_oFont.Italic)
+					oWriter.WriteString(g_bstr_text_italic_true);
+
+				if (bIsAddSpace)
+				{
+					m_dWidth  += m_dSpaceWidthMM;
+					m_strText += _T(" ");
+				}
+			}
+			else
+			{
+				if (0x01 == (0x01 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (0x02 == (0x02 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_italic_true);
+
+				if (bIsAddSpace)
+				{
+					m_dWidth  += pManagerLight->GetSpaceWidth();
+					m_strText += _T(" ");
+				}
+
+				//  ...
+				double ___dSize = (double)((LONG)(m_oFont.Size * 2)) / 2;
+				pManagerLight->LoadFont(m_strPickFontName, m_lPickFontStyle, ___dSize, FALSE);
+				double dWidth = pManagerLight->MeasureStringWidth(m_strText);
+
+				if (fabs(dWidth - m_dWidth) > 2)
+				{
+					double dSpacing = (m_dWidth - dWidth) / (m_strText.GetLength() + 1);
+					dSpacing *= c_dMMToDx;
+
+					CString strSpacing = _T("");
+					strSpacing.Format(g_string_spacing_character, (LONG)dSpacing);
+					oWriter.WriteString(strSpacing);
+				}
+			}
+
+			CString strSize = _T("");
+			LONG lSize = (LONG)(2 * m_oFont.Size);
+			strSize.Format(g_string_text_font_size, lSize, lSize);
+			oWriter.WriteString(strSize);
+
+			CString strName = _T("");
+
+			if (_T("") == m_strPickFontName)
+				strName.Format(g_string_text_font_name, m_oFont.Name, m_oFont.Name, m_oFont.Name);
+			else
+				strName.Format(g_string_text_font_name, m_strPickFontName, m_strPickFontName, m_strPickFontName);
+
+			oWriter.WriteString(strName);
+
+			CString strColor = _T("");
+			strColor.Format(g_string_text_color, ConvertColor(m_oBrush.Color1));
+			oWriter.WriteString(strColor);
+
+			oWriter.WriteString(g_bstr_text_run_PropEnd);
+
+			oWriter.WriteString(g_bstr_text_run_text1);
+
+			CString strText = m_strText;
+			CorrectString(strText);
+
+			oWriter.WriteString(strText);
+			oWriter.WriteString(g_bstr_text_run_text2);
+
+			oWriter.WriteString(g_bstr_text_run_End);
+		}
+
+		AVSINLINE void WriteTo(double dSpacingMM, NSDocxRenderer::CStringWriter& oWriter, CFontManagerLight* pManagerLight)
+		{
+			oWriter.WriteString(g_bstr_text_run_Start);
+
+			double dSpaceMMSize = m_dSpaceWidthMM;
+			if (_T("") == m_strPickFontName)
+			{
+				if (m_oFont.Bold)
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (m_oFont.Italic)
+					oWriter.WriteString(g_bstr_text_italic_true);
+			}
+			else
+			{
+				if (0x01 == (0x01 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (0x02 == (0x02 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_italic_true);
+
+				dSpaceMMSize = pManagerLight->GetSpaceWidth();
+			}
+
+			CString strSize = _T("");
+			LONG lSize = (LONG)(2 * m_oFont.Size);
+			strSize.Format(g_string_text_font_size, lSize, lSize);
+			oWriter.WriteString(strSize);
+
+			CString strName = _T("");
+
+			if (_T("") == m_strPickFontName)
+				strName.Format(g_string_text_font_name, m_oFont.Name, m_oFont.Name, m_oFont.Name);
+			else
+				strName.Format(g_string_text_font_name, m_strPickFontName, m_strPickFontName, m_strPickFontName);
+
+			oWriter.WriteString(strName);
+
+			CString strColor = _T("");
+			strColor.Format(g_string_text_color, ConvertColor(m_oBrush.Color1));
+			oWriter.WriteString(strColor);
+
+			LONG lSpacing = (LONG)((dSpacingMM - dSpaceMMSize) * c_dMMToDx);
+			CString strSpacing = _T("");
+			strSpacing.Format(g_string_spacing_character, lSpacing);
+			oWriter.WriteString(strSpacing);
+
+			oWriter.WriteString(g_bstr_text_run_PropEnd);
+
+			oWriter.WriteString(g_bstr_text_run_text1);
+
+			CString strText = _T(" ");
+			oWriter.WriteString(strText);
+			oWriter.WriteString(g_bstr_text_run_text2);
+
+			oWriter.WriteString(g_bstr_text_run_End);
+		}
+	};
+	
+	class CTextLine
+	{
+	public:
+		CAtlArray<CContText*> m_arConts;
+
+		double m_dBaselinePos;
+		double m_dBaselineOffset;
+
+		double m_dX;
+		double m_dY;
+		double m_dWidth;
+		double m_dHeight;
+
+	public:
+		CTextLine() : m_arConts()
+		{
+			m_dBaselinePos	= 0;
+			
+			m_dX			= 0;
+			m_dY			= 0;
+			m_dWidth		= 0;
+			m_dHeight		= 0;
+		}
+		AVSINLINE void Clear()
+		{
+			size_t nCount = m_arConts.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CContText* pText = m_arConts[i];
+				RELEASEOBJECT(pText);
+			}
+			m_arConts.RemoveAll();
+		}
+
+		~CTextLine()
+		{
+			Clear();
+		}
+
+		CTextLine(const CTextLine& oSrc)
+		{
+			*this = oSrc;
+		}
+		CTextLine& operator=(const CTextLine& oSrc)
+		{
+			Clear();
+			size_t nCount = oSrc.m_arConts.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				m_arConts.Add(new CContText(*oSrc.m_arConts[i]));
+			}
+
+			m_dBaselinePos	= oSrc.m_dBaselinePos;
+			m_dX			= oSrc.m_dX;
+			m_dY			= oSrc.m_dY;
+			m_dWidth		= oSrc.m_dWidth;
+			m_dHeight		= oSrc.m_dHeight;
+		}
+
+		AVSINLINE void AddCont(CContText* pCont, double dBaselineOffset)
+		{
+			if (0 == m_arConts.GetCount())
+				m_dBaselineOffset = dBaselineOffset;
+
+			if ( ( pCont->m_dX > 0 ) && ( ( m_dX == 0 ) || ( pCont->m_dX < m_dX ) ) )
+				m_dX = pCont->m_dX;
+
+			if (m_dHeight < pCont->m_dHeight)
+				m_dHeight = pCont->m_dHeight;
+
+			m_arConts.Add(pCont);
+		}
+
+		AVSINLINE bool IsBigger(const CTextLine* oSrc)
+		{
+			return (m_dBaselinePos > oSrc->m_dBaselinePos) ? true : false;
+		}
+		AVSINLINE bool IsBiggerOrEqual(const CTextLine* oSrc)
+		{
+			return (m_dBaselinePos >= oSrc->m_dBaselinePos) ? true : false;
+		}
+
+		AVSINLINE void SortConts()
+		{
+			//     m_dX
+			SortElements(m_arConts);
+		}
+
+		void Merge(CTextLine* pTextLine)
+		{
+			size_t nCount = pTextLine->m_arConts.GetCount();
+			if (0 != nCount)
+			{
+				if (pTextLine->m_dX < m_dX)
+				{
+					m_dX = pTextLine->m_dX;
+				}
+				if (pTextLine->m_dBaselinePos < m_dBaselinePos)
+				{
+					m_dHeight = (m_dBaselinePos - pTextLine->m_dBaselinePos + pTextLine->m_dHeight);
+				}
+				else
+				{
+					m_dHeight = (pTextLine->m_dBaselinePos - m_dBaselinePos + m_dHeight);
+				}
+
+				double dSubPosition = m_dBaselinePos - pTextLine->m_dBaselinePos;
+				
+				for (size_t i = 0; i < nCount; ++i)
+				{
+					pTextLine->m_arConts[i]->m_dPosition = dSubPosition;
+					m_arConts.Add(pTextLine->m_arConts[i]);
+				}
+			}			
+		}
+
+		void ToXml(NSDocxRenderer::CStringWriter& oWriter, CFontManagerLight* pManagerLight)
+		{
+			size_t nCountConts = m_arConts.GetCount();
+
+			if (0 == nCountConts)
+				return;
+
+			CContText* pPrev = m_arConts[0];
+			double dDelta = 0;
+
+			for (size_t i = 1; i < nCountConts; ++i)
+			{
+				CContText* pCurrent = m_arConts[i];
+
+				if (0 == pCurrent->m_dWidthWithoutSpaces)
+					continue;
+
+				dDelta = pCurrent->m_dLeftWithoutSpaces - (pPrev->m_dLeftWithoutSpaces + pPrev->m_dWidthWithoutSpaces);
+
+				if (dDelta < 0.5)
+				{
+					//        (font/brush)
+					pPrev->Write(oWriter, pManagerLight);
+					pPrev  = pCurrent;
+				}
+				//else if (dDelta < 2 * pPrev->m_dSpaceWidthMM)
+				//{
+				//	//  ,   -  
+				//	pPrev->Write(oWriter, pManagerLight, true);
+				//	pPrev = pCurrent;
+				//}
+				else
+				{
+					//   .    
+					pPrev->Write(oWriter, pManagerLight);
+					pPrev->WriteTo(dDelta, oWriter, pManagerLight);
+					pPrev = pCurrent;
+				}
+			}
+
+			pPrev->Write(oWriter, pManagerLight);
+		}
+	};
+
+	class CParagraph : public CBaseItem
+	{
+	public: 
+		// text frame properties
+		bool		m_bIsTextFrameProperties;
+
+		// geometry paragraph
+		double		m_dLeft;
+		double		m_dTop;
+		double		m_dWidth;
+		double		m_dHeight;
+
+		CFontManagerLight* m_pManagerLight;
+
+		double		m_dSpaceBefore;
+		TextAssociationType m_eTextAssociationType;
+
+		CAtlArray<CTextLine*> m_arLines;
+
+	public:
+		CParagraph(const TextAssociationType& eType) : m_arLines()
+		{
+			m_eType = etParagraph;
+
+			m_bIsTextFrameProperties	= false;
+
+			m_dLeft		= 0.0;
+			m_dTop		= 0.0;
+			m_dWidth	= 0.0;
+			m_dHeight	= 0.0;
+
+			m_dSpaceBefore = 0.0;
+
+			m_pManagerLight = NULL;
+			m_eTextAssociationType = eType;
+		}
+		CParagraph(const CParagraph& oSrc)
+		{
+			*this = oSrc;
+		}
+		~CParagraph()
+		{
+			Clear();
+		}
+
+		AVSINLINE void Clear()
+		{
+			size_t nCount = m_arLines.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CTextLine* pText = m_arLines[i];
+				RELEASEOBJECT(pText);
+			}
+			m_arLines.RemoveAll();
+
+			m_pManagerLight = NULL;
+		}
+
+		CParagraph& operator=(const CParagraph& oSrc)
+		{
+			m_eType = etParagraph;
+
+			m_bIsTextFrameProperties	= oSrc.m_bIsTextFrameProperties;
+
+			m_dLeft		= oSrc.m_dLeft;
+			m_dTop		= oSrc.m_dTop;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_dSpaceBefore	= oSrc.m_dSpaceBefore;
+
+			m_eTextAssociationType		= oSrc.m_eTextAssociationType;
+
+			Clear();
+			size_t nCount = oSrc.m_arLines.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				m_arLines.Add(new CTextLine(*oSrc.m_arLines[i]));
+			}
+
+			m_pManagerLight = oSrc.m_pManagerLight;
+
+			return *this;
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			oWriter.WriteString(g_bstr_text_par_start);
+
+			switch (m_eTextAssociationType)
+			{
+			case TextAssociationTypeDefault:
+			case TextAssociationTypeLine:
+				{
+					LONG lX		= (LONG)(m_dLeft * c_dMMToDx);
+					LONG lY		= (LONG)(m_dTop * c_dMMToDx);
+
+					CString strTextProps = _T("");
+					strTextProps.Format(g_string_par_props_mode2, lX, lY);
+					oWriter.WriteString(strTextProps);
+					break;
+				}
+			case TextAssociationTypeBlock:
+				{
+					LONG lX		= (LONG)(m_dLeft * c_dMMToDx);
+					LONG lY		= (LONG)(m_dTop * c_dMMToDx);
+
+					CString strTextProps = _T("");
+					strTextProps.Format(g_string_par_props_mode2, lX, lY);
+					oWriter.WriteString(strTextProps);
+					break;
+				}
+			case TextAssociationTypeNoFrames:
+				{
+					LONG lSpaceBefore	= (LONG)(m_dSpaceBefore * c_dMMToDx);
+					LONG lHeight		= (LONG)(m_dHeight * c_dMMToDx);
+					LONG lLeft			= (LONG)(m_dLeft * c_dMMToDx);
+					
+					CString strParProperties = _T("");
+					strParProperties.Format(g_string_text_paragraph_noframes, lSpaceBefore, lHeight, lLeft);
+
+					oWriter.WriteString(strParProperties);
+					break;
+				}
+			default:
+				break;
+			}
+
+			size_t nCount = m_arLines.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CTextLine* pTextLine = m_arLines[i];
+				pTextLine->SortConts();
+				pTextLine->ToXml(oWriter, m_pManagerLight);
+			}
+
+			oWriter.WriteString(g_bstr_text_par_end);
+		}
+	};
+}
\ No newline at end of file

DocxRenderer/src/logic/ElementShape.h

+#pragma once
+#include "Common.h"
+
+namespace NSDocxRenderer
+{
+	static _bstr_t g_vml_bstr_ClosePath			= L"x";
+	static _bstr_t g_vml_bstr_EndPath			= L"e";
+	static _bstr_t g_vml_bstr_NoFill			= L"nf";
+	static _bstr_t g_vml_bstr_NoStroke			= L"ns";
+	static CString g_vml_string_MoveTo			= _T("m%d,%d");
+	static CString g_vml_string_LineTo			= _T("l%d,%d");
+	static CString g_vml_string_CurveTo			= _T("c%d,%d %d,%d %d,%d");
+
+	static _bstr_t g_bstr_shape1				= L"<w:r><w:pict><v:shape id=\"\" o:spid=\"\" style=\"position:absolute;";
+	static _bstr_t g_bstr_shape2				= L"z-index:-1;mso-position-horizontal-relative:page;mso-position-vertical-relative:page;\"";
+	static CString g_string_shape_position		= _T("margin-left:%.2lfmm;margin-top:%.2lfmm;width:%.2lfmm;height:%.2lfmm;");
+
+	static CString g_string_shape_geometry		= _T(" coordsize=\"%d,%d\" path=\"%s\" fillcolor=\"#%06x\" strokecolor=\"#%06x\" strokeweight=\"%.2lfmm\">");
+
+	static CString g_string_tx_rid				= _T("<v:imagedata r:id=\"rId%d\" o:title=\"\"/>");
+	static CString g_string_fill_opacity		= _T("<v:fill opacity=\"%.2lf\"/>");
+	static CString g_string_stroke_opacity		= _T("<v:stroke opacity=\"%.2lf\"/>");
+
+	static _bstr_t g_bstr_shape3				= L"<w10:wrap anchorx=\"page\" anchory=\"page\"/></v:shape></w:pict></w:r>";
+
+	class CVectorGraphics
+	{
+	public:
+		double*	m_pData;
+		size_t	m_lSize;
+
+		double*	m_pDataCur;
+		size_t	m_lSizeCur;
+
+	public:
+		double m_dLeft;
+		double m_dTop;
+		double m_dRight;
+		double m_dBottom;
+
+	public:
+		CVectorGraphics()
+		{
+			m_pData = NULL;
+			m_lSize = 0;
+
+			m_pDataCur	= m_pData;
+			m_lSizeCur	= m_lSize;
+
+			End();
+		}
+		~CVectorGraphics()
+		{
+			RELEASEMEM(m_pData);
+		}
+
+		AVSINLINE void AddSize(size_t nSize)
+		{
+			if (NULL == m_pData)
+			{
+				m_lSize = max(nSize, 500);				
+				m_pData = (double*)malloc(m_lSize * sizeof(double));
+				
+				m_lSizeCur = 0;
+				m_pDataCur = m_pData;
+				return;
+			}
+
+			if ((m_lSizeCur + nSize) > m_lSize)
+			{
+				while ((m_lSizeCur + nSize) > m_lSize)
+				{
+					m_lSize *= 2;
+				}
+
+				double* pRealloc = (double*)realloc(m_pData, m_lSize * sizeof(double));
+				if (NULL != pRealloc)
+				{
+					//  
+					m_pData		= pRealloc;
+					m_pDataCur	= m_pData + m_lSizeCur;
+				}
+				else
+				{
+					double* pMalloc = (double*)malloc(m_lSize * sizeof(double));
+					memcpy(pMalloc, m_pData, m_lSizeCur * sizeof(double));
+
+					free(m_pData);
+					m_pData		= pMalloc;
+					m_pDataCur	= m_pData + m_lSizeCur;
+				}
+			}
+		}
+
+	public:
+		AVSINLINE void MoveTo(const double& x1, const double& y1)
+		{
+			AddSize(3);
+			*m_pDataCur = 0;	++m_pDataCur;
+
+			*m_pDataCur = x1;	++m_pDataCur;
+			*m_pDataCur = y1;	++m_pDataCur;
+
+			m_lSizeCur += 3;
+
+			CheckPoint(x1, y1);			
+		}
+		AVSINLINE void LineTo(const double& x1, const double& y1)
+		{
+			AddSize(3);
+			*m_pDataCur = 1;	++m_pDataCur;
+
+			*m_pDataCur = x1;	++m_pDataCur;
+			*m_pDataCur = y1;	++m_pDataCur;
+
+			m_lSizeCur += 3;
+
+			CheckPoint(x1, y1);
+		}
+		AVSINLINE void CurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
+		{
+			AddSize(7);
+			*m_pDataCur = 2;	++m_pDataCur;
+
+			*m_pDataCur = x1;	++m_pDataCur;
+			*m_pDataCur = y1;	++m_pDataCur;
+			*m_pDataCur = x2;	++m_pDataCur;
+			*m_pDataCur = y2;	++m_pDataCur;
+			*m_pDataCur = x3;	++m_pDataCur;
+			*m_pDataCur = y3;	++m_pDataCur;
+
+			m_lSizeCur += 7;
+
+			CheckPoint(x1, y1);
+			CheckPoint(x2, y2);
+			CheckPoint(x3, y3);
+		}
+		AVSINLINE void Close()
+		{
+			AddSize(1);
+			*m_pDataCur = 3;	++m_pDataCur;
+
+			m_lSizeCur += 1;
+		}
+
+		AVSINLINE size_t GetCurSize()
+		{
+			return m_lSizeCur;
+		}
+
+		AVSINLINE void Clear()
+		{
+			RELEASEMEM(m_pData);
+			
+			m_pData = NULL;
+			m_lSize = 0;
+
+			m_pDataCur	= m_pData;
+			m_lSizeCur	= 0;
+		}
+		AVSINLINE void ClearNoAttack()
+		{
+			m_pDataCur	= m_pData;
+			m_lSizeCur	= 0;
+		}
+
+		AVSINLINE void End()
+		{
+			ClearNoAttack();
+
+			m_dLeft		= 0xFFFFFF;
+			m_dTop		= 0xFFFFFF;
+			m_dRight	= -0xFFFFFF;
+			m_dBottom	= -0xFFFFFF;
+		}
+
+		AVSINLINE void CheckPoint(const double& x, const double& y)
+		{
+			if (m_dLeft > x)
+				m_dLeft = x;
+			if (m_dRight < x)
+				m_dRight = x;
+			if (m_dTop > y)
+				m_dTop = y;
+			if (m_dBottom < y)
+				m_dBottom = y;
+		}
+	};
+
+	class CShape : public CBaseItem
+	{
+	public:
+		CString m_strPath;
+		NSStructures::CBrush	m_oBrush;
+		NSStructures::CPen		m_oPen;
+
+		double m_dLeft;
+		double m_dTop;
+		double m_dWidth;
+		double m_dHeight;
+		
+		bool m_bIsFill;
+		bool m_bIsStroke;
+
+		LONG m_lCoordSizeX;
+		LONG m_lCoordSizeY;
+
+		LONG m_lTxId;
+
+	public:
+		CShape()
+		{
+			m_dLeft		= 0;
+			m_dTop		= 0;
+			m_dWidth	= 0;
+			m_dHeight	= 0;
+			
+			m_bIsFill	= false;
+			m_bIsStroke	= false;
+
+			m_lCoordSizeX	= 100000;
+			m_lCoordSizeY	= 100000;
+
+			m_lTxId			= -1;
+		}
+
+		CShape(const CShape& oSrc)
+		{
+			*this = oSrc;
+		}
+
+		CShape& operator=(const CShape& oSrc)
+		{
+			m_eType		= etShape;
+			m_strPath	= oSrc.m_strPath;
+
+			m_oBrush	= oSrc.m_oBrush;
+			m_oPen		= oSrc.m_oPen;
+
+			m_dLeft		= oSrc.m_dLeft;
+			m_dTop		= oSrc.m_dTop;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_bIsFill	= oSrc.m_bIsFill;
+			m_bIsStroke	= oSrc.m_bIsStroke;
+
+			m_lTxId		= oSrc.m_lTxId;
+
+			return *this;
+		}
+
+		void CreateFromVectorData(CVectorGraphics* pVector, NSDocxRenderer::CStringWriter& oWriter, const LONG& lCoordSize, LONG lType)
+		{
+			m_dLeft		= pVector->m_dLeft;
+			m_dTop		= pVector->m_dTop;
+			m_dWidth	= pVector->m_dRight - m_dLeft;
+			m_dHeight	= pVector->m_dBottom - m_dTop;
+
+			m_lCoordSizeX = lCoordSize;
+			m_lCoordSizeY = lCoordSize;
+			
+			size_t nCount = pVector->GetCurSize();
+			double* pData = pVector->m_pData;
+			while (nCount > 0)
+			{
+				double dType = *pData++;
+				if (0 == dType)
+				{
+					LONG lX = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					CString strPath = _T("");
+					strPath.Format(g_vml_string_MoveTo, lX, lY);
+
+					oWriter.WriteString(strPath);
+
+					nCount -= 3;
+				}
+				else if (1 == dType)
+				{
+					LONG lX = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					CString strPath = _T("");
+					strPath.Format(g_vml_string_LineTo, lX, lY);
+
+					oWriter.WriteString(strPath);
+
+					nCount -= 3;
+				}
+				else if (2 == dType)
+				{
+					LONG lX1 = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY1 = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					LONG lX2 = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY2 = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					LONG lX3 = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY3 = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					CString strPath = _T("");
+					strPath.Format(g_vml_string_CurveTo, lX1, lY1, lX2, lY2, lX3, lY3);
+
+					oWriter.WriteString(strPath);
+
+					nCount -= 7;
+				}
+				else
+				{
+					oWriter.WriteString(g_vml_bstr_ClosePath);
+					--nCount;
+				}
+			}
+
+			if (0x00 == (lType & 0x01))
+				oWriter.WriteString(g_vml_bstr_NoStroke);
+			if (0x00 == (lType >> 8))
+				oWriter.WriteString(g_vml_bstr_NoFill);
+
+			oWriter.WriteString(g_vml_bstr_EndPath);
+
+			m_strPath = oWriter.GetData();
+			oWriter.ClearNoAttack();
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			oWriter.WriteString(g_bstr_shape1);
+
+			CString strPosition = _T("");
+			strPosition.Format(g_string_shape_position, m_dLeft, m_dTop, m_dWidth, m_dHeight);
+			oWriter.WriteString(strPosition);
+
+			oWriter.WriteString(strPosition);
+			oWriter.WriteString(g_bstr_shape2);
+
+			CString strStyle = _T("");
+			strStyle.Format(g_string_shape_geometry, m_lCoordSizeX, m_lCoordSizeY, m_strPath, ConvertColor(m_oBrush.Color1), ConvertColor(m_oPen.Color), m_oPen.Size);
+			oWriter.WriteString(strStyle);
+
+			if (c_BrushTypeTexture == m_oBrush.Type)
+			{
+				CString strImage = _T("");
+				strImage.Format(g_string_tx_rid, 10 + m_lTxId);
+				oWriter.WriteString(strImage);
+
+				if (0xFF != m_oBrush.TextureAlpha)
+				{
+					CString strFillOpacity = _T("");
+					strFillOpacity.Format(g_string_fill_opacity, (double)m_oBrush.TextureAlpha / 255.0);
+					oWriter.WriteString(strFillOpacity);
+				}
+			}
+			else
+			{
+				if (0xFF != m_oBrush.Alpha1)
+				{
+					CString strFillOpacity = _T("");
+					strFillOpacity.Format(g_string_fill_opacity, (double)m_oBrush.Alpha1 / 255.0);
+					oWriter.WriteString(strFillOpacity);
+				}
+				if (0xFF != m_oPen.Alpha)
+				{
+					CString strPenOpacity = _T("");
+					strPenOpacity.Format(g_string_stroke_opacity, (double)m_oPen.Alpha / 255.0);
+					oWriter.WriteString(strPenOpacity);
+				}
+			}
+
+			oWriter.WriteString(g_bstr_shape3);
+		}
+	};
+}
\ No newline at end of file

DocxRenderer/src/logic/FontManager.h

+#pragma once
+#include "Common.h"
+#include "FontManagerBase.h"
+
+namespace NSDocxRenderer
+{
+	using namespace NSFontManager;
+
+	const double c_dDpiX		= 72.0;
+	const double c_dDpiY		= 72.0;
+
+	enum TextAssociationType
+	{
+		TextAssociationTypeDefault	= 0,
+		TextAssociationTypeLine		= 1,
+		TextAssociationTypeNoFrames	= 2,
+		TextAssociationTypeBlock	= 3
+	};
+
+	class CFontTableEntry
+	{
+	public:
+		CString							m_strFamilyName;
+		CString							m_strPANOSE;
+		LONG							m_lStyle;
+		CAtlArray<DWORD>				m_arSignature;
+		bool							m_bIsFixedWidth;
+
+	public:
+		CFontTableEntry() : m_arSignature()
+		{
+			m_strFamilyName		= _T("");
+			m_strPANOSE			= _T("");
+			m_lStyle			= 0;
+			m_bIsFixedWidth		= false;
+		}
+		~CFontTableEntry()
+		{
+		}
+		CFontTableEntry(const CFontTableEntry& oSrc)
+		{
+			*this = oSrc;
+		}
+		CFontTableEntry& operator =(const CFontTableEntry& oSrc)
+		{
+			m_strFamilyName	= oSrc.m_strFamilyName;
+			m_strPANOSE		= oSrc.m_strPANOSE;
+			m_lStyle		= oSrc.m_lStyle;
+			m_arSignature.Copy(oSrc.m_arSignature);
+			m_bIsFixedWidth	= oSrc.m_bIsFixedWidth;
+
+			return *this;
+		}
+	};
+
+	class CFontTable
+	{
+	public:
+		CAtlMap<CString, CFontTableEntry> m_mapTable;
+
+	public:
+		CFontTable() : m_mapTable()
+		{
+		}
+	};
+
+	class CFontManager : public CFontManagerBase
+	{
+	public:
+		NSStructures::CFont*			m_pFont;
+		NSDocxRenderer::CMatrix*		m_pTransform;
+		double							m_dSpaceWidthMM;
+
+	public:
+		CFontTable						m_oFontTable;
+
+	public:
+		CFontManager() : m_pFont(NULL), CFontManagerBase()
+		{
+			m_pTransform = NULL;
+
+			m_dSpaceWidthMM = 0;
+		}
+		virtual ~CFontManager()
+		{
+		}
+
+	public:
+		AVSINLINE void Init()
+		{
+			m_oFontTable.m_mapTable.RemoveAll();
+		}
+		AVSINLINE void AddFontToMap()
+		{
+			CAtlMap<CString, CFontTableEntry>::CPair* pPair = m_oFontTable.m_mapTable.Lookup(m_oFont.m_strFamilyName);
+			if (NULL == pPair)
+			{
+				CFontTableEntry oEntry;
+				oEntry.m_strFamilyName	= m_oFont.m_strFamilyName;
+				oEntry.m_strPANOSE		= m_oFont.m_strPANOSE;
+				oEntry.m_lStyle			= m_oFont.m_lStyle;
+				oEntry.m_bIsFixedWidth	= m_oFont.m_bIsFixedWidth;
+				oEntry.m_arSignature.Copy(m_oFont.m_arSignature);
+
+				m_oFontTable.m_mapTable.SetAt(m_oFont.m_strFamilyName, oEntry);
+			}
+		}
+
+	public:
+		virtual void LoadFont(long lFaceIndex = 0, bool bNeedAddToMap = true)
+		{
+			if (NULL == m_pManager)
+				return;
+
+			double dSize = m_pFont->Size;
+			double dSizeFont = dSize * ((m_pTransform->m_agg_mtx.sx + m_pTransform->m_agg_mtx.sy) / 2);
+
+			double dPix = m_pFont->CharSpace / c_dPixToMM;
+
+			m_pFont->Size = dSizeFont;
+
+			if (m_pFont->IsEqual2(&m_oFont.m_oFont))
+			{
+				m_pFont->Size = dSize;
+				m_pManager->SetCharSpacing(dPix);
+				m_pManager->SetStringGID(m_oFont.m_oFont.StringGID);
+				return;
+			}
+
+			m_oFont.m_oFont	= *m_pFont;
+			m_pFont->Size = dSize;
+
+			bool bIsPath = false;
+
+			if (_T("") == m_pFont->Path)
+			{
+				CFontManagerBase::LoadFontByName(m_oFont.m_oFont.Name, m_oFont.m_oFont.Size, m_oFont.m_oFont.GetStyle(), c_dDpiX, c_dDpiY);
+			}
+			else
+			{
+				CFontManagerBase::LoadFontByFile(m_oFont.m_oFont.Path, m_oFont.m_oFont.Size, c_dDpiX, c_dDpiY, lFaceIndex);
+
+				m_pFont->SetStyle(m_oFont.m_lStyle);
+				m_oFont.m_oFont.SetStyle(m_oFont.m_lStyle);
+
+				bIsPath = true;
+			}
+
+			long lGid = 0;
+			m_pManager->GetStringGID(&lGid);
+			m_pManager->SetStringGID(FALSE);
+			
+			m_pManager->LoadString(L" ", 0, 0);
+			float _x = 0;
+			float _y = 0;
+			float _w = 0;
+			float _h = 0;
+
+			m_pManager->MeasureString2(&_x, &_y, &_w, &_h);
+
+			m_dSpaceWidthMM = (double)_w * c_dPixToMM;
+			if (0 >= m_dSpaceWidthMM)
+			{
+				m_dSpaceWidthMM = 1.0;
+			}
+
+			m_pManager->SetStringGID(lGid);
+
+			LoadFontMetrics();
+			LoadFontParams(bIsPath);
+
+			if (bNeedAddToMap)
+				AddFontToMap();
+		}
+		
+		AVSINLINE void MeasureString(const CString& strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			BSTR bsText = strText.AllocSysString();
+			MeasureString(bsText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			SysFreeString(bsText);
+		}
+		AVSINLINE void MeasureStringUNICODE(const CString& strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			m_pManager->SetStringGID(FALSE);
+			MeasureString(strText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			m_pManager->SetStringGID(TRUE);
+		}
+		AVSINLINE void MeasureStringUNICODE(BSTR strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			m_pManager->SetStringGID(FALSE);
+			MeasureString(strText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			m_pManager->SetStringGID(TRUE);
+		}
+		void MeasureString(BSTR bsText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			LoadFont();
+
+			dBoxX		= 0;
+			dBoxY		= 0;
+			dBoxWidth	= 0;
+			dBoxHeight	= 0;
+
+			if (NULL == m_pManager)
+				return;
+
+			m_pManager->LoadString(bsText, (float)x, (float)y);
+
+			float fx		= 0;
+			float fy		= 0;
+			float fwidth	= 0;
+			float fheight	= 0;
+
+			if (MeasureTypeGlyph == measureType)
+			{
+				m_pManager->MeasureString(&fx, &fy, &fwidth, &fheight);
+			}
+			else if (MeasureTypePosition == measureType)
+			{
+				m_pManager->MeasureString2(&fx, &fy, &fwidth, &fheight);
+			}
+
+			dBoxX		= (double)fx;
+			dBoxY		= (double)fy;
+			dBoxWidth	= (double)fwidth;
+			dBoxHeight	= (double)fheight;
+
+			//   
+			dBoxX		*= c_dPixToMM;
+			dBoxY		*= c_dPixToMM;
+			dBoxWidth	*= c_dPixToMM;
+			dBoxHeight	*= c_dPixToMM;
+		}
+
+
+		__forceinline double GetBaseLineOffset()
+		{
+			LoadFont();
+
+			double d1 = 3 * (m_oFont.m_dLineSpacing - m_oFont.m_dDescent) - m_oFont.m_dAscent;
+			d1 /= 2.0;
+
+			d1 *= (m_oFont.m_oFont.Size / m_oFont.m_dEmHeight);
+			return d1;
+		}
+
+		__forceinline double GetFontHeight()
+		{
+			return c_dPtToMM * (m_oFont.m_dLineSpacing * m_oFont.m_oFont.Size ) / m_oFont.m_dEmHeight;
+		}
+
+		__forceinline void SetStringGid(const LONG& lGid)
+		{
+			if (NULL != m_pManager)
+				m_pManager->SetStringGID(lGid);
+		}
+
+		__forceinline void GenerateFontName2(CString& strText)
+		{
+			bool bIsNeedAddToMap = CFontManagerBase::GenerateFontName(strText);
+
+			if (bIsNeedAddToMap)
+			{
+				CAtlMap<CString, CFontTableEntry>::CPair* pPair = m_oFontTable.m_mapTable.Lookup(m_strCurrentPickFont);
+				if (NULL == pPair)
+				{
+					CFontTableEntry oEntry;
+					oEntry.m_strFamilyName	= m_strCurrentPickFont;
+					oEntry.m_strPANOSE		= m_oFont.m_strPANOSE;
+					oEntry.m_lStyle			= m_oFont.m_lStyle;
+					oEntry.m_bIsFixedWidth	= m_oFont.m_bIsFixedWidth;
+					oEntry.m_arSignature.Copy(m_oFont.m_arSignature);
+
+					m_oFontTable.m_mapTable.SetAt(m_oFont.m_oFont.Path, oEntry);
+				}
+			}
+		}
+	};
+
+	class CFontManagerLight
+	{
+	private:
+		CString m_strFontName;
+		LONG	m_lFontStyle;
+		double	m_dSize;
+
+		double	m_dSpaceWidth;
+
+		AVSGraphics::IASCFontManager*	m_pManager;
+	
+	public:
+		CFontManagerLight()
+		{
+			m_strFontName	= _T("");
+			m_lFontStyle	= 0;
+			m_dSize			= 0;
+			m_dSpaceWidth	= 0;
+
+			m_pManager = NULL;
+			CoCreateInstance(AVSGraphics::CLSID_CASCFontManager, NULL, CLSCTX_ALL, AVSGraphics::IID_IASCFontManager, (void**)&m_pManager);
+
+			m_pManager->Initialize(L"");
+			m_pManager->SetDefaultFont(L"Arial");
+		}
+		~CFontManagerLight()
+		{
+			RELEASEINTERFACE(m_pManager);
+		}
+
+		AVSINLINE double GetSpaceWidth()
+		{
+			return m_dSpaceWidth;
+		}
+
+	public:
+		AVSINLINE void LoadFont(CString& strFontName, LONG& lStyle, double& dSize, const BOOL& bIsGID)
+		{
+			if ((strFontName == m_strFontName) && (lStyle == m_lFontStyle) && (dSize == m_dSize))
+			{
+				m_pManager->SetStringGID(bIsGID);
+				return;
+			}
+
+			m_strFontName	= strFontName;
+			m_lFontStyle	= lStyle;
+			m_dSize			= dSize;
+
+			BSTR bsName = m_strFontName.AllocSysString();
+			m_pManager->LoadFontByName(bsName, (float)m_dSize, m_lFontStyle, c_dDpiX, c_dDpiY);
+			SysFreeString(bsName);
+
+			CString strSpace = _T(" ");
+			m_dSpaceWidth = MeasureStringWidth(strSpace);
+
+			m_pManager->SetStringGID(bIsGID);
+		}
+
+		AVSINLINE double MeasureStringWidth(CString& sText)
+		{
+			BSTR bsText = sText.AllocSysString();
+			m_pManager->LoadString(bsText, (float)0, (float)0);
+			SysFreeString(bsText);
+
+			float fx		= 0;
+			float fy		= 0;
+			float fwidth	= 0;
+			float fheight	= 0;
+
+			m_pManager->MeasureString2(&fx, &fy, &fwidth, &fheight);
+
+			return fwidth * c_dPixToMM;
+		}
+	};
+
+}
\ No newline at end of file

DocxRenderer/src/logic/FontManagerBase.h

+#pragma once
+
+#include "..\stdafx.h"
+#include "StringWriter.h"
+#include "..\Graphics\Structures.h"
+#include "..\Graphics\Matrix.h"
+
+namespace NSFontManager
+{
+	const double c_dInchToMM	= 25.4;
+	const double c_dPixToMM		= 25.4 / 72.0;
+	const double c_dPtToMM		= 25.4 / 72.0;
+	const double c_dMMToPt		= 72.0 / 25.4;
+
+	class CFontAdvanced
+	{
+	public:
+		NSStructures::CFont m_oFont;
+
+		// font metrics
+		double							m_dAscent;
+		double							m_dDescent;
+		double							m_dLineSpacing;
+		double							m_dEmHeight;
+
+		double							m_dBaselineOffset;
+
+		double							m_dSpaceWidthMM;
+
+		// font params
+		CString							m_strFamilyName;
+		CString							m_strPANOSE;
+		LONG							m_lStyle;
+		CAtlArray<DWORD>				m_arSignature;
+		bool							m_bIsFixedWidth;
+		LONG							m_lAvgWidth;
+
+	public:
+		CFontAdvanced()
+		{
+			m_oFont.SetDefaultParams();
+
+			m_dAscent			= 0;
+			m_dDescent			= 0;
+			m_dLineSpacing		= 0;
+			m_dEmHeight			= 0;
+
+			m_dBaselineOffset	= 0;
+
+			m_dSpaceWidthMM		= 0;
+
+			m_strFamilyName		= _T("");
+			m_strPANOSE			= _T("");
+			m_lStyle			= 0;
+			m_arSignature.RemoveAll();
+			m_bIsFixedWidth		= false;
+			m_lAvgWidth			= -1;
+		}
+
+		CFontAdvanced(const CFontAdvanced& oSrc)
+		{
+			*this = oSrc;
+		}
+
+		CFontAdvanced& operator=(const CFontAdvanced& oSrc)
+		{
+			m_oFont				= oSrc.m_oFont;
+
+			m_dAscent			= oSrc.m_dAscent;
+			m_dDescent			= oSrc.m_dDescent;
+			m_dLineSpacing		= oSrc.m_dLineSpacing;
+			m_dEmHeight			= oSrc.m_dEmHeight;
+
+			m_dBaselineOffset	= oSrc.m_dBaselineOffset;
+
+			m_dSpaceWidthMM		= oSrc.m_dSpaceWidthMM;
+
+			m_strFamilyName		= oSrc.m_strFamilyName;
+			m_strPANOSE			= oSrc.m_strPANOSE;
+			m_lStyle			= oSrc.m_lStyle;
+			m_arSignature.Copy(oSrc.m_arSignature);
+			m_bIsFixedWidth		= oSrc.m_bIsFixedWidth;
+			m_lAvgWidth			= oSrc.m_lAvgWidth;
+
+			return *this;
+		}
+	};
+
+	class CFontPickUp
+	{
+	public:
+		CFontAdvanced	m_oFont;
+		BYTE			m_lRangeNum;
+		BYTE			m_lRange;
+		CString			m_strPickFont;
+		LONG			m_lPickStyle;
+
+	public:
+		CFontPickUp() : m_oFont()
+		{
+			m_lRangeNum		= 0xFF;
+			m_lRange		= 0xFF;
+			m_strPickFont	= _T("");
+			m_lPickStyle	= 0;
+		}
+		CFontPickUp(const CFontPickUp& oSrc)
+		{
+			*this = oSrc;
+		}
+		CFontPickUp& operator=(const CFontPickUp& oSrc)
+		{
+			m_oFont			= oSrc.m_oFont;
+			m_lRange		= oSrc.m_lRange;
+			m_lRangeNum		= oSrc.m_lRangeNum;
+			m_strPickFont	= oSrc.m_strPickFont;
+			m_lPickStyle	= oSrc.m_lPickStyle;
+
+			return *this;
+		}
+	};
+
+	class CFontManagerBase
+	{
+	public:
+		enum MeasureType
+		{
+			MeasureTypeGlyph	= 0,
+			MeasureTypePosition	= 1
+		};
+
+	protected:
+		AVSGraphics::IASCWinFonts*		m_pWinFonts;
+		AVSGraphics::IASCFontManager*	m_pManager;
+		CString							m_strDefaultFont;
+
+	public:
+
+		CFontAdvanced					m_oFont;
+
+		//  
+		BYTE							m_pRanges[0xFFFF];
+		BYTE							m_pRangesNums[0xFFFF];
+
+		CAtlList<CFontPickUp>			m_arListPicUps;
+		CString							m_strCurrentPickFont;
+		LONG							m_lCurrentPictFontStyle;
+
+	public:
+		CFontManagerBase() : m_oFont()
+		{
+			m_pManager = NULL;
+			CoCreateInstance(AVSGraphics::CLSID_CASCFontManager, NULL, CLSCTX_ALL, AVSGraphics::IID_IASCFontManager, (void**)&m_pManager);
+
+			m_pManager->Initialize(L"");
+
+			SetDefaultFont(_T("Arial"));
+
+			ClearPickUps();
+
+			InitializeRanges();
+
+			ClearPickUps();
+		}
+		virtual ~CFontManagerBase()
+		{
+			RELEASEINTERFACE(m_pManager);
+		}
+
+		__forceinline void ClearPickUps()
+		{
+			m_arListPicUps.RemoveAll();
+			m_strCurrentPickFont = _T("");
+			m_lCurrentPictFontStyle = 0;
+		}
+
+	public:
+		__forceinline void SetDefaultFont(const CString& strName)
+		{
+			m_strDefaultFont = strName;
+
+			BSTR bsDefault = m_strDefaultFont.AllocSysString();
+			m_pManager->SetDefaultFont(bsDefault);
+			SysFreeString(bsDefault);
+		}
+		__forceinline CString GetDefaultFont()
+		{
+			return m_strDefaultFont;
+		}
+
+		virtual void LoadFont(long lFaceIndex = 0, bool bIsNeedAddToMap = true)
+		{
+		}
+
+		void LoadFontByName(CString& strName, const double& dSize, const LONG& lStyle, const double& dDpiX, const double& dDpiY)
+		{
+			BSTR bsName = strName.AllocSysString();
+			m_pManager->LoadFontByName(bsName, (float)dSize, lStyle, dDpiX, dDpiY);
+			SysFreeString(bsName);
+
+			LoadFontMetrics();
+			LoadFontParams();
+
+			m_oFont.m_lAvgWidth = -1;
+		}
+
+		void LoadFontByFile(CString& strPath, const double& dSize, const double& dDpiX, const double& dDpiY, const LONG& lFaceIndex)
+		{
+			BSTR bsPath = strPath.AllocSysString();
+			m_pManager->LoadFontFromFile(bsPath, (float)dSize, dDpiX, dDpiY, lFaceIndex);
+			SysFreeString(bsPath);
+
+			LoadFontMetrics();
+			LoadFontParams();
+
+			m_oFont.m_lAvgWidth = -1;
+
+			wchar_t wsDrive[MAX_PATH], wsDir[MAX_PATH], wsFilename[MAX_PATH], wsExt[MAX_PATH];
+			_wsplitpath( strPath.GetBuffer(), wsDrive, wsDir, wsFilename, wsExt );
+			CString wsEncodingPath = CString(wsDrive) + CString(wsDir) + CString(wsFilename) + CString(_T(".enc"));
+
+			bool bIsCID = false;
+			CString strExt(wsExt);
+			if (-1 != strExt.Find(_T("cid")))
+				bIsCID = true;
+
+			XmlUtils::CXmlNode oMainNode;
+			oMainNode.FromXmlFile(wsEncodingPath);
+
+			if (_T("PDF-resources") == oMainNode.GetName())
+			{
+				if (bIsCID)
+				{
+					XmlUtils::CXmlNode oType0Node;
+					if ( oMainNode.GetNode( _T("Type0"), oType0Node ) )
+					{
+						XmlUtils::CXmlNode oNode;
+						if ( oType0Node.GetNode( _T("DescendantFonts"), oNode ) )
+						{
+							XmlUtils::CXmlNode oDescNode;
+							if ( oNode.GetNode( _T("FontDescriptor"), oDescNode ) )
+							{
+								XmlUtils::CXmlNode oCurNode;
+								if ( oNode.GetNode( _T("AvgWidth"), oCurNode ) )
+								{
+									CString sValue = oCurNode.GetAttribute( _T("value") );
+									m_oFont.m_lAvgWidth = XmlUtils::GetInteger( sValue );
+								}
+							}
+						}
+					}
+				}
+				else
+				{
+					XmlUtils::CXmlNode oNode;
+					if ( oMainNode.GetNode( _T("FontDescriptor"), oNode ) )
+					{
+						XmlUtils::CXmlNode oCurNode;
+						if ( oNode.GetNode( _T("AvgWidth"), oCurNode ) )
+						{
+							CString sValue = oCurNode.GetAttribute( _T("value") );
+							m_oFont.m_lAvgWidth = XmlUtils::GetInteger( sValue );
+						}
+					}
+				}
+			}
+		}
+
+	public:
+	
+		__forceinline void MeasureString(const CString& strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			BSTR bsText = strText.AllocSysString();
+			MeasureString(bsText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			SysFreeString(bsText);
+		}
+		__forceinline void MeasureStringUNICODE(const CString& strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			m_pManager->SetStringGID(FALSE);
+			MeasureString(strText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			m_pManager->SetStringGID(TRUE);
+		}
+		__forceinline void MeasureStringUNICODE(BSTR strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			m_pManager->SetStringGID(FALSE);
+			MeasureString(strText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			m_pManager->SetStringGID(TRUE);
+		}
+		virtual void MeasureString(BSTR bsText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+		}
+		virtual void CalculateBaselineOffset()
+		{
+			LoadFont();
+
+			double d1 = 3 * (m_oFont.m_dLineSpacing - m_oFont.m_dDescent) - m_oFont.m_dAscent;
+			d1 /= 2.0;
+
+			d1 *= (m_oFont.m_oFont.Size / m_oFont.m_dEmHeight);
+			m_oFont.m_dBaselineOffset = d1;
+		}
+
+	public:
+		void LoadFontMetrics()
+		{
+			unsigned short iTemp = 0;
+			m_pManager->GetCellAscent(&iTemp);
+			m_oFont.m_dAscent = iTemp;
+			m_pManager->GetCellDescent(&iTemp);
+			m_oFont.m_dDescent = iTemp;
+			m_pManager->GetLineSpacing(&iTemp);
+			m_oFont.m_dLineSpacing = iTemp;
+			m_pManager->GetEmHeight(&iTemp);
+			m_oFont.m_dEmHeight = iTemp;
+
+			m_oFont.m_dBaselineOffset = (c_dPtToMM * m_oFont.m_dDescent * m_oFont.m_oFont.Size / m_oFont.m_dEmHeight);
+		}
+
+		__forceinline CString ToHexString( BYTE uc )
+		{
+			CString strRes = _T("");
+			strRes.Format(_T("%02X"), uc);
+			return strRes;
+		}
+
+		void LoadFontParams(BOOL bIsPath = TRUE)
+		{
+			//      
+			if (NULL == m_pManager)
+				return;
+
+			if (_T("") == m_oFont.m_oFont.Name)
+			{
+				// FamilyName
+				BSTR bsFamilyName = NULL;
+				m_pManager->GetFamilyNameEx(_bstr_t("<DeletePDFPrefix/>"), &bsFamilyName);
+				m_oFont.m_strFamilyName = (CString)bsFamilyName;
+				SysFreeString(bsFamilyName);
+			}
+			else
+			{
+				m_oFont.m_strFamilyName = m_oFont.m_oFont.Name;
+			}
+
+			// StyleName
+			BSTR bsStyleName = NULL;
+			m_pManager->GetStyleName(&bsStyleName);
+			CString strStyle = (CString)bsStyleName;
+			SysFreeString(bsStyleName);
+
+			if (_T("Bold") == strStyle)
+			{
+				m_oFont.m_lStyle = 0x01;
+			}
+			else if (_T("Italic") == strStyle)
+			{
+				m_oFont.m_lStyle = 0x02;
+			}
+			else if (_T("Bold Italic") == strStyle)
+			{
+				m_oFont.m_lStyle = 0x03;				
+			}
+			else
+			{
+				m_oFont.m_lStyle = 0x00;
+			}
+
+			// PANOSE
+			SAFEARRAY* panoseSafeArray = NULL;
+			m_oFont.m_strPANOSE = _T("");
+			m_pManager->GetPanose(&panoseSafeArray);
+
+			if (NULL != panoseSafeArray)
+			{
+				LONG lCount = panoseSafeArray->rgsabound[0].cElements;
+				BYTE* pData = (BYTE*)(panoseSafeArray->pvData);
+
+				for ( LONG i = 0; i < (LONG)( lCount ); i++ )
+				{
+					m_oFont.m_strPANOSE += ToHexString(pData[i]);
+				}
+
+				SafeArrayDestroy(panoseSafeArray);
+			}
+
+			// IsFixed
+			LONG lIsFixedWidthLong = 0;
+			m_pManager->IsFixedWidth(&lIsFixedWidthLong);
+			m_oFont.m_bIsFixedWidth = (lIsFixedWidthLong != 0) ? true : false;
+
+			// Signature
+			VARIANT_BOOL vbSuccess = VARIANT_FALSE;
+			m_oFont.m_arSignature.RemoveAll();
+
+			for ( unsigned int i = 0; i < 6; i++ )
+			{
+				DWORD value = 0;
+
+				for ( unsigned long bit = 0; bit < 32; bit++ )
+				{
+					m_pManager->IsUnicodeRangeAvailable( bit, i, &vbSuccess );
+
+					if( VARIANT_TRUE == vbSuccess )
+					{
+						value |= ( 1 << bit );
+					}
+				}
+
+				m_oFont.m_arSignature.Add(value);
+			}
+		}
+
+	private:
+		void InitializeRanges()
+		{
+			memset(m_pRanges, 0xFF, 0xFFFF);
+			memset(m_pRangesNums, 0xFF, 0xFFFF);
+
+			//       
+			int nStart = 0;
+			int nCount = 0;
+			
+			// rangeNum 0
+			// case 00: sUCRName = "Basic Latin"; break; /* U+0020-U+007E */
+			nStart = 0x0020;
+			nCount = 0x007E - nStart + 1;
+			memset(m_pRanges + nStart, 0, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+			
+            //case 01: sUCRName = "Latin-1 Supplement"; break; /* U+0080-U+00FF */
+			nStart = 0x0080;
+			nCount = 0x00FF - nStart + 1;
+			memset(m_pRanges + nStart, 1, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 02: sUCRName = "Latin Extended-A"; break; /* U+0100-U+017F */
+			nStart = 0x0100;
+			nCount = 0x017F - nStart + 1;
+			memset(m_pRanges + nStart, 2, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 03: sUCRName = "Latin Extended-B"; break; /* U+0180-U+024F */
+			nStart = 0x0180;
+			nCount = 0x024F - nStart + 1;
+			memset(m_pRanges + nStart, 3, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 04: sUCRName = "IPA Extensions"; break; /* U+0250-U+02AF */ /* U+1D00-U+1D7F */ /* U+1D80-U+1DBF */
+			nStart = 0x0250;
+			nCount = 0x02AF - nStart + 1;
+			memset(m_pRanges + nStart, 4, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x1D00;
+			nCount = 0x1D7F - nStart + 1;
+			memset(m_pRanges + nStart, 4, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x1D80;
+			nCount = 0x1DBF - nStart + 1;
+			memset(m_pRanges + nStart, 4, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			//case 05: sUCRName = "Spacing Modifier Letters"; break; /* U+02B0-U+02FF */ /* U+A700-U+A71F */
+			nStart = 0x02B0;
+			nCount = 0x02FF - nStart + 1;
+			memset(m_pRanges + nStart, 5, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0xA700;
+			nCount = 0xA71F - nStart + 1;
+			memset(m_pRanges + nStart, 5, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 06: sUCRName = "Combining Diacritical Marks"; break; /* U+0300-U+036F */ /* U+1DC0-U+1DFF */
+			nStart = 0x0300;
+			nCount = 0x036F - nStart + 1;
+			memset(m_pRanges + nStart, 6, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x1DC0;
+			nCount = 0x1DFF - nStart + 1;
+			memset(m_pRanges + nStart, 6, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 07: sUCRName = "Greek and Coptic"; break; /* U+0370-U+03FF */
+			nStart = 0x0370;
+			nCount = 0x03FF - nStart + 1;
+			memset(m_pRanges + nStart, 7, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 08: sUCRName = "Coptic"; break; /* U+2C80-U+2CFF */
+			nStart = 0x2C80;
+			nCount = 0x2CFF - nStart + 1;
+			memset(m_pRanges + nStart, 8, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+			
+            //case 09: sUCRName = "Cyrillic"; break; /* U+0400-U+04FF */ /* U+0500-U+052F */ /* U+2DE0-U+2DFF */ /* U+A640-U+A69F */
+			nStart = 0x0400;
+			nCount = 0x04FF - nStart + 1;
+			memset(m_pRanges + nStart, 9, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x0500;
+			nCount = 0x052F - nStart + 1;
+			memset(m_pRanges + nStart, 9, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x2DE0;
+			nCount = 0x2DFF - nStart + 1;
+			memset(m_pRanges + nStart, 9, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0xA640;
+			nCount = 0xA69F - nStart + 1;
+			memset(m_pRanges + nStart, 9, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 10: sUCRName = "Armenian"; break; /* U+0530-U+058F */
+			nStart = 0x0530;
+			nCount = 0x058F - nStart + 1;
+			memset(m_pRanges + nStart, 10, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 11: sUCRName = "Hebrew"; break; /* U+0590-U+05FF */
+			nStart = 0x0590;
+			nCount = 0x05FF - nStart + 1;
+			memset(m_pRanges + nStart, 11, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 12: sUCRName = "Vai"; break; /* U+A500-U+A63F */
+			nStart = 0xA500;
+			nCount = 0xA63F - nStart + 1;
+			memset(m_pRanges + nStart, 12, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 13: sUCRName = "Arabic"; break; /* U+0600-U+06FF */ /* U+0750-U+077F */
+			nStart = 0x0600;
+			nCount = 0x06FF - nStart + 1;
+			memset(m_pRanges + nStart, 13, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x0750;
+			nCount = 0x077F - nStart + 1;
+			memset(m_pRanges + nStart, 13, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 14: sUCRName = "NKo"; break; /* U+07C0-U+07FF */
+			nStart = 0x07C0;
+			nCount = 0x07FF - nStart + 1;
+			memset(m_pRanges + nStart, 14, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 15: sUCRName = "Devanagari"; break; /* U+0900-U+097F */
+			nStart = 0x0900;
+			nCount = 0x097F - nStart + 1;
+			memset(m_pRanges + nStart, 15, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 16: sUCRName = "Bengali"; break; /* U+0980-U+09FF */
+			nStart = 0x0980;
+			nCount = 0x09FF - nStart + 1;
+			memset(m_pRanges + nStart, 16, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 17: sUCRName = "Gurmukhi"; break; /* U+0A00-U+0A7F */
+			nStart = 0x0A00;
+			nCount = 0x0A7F - nStart + 1;
+			memset(m_pRanges + nStart, 17, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 18: sUCRName = "Gujarati"; break; /* U+0A80-U+0AFF */
+			nStart = 0x0A80;
+			nCount = 0x0AFF - nStart + 1;
+			memset(m_pRanges + nStart, 18, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 19: sUCRName = "Oriya"; break; /* U+0B00-U+0B7F */
+			nStart = 0x0B00;
+			nCount = 0x0B7F - nStart + 1;
+			memset(m_pRanges + nStart, 19, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 20: sUCRName = "Tamil"; break; /* U+0B80-U+0BFF */
+			nStart = 0x0B80;
+			nCount = 0x0BFF - nStart + 1;
+			memset(m_pRanges + nStart, 20, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 21: sUCRName = "Telugu"; break; /* U+0C00-U+0C7F */
+			nStart = 0x0C00;
+			nCount = 0x0C7F - nStart + 1;
+			memset(m_pRanges + nStart, 21, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 22: sUCRName = "Kannada"; break; /* U+0C80-U+0CFF */
+			nStart = 0x0C80;
+			nCount = 0x0CFF - nStart + 1;
+			memset(m_pRanges + nStart, 22, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 23: sUCRName = "Malayalam"; break; /* U+0D00-U+0D7F */
+			nStart = 0x0D00;
+			nCount = 0x0D7F - nStart + 1;
+			memset(m_pRanges + nStart, 23, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 24: sUCRName = "Thai"; break; /* U+0E00-U+0E7F */
+			nStart = 0x0E00;
+			nCount = 0x0E7F - nStart + 1;
+			memset(m_pRanges + nStart, 24, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 25: sUCRName = "Lao"; break; /* U+0E80-U+0EFF */
+			nStart = 0x0E80;
+			nCount = 0x0EFF - nStart + 1;
+			memset(m_pRanges + nStart, 25, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 26: sUCRName = "Georgian"; break; /* U+10A0-U+10FF */ /* U+2D00-U+2D2F */
+			nStart = 0x10A0;
+			nCount = 0x10FF - nStart + 1;
+			memset(m_pRanges + nStart, 26, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x2D00;
+			nCount = 0x2D2F - nStart + 1;
+			memset(m_pRanges + nStart, 26, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 27: sUCRName = "Balinese"; break; /* U+1B00-U+1B7F */
+			nStart = 0x1B00;
+			nCount = 0x1B7F - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 28: sUCRName = "Hangul Jamo"; break; /* U+1100-U+11FF */
+			nStart = 0x1100;
+			nCount = 0x11FF - nStart + 1;
+			memset(m_pRanges + nStart, 28, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 29: sUCRName = "Latin Extended Additional"; break; /* U+1E00-U+1EFF */ /* U+2C60-U+2C7F */ /* U+A720-U+A7FF */
+			nStart = 0x1E00;
+			nCount = 0x1EFF - nStart + 1;
+			memset(m_pRanges + nStart, 29, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x2C60;
+			nCount = 0x2C7F - nStart + 1;
+			memset(m_pRanges + nStart, 29, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0xA720;
+			nCount = 0xA7FF - nStart + 1;
+			memset(m_pRanges + nStart, 29, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 30: sUCRName = "Greek Extended"; break; /* U+1F00-U+1FFF */
+			nStart = 0x1F00;
+			nCount = 0x1FFF - nStart + 1;
+			memset(m_pRanges + nStart, 30, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+            //case 31: sUCRName = "General Punctuation"; break; /* U+2000-U+206F */ /* U+2E00-U+2E7F */
+			nStart = 0x2000;
+			nCount = 0x206F - nStart + 1;
+			memset(m_pRanges + nStart, 31, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			nStart = 0x2E00;
+			nCount = 0x2E7F - nStart + 1;
+			memset(m_pRanges + nStart, 31, nCount);
+			memset(m_pRangesNums + nStart, 0, nCount);
+
+			// rangeNum 1
+			//case 00: sUCRName = "Superscripts And Subscripts"; break; /* U+2070-U+209F */
+			nStart = 0x2070;
+			nCount = 0x209F - nStart + 1;
+			memset(m_pRanges + nStart, 0, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 01: sUCRName = "Currency Symbols"; break; /* U+20A0-U+20CF */
+			nStart = 0x20A0;
+			nCount = 0x20CF - nStart + 1;
+			memset(m_pRanges + nStart, 1, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 02: sUCRName = "Combining Diacritical Marks For Symbols"; break; /* U+20D0-U+20FF */
+			nStart = 0x20D0;
+			nCount = 0x20FF - nStart + 1;
+			memset(m_pRanges + nStart, 2, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 03: sUCRName = "Letterlike Symbols"; break; /* U+2100-U+214F */
+			nStart = 0x2100;
+			nCount = 0x214F - nStart + 1;
+			memset(m_pRanges + nStart, 3, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 04: sUCRName = "Number Forms"; break; /* U+2150-U+218F */
+			nStart = 0x2150;
+			nCount = 0x218F - nStart + 1;
+			memset(m_pRanges + nStart, 4, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 05: sUCRName = "Arrows"; break; /* U+2190-U+21FF */ /* U+27F0-U+27FF */ /* U+2900-U+297F */ /* U+2B00-U+2BFF */
+			nStart = 0x2190;
+			nCount = 0x21FF - nStart + 1;
+			memset(m_pRanges + nStart, 5, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x27F0;
+			nCount = 0x27FF - nStart + 1;
+			memset(m_pRanges + nStart, 5, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x2900;
+			nCount = 0x297F - nStart + 1;
+			memset(m_pRanges + nStart, 5, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x2B00;
+			nCount = 0x2BFF - nStart + 1;
+			memset(m_pRanges + nStart, 5, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 06: sUCRName = "Mathematical Operators"; break; /* U+2200-U+22FF */ /* U+2A00-U+2AFF */ /* U+27C0-U+27EF */ /* U+2980-U+29FF */
+			nStart = 0x2200;
+			nCount = 0x22FF - nStart + 1;
+			memset(m_pRanges + nStart, 6, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x2A00;
+			nCount = 0x2AFF - nStart + 1;
+			memset(m_pRanges + nStart, 6, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x27C0;
+			nCount = 0x27EF - nStart + 1;
+			memset(m_pRanges + nStart, 6, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x2980;
+			nCount = 0x29FF - nStart + 1;
+			memset(m_pRanges + nStart, 6, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 07: sUCRName = "Miscellaneous Technical"; break; /* U+2300-U+23FF */
+			nStart = 0x2300;
+			nCount = 0x23FF - nStart + 1;
+			memset(m_pRanges + nStart, 7, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 08: sUCRName = "Control Pictures"; break; /* U+2400-U+243F */
+			nStart = 0x2400;
+			nCount = 0x243F - nStart + 1;
+			memset(m_pRanges + nStart, 8, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 09: sUCRName = "Optical Character Recognition"; break; /* U+2440-U+245F */
+			nStart = 0x2440;
+			nCount = 0x245F - nStart + 1;
+			memset(m_pRanges + nStart, 9, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 10: sUCRName = "Enclosed Alphanumerics"; break; /* U+2460-U+24FF */
+			nStart = 0x2460;
+			nCount = 0x24FF - nStart + 1;
+			memset(m_pRanges + nStart, 10, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 11: sUCRName = "Box Drawing"; break; /* U+2500-U+257F */
+			nStart = 0x2500;
+			nCount = 0x257F - nStart + 1;
+			memset(m_pRanges + nStart, 11, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 12: sUCRName = "Block Elements"; break; /* U+2580-U+259F */
+			nStart = 0x2580;
+			nCount = 0x259F - nStart + 1;
+			memset(m_pRanges + nStart, 12, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 13: sUCRName = "Geometric Shapes"; break; /* U+25A0-U+25FF */
+			nStart = 0x25A0;
+			nCount = 0x25FF - nStart + 1;
+			memset(m_pRanges + nStart, 13, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 14: sUCRName = "Miscellaneous Symbols"; break; /* U+2600-U+26FF */
+			nStart = 0x2600;
+			nCount = 0x26FF - nStart + 1;
+			memset(m_pRanges + nStart, 14, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 15: sUCRName = "Dingbats"; break; /* U+2700-U+27BF */
+			nStart = 0x2700;
+			nCount = 0x27BF - nStart + 1;
+			memset(m_pRanges + nStart, 15, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 16: sUCRName = "CJK Symbols and Punctuation"; break; /* U+3000-U+303F */
+			nStart = 0x3000;
+			nCount = 0x303F - nStart + 1;
+			memset(m_pRanges + nStart, 16, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 17: sUCRName = "Hiragana"; break;  /* U+3040-U+309F */
+			nStart = 0x3040;
+			nCount = 0x309F - nStart + 1;
+			memset(m_pRanges + nStart, 17, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 18: sUCRName = "Katakana"; break; /* U+30A0-U+30FF */ /* U+31F0-U+31FF */
+			nStart = 0x30A0;
+			nCount = 0x30FF - nStart + 1;
+			memset(m_pRanges + nStart, 18, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x31F0;
+			nCount = 0x31FF - nStart + 1;
+			memset(m_pRanges + nStart, 18, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 19: sUCRName = "Bopomofo"; break; /* U+3100-U+312F */ /* U+31A0-U+31BF */
+			nStart = 0x3100;
+			nCount = 0x312F - nStart + 1;
+			memset(m_pRanges + nStart, 19, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x31A0;
+			nCount = 0x31BF - nStart + 1;
+			memset(m_pRanges + nStart, 19, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 20: sUCRName = "Hangul Compatibility Jamo"; break; /* U+3130-U+318F */
+			nStart = 0x3130;
+			nCount = 0x318F - nStart + 1;
+			memset(m_pRanges + nStart, 20, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 21: sUCRName = "Phags-pa"; break; /* U+A840-U+A87F */
+			nStart = 0xA840;
+			nCount = 0xA87F - nStart + 1;
+			memset(m_pRanges + nStart, 21, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 22: sUCRName = "Enclosed CJK Letters and Months"; break; /* U+3200-U+32FF */
+			nStart = 0x3200;
+			nCount = 0x32FF - nStart + 1;
+			memset(m_pRanges + nStart, 22, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 23: sUCRName = "CJK Compatibility"; break; /* U+3300-U+33FF */
+			nStart = 0x3300;
+			nCount = 0x33FF - nStart + 1;
+			memset(m_pRanges + nStart, 23, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 24: sUCRName = "Hangul Syllables"; break; /* U+AC00-U+D7AF */
+			nStart = 0xAC00;
+			nCount = 0xD7AF - nStart + 1;
+			memset(m_pRanges + nStart, 24, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 25: sUCRName = "Non-Plane 0"; break; /* U+D800-U+DB7F */ /* U+DB80-U+DBFF */ /* U+DC00-U+DFFF */ //   
+			nStart = 0xD800;
+			nCount = 0xDB7F - nStart + 1;
+			memset(m_pRanges + nStart, 25, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0xDB80;
+			nCount = 0xDBFF - nStart + 1;
+			memset(m_pRanges + nStart, 25, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0xDC00;
+			nCount = 0xDFFF - nStart + 1;
+			memset(m_pRanges + nStart, 25, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 26: sUCRName = "Phoenician"; break; /*U+10900-U+1091F*/
+
+            //case 27: sUCRName = "CJK Unified Ideographs"; break; /* U+4E00-U+9FFF */ /* U+2E80-U+2EFF */ /* U+2F00-U+2FDF */ /* U+2FF0-U+2FFF */ /* U+3400-U+4DB5 */ /*U+20000-U+2A6D6*/ /* U+3190-U+319F */
+			nStart = 0x4E00;
+			nCount = 0x9FFF - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x2E80;
+			nCount = 0x2EFF - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x2F00;
+			nCount = 0x2FDF - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x2FF0;
+			nCount = 0x2FFF - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x3400;
+			nCount = 0x4DB5 - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0x3190;
+			nCount = 0x319F - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 28: sUCRName = "Private Use Area (plane 0)"; break; /* U+E000-U+F8FF */ //   
+			nStart = 0xE000;
+			nCount = 0xF8FF - nStart + 1;
+			memset(m_pRanges + nStart, 28, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 29: sUCRName = "CJK Strokes"; break; /* U+31C0-U+31EF */ /* U+F900-U+FAFF */ /*U+2F800-U+2FA1F*/
+			nStart = 0x31C0;
+			nCount = 0x31EF - nStart + 1;
+			memset(m_pRanges + nStart, 29, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			nStart = 0xF900;
+			nCount = 0xFAFF - nStart + 1;
+			memset(m_pRanges + nStart, 29, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 30: sUCRName = "Alphabetic Presentation Forms"; break; /* U+FB00-U+FB4F */
+			nStart = 0xFB00;
+			nCount = 0xFB4F - nStart + 1;
+			memset(m_pRanges + nStart, 30, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+            //case 31: sUCRName = "Arabic Presentation Forms-A"; break; /* U+FB50-U+FDFF */
+			nStart = 0xFB50;
+			nCount = 0xFDFF - nStart + 1;
+			memset(m_pRanges + nStart, 31, nCount);
+			memset(m_pRangesNums + nStart, 1, nCount);
+
+			// rangeNum 2
+			//case 00: sUCRName = "Combining Half Marks"; break; /* U+FE20-U+FE2F */
+			nStart = 0xFE20;
+			nCount = 0xFE2F - nStart + 1;
+			memset(m_pRanges + nStart, 0, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 01: sUCRName = "Vertical forms"; break; /* U+FE10-U+FE1F */ /* U+FE30-U+FE4F */
+			nStart = 0xFE10;
+			nCount = 0xFE1F - nStart + 1;
+			memset(m_pRanges + nStart, 1, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0xFE30;
+			nCount = 0xFE4F - nStart + 1;
+			memset(m_pRanges + nStart, 1, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 02: sUCRName = "Small Form Variants"; break; /* U+FE50-U+FE6F */
+			nStart = 0xFE50;
+			nCount = 0xFE6F - nStart + 1;
+			memset(m_pRanges + nStart, 2, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 03: sUCRName = "Arabic Presentation Forms-B"; break; /* U+FE70-U+FEFE */
+			nStart = 0xFE70;
+			nCount = 0xFEFE - nStart + 1;
+			memset(m_pRanges + nStart, 3, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 04: sUCRName = "Halfwidth and Fullwidth Forms"; break; /* U+FF00-U+FFEF */
+			nStart = 0xFF00;
+			nCount = 0xFFEF - nStart + 1;
+			memset(m_pRanges + nStart, 4, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 05: sUCRName = "Specials"; break; /* U+FFF0-U+FFFF */
+			nStart = 0xFFF0;
+			nCount = 0xFFFF - nStart + 1;
+			memset(m_pRanges + nStart, 5, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 06: sUCRName = "Tibetan"; break; /* U+0F00-U+0FFF */
+			nStart = 0x0F00;
+			nCount = 0x0FFF - nStart + 1;
+			memset(m_pRanges + nStart, 6, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 07: sUCRName = "Syriac"; break; /* U+0700-U+074F */
+			nStart = 0x0700;
+			nCount = 0x074F - nStart + 1;
+			memset(m_pRanges + nStart, 7, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 08: sUCRName = "Thaana"; break; /* U+0780-U+07BF */
+			nStart = 0x0780;
+			nCount = 0x07BF - nStart + 1;
+			memset(m_pRanges + nStart, 8, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 09: sUCRName = "Sinhala"; break; /* U+0D80-U+0DFF */
+			nStart = 0x0D80;
+			nCount = 0x0DFF - nStart + 1;
+			memset(m_pRanges + nStart, 9, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 10: sUCRName = "Myanmar"; break; /* U+1000-U+109F */
+			nStart = 0x1000;
+			nCount = 0x109F - nStart + 1;
+			memset(m_pRanges + nStart, 10, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 11: sUCRName = "Ethiopic"; break; /* U+1200-U+137F */ /* U+1380-U+139F */ /* U+2D80-U+2DDF */
+			nStart = 0x1200;
+			nCount = 0x137F - nStart + 1;
+			memset(m_pRanges + nStart, 11, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0x1380;
+			nCount = 0x139F - nStart + 1;
+			memset(m_pRanges + nStart, 11, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0x2D80;
+			nCount = 0x2DDF - nStart + 1;
+			memset(m_pRanges + nStart, 11, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 12: sUCRName = "Cherokee"; break; /* U+13A0-U+13FF */
+			nStart = 0x13A0;
+			nCount = 0x13FF - nStart + 1;
+			memset(m_pRanges + nStart, 12, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 13: sUCRName = "Unified Canadian Aboriginal Syllabics"; break; /* U+1400-U+167F */
+			nStart = 0x1400;
+			nCount = 0x167F - nStart + 1;
+			memset(m_pRanges + nStart, 13, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 14: sUCRName = "Ogham"; break; /* U+1680-U+169F */
+			nStart = 0x1680;
+			nCount = 0x169F - nStart + 1;
+			memset(m_pRanges + nStart, 14, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 15: sUCRName = "Runic"; break; /* U+16A0-U+16FF */
+			nStart = 0x16A0;
+			nCount = 0x16FF - nStart + 1;
+			memset(m_pRanges + nStart, 15, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 16: sUCRName = "Khmer"; break; /* U+1780-U+17FF */ /* U+19E0-U+19FF */
+			nStart = 0x1780;
+			nCount = 0x17FF - nStart + 1;
+			memset(m_pRanges + nStart, 16, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0x19E0;
+			nCount = 0x19FF - nStart + 1;
+			memset(m_pRanges + nStart, 16, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 17: sUCRName = "Mongolian"; break; /* U+1800-U+18AF */
+			nStart = 0x1800;
+			nCount = 0x18AF - nStart + 1;
+			memset(m_pRanges + nStart, 17, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 18: sUCRName = "Braille Patterns"; break; /* U+2800-U+28FF */
+			nStart = 0x2800;
+			nCount = 0x28FF - nStart + 1;
+			memset(m_pRanges + nStart, 18, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 19: sUCRName = "Yi Syllables"; break; /* U+A000-U+A48F */ /* U+A490-U+A4CF */
+			nStart = 0xA000;
+			nCount = 0xA48F - nStart + 1;
+			memset(m_pRanges + nStart, 19, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0xA490;
+			nCount = 0xA4CF - nStart + 1;
+			memset(m_pRanges + nStart, 19, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 20: sUCRName = "Tagalog"; break; /* U+1700-U+171F */ /* U+1720-U+173F */ /* U+1740-U+175F */ /* U+1760-U+177F */
+			nStart = 0x1700;
+			nCount = 0x171F - nStart + 1;
+			memset(m_pRanges + nStart, 20, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0x1720;
+			nCount = 0x173F - nStart + 1;
+			memset(m_pRanges + nStart, 20, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0x1740;
+			nCount = 0x175F - nStart + 1;
+			memset(m_pRanges + nStart, 20, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			nStart = 0x1760;
+			nCount = 0x177F - nStart + 1;
+			memset(m_pRanges + nStart, 20, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 21: sUCRName = "Old Italic"; break; /*U+10300-U+1032F*/
+            //case 22: sUCRName = "Gothic"; break; /*U+10330-U+1034F*/
+            //case 23: sUCRName = "Deseret"; break; /*U+10400-U+1044F*/
+            //case 24: sUCRName = "Byzantine Musical Symbols"; break; /*U+1D000-U+1D0FF*/ /*U+1D100-U+1D1FF*/ /*U+1D200-U+1D24F*/
+            //case 25: sUCRName = "Mathematical Alphanumeric Symbols"; break; /*U+1D400-U+1D7FF*/
+            //case 26: sUCRName = "Private Use (plane 15)"; break; /*U+F0000-U+FFFFD*/ /*U+100000-U+10FFFD*/ //   
+            
+			//case 27: sUCRName = "Variation Selectors"; break; /* U+FE00-U+FE0F */ /*U+E0100-U+E01EF*/
+			nStart = 0xFE00;
+			nCount = 0xFE0F - nStart + 1;
+			memset(m_pRanges + nStart, 27, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 28: sUCRName = "Tags"; break; /*U+E0000-U+E007F*/
+            //case 29: sUCRName = "Limbu"; break; /* U+1900-U+194F */
+			nStart = 0x1900;
+			nCount = 0x194F - nStart + 1;
+			memset(m_pRanges + nStart, 29, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 30: sUCRName = "Tai Le"; break; /* U+1950-U+197F */
+			nStart = 0x1950;
+			nCount = 0x197F - nStart + 1;
+			memset(m_pRanges + nStart, 30, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+            //case 31: sUCRName = "New Tai Lue"; break; /* U+1980-U+19DF */
+			nStart = 0x1980;
+			nCount = 0x19DF - nStart + 1;
+			memset(m_pRanges + nStart, 31, nCount);
+			memset(m_pRangesNums + nStart, 2, nCount);
+
+			// rangeNum 3
+			//case 00: sUCRName = "Buginese"; break; /* U+1A00-U+1A1F */
+			nStart = 0x1A00;
+			nCount = 0x1A1F - nStart + 1;
+			memset(m_pRanges + nStart, 0, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 01: sUCRName = "Glagolitic"; break; /* U+2C00-U+2C5F */
+			nStart = 0x2C00;
+			nCount = 0x2C5F - nStart + 1;
+			memset(m_pRanges + nStart, 1, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 02: sUCRName = "Tifinagh"; break; /* U+2D30-U+2D7F */
+			nStart = 0x2D30;
+			nCount = 0x2D7F - nStart + 1;
+			memset(m_pRanges + nStart, 2, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 03: sUCRName = "Yijing Hexagram Symbols"; break; /* U+4DC0-U+4DFF */
+			nStart = 0x4DC0;
+			nCount = 0x4DFF - nStart + 1;
+			memset(m_pRanges + nStart, 3, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 04: sUCRName = "Syloti Nagri"; break; /* U+A800-U+A82F */
+			nStart = 0xA800;
+			nCount = 0xA82F - nStart + 1;
+			memset(m_pRanges + nStart, 4, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 05: sUCRName = "Linear B Syllabary"; break; /*U+10000-U+1007F*/ /*U+10080-U+100FF*/ /*U+10100-U+1013F*/
+            //case 06: sUCRName = "Ancient Greek Numbers"; break; /*U+10140-U+1018F*/
+            //case 07: sUCRName = "Ugaritic"; break; /*U+10380-U+1039F*/
+            //case 08: sUCRName = "Old Persian"; break; /*U+103A0-U+103DF*/
+            //case 09: sUCRName = "Shavian"; break; /*U+10450-U+1047F*/
+            //case 10: sUCRName = "Osmanya"; break; /*U+10480-U+104AF*/
+            //case 11: sUCRName = "Cypriot Syllabary"; break; /*U+10800-U+1083F*/
+            //case 12: sUCRName = "Kharoshthi"; break; /*U+10A00-U+10A5F*/
+            //case 13: sUCRName = "Tai Xuan Jing Symbols"; break; /*U+1D300-U+1D35F*/
+            //case 14: sUCRName = "Cuneiform"; break; /*U+12000-U+123FF*/ /*U+12400-U+1247F*/
+            //case 15: sUCRName = "Counting Rod Numerals"; break; /*U+1D360-U+1D37F*/
+            
+			//case 16: sUCRName = "Sundanese"; break; /* U+1B80-U+1BBF */
+			nStart = 0x1B80;
+			nCount = 0x1BBF - nStart + 1;
+			memset(m_pRanges + nStart, 16, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 17: sUCRName = "Lepcha"; break; /* U+1C00-U+1C4F */
+			nStart = 0x1C00;
+			nCount = 0x1C4F - nStart + 1;
+			memset(m_pRanges + nStart, 17, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 18: sUCRName = "Ol Chiki"; break; /* U+1C50-U+1C7F */
+			nStart = 0x1C50;
+			nCount = 0x1C7F - nStart + 1;
+			memset(m_pRanges + nStart, 18, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 19: sUCRName = "Saurashtra"; break; /* U+A880-U+A8DF */
+			nStart = 0xA880;
+			nCount = 0xA8DF - nStart + 1;
+			memset(m_pRanges + nStart, 19, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 20: sUCRName = "Kayah Li"; break; /* U+A900-U+A92F */
+			nStart = 0xA900;
+			nCount = 0xA92F - nStart + 1;
+			memset(m_pRanges + nStart, 20, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 21: sUCRName = "Rejang"; break; /* U+A930-U+A95F */
+			nStart = 0xA930;
+			nCount = 0xA95F - nStart + 1;
+			memset(m_pRanges + nStart, 21, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 22: sUCRName = "Cham"; break; /* U+AA00-U+AA5F */
+			nStart = 0xAA00;
+			nCount = 0xAA5F - nStart + 1;
+			memset(m_pRanges + nStart, 22, nCount);
+			memset(m_pRangesNums + nStart, 3, nCount);
+
+            //case 23: sUCRName = "Ancient Symbols"; break; /*U+10190-U+101CF*/
+            //case 24: sUCRName = "Phaistos Disc"; break; /*U+101D0-U+101FF*/
+			//case 25: sUCRName = "Carian"; break; /*U+102A0-U+102DF*/ /*U+10280-U+1029F*/ /*U+10920-U+1093F*/
+            //case 26: sUCRName = "Domino Tiles"; break; /*U+1F030-U+1F09F*/ /*U+1F000-U+1F02F*/
+            //case 27: sUCRName = "Reserved for process-internal usage"; break;
+            //case 28: sUCRName = "Reserved for process-internal usage"; break;
+            //case 29: sUCRName = "Reserved for process-internal usage"; break;
+            //case 30: sUCRName = "Reserved for process-internal usage"; break;
+            //case 31: sUCRName = "Reserved for process-internal usage"; break;
+		}
+
+		__forceinline bool GetRange(const WCHAR& symbol, BYTE& lRangeNum, BYTE& lRange)
+		{
+			lRangeNum	= m_pRangesNums[symbol];
+			lRange		= m_pRanges[symbol];
+
+			return (0xFF != lRangeNum);
+		}
+
+		__forceinline void CheckRanges(DWORD& lRange1, DWORD& lRange2, DWORD& lRange3, DWORD& lRange4, CString strText)
+		{
+			int lCount   = strText.GetLength();
+			WCHAR* pData = strText.GetBuffer();
+
+			BYTE lRangeNum  = 0xFF;
+			BYTE lRange		= 0xFF;
+			for (int i = 0; i < lCount; ++i, ++pData)
+			{
+				if (GetRange(*pData, lRangeNum, lRange))
+				{
+					if (0 == lRangeNum)
+						lRange1 |= 1 << lRange;
+					else if (1 == lRangeNum)
+						lRange2 |= 1 << lRange;
+					else if (2 == lRangeNum)
+						lRange3 |= 1 << lRange;
+					else
+						lRange4 |= 1 << lRange;
+				}
+			}
+		}
+		__forceinline void CheckRanges(DWORD& lRange1, DWORD& lRange2, DWORD& lRange3, DWORD& lRange4, BYTE& lRangeNum, BYTE& lRange)
+		{
+			if (0 == lRangeNum)
+				lRange1 |= 1 << lRange;
+			else if (1 == lRangeNum)
+				lRange2 |= 1 << lRange;
+			else if (2 == lRangeNum)
+				lRange3 |= 1 << lRange;
+			else
+				lRange4 |= 1 << lRange;
+		}
+
+		
+	public:		
+		__forceinline bool GenerateFontName(CString& strText)
+		{
+			if (_T("") == m_oFont.m_oFont.Path || (0 == strText.GetLength()))
+			{
+				m_strCurrentPickFont = m_oFont.m_strFamilyName;
+				m_lCurrentPictFontStyle = m_oFont.m_lStyle;
+				return false;
+			}
+
+			BYTE lRangeNum	= 0xFF;
+			BYTE lRange		= 0xFF;
+
+			GetRange(strText[0], lRangeNum, lRange);
+			POSITION posStart = m_arListPicUps.GetHeadPosition();
+			POSITION pos = posStart;
+
+			while (NULL != pos)
+			{
+				POSITION posOld = pos;
+				CFontPickUp& oPick = m_arListPicUps.GetNext(pos);
+				if ((oPick.m_oFont.m_oFont.IsEqual3(&m_oFont.m_oFont)) && (lRangeNum == oPick.m_lRangeNum) && (lRange == oPick.m_lRange))
+				{
+					// !    
+					//      
+					m_arListPicUps.MoveToHead(posOld);
+					m_strCurrentPickFont = oPick.m_strPickFont;
+					m_lCurrentPictFontStyle = oPick.m_lPickStyle;
+					return false;
+				}
+			}
+
+			//  ...
+			m_arListPicUps.AddHead();
+			CFontPickUp& oPick = m_arListPicUps.GetHead();
+
+			oPick.m_lRangeNum	= lRangeNum;
+			oPick.m_lRange		= lRange;
+			oPick.m_oFont		= m_oFont;
+			oPick.m_strPickFont	= m_oFont.m_strFamilyName;
+			oPick.m_lPickStyle	= m_oFont.m_lStyle;
+			
+			AVSGraphics::IASCFontManager2* pManager2 = NULL;
+			m_pManager->QueryInterface(AVSGraphics::IID_IASCFontManager2, (void**)&pManager2);
+
+			BSTR bsFontName = m_oFont.m_strFamilyName.AllocSysString();
+			BSTR bsNewFontName = NULL;
+
+			DWORD dwR1 = m_oFont.m_arSignature[0];
+			DWORD dwR2 = m_oFont.m_arSignature[1];
+			DWORD dwR3 = m_oFont.m_arSignature[2];
+			DWORD dwR4 = m_oFont.m_arSignature[3];
+			DWORD dwCodePage1	= 0;
+			DWORD dwCodePage2	= 0;
+
+			if ((lRangeNum == 1) && (lRange == 28))
+			{
+				dwCodePage1 = 0x80000000;
+				//strText = (WCHAR)(strText[0] - 0xF000);
+			}
+			else if (((lRangeNum == 2) && (lRange == 3)) || ((lRangeNum == 1) && (lRange == 31)) || ((lRangeNum == 0) && (lRange == 13)))
+			{
+				//   !!!
+				dwR1 = 1 << 13;
+				dwR2 = 1 << 31;
+				dwR3 = 1 << 3;
+			}
+			else
+			{
+				CheckRanges(dwR1, dwR2, dwR3, dwR4, lRangeNum, lRange);
+			}
+
+			BSTR bsPanose = m_oFont.m_strPANOSE.AllocSysString();
+
+			LONG lFontStyle = m_oFont.m_oFont.GetStyle();
+			pManager2->GetWinFontByParams2(&bsNewFontName, bsFontName, -1, NULL, &lFontStyle, m_oFont.m_bIsFixedWidth ? 1 : 0, bsPanose, 
+				dwR1, dwR2, dwR3, dwR4, dwCodePage1, dwCodePage2, m_oFont.m_lAvgWidth);
+
+			oPick.m_strPickFont = (CString)bsNewFontName;
+			oPick.m_lPickStyle	= lFontStyle;
+			m_strCurrentPickFont = oPick.m_strPickFont;
+			m_lCurrentPictFontStyle = oPick.m_lPickStyle;
+
+			SysFreeString(bsFontName);
+			SysFreeString(bsPanose);
+			SysFreeString(bsNewFontName);
+
+			RELEASEINTERFACE(pManager2);
+
+			return true;
+		}
+	};
+};
\ No newline at end of file

DocxRenderer/src/logic/Page.h

+#pragma once
+#include "ElementShape.h"
+#include "ElementParagraph.h"
+#include "ElementImage.h"
+
+namespace NSDocxRenderer
+{
+	const double STANDART_STRING_HEIGHT_MM		= 4.2333333333333334;
+	const double THE_SAME_STRING_Y_PRECISION_MM = 0.01;
+
+	static _bstr_t g_bstr_sectStart			= L"<w:p><w:pPr><w:sectPr>";
+	static _bstr_t g_bstr_lastSect			= L"<w:type w:val=\"continuous\"/>";
+	static _bstr_t g_bstr_sectEnd			= L"<w:pgMar w:top=\"0\" w:right=\"0\" w:bottom=\"0\" w:left=\"0\"/></w:sectPr><w:spacing w:line=\"1\" w:lineRule=\"exact\"/></w:pPr></w:p>";
+	static CString g_string_sectSizeVer		= _T("<w:pgSz w:w=\"%d\" w:h=\"%d\" w:orient=\"portrait\"/>");
+	static CString g_string_sectSizeHor		= _T("<w:pgSz w:w=\"%d\" w:h=\"%d\" w:orient=\"landscape\"/>");
+
+	static _bstr_t g_bstr_drawingParStart	= L"<w:p><w:pPr><w:spacing w:line=\"1\" w:lineRule=\"exact\"/></w:pPr>";
+	static _bstr_t g_bstr_ParEnd			= L"</w:p>";
+
+	static CString g_bstr_lastsection1		= L"<w:sectPr>";
+	static CString g_bstr_lastsection2		= L"<w:pgMar w:top=\"0\" w:right=\"0\" w:bottom=\"0\" w:left=\"0\" w:header=\"0\" w:footer=\"0\" w:gutter=\"0\"/></w:sectPr>";
+
+	AVSINLINE bool IsUnicodeSymbol( WCHAR symbol )
+	{
+		bool result = false;
+
+		if ( ( 0x0009 == symbol ) || ( 0x000A == symbol ) || ( 0x000D == symbol ) ||
+		   ( ( 0x0020 <= symbol ) && ( 0xD7FF >= symbol ) ) || ( ( 0xE000 <= symbol ) && ( symbol <= 0xFFFD ) ) ||
+		   ( ( 0x10000 <= symbol ) && symbol ) )
+		{
+			result = true;  
+		}
+
+		return result;		  
+	}
+
+	class CPage
+	{
+	public:
+		NSStructures::CFont*		m_pFont;
+		NSStructures::CPen*			m_pPen;
+		NSStructures::CBrush*		m_pBrush;
+		NSStructures::CShadow*		m_pShadow;
+		NSStructures::CEdgeText*	m_pEdgeText;
+
+		NSDocxRenderer::CMatrix*					m_pTransform;
+		AVSGraphics::IASCGraphicSimpleComverter*	m_pSimpleGraphicsConverter;
+
+		CVectorGraphics				m_oVector;
+
+		double m_dWidth;
+		double m_dHeight;
+
+		LONG						m_lCurrentCommand;
+
+		CAtlArray<CBaseItem*>	m_arGraphicItems;
+		CAtlArray<CParagraph*>	m_arParagraphs;
+
+		CAtlArray<CTextLine*> m_arTextLine;
+		CTextLine* m_pCurrentLine;
+
+		CFontManager		m_oManager;
+		CFontManagerLight	m_oManagerLight;
+
+		TextAssociationType m_eTextAssociationType;
+
+		NSDocxRenderer::CStringWriter m_oWriterVML;
+
+		bool m_bIsDeleteTextClipPage;
+
+	public:
+		CPage() : m_oManager(), m_oManagerLight()
+		{
+			m_pFont			= NULL;
+			m_pBrush		= NULL;
+			m_pPen			= NULL;
+			m_pShadow		= NULL;
+			m_pEdgeText		= NULL;
+
+			m_pTransform	= NULL;
+			m_pSimpleGraphicsConverter	= NULL;
+
+			m_dWidth		= 0;
+			m_dHeight		= 0;
+
+			m_pCurrentLine	= NULL;
+			m_eTextAssociationType = TextAssociationTypeNoFrames;
+
+			m_bIsDeleteTextClipPage = true;
+		}
+
+	public:
+		AVSINLINE void Init(NSStructures::CFont* pFont, NSStructures::CPen* pPen, NSStructures::CBrush* pBrush,
+			NSStructures::CShadow* pShadow, NSStructures::CEdgeText* pEdge, NSDocxRenderer::CMatrix* pMatrix, AVSGraphics::IASCGraphicSimpleComverter* pSimple)
+		{
+			m_pFont		= pFont;
+			m_pPen		= pPen;
+			m_pBrush	= pBrush;
+			m_pShadow	= pShadow;
+			m_pEdgeText	= pEdge;
+
+			m_pTransform				= pMatrix;
+			m_pSimpleGraphicsConverter	= pSimple;
+
+			m_oManager.m_pFont			= m_pFont;
+			m_oManager.m_pTransform		= m_pTransform;
+
+			m_pCurrentLine = NULL;
+
+			m_oWriterVML.AddSize(1000, 1000);
+		}
+
+		AVSINLINE void Clear()
+		{
+			size_t nCount = 0;
+
+			nCount = m_arTextLine.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CTextLine* pTemp = m_arTextLine[i];
+				RELEASEOBJECT(pTemp);
+			}
+			m_arTextLine.RemoveAll();
+
+			nCount = m_arGraphicItems.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CBaseItem* pTemp = m_arGraphicItems[i];
+				RELEASEOBJECT(pTemp);
+			}
+			m_arGraphicItems.RemoveAll();
+
+			nCount = m_arParagraphs.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CParagraph* pTemp = m_arParagraphs[i];
+				RELEASEOBJECT(pTemp);
+			}
+			m_arParagraphs.RemoveAll();
+
+			m_pCurrentLine = NULL;
+
+			m_oWriterVML.ClearNoAttack();
+		}
+
+		~CPage()
+		{
+			Clear();
+		}
+
+		AVSINLINE void SetCurrentLineByBaseline(const double& dBaseLinePos)
+		{
+			if ((NULL == m_pCurrentLine) || (TextAssociationTypeDefault == m_eTextAssociationType))
+			{
+				//  (  ) 
+				m_pCurrentLine = new CTextLine();
+
+				m_pCurrentLine->m_dBaselinePos = dBaseLinePos;
+				m_arTextLine.Add(m_pCurrentLine);
+				return;
+			}
+			if (fabs(m_pCurrentLine->m_dBaselinePos - dBaseLinePos) <= THE_SAME_STRING_Y_PRECISION_MM)
+			{
+				return;
+			}
+			size_t nCount = m_arTextLine.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				if (fabs(m_arTextLine[i]->m_dBaselinePos - dBaseLinePos) <= THE_SAME_STRING_Y_PRECISION_MM)
+				{
+					m_pCurrentLine = m_arTextLine[i];
+					return;
+				}
+			}
+
+			//    -   -  
+			m_pCurrentLine = new CTextLine();
+			m_pCurrentLine->m_dBaselinePos = dBaseLinePos;
+			m_arTextLine.Add(m_pCurrentLine);
+			return;
+		}
+
+		// image commands
+		AVSINLINE void WriteImage(CImageInfo& oInfo, double& fX, double& fY, double& fWidth, double& fHeight)
+		{
+			CImage* pImage = new CImage(oInfo, _T(""));
+
+			double dRotation = m_pTransform->z_Rotation();
+
+			if (fabs(dRotation) < 5.0)
+			{
+				double x1 = fX;
+				double y1 = fY;
+				double x2 = fX + fWidth;
+				double y2 = fY + fHeight;
+
+				m_pTransform->TransformPoint(x1, y1);
+				m_pTransform->TransformPoint(x2, y2);
+
+				if (x1 <= x2)
+				{
+					pImage->m_dLeft		= x1;
+					pImage->m_dWidth	= x2 - x1;
+				}
+				else
+				{
+					pImage->m_dLeft		= x2;
+					pImage->m_dWidth	= x1 - x2;
+				}
+
+				if (y1 <= y2)
+				{
+					pImage->m_dTop		= y1;
+					pImage->m_dHeight	= y2 - y1;
+				}
+				else
+				{
+					pImage->m_dTop		= y2;
+					pImage->m_dHeight	= y1 - y2;
+				}
+
+				pImage->m_dRotate = 0.0;
+			}
+			else
+			{
+				double x1 = fX;
+				double y1 = fY;
+				double x2 = fX + fWidth;
+				double y2 = fY + fHeight;
+
+				NSDocxRenderer::CMatrix oTemp  = *m_pTransform;
+		
+				double dCx = (x1 + x2) / 2;
+				double dCy = (y1 + y2) / 2;
+				m_pTransform->TransformPoint(dCx, dCy);
+				oTemp.RotateAt(-dRotation, dCx, dCy, Aggplus::MatrixOrderAppend);
+
+				oTemp.TransformPoint(x1, y1);
+				oTemp.TransformPoint(x2, y2);
+
+				if (x1 <= x2)
+				{
+					pImage->m_dLeft		= x1;
+					pImage->m_dWidth	= x2 - x1;
+				}
+				else
+				{
+					pImage->m_dLeft		= x2;
+					pImage->m_dWidth	= x1 - x2;
+				}
+
+				if (y1 <= y2)
+				{
+					pImage->m_dTop		= y1;
+					pImage->m_dHeight	= y2 - y1;
+				}
+				else
+				{
+					pImage->m_dTop		= y2;
+					pImage->m_dHeight	= y1 - y2;
+				}
+
+				pImage->m_dRotate = dRotation;
+			}
+
+			m_arGraphicItems.Add(pImage);
+		}
+
+		// path commands
+		AVSINLINE void MoveTo(double& dX, double& dY)
+		{
+			m_pTransform->TransformPoint(dX, dY);
+			m_oVector.MoveTo(dX, dY);
+
+		}
+		AVSINLINE void LineTo(double& dX, double& dY)
+		{
+			m_pTransform->TransformPoint(dX, dY);
+			m_oVector.LineTo(dX, dY);
+		}
+		AVSINLINE void CurveTo(double& x1, double& y1, double& x2, double& y2, double& x3, double& y3)
+		{
+			m_pTransform->TransformPoint(x1, y1);
+			m_pTransform->TransformPoint(x2, y2);
+			m_pTransform->TransformPoint(x3, y3);
+
+			m_oVector.CurveTo(x1, y1, x2, y2, x3, y3);
+		}
+		AVSINLINE void Start()
+		{			
+		}
+		AVSINLINE void End()
+		{
+			m_oVector.End();
+			m_oWriterVML.ClearNoAttack();
+		}
+		AVSINLINE void Close()
+		{
+			m_oVector.Close();
+		}
+		AVSINLINE void DrawPath(LONG lType, LONG lTxId)
+		{
+			if ((m_oVector.m_dLeft <= m_oVector.m_dRight) && (m_oVector.m_dTop <= m_oVector.m_dBottom))
+			{
+				CShape* pShape = new CShape();
+
+				pShape->m_lTxId		= lTxId;
+
+				pShape->m_oPen		= *m_pPen;
+				pShape->m_oBrush	= *m_pBrush;
+
+				//   
+				double dScaleTransform = (m_pTransform->m_agg_mtx.sx + m_pTransform->m_agg_mtx.sy) / 2.0;
+				pShape->m_oPen.Size *= dScaleTransform;
+
+				if ((lType & 0x01) == 0x00)
+				{
+					if ((fabs(m_oVector.m_dLeft - m_oVector.m_dRight) < 0.3) || (fabs(m_oVector.m_dTop - m_oVector.m_dBottom) < 0.3))
+					{
+						lType = 0x01;
+						pShape->m_bIsStroke  = true;
+						pShape->m_oPen.Color = m_pBrush->Color1;
+						pShape->m_oPen.Alpha = m_pBrush->Alpha1;
+						//pShape->m_oPen.Size	 = max(pShape->m_oPen.Size, 1);	
+					}
+				}
+
+				pShape->CreateFromVectorData(&m_oVector, m_oWriterVML, 100000, lType);
+				m_arGraphicItems.Add(pShape);
+			}
+		}
+
+		AVSINLINE void WriteText(BSTR bsText, BSTR bsGid, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, bool bIsPDFAnalyzer)
+		{
+			double dTextX = fX;
+			double dTextY = fY;
+			double dTextR = fX + fWidth;
+			double dTextB = fY + fHeight;
+
+			m_pTransform->TransformPoint(dTextX, dTextY);
+			m_pTransform->TransformPoint(dTextR, dTextB);
+			
+			double dTextW = dTextR - dTextX;
+			double dTextH = dTextB - dTextY;
+
+			CString strText = _T("");
+
+			if ((bsText != NULL) && (bsGid != NULL))
+			{
+				UINT lLen = SysStringLen(bsText);
+				for (unsigned int i = 0; i < lLen; ++i)
+				{
+					if ( IsUnicodeSymbol( bsText[i] ) )
+					{
+						strText += bsText[i];
+					}
+					else
+					{
+						strText += _T(" ");
+					}
+				}
+			}
+			else
+			{
+				strText = (CString)bsText;
+			}
+
+			bool bIsPath = ((NULL == bsGid) && !bIsPDFAnalyzer) ? false : true;
+
+			m_oManager.LoadFont(0, !bIsPath);
+			
+			if (bIsPath)
+				m_oManager.GenerateFontName2(strText);
+
+			if ((0 == dTextW) || (dTextW > 5 * m_oManager.m_dSpaceWidthMM))
+			{
+				double _x = 0;
+				double _y = 0;
+				double _w = 0;
+				double _h = 0;
+
+				if (NULL != bsGid)
+				{
+					m_oManager.SetStringGid(1);
+					m_oManager.MeasureString(bsGid, dTextX, dTextY, _x, _y, _w, _h, CFontManager::MeasureTypePosition);
+				}
+				else
+				{
+					//     (  xps)
+					m_oManager.SetStringGid(0);
+					m_oManager.MeasureString(bsText, dTextX, dTextY, _x, _y, _w, _h, CFontManager::MeasureTypePosition);
+				}
+
+				dTextW = _w;
+				//dTextW *= c_dPixToMM;
+			}
+
+			double dBaseLinePos = dTextY + fBaseLineOffset;
+			dTextH = m_oManager.GetFontHeight();
+
+			SetCurrentLineByBaseline(dBaseLinePos);
+
+			CContText* pLastCont = NULL;
+			size_t nCountConts = m_pCurrentLine->m_arConts.GetCount();
+			if (nCountConts != 0)
+				pLastCont = m_pCurrentLine->m_arConts[nCountConts - 1];
+
+			if (NULL == pLastCont)
+			{
+				//    
+				CContText* pCont = new CContText();
+
+				pCont->m_dX = dTextX;
+				pCont->m_dY = dBaseLinePos;
+
+				pCont->m_dWidth		= dTextW;
+				pCont->m_dHeight	= dTextH;
+
+				if (_T(" ") == strText)
+				{
+					pCont->m_dWidthWithoutSpaces	= 0;
+					pCont->m_dLeftWithoutSpaces		= dTextX + dTextW;
+				}
+				else
+				{
+					pCont->m_dWidthWithoutSpaces	= dTextW;
+					pCont->m_dLeftWithoutSpaces		= dTextX;
+				}
+
+				pCont->m_strText	= strText;
+
+				pCont->m_oFont		= m_oManager.m_oFont.m_oFont;
+				pCont->m_oBrush		= *m_pBrush;
+
+				if (bIsPath)
+				{
+					pCont->m_strPickFontName	= m_oManager.m_strCurrentPickFont;
+					pCont->m_lPickFontStyle		= m_oManager.m_lCurrentPictFontStyle;
+				}
+
+				pCont->m_dSpaceWidthMM = m_oManager.m_dSpaceWidthMM;
+				
+				m_pCurrentLine->AddCont(pCont, m_oManager.m_oFont.m_dBaselineOffset);
+				return;
+			}
+			
+			//  
+			//if (m_lCurrentCommand == c_nTextType && pLastCont->m_oFont.IsEqual(&m_oManager.m_oFontOld) && pLastCont->m_oBrush.IsEqual(m_pBrush))
+			//{
+			//	//    
+			//	pLastCont->m_strText += strText;
+			//	pLastCont->m_dWidth	= (dTextX + dTextW - pLastCont->m_dX);
+			//	return;
+			//}
+			
+			double dRight = pLastCont->m_dX + pLastCont->m_dWidth;
+
+			if (pLastCont->m_oFont.IsEqual(&m_oManager.m_oFont.m_oFont) && pLastCont->m_oBrush.IsEqual(m_pBrush))
+			{
+				//  .  ,  
+				if (fabs(dRight - dTextX) < 0.5)
+				{
+					//  
+					pLastCont->m_strText += strText;
+					pLastCont->m_dWidth	= (dTextX + dTextW - pLastCont->m_dX);
+
+					if (_T(" ") != strText)
+					{
+						if (0 == pLastCont->m_dWidthWithoutSpaces)
+							pLastCont->m_dLeftWithoutSpaces = dTextX;
+						
+						pLastCont->m_dWidthWithoutSpaces = dTextX + dTextW - pLastCont->m_dLeftWithoutSpaces;
+					}
+					else if (0 == pLastCont->m_dWidthWithoutSpaces)
+					{
+						pLastCont->m_dLeftWithoutSpaces = dTextX + dTextW;
+					}
+
+					return;
+				}
+				else if ((dRight < dTextX) && ((dTextX - dRight) < m_oManager.m_dSpaceWidthMM))
+				{
+					//    
+					pLastCont->m_strText += (_T(" ") + strText);
+					pLastCont->m_dWidth	= (dTextX + dTextW - pLastCont->m_dX);
+
+					if (_T(" ") != strText)
+					{
+						if (0 == pLastCont->m_dWidthWithoutSpaces)
+							pLastCont->m_dLeftWithoutSpaces = dTextX;
+
+						pLastCont->m_dWidthWithoutSpaces = dTextX + dTextW - pLastCont->m_dLeftWithoutSpaces;
+					}
+					else if (0 == pLastCont->m_dWidthWithoutSpaces)
+					{
+						pLastCont->m_dLeftWithoutSpaces = dTextX + dTextW;
+					}
+
+					return;
+				}
+			}
+			
+			//     ,    ,     (, )
+			//   ...    
+			CContText* pCont = new CContText();
+
+			pCont->m_dX = dTextX;
+			pCont->m_dY = dBaseLinePos;
+
+			pCont->m_dWidth		= dTextW;
+			pCont->m_dHeight	= dTextH;
+
+			if (_T(" ") == strText)
+			{
+				pCont->m_dWidthWithoutSpaces	= 0;
+				pCont->m_dLeftWithoutSpaces		= dTextX + dTextW;
+			}
+			else
+			{
+				pCont->m_dWidthWithoutSpaces	= dTextW;
+				pCont->m_dLeftWithoutSpaces		= dTextX;
+			}
+
+			pCont->m_strText	= strText;
+
+			pCont->m_oFont		= m_oManager.m_oFont.m_oFont;
+			pCont->m_oBrush		= *m_pBrush;
+
+			if (bIsPath)
+			{
+				pCont->m_strPickFontName	= m_oManager.m_strCurrentPickFont;
+				pCont->m_lPickFontStyle		= m_oManager.m_lCurrentPictFontStyle;
+			}
+
+			pCont->m_dSpaceWidthMM = m_oManager.m_dSpaceWidthMM;
+			
+			m_pCurrentLine->AddCont(pCont, m_oManager.m_oFont.m_dBaselineOffset);
+		}
+
+		void Build()
+		{
+			if (m_bIsDeleteTextClipPage)
+			{
+				//   ,     
+				size_t nCount = m_arTextLine.GetCount();
+				for (size_t i = 0; i < nCount; ++i)
+				{
+					CTextLine* pTextLine = m_arTextLine[i];
+
+					double _top = pTextLine->m_dBaselinePos - pTextLine->m_dHeight;
+					double _bottom = pTextLine->m_dBaselinePos;
+
+					if (_top >= m_dHeight || _bottom <= 0)
+					{
+						m_arTextLine.RemoveAt(i);
+						--i;
+						--nCount;
+					}
+				}
+			}
+
+			switch (m_eTextAssociationType)
+			{
+			case TextAssociationTypeDefault:
+			case TextAssociationTypeLine:
+				{
+					size_t nCount = m_arTextLine.GetCount();
+					for (size_t i = 0; i < nCount; ++i)
+					{
+						CTextLine* pTextLine = m_arTextLine[i];
+
+						CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+						pParagraph->m_pManagerLight = &m_oManagerLight;
+						pParagraph->m_bIsTextFrameProperties = true;
+
+						pParagraph->m_dLeft	= pTextLine->m_dX;
+						pParagraph->m_dTop	= pTextLine->m_dBaselinePos - pTextLine->m_dHeight + pTextLine->m_dBaselineOffset;
+
+						pParagraph->m_arLines.Add(pTextLine);
+
+						m_arParagraphs.Add(pParagraph);
+					}
+
+					//   
+					m_arTextLine.RemoveAll();
+					break;
+				}
+			case TextAssociationTypeBlock:
+				{
+					size_t nCount = m_arTextLine.GetCount();
+
+					if (0 == nCount)
+						break;
+
+					CTextLine* pFirstLine = m_arTextLine[0];
+
+					CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+					pParagraph->m_pManagerLight = &m_oManagerLight;
+					pParagraph->m_bIsTextFrameProperties = true;
+					
+					pParagraph->m_dLeft	= pFirstLine->m_dX;
+					pParagraph->m_dTop	= pFirstLine->m_dBaselinePos - pFirstLine->m_dHeight + pFirstLine->m_dBaselineOffset;
+
+					pParagraph->m_arLines.Add(pFirstLine);
+
+					m_arParagraphs.Add(pParagraph);
+					
+					for (size_t i = 1; i < nCount; ++i)
+					{
+						CTextLine* pTextLine = m_arTextLine[i];
+
+						CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+						pParagraph->m_pManagerLight = &m_oManagerLight;
+						pParagraph->m_bIsTextFrameProperties = true;
+
+						if (((fabs(pTextLine->m_dBaselinePos - pTextLine->m_dHeight - pFirstLine->m_dBaselinePos) > STANDART_STRING_HEIGHT_MM) && (pTextLine->m_dX == pFirstLine->m_dX)) ||
+							((pTextLine->m_dX != pFirstLine->m_dX) && (pTextLine->m_dBaselinePos != pFirstLine->m_dBaselinePos)))
+						{
+							pParagraph->m_dLeft	= pTextLine->m_dX;
+							pParagraph->m_dTop	= pTextLine->m_dBaselinePos - pTextLine->m_dHeight + pTextLine->m_dBaselineOffset;
+						}
+						else
+						{
+							pParagraph->m_dLeft	= pFirstLine->m_dX;
+							pParagraph->m_dTop	= pFirstLine->m_dBaselinePos - pFirstLine->m_dHeight + pFirstLine->m_dBaselineOffset;
+						}
+
+						pFirstLine = pTextLine;
+
+						pParagraph->m_arLines.Add(pTextLine);
+						m_arParagraphs.Add(pParagraph);
+					}
+
+					//   
+					m_arTextLine.RemoveAll();
+					break;
+				}
+			case TextAssociationTypeNoFrames:
+				{
+					SortElements(m_arTextLine);
+					Merge(STANDART_STRING_HEIGHT_MM / 3);
+
+					double previousStringOffset = 0;
+					size_t nCount = m_arTextLine.GetCount();
+					for (size_t i = 0; i < nCount; ++i)
+					{
+						CTextLine* pTextLine = m_arTextLine[i];
+
+						CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+						pParagraph->m_pManagerLight = &m_oManagerLight;
+						pParagraph->m_bIsTextFrameProperties = false;
+
+						pParagraph->m_dLeft	= pTextLine->m_dX;
+						
+						double dBeforeSpacing = (pTextLine->m_dBaselinePos - previousStringOffset - pTextLine->m_dHeight + pTextLine->m_dBaselineOffset);
+
+						pParagraph->m_dSpaceBefore = max(dBeforeSpacing, 0);
+
+						double dHeight = 1;
+						if (pTextLine->m_dHeight != 0)
+						{
+							dHeight = pTextLine->m_dHeight;
+
+							if (dBeforeSpacing < 0)
+								dHeight += dBeforeSpacing;
+						}
+
+						pParagraph->m_dHeight = dHeight;
+
+						previousStringOffset = pTextLine->m_dBaselinePos + pTextLine->m_dBaselineOffset;
+
+						pParagraph->m_arLines.Add(pTextLine);
+						m_arParagraphs.Add(pParagraph);
+					}
+
+					m_arTextLine.RemoveAll();
+					break;
+				}
+			}
+		}
+
+		void Merge(double dAffinity)
+		{
+			size_t nCount = m_arTextLine.GetCount();
+			if (1 < nCount)
+			{
+				CTextLine* pPrev = m_arTextLine[0];
+				for (size_t i = 1; i < nCount; ++i)
+				{
+					CTextLine* pNext = m_arTextLine[i];
+
+					if (fabs(pNext->m_dBaselinePos - pPrev->m_dBaselinePos) < dAffinity)
+					{
+						pPrev->Merge(pNext);
+
+						pNext->m_arConts.RemoveAll();
+						RELEASEOBJECT(pNext);
+
+						m_arTextLine.RemoveAt(i);
+						--i;
+						--nCount;
+						continue;
+					}
+					pPrev = pNext;
+				}
+			}
+		}
+
+		void Write(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			// drawings
+			size_t nCountDrawings = m_arGraphicItems.GetCount();
+			if (0 != nCountDrawings)
+			{
+				oWriter.WriteString(g_bstr_drawingParStart);
+
+				for (size_t i = 0; i < nCountDrawings; ++i)
+				{
+					m_arGraphicItems[i]->ToXml(oWriter);
+				}
+
+				oWriter.WriteString(g_bstr_ParEnd);
+			}
+
+			size_t nCountParagraphs = m_arParagraphs.GetCount();
+			for (size_t i = 0; i < nCountParagraphs; ++i)
+			{
+				m_arParagraphs[i]->ToXml(oWriter);
+			}
+		}
+
+		AVSINLINE void WriteSectionToFile(bool bLastPage, NSDocxRenderer::CStringWriter& oWriter)
+		{
+			// section
+			LONG lWidthDx  = (LONG)(m_dWidth * c_dMMToDx);
+			LONG lHeightDx = (LONG)(m_dHeight * c_dMMToDx);
+
+			if (!bLastPage)
+				oWriter.WriteString(g_bstr_sectStart);
+			else
+				oWriter.WriteString(g_bstr_lastsection1);
+				
+			if (lWidthDx >= lHeightDx)
+			{
+				CString strSize = _T("");
+				strSize.Format(g_string_sectSizeHor, lWidthDx, lHeightDx);
+				oWriter.WriteString(strSize);
+			}
+			else
+			{
+				CString strSize = _T("");
+				strSize.Format(g_string_sectSizeVer, lWidthDx, lHeightDx);
+				oWriter.WriteString(strSize);
+			}
+
+			if (!bLastPage)
+				oWriter.WriteString(g_bstr_sectEnd);
+			else
+				oWriter.WriteString(g_bstr_lastsection2);
+		}
+	};
+}
\ No newline at end of file

DocxRenderer/src/resources/resources.h

+#pragma once
+
+#ifndef DOCX_RENDERER_RESOURCES
+#define DOCX_RENDERER_RESOURCES
+
+const char* g_resource_app = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><Properties xmlns=\"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties\"><Template>Normal.dotm</Template><TotalTime>1</TotalTime><Pages>1</Pages><Words>0</Words><Characters>0</Characters><Application>Microsoft Office Word</Application><DocSecurity>0</DocSecurity><Lines>1</Lines><Paragraphs>1</Paragraphs><ScaleCrop>false</ScaleCrop><LinksUpToDate>false</LinksUpToDate><CharactersWithSpaces>0</CharactersWithSpaces><SharedDoc>false</SharedDoc><HyperlinksChanged>false</HyperlinksChanged><AppVersion>12.0000</AppVersion></Properties>";
+const char* g_resource_contenttypes = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\"><Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/><Default Extension=\"xml\" ContentType=\"application/xml\"/><Default Extension=\"png\" ContentType=\"image/png\"/><Default Extension=\"jpg\" ContentType=\"image/jpg\"/><Override PartName=\"/word/document.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/><Override PartName=\"/word/styles.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml\"/><Override PartName=\"/word/settings.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml\"/><Override PartName=\"/word/webSettings.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml\"/><Override PartName=\"/word/fontTable.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml\"/><Override PartName=\"/word/theme/theme.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\"/><Override PartName=\"/docProps/core.xml\" ContentType=\"application/vnd.openxmlformats-package.core-properties+xml\"/><Override PartName=\"/docProps/app.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.extended-properties+xml\"/></Types>";
+const char* g_resource_core = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><cp:coreProperties xmlns:cp=\"http://schemas.openxmlformats.org/package/2006/metadata/core-properties\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\"><dc:title/><dc:subject/><dc:creator/><cp:keywords/><dc:description/><cp:lastModifiedBy/><cp:revision>1</cp:revision></cp:coreProperties>";
+const char* g_resource_rels = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"><Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"word/document.xml\"/><Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties\" Target=\"docProps/core.xml\"/><Relationship Id=\"rId3\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties\" Target=\"docProps/app.xml\"/></Relationships>";
+const char* g_resource_settings = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><w:settings xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:v=\"urn:schemas-microsoft-com:vml\"><w:zoom w:percent=\"100\"/><w:defaultTabStop w:val=\"708\"/><w:drawingGridHorizontalSpacing/><w:displayHorizontalDrawingGridEvery/><w:characterSpacingControl w:val=\"doNotCompress\"/><w:compat/><m:mathPr><m:mathFont m:val=\"Cambria Math\"/><m:brkBin m:val=\"before\"/><m:brkBinSub m:val=\"--\"/><m:smallFrac m:val=\"off\"/><m:dispDef/><m:lMargin m:val=\"0\"/><m:rMargin m:val=\"0\"/><m:defJc m:val=\"centerGroup\"/><m:wrapIndent m:val=\"1440\"/><m:intLim m:val=\"subSup\"/><m:naryLim m:val=\"undOvr\"/></m:mathPr><w:themeFontLang w:val=\"ru-RU\"/><w:clrSchemeMapping w:bg1=\"light1\" w:t1=\"dark1\" w:bg2=\"light2\" w:t2=\"dark2\" w:accent1=\"accent1\" w:accent2=\"accent2\" w:accent3=\"accent3\" w:accent4=\"accent4\" w:accent5=\"accent5\" w:accent6=\"accent6\" w:hyperlink=\"hyperlink\" w:followedHyperlink=\"followedHyperlink\"/><w:shapeDefaults><o:shapedefaults v:ext=\"edit\" spidmax=\"3074\"/><o:shapelayout v:ext=\"edit\"><o:idmap v:ext=\"edit\" data=\"1\"/><o:rules v:ext=\"\"/></o:shapelayout></w:shapeDefaults><w:decimalSymbol w:val=\",\"/><w:listSeparator w:val=\";\"/></w:settings>";
+const char* g_resource_styles = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><w:styles xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:docDefaults><w:rPrDefault><w:rPr><w:webHidden w:val=\"false\"/><w:lang w:val=\"ru-RU\" w:eastAsia=\"en-US\" w:bidi=\"ar-SA\"/><w:rFonts w:eastAsiaTheme=\"minorHAnsi\" w:ascii=\"Times New Roman\" w:hAnsi=\"Times New Roman\" w:cs=\"Times New Roman\"/></w:rPr></w:rPrDefault><w:pPrDefault><w:pPr/></w:pPrDefault></w:docDefaults><w:latentStyles w:defLockedState=\"false\" w:defUIPriority=\"99\" w:defSemiHidden=\"true\" w:defUnhideWhenUsed=\"true\" w:defQFormat=\"false\" w:count=\"267\"><w:lsdException w:name=\"Normal\" w:semiHidden=\"false\" w:uiPriority=\"0\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"heading 1\" w:semiHidden=\"false\" w:uiPriority=\"9\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 2\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 3\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 4\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 5\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 6\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 7\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 8\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"heading 9\" w:uiPriority=\"9\" w:qFormat=\"true\"/><w:lsdException w:name=\"toc 1\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 2\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 3\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 4\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 5\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 6\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 7\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 8\" w:uiPriority=\"39\"/><w:lsdException w:name=\"toc 9\" w:uiPriority=\"39\"/><w:lsdException w:name=\"caption\" w:uiPriority=\"35\" w:qFormat=\"true\"/><w:lsdException w:name=\"Title\" w:semiHidden=\"false\" w:uiPriority=\"10\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Default Paragraph Font\" w:uiPriority=\"1\"/><w:lsdException w:name=\"Subtitle\" w:semiHidden=\"false\" w:uiPriority=\"11\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Strong\" w:semiHidden=\"false\" w:uiPriority=\"22\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Emphasis\" w:semiHidden=\"false\" w:uiPriority=\"20\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Table Grid\" w:semiHidden=\"false\" w:uiPriority=\"59\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Placeholder Text\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"No Spacing\" w:semiHidden=\"false\" w:uiPriority=\"1\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Light Shading\" w:semiHidden=\"false\" w:uiPriority=\"60\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light List\" w:semiHidden=\"false\" w:uiPriority=\"61\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Grid\" w:semiHidden=\"false\" w:uiPriority=\"62\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 1\" w:semiHidden=\"false\" w:uiPriority=\"63\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 2\" w:semiHidden=\"false\" w:uiPriority=\"64\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 1\" w:semiHidden=\"false\" w:uiPriority=\"65\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 2\" w:semiHidden=\"false\" w:uiPriority=\"66\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 1\" w:semiHidden=\"false\" w:uiPriority=\"67\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 2\" w:semiHidden=\"false\" w:uiPriority=\"68\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 3\" w:semiHidden=\"false\" w:uiPriority=\"69\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Dark List\" w:semiHidden=\"false\" w:uiPriority=\"70\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Shading\" w:semiHidden=\"false\" w:uiPriority=\"71\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful List\" w:semiHidden=\"false\" w:uiPriority=\"72\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Grid\" w:semiHidden=\"false\" w:uiPriority=\"73\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Shading Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"60\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light List Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"61\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Grid Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"62\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 1 Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"63\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 2 Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"64\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 1 Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"65\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Revision\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"List Paragraph\" w:semiHidden=\"false\" w:uiPriority=\"34\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Quote\" w:semiHidden=\"false\" w:uiPriority=\"29\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Intense Quote\" w:semiHidden=\"false\" w:uiPriority=\"30\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Medium List 2 Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"66\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 1 Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"67\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 2 Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"68\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 3 Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"69\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Dark List Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"70\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Shading Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"71\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful List Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"72\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Grid Accent 1\" w:semiHidden=\"false\" w:uiPriority=\"73\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Shading Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"60\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light List Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"61\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Grid Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"62\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 1 Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"63\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 2 Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"64\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 1 Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"65\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 2 Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"66\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 1 Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"67\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 2 Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"68\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 3 Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"69\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Dark List Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"70\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Shading Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"71\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful List Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"72\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Grid Accent 2\" w:semiHidden=\"false\" w:uiPriority=\"73\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Shading Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"60\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light List Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"61\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Grid Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"62\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 1 Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"63\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 2 Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"64\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 1 Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"65\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 2 Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"66\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 1 Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"67\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 2 Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"68\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 3 Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"69\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Dark List Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"70\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Shading Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"71\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful List Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"72\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Grid Accent 3\" w:semiHidden=\"false\" w:uiPriority=\"73\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Shading Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"60\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light List Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"61\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Grid Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"62\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 1 Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"63\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 2 Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"64\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 1 Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"65\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 2 Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"66\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 1 Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"67\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 2 Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"68\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 3 Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"69\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Dark List Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"70\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Shading Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"71\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful List Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"72\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Grid Accent 4\" w:semiHidden=\"false\" w:uiPriority=\"73\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Shading Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"60\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light List Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"61\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Grid Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"62\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 1 Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"63\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 2 Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"64\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 1 Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"65\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 2 Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"66\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 1 Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"67\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 2 Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"68\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 3 Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"69\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Dark List Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"70\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Shading Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"71\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful List Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"72\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Grid Accent 5\" w:semiHidden=\"false\" w:uiPriority=\"73\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Shading Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"60\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light List Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"61\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Light Grid Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"62\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 1 Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"63\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Shading 2 Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"64\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 1 Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"65\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium List 2 Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"66\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 1 Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"67\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 2 Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"68\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Medium Grid 3 Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"69\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Dark List Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"70\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Shading Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"71\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful List Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"72\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Colorful Grid Accent 6\" w:semiHidden=\"false\" w:uiPriority=\"73\" w:unhideWhenUsed=\"false\"/><w:lsdException w:name=\"Subtle Emphasis\" w:semiHidden=\"false\" w:uiPriority=\"19\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Intense Emphasis\" w:semiHidden=\"false\" w:uiPriority=\"21\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Subtle Reference\" w:semiHidden=\"false\" w:uiPriority=\"31\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Intense Reference\" w:semiHidden=\"false\" w:uiPriority=\"32\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Book Title\" w:semiHidden=\"false\" w:uiPriority=\"33\" w:unhideWhenUsed=\"false\" w:qFormat=\"true\"/><w:lsdException w:name=\"Bibliography\" w:uiPriority=\"37\"/><w:lsdException w:name=\"TOC Heading\" w:uiPriority=\"39\" w:qFormat=\"true\"/></w:latentStyles><w:style w:type=\"paragraph\" w:default=\"1\" w:styleId=\"Normal\"><w:name w:val=\"Normal\"/></w:style><w:style w:type=\"character\" w:default=\"1\" w:styleId=\"DefaultParagraphFont\"><w:name w:val=\"Default Paragraph Font\"/><w:semiHidden/><w:unhideWhenUsed/><w:uiPriority w:val=\"1\"/></w:style><w:style w:type=\"table\" w:default=\"1\" w:styleId=\"TableNormal\"><w:name w:val=\"Normal Table\"/><w:semiHidden/><w:unhideWhenUsed/><w:qFormat/><w:uiPriority w:val=\"99\"/><w:tblPr><w:tblInd w:w=\"0\" w:type=\"dxa\"/><w:tblCellMar><w:top w:w=\"0\" w:type=\"dxa\"/><w:left w:w=\"108\" w:type=\"dxa\"/><w:bottom w:w=\"0\" w:type=\"dxa\"/><w:right w:w=\"108\" w:type=\"dxa\"/></w:tblCellMar></w:tblPr></w:style><w:style w:type=\"numbering\" w:default=\"1\" w:styleId=\"NoList\"><w:name w:val=\"No List\"/><w:semiHidden/><w:unhideWhenUsed/><w:uiPriority w:val=\"99\"/></w:style></w:styles>";
+const char* g_resource_theme = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><a:theme xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" name=\"Office Theme\"><a:themeElements><a:clrScheme name=\"Office\"><a:dk1><a:sysClr val=\"windowText\" lastClr=\"000000\"/></a:dk1><a:lt1><a:sysClr val=\"window\" lastClr=\"FFFFFF\"/></a:lt1><a:dk2><a:srgbClr val=\"1F497D\"/></a:dk2><a:lt2><a:srgbClr val=\"EEECE1\"/></a:lt2><a:accent1><a:srgbClr val=\"4F81BD\"/></a:accent1><a:accent2><a:srgbClr val=\"C0504D\"/></a:accent2><a:accent3><a:srgbClr val=\"9BBB59\"/></a:accent3><a:accent4><a:srgbClr val=\"8064A2\"/></a:accent4><a:accent5><a:srgbClr val=\"4BACC6\"/></a:accent5><a:accent6><a:srgbClr val=\"F79646\"/></a:accent6><a:hlink><a:srgbClr val=\"0000FF\"/></a:hlink><a:folHlink><a:srgbClr val=\"800080\"/></a:folHlink></a:clrScheme><a:fontScheme name=\"Office\"><a:majorFont><a:latin typeface=\"Cambria\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/><a:font script=\"Jpan\" typeface=\"ＭＳ ゴシック\"/><a:font script=\"Hang\" typeface=\"맑은 고딕\"/><a:font script=\"Hans\" typeface=\"宋体\"/><a:font script=\"Hant\" typeface=\"新細明體\"/><a:font script=\"Arab\" typeface=\"Times New Roman\"/><a:font script=\"Hebr\" typeface=\"Times New Roman\"/><a:font script=\"Thai\" typeface=\"Angsana New\"/><a:font script=\"Ethi\" typeface=\"Nyala\"/><a:font script=\"Beng\" typeface=\"Vrinda\"/><a:font script=\"Gujr\" typeface=\"Shruti\"/><a:font script=\"Khmr\" typeface=\"MoolBoran\"/><a:font script=\"Knda\" typeface=\"Tunga\"/><a:font script=\"Guru\" typeface=\"Raavi\"/><a:font script=\"Cans\" typeface=\"Euphemia\"/><a:font script=\"Cher\" typeface=\"Plantagenet Cherokee\"/><a:font script=\"Yiii\" typeface=\"Microsoft Yi Baiti\"/><a:font script=\"Tibt\" typeface=\"Microsoft Himalaya\"/><a:font script=\"Thaa\" typeface=\"MV Boli\"/><a:font script=\"Deva\" typeface=\"Mangal\"/><a:font script=\"Telu\" typeface=\"Gautami\"/><a:font script=\"Taml\" typeface=\"Latha\"/><a:font script=\"Syrc\" typeface=\"Estrangelo Edessa\"/><a:font script=\"Orya\" typeface=\"Kalinga\"/><a:font script=\"Mlym\" typeface=\"Kartika\"/><a:font script=\"Laoo\" typeface=\"DokChampa\"/><a:font script=\"Sinh\" typeface=\"Iskoola Pota\"/><a:font script=\"Mong\" typeface=\"Mongolian Baiti\"/><a:font script=\"Viet\" typeface=\"Times New Roman\"/><a:font script=\"Uigh\" typeface=\"Microsoft Uighur\"/></a:majorFont><a:minorFont><a:latin typeface=\"Calibri\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/><a:font script=\"Jpan\" typeface=\"ＭＳ 明朝\"/><a:font script=\"Hang\" typeface=\"맑은 고딕\"/><a:font script=\"Hans\" typeface=\"宋体\"/><a:font script=\"Hant\" typeface=\"新細明體\"/><a:font script=\"Arab\" typeface=\"Arial\"/><a:font script=\"Hebr\" typeface=\"Arial\"/><a:font script=\"Thai\" typeface=\"Cordia New\"/><a:font script=\"Ethi\" typeface=\"Nyala\"/><a:font script=\"Beng\" typeface=\"Vrinda\"/><a:font script=\"Gujr\" typeface=\"Shruti\"/><a:font script=\"Khmr\" typeface=\"DaunPenh\"/><a:font script=\"Knda\" typeface=\"Tunga\"/><a:font script=\"Guru\" typeface=\"Raavi\"/><a:font script=\"Cans\" typeface=\"Euphemia\"/><a:font script=\"Cher\" typeface=\"Plantagenet Cherokee\"/><a:font script=\"Yiii\" typeface=\"Microsoft Yi Baiti\"/><a:font script=\"Tibt\" typeface=\"Microsoft Himalaya\"/><a:font script=\"Thaa\" typeface=\"MV Boli\"/><a:font script=\"Deva\" typeface=\"Mangal\"/><a:font script=\"Telu\" typeface=\"Gautami\"/><a:font script=\"Taml\" typeface=\"Latha\"/><a:font script=\"Syrc\" typeface=\"Estrangelo Edessa\"/><a:font script=\"Orya\" typeface=\"Kalinga\"/><a:font script=\"Mlym\" typeface=\"Kartika\"/><a:font script=\"Laoo\" typeface=\"DokChampa\"/><a:font script=\"Sinh\" typeface=\"Iskoola Pota\"/><a:font script=\"Mong\" typeface=\"Mongolian Baiti\"/><a:font script=\"Viet\" typeface=\"Arial\"/><a:font script=\"Uigh\" typeface=\"Microsoft Uighur\"/></a:minorFont></a:fontScheme><a:fmtScheme name=\"Office\"><a:fillStyleLst><a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\"><a:schemeClr val=\"phClr\"><a:tint val=\"50000\"/><a:satMod val=\"300000\"/></a:schemeClr></a:gs><a:gs pos=\"35000\"><a:schemeClr val=\"phClr\"><a:tint val=\"37000\"/><a:satMod val=\"300000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\"><a:schemeClr val=\"phClr\"><a:tint val=\"15000\"/><a:satMod val=\"350000\"/></a:schemeClr></a:gs></a:gsLst><a:lin ang=\"16200000\" scaled=\"1\"/></a:gradFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\"><a:schemeClr val=\"phClr\"><a:shade val=\"51000\"/><a:satMod val=\"130000\"/></a:schemeClr></a:gs><a:gs pos=\"80000\"><a:schemeClr val=\"phClr\"><a:shade val=\"93000\"/><a:satMod val=\"130000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\"><a:schemeClr val=\"phClr\"><a:shade val=\"94000\"/><a:satMod val=\"135000\"/></a:schemeClr></a:gs></a:gsLst><a:lin ang=\"16200000\" scaled=\"0\"/></a:gradFill></a:fillStyleLst><a:lnStyleLst><a:ln w=\"9525\" cap=\"flat\" cmpd=\"sng\" algn=\"ctr\"><a:solidFill><a:schemeClr val=\"phClr\"><a:shade val=\"95000\"/><a:satMod val=\"105000\"/></a:schemeClr></a:solidFill><a:prstDash val=\"solid\"/></a:ln><a:ln w=\"25400\" cap=\"flat\" cmpd=\"sng\" algn=\"ctr\"><a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:prstDash val=\"solid\"/></a:ln><a:ln w=\"38100\" cap=\"flat\" cmpd=\"sng\" algn=\"ctr\"><a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:prstDash val=\"solid\"/></a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle><a:effectLst><a:outerShdw blurRad=\"40000\" dist=\"20000\" dir=\"5400000\" rotWithShape=\"0\"><a:srgbClr val=\"000000\"><a:alpha val=\"38000\"/></a:srgbClr></a:outerShdw></a:effectLst></a:effectStyle><a:effectStyle><a:effectLst><a:outerShdw blurRad=\"40000\" dist=\"23000\" dir=\"5400000\" rotWithShape=\"0\"><a:srgbClr val=\"000000\"><a:alpha val=\"35000\"/></a:srgbClr></a:outerShdw></a:effectLst></a:effectStyle><a:effectStyle><a:effectLst><a:outerShdw blurRad=\"40000\" dist=\"23000\" dir=\"5400000\" rotWithShape=\"0\"><a:srgbClr val=\"000000\"><a:alpha val=\"35000\"/></a:srgbClr></a:outerShdw></a:effectLst><a:scene3d><a:camera  prst=\"orthographicFront\"><a:rot lat=\"0\" lon=\"0\" rev=\"0\"/></a:camera ><a:lightRig rig=\"threePt\" dir=\"t\"><a:rot lat=\"0\" lon=\"0\" rev=\"1200000\"/></a:lightRig></a:scene3d><a:sp3d><a:bevelT w=\"63500\" h=\"25400\"/></a:sp3d></a:effectStyle></a:effectStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\"><a:schemeClr val=\"phClr\"><a:tint val=\"40000\"/><a:satMod val=\"350000\"/></a:schemeClr></a:gs><a:gs pos=\"40000\"><a:schemeClr val=\"phClr\"><a:tint val=\"45000\"/><a:shade val=\"99000\"/><a:satMod val=\"350000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\"><a:schemeClr val=\"phClr\"><a:shade val=\"20000\"/><a:satMod val=\"255000\"/></a:schemeClr></a:gs></a:gsLst><a:path path=\"circle\"><a:fillToRect l=\"50000\" t=\"-80000\" r=\"50000\" b=\"180000\"/></a:path></a:gradFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\"><a:schemeClr val=\"phClr\"><a:tint val=\"80000\"/><a:satMod val=\"300000\"/></a:schemeClr></a:gs><a:gs pos=\"100000\"><a:schemeClr val=\"phClr\"><a:shade val=\"30000\"/><a:satMod val=\"200000\"/></a:schemeClr></a:gs></a:gsLst><a:path path=\"circle\"><a:fillToRect l=\"50000\" t=\"50000\" r=\"50000\" b=\"50000\"/></a:path></a:gradFill></a:bgFillStyleLst></a:fmtScheme></a:themeElements><a:objectDefaults/><a:extraClrSchemeLst/></a:theme>";
+const char* g_resource_websettings = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><w:webSettings xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:optimizeForBrowser/></w:webSettings>";
+
+#endif

DocxRenderer/src/tmp/ASCDocxRenderer.cpp

+// AVSDocxRenderer.cpp : Implementation of CAVSDocxRenderer
+
+#include "stdafx.h"
+#include "ASCDocxRenderer.h"
+
+
+// CAVSDocxRenderer
+
+STDMETHODIMP CAVSDocxRenderer::get_Type(LONG* lType)
+{
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::NewPage()
+{
+	return m_oDocument.NewPage();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_Height(double* dHeight)
+{
+	return m_oDocument.get_Height(dHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_Height(double dHeight)
+{
+	return m_oDocument.put_Height(dHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_Width(double* dWidth)
+{
+	return m_oDocument.get_Width(dWidth);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_Width(double dWidth)
+{
+	return m_oDocument.put_Width(dWidth);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_DpiX(double* dDpiX)
+{
+	return m_oDocument.get_DpiX(dDpiX);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_DpiY(double* dDpiY)
+{
+	return m_oDocument.get_DpiY(dDpiY);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetPen(BSTR bsXML)
+{
+	return m_oDocument.SetPen(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenColor(LONG* lColor)
+{
+	return m_oDocument.get_PenColor(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenColor(LONG lColor)
+{
+	return m_oDocument.put_PenColor(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenAlpha(LONG* lAlpha)
+{
+	return m_oDocument.get_PenAlpha(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenAlpha(LONG lAlpha)
+{
+	return m_oDocument.put_PenAlpha(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenSize(double* dSize)
+{
+	return m_oDocument.get_PenSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenSize(double dSize)
+{
+	return m_oDocument.put_PenSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenDashStyle(BYTE* val)
+{
+	return m_oDocument.get_PenDashStyle(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenDashStyle(BYTE val)
+{
+	return m_oDocument.put_PenDashStyle(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenLineStartCap(BYTE* val)
+{
+	return m_oDocument.get_PenLineStartCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenLineStartCap(BYTE val)
+{
+	return m_oDocument.put_PenLineStartCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenLineEndCap(BYTE* val)
+{
+	return m_oDocument.get_PenLineEndCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenLineEndCap(BYTE val)
+{
+	return m_oDocument.put_PenLineEndCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenLineJoin(BYTE* val)
+{
+	return m_oDocument.get_PenLineJoin(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenLineJoin(BYTE val)
+{
+	return m_oDocument.put_PenLineJoin(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenDashOffset(double* val)
+{
+	return m_oDocument.get_PenDashOffset(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenDashOffset(double val)
+{
+	return m_oDocument.put_PenDashOffset(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenAlign(LONG* val)
+{
+	return m_oDocument.get_PenAlign(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenAlign(LONG val)
+{
+	return m_oDocument.put_PenAlign(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenMiterLimit(double* val)
+{
+	return m_oDocument.get_PenMiterLimit(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenMiterLimit(double val)
+{
+	return m_oDocument.put_PenMiterLimit(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PenDashPattern(SAFEARRAY* pPattern)
+{
+	return m_oDocument.PenDashPattern(pPattern);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetBrush(BSTR bsXML)
+{
+	return m_oDocument.SetBrush(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushType(LONG* lType)
+{
+	return m_oDocument.get_BrushType(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushType(LONG lType)
+{
+	return m_oDocument.put_BrushType(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushColor1(LONG* lColor)
+{
+	return m_oDocument.get_BrushColor1(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushColor1(LONG lColor)
+{
+	return m_oDocument.put_BrushColor1(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushAlpha1(LONG* lAlpha)
+{
+	return m_oDocument.get_BrushAlpha1(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushAlpha1(LONG lAlpha)
+{
+	return m_oDocument.put_BrushAlpha1(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushColor2(LONG* lColor)
+{
+	return m_oDocument.get_BrushColor2(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushColor2(LONG lColor)
+{
+	return m_oDocument.put_BrushColor2(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushAlpha2(LONG* lAlpha)
+{
+	return m_oDocument.get_BrushAlpha2(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushAlpha2(LONG lAlpha)
+{
+	return m_oDocument.put_BrushAlpha2(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushTexturePath(BSTR* bsPath)
+{
+	return m_oDocument.get_BrushTexturePath(bsPath);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushTexturePath(BSTR bsPath)
+{
+	return m_oDocument.put_BrushTexturePath(bsPath);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushTextureMode(LONG* lMode)
+{
+	return m_oDocument.get_BrushTextureMode(lMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushTextureMode(LONG lMode)
+{
+	return m_oDocument.put_BrushTextureMode(lMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushTextureAlpha(LONG* lTxAlpha)
+{
+	return m_oDocument.get_BrushTextureAlpha(lTxAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushTextureAlpha(LONG lTxAlpha)
+{
+	return m_oDocument.put_BrushTextureAlpha(lTxAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushLinearAngle(double* dAngle)
+{
+	return m_oDocument.get_BrushLinearAngle(dAngle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushLinearAngle(double dAngle)
+{
+	return m_oDocument.put_BrushLinearAngle(dAngle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::BrushRect(BOOL val, double left, double top, double width, double height)
+{
+	return m_oDocument.BrushRect(val, left, top, width, height);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetFont(BSTR bsXML)
+{
+	return m_oDocument.SetFont(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontName(BSTR* bsName)
+{
+	return m_oDocument.get_FontName(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontName(BSTR bsName)
+{
+	return m_oDocument.put_FontName(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontPath(BSTR* bsName)
+{
+	return m_oDocument.get_FontPath(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontPath(BSTR bsName)
+{
+	return m_oDocument.put_FontPath(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontSize(double* dSize)
+{
+	return m_oDocument.get_FontSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontSize(double dSize)
+{
+	return m_oDocument.put_FontSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontStyle(LONG* lStyle)
+{
+	return m_oDocument.get_FontStyle(lStyle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontStyle(LONG lStyle)
+{
+	return m_oDocument.put_FontStyle(lStyle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontStringGID(BOOL* bGID)
+{
+	return m_oDocument.get_FontStringGID(bGID);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontStringGID(BOOL bGID)
+{
+	return m_oDocument.put_FontStringGID(bGID);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontCharSpace(double* dSpace)
+{
+	return m_oDocument.get_FontCharSpace(dSpace);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontCharSpace(double dSpace)
+{
+	return m_oDocument.put_FontCharSpace(dSpace);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetShadow(BSTR bsXML)
+{
+	return m_oDocument.SetShadow(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowDistanceX(double* val)
+{
+	return m_oDocument.get_ShadowDistanceX(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowDistanceX(double val)
+{
+	return m_oDocument.put_ShadowDistanceX(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowDistanceY(double* val)
+{
+	return m_oDocument.get_ShadowDistanceY(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowDistanceY(double val)
+{
+	return m_oDocument.put_ShadowDistanceY(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowBlurSize(double* val)
+{
+	return m_oDocument.get_ShadowBlurSize(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowBlurSize(double val)
+{
+	return m_oDocument.put_ShadowBlurSize(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowColor(LONG* val)
+{
+	return m_oDocument.get_ShadowColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowColor(LONG val)
+{
+	return m_oDocument.put_ShadowColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowAlpha(LONG* val)
+{
+	return m_oDocument.get_ShadowAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowAlpha(LONG val)
+{
+	return m_oDocument.put_ShadowAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowVisible(BOOL* val)
+{
+	return m_oDocument.get_ShadowVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowVisible(BOOL val)
+{
+	return m_oDocument.put_ShadowVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetEdgeText(BSTR bsXML)
+{
+	return m_oDocument.SetEdgeText(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeVisible(LONG* val)
+{
+	return m_oDocument.get_EdgeVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeVisible(LONG val)
+{
+	return m_oDocument.put_EdgeVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeColor(LONG* val)
+{
+	return m_oDocument.get_EdgeColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeColor(LONG val)
+{
+	return m_oDocument.put_EdgeColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeAlpha(LONG* val)
+{
+	return m_oDocument.get_EdgeAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeAlpha(LONG val)
+{
+	return m_oDocument.put_EdgeAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeDist(double* val)
+{
+	return m_oDocument.get_EdgeDist(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeDist(double val)
+{
+	return m_oDocument.put_EdgeDist(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CommandDrawText(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset)
+{
+	return m_oDocument.CommandDrawText(bsText, fX, fY, fWidth, fHeight, fBaseLineOffset);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CommandDrawTextEx(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags)
+{
+	return m_oDocument.CommandDrawTextEx(bsUnicodeText, bsGidText, bsSourceCodeText, fX, fY, fWidth, fHeight, fBaseLineOffset, lFlags);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::BeginCommand(DWORD lType)
+{
+	return m_oDocument.BeginCommand(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::EndCommand(DWORD lType)
+{
+	return m_oDocument.EndCommand(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandMoveTo(double fX, double fY)
+{
+	return m_oDocument.PathCommandMoveTo(fX, fY);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandLineTo(double fX, double fY)
+{
+	return m_oDocument.PathCommandLineTo(fX, fY);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandLinesTo(SAFEARRAY* pPoints)
+{
+	return m_oDocument.PathCommandLinesTo(pPoints);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandCurveTo(double fX1, double fY1, double fX2, double fY2, double fX3, double fY3)
+{
+	return m_oDocument.PathCommandCurveTo(fX1, fY1, fX2, fY2, fX3, fY3);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandCurvesTo(SAFEARRAY* pPoints)
+{
+	return m_oDocument.PathCommandCurvesTo(pPoints);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandArcTo(double fX, double fY, double fWidth, double fHeight, double fStartAngle, double fSweepAngle)
+{
+	return m_oDocument.PathCommandArcTo(fX, fY, fWidth, fHeight, fStartAngle, fSweepAngle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandClose()
+{
+	return m_oDocument.PathCommandClose();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandEnd()
+{
+	return m_oDocument.PathCommandEnd();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::DrawPath(long nType)
+{
+	return m_oDocument.DrawPath(nType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandStart()
+{
+	return m_oDocument.PathCommandStart();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandGetCurrentPoint(double* fX, double* fY)
+{
+	return m_oDocument.PathCommandGetCurrentPoint( fX, fY );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::GetCommandParams(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags)
+{
+	return m_oDocument.GetCommandParams( dAngle, dLeft, dTop, dWidth, dHeight, lFlags );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetCommandParams(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags)
+{
+	return m_oDocument.SetCommandParams( dAngle, dLeft, dTop, dWidth, dHeight, lFlags );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::DrawImage(IUnknown* pInterface, double fX, double fY, double fWidth, double fHeight)
+{
+	return m_oDocument.DrawImage( pInterface, fX, fY, fWidth, fHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::DrawImageFromFile(BSTR bstrVal, double fX, double fY, double fWidth, double fHeight)
+{
+	return m_oDocument.DrawImageFromFile( bstrVal, fX, fY, fWidth, fHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetAdditionalParam(BSTR ParamName, VARIANT ParamValue)
+{
+	CString sParamName = ParamName;
+	if ( _T("SourceRendererType") == sParamName && VT_I4 == ParamValue.vt )
+	{
+		m_oDocument.m_bIsNeedPDFTextAnalyzer = ( ParamValue.lVal == c_nPDFWriter ? true : false );
+	}
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::GetAdditionalParam(BSTR ParamName, VARIANT* ParamValue)
+{
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetTransform(double dA, double dB, double dC, double dD, double dE, double dF)
+{
+	return m_oDocument.SetTransform( dA, dB, dC, dD, dE, dF );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
+{
+	return m_oDocument.GetTransform( pdA, pdB, pdC, pdD, pdE, pdF );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::ResetTransform(void)
+{
+	return m_oDocument.ResetTransform();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ClipMode(LONG* plMode)
+{
+	return m_oDocument.get_ClipMode(plMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ClipMode(LONG lMode)
+{
+	return m_oDocument.put_ClipMode(lMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandText(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset)
+{
+	return m_oDocument.PathCommandText(bsText, fX, fY, fWidth, fHeight, fBaseLineOffset);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandTextEx(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags)
+{
+	return m_oDocument.PathCommandTextEx( bsUnicodeText, bsGidText, bsSourceCodeText, fX, fY, fWidth, fHeight, fBaseLineOffset, lFlags );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::Initialize(BSTR bsXMLOptions)
+{
+	BaseInitialize(bsXMLOptions);
+
+	IUnknown* punkRenderer = NULL;
+	this->QueryInterface(IID_IUnknown, (void**)&punkRenderer);
+
+	m_oDocument.CreateDocument(punkRenderer, m_strTempFileDir);
+
+	RELEASEINTERFACE(punkRenderer);
+
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::Save()
+{
+	m_oDocument.Close();
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CreateOfficeFile(BSTR bsXMLOptions)
+{
+	BaseInitialize(bsXMLOptions);
+
+	IUnknown* punkRenderer = NULL;
+	this->QueryInterface(IID_IUnknown, (void**)&punkRenderer);
+
+	m_oDocument.CreateDocument(punkRenderer, m_strTempFileDir);
+
+	RELEASEINTERFACE(punkRenderer);
+
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CloseFile()
+{
+	m_oDocument.Close();
+	return S_OK;
+}
+
+/*========================================================================================================*/
\ No newline at end of file

DocxRenderer/src/tmp/ASCDocxRenderer.h

+// AVSDocxRenderer.h : Declaration of the CAVSDocxRenderer
+
+#pragma once
+#include "stdafx.h"
+#include "resource.h"       // main symbols
+
+#include "Logic/Document.h"
+
+#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA)
+#error "Single-threaded COM objects are not properly supported on Windows CE platform, such as the Windows Mobile platforms that do not include full DCOM support. Define _CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA to force ATL to support creating single-thread COM object's and allow use of it's single-threaded COM object implementations. The threading model in your rgs file was set to 'Free' as that is the only threading model supported in non DCOM Windows CE platforms."
+#endif
+
+// IAVSDocxRenderer
+[object, uuid("5BEC40F1-CA4F-4275-BCC8-D4ABF47D896D"), dual, pointer_default(unique)]
+__interface IAVSDocxRenderer : IASCRenderer
+{
+	[id(11001)]  HRESULT Initialize([in]BSTR bsXMLOptions);
+	[id(11002)]  HRESULT Save();
+};
+
+[object, uuid("84411C25-B8A1-4f16-A37A-9C142FBE8D26"), dual, pointer_default(unique)]
+__interface IAVSDocxRenderer2 : IDispatch
+{
+	[id(12001)]  HRESULT CreateOfficeFile([in]BSTR bstrFileName);
+	[id(12002)]  HRESULT CloseFile();
+};
+
+// CAVSDocxRenderer
+[coclass, default(IAVSDocxRenderer), threading(apartment), vi_progid("AVSOfficeDocxRenderer.AVSDocxRenderer"), progid("AVSOfficeDocxRenderer.AVSDocxRenderer.1"), version(1.0), uuid("77B37E21-16F0-4BCC-8901-DFD89B962174")]
+class ATL_NO_VTABLE CAVSDocxRenderer :
+	public IAVSDocxRenderer,
+	public IAVSDocxRenderer2
+{
+public:
+	CAVSDocxRenderer()
+	{
+	}
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+	HRESULT FinalConstruct()
+	{
+		m_strDstFilePath	= _T("");
+		m_strTempFileDir	= _T("");
+		m_strTempFileName	= _T("");
+
+		InitializeCriticalSection(&m_oCS);
+
+		return S_OK;
+	}
+
+	void FinalRelease()
+	{
+		CloseFile();
+		DeleteCriticalSection(&m_oCS);
+	}
+
+public:
+    // IASCRenderer Methods
+
+	//  -----------------------------------------------------------------------------
+	STDMETHOD(get_Type)(LONG* lType);
+
+	//--------      --------------------------------------------------
+	STDMETHOD(NewPage)();
+	STDMETHOD(get_Height)(double* dHeight);
+	STDMETHOD(put_Height)(double dHeight);
+	STDMETHOD(get_Width)(double* dWidth);
+	STDMETHOD(put_Width)(double dWidth);
+	STDMETHOD(get_DpiX)(double* dDpiX);
+	STDMETHOD(get_DpiY)(double* dDpiY);
+	//--------      ----------------------------------------------
+	STDMETHOD(SetPen)(BSTR bsXML);
+
+    STDMETHOD(get_PenColor)(LONG* lColor);
+	STDMETHOD(put_PenColor)(LONG lColor);
+	STDMETHOD(get_PenAlpha)(LONG* lAlpha);
+	STDMETHOD(put_PenAlpha)(LONG lAlpha);
+	STDMETHOD(get_PenSize)(double* dSize);
+	STDMETHOD(put_PenSize)(double dSize);
+	STDMETHOD(get_PenDashStyle)(BYTE* val);
+	STDMETHOD(put_PenDashStyle)(BYTE val);
+	STDMETHOD(get_PenLineStartCap)(BYTE* val);
+	STDMETHOD(put_PenLineStartCap)(BYTE val);
+	STDMETHOD(get_PenLineEndCap)(BYTE* val);
+	STDMETHOD(put_PenLineEndCap)(BYTE val);
+	STDMETHOD(get_PenLineJoin)(BYTE* val);
+	STDMETHOD(put_PenLineJoin)(BYTE val);
+	STDMETHOD(get_PenDashOffset)(double* val);
+	STDMETHOD(put_PenDashOffset)(double val);
+	STDMETHOD(get_PenAlign)(LONG* val);
+	STDMETHOD(put_PenAlign)(LONG val);
+	STDMETHOD(get_PenMiterLimit)(double* val);
+	STDMETHOD(put_PenMiterLimit)(double val);
+	STDMETHOD(PenDashPattern)(SAFEARRAY* pPattern);
+
+	STDMETHOD(SetBrush)(BSTR bsXML);
+
+	STDMETHOD(get_BrushType)(LONG* lType);
+	STDMETHOD(put_BrushType)(LONG lType);
+	STDMETHOD(get_BrushColor1)(LONG* lColor);
+	STDMETHOD(put_BrushColor1)(LONG lColor);
+	STDMETHOD(get_BrushAlpha1)(LONG* lAlpha);
+	STDMETHOD(put_BrushAlpha1)(LONG lAlpha);
+	STDMETHOD(get_BrushColor2)(LONG* lColor);
+	STDMETHOD(put_BrushColor2)(LONG lColor);
+	STDMETHOD(get_BrushAlpha2)(LONG* lAlpha);
+	STDMETHOD(put_BrushAlpha2)(LONG lAlpha);
+	STDMETHOD(get_BrushTexturePath)(BSTR* bsPath);
+	STDMETHOD(put_BrushTexturePath)(BSTR bsPath);
+	STDMETHOD(get_BrushTextureMode)(LONG* lMode);
+	STDMETHOD(put_BrushTextureMode)(LONG lMode);
+	STDMETHOD(get_BrushTextureAlpha)(LONG* lTxAlpha);
+	STDMETHOD(put_BrushTextureAlpha)(LONG lTxAlpha);
+	STDMETHOD(get_BrushLinearAngle)(double* dAngle);
+	STDMETHOD(put_BrushLinearAngle)(double dAngle);
+	STDMETHOD(BrushRect)(BOOL val, double left, double top, double width, double height);
+
+	STDMETHOD(SetFont)(BSTR bsXML);
+
+    STDMETHOD(get_FontName)(BSTR* bsName);
+	STDMETHOD(put_FontName)(BSTR bsName);
+	STDMETHOD(get_FontPath)(BSTR* bsName);
+	STDMETHOD(put_FontPath)(BSTR bsName);
+	STDMETHOD(get_FontSize)(double* dSize);
+	STDMETHOD(put_FontSize)(double dSize);
+	STDMETHOD(get_FontStyle)(LONG* lStyle);
+	STDMETHOD(put_FontStyle)(LONG lStyle);
+	STDMETHOD(get_FontStringGID)(BOOL* bGID);
+	STDMETHOD(put_FontStringGID)(BOOL bGID);
+	STDMETHOD(get_FontCharSpace)(double* dSpace);
+	STDMETHOD(put_FontCharSpace)(double dSpace);
+
+	STDMETHOD(SetShadow)(BSTR bsXML);
+
+    STDMETHOD(get_ShadowDistanceX)(double* val);
+	STDMETHOD(put_ShadowDistanceX)(double val);
+	STDMETHOD(get_ShadowDistanceY)(double* val);
+	STDMETHOD(put_ShadowDistanceY)(double val);
+	STDMETHOD(get_ShadowBlurSize)(double* val);
+	STDMETHOD(put_ShadowBlurSize)(double val);
+	STDMETHOD(get_ShadowColor)(LONG* val);
+	STDMETHOD(put_ShadowColor)(LONG val);
+	STDMETHOD(get_ShadowAlpha)(LONG* val);
+	STDMETHOD(put_ShadowAlpha)(LONG val);
+	STDMETHOD(get_ShadowVisible)(BOOL* val);
+	STDMETHOD(put_ShadowVisible)(BOOL val);
+
+	STDMETHOD(SetEdgeText)(BSTR bsXML);
+
+    STDMETHOD(get_EdgeVisible)(LONG* val);
+	STDMETHOD(put_EdgeVisible)(LONG val);
+	STDMETHOD(get_EdgeColor)(LONG* val);
+	STDMETHOD(put_EdgeColor)(LONG val);
+	STDMETHOD(get_EdgeAlpha)(LONG* val);
+	STDMETHOD(put_EdgeAlpha)(LONG val);
+	STDMETHOD(get_EdgeDist)(double* val);
+	STDMETHOD(put_EdgeDist)(double val);
+
+    //--------     --------------------------------------------------------
+	STDMETHOD(CommandDrawText)(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset);
+	STDMETHOD(CommandDrawTextEx)(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags);
+	//--------    ---------------------------------------------------------------
+	STDMETHOD(BeginCommand)(DWORD lType);
+	STDMETHOD(EndCommand)(DWORD lType);
+    //--------     Graphics Path -----------------------------------------------
+	STDMETHOD(PathCommandMoveTo)(double fX, double fY);
+	STDMETHOD(PathCommandLineTo)(double fX, double fY);
+	STDMETHOD(PathCommandLinesTo)(SAFEARRAY* pPoints);
+	STDMETHOD(PathCommandCurveTo)(double fX1, double fY1, double fX2, double fY2, double fX3, double fY3);
+	STDMETHOD(PathCommandCurvesTo)(SAFEARRAY* pPoints);
+	STDMETHOD(PathCommandArcTo)(double fX, double fY, double fWidth, double fHeight, double fStartAngle, double fSweepAngle);
+	STDMETHOD(PathCommandClose)();
+	STDMETHOD(PathCommandEnd)();
+	STDMETHOD(DrawPath)(long nType);
+	STDMETHOD(PathCommandStart)();
+	STDMETHOD(PathCommandGetCurrentPoint)(double* fX, double* fY);
+
+	STDMETHOD(PathCommandText)(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset);
+	STDMETHOD(PathCommandTextEx)(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags);
+	
+	STDMETHOD(GetCommandParams)(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags);
+	STDMETHOD(SetCommandParams)(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags);
+    //--------     --------------------------------------------------
+	STDMETHOD(DrawImage)(IUnknown* pInterface, double fX, double fY, double fWidth, double fHeight);
+	STDMETHOD(DrawImageFromFile)(BSTR bstrVal, double fX, double fY, double fWidth, double fHeight);
+	//------------------------------------------------------------------------------------------
+	STDMETHOD(SetAdditionalParam)(BSTR ParamName, VARIANT ParamValue);
+	STDMETHOD(GetAdditionalParam)(BSTR ParamName, VARIANT* ParamValue);
+
+    STDMETHOD(SetTransform)(double dA, double dB, double dC, double dD, double dE, double dF);
+	STDMETHOD(GetTransform)(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF);
+	STDMETHOD(ResetTransform)(void);
+	STDMETHOD(get_ClipMode)(LONG* plMode);
+	STDMETHOD(put_ClipMode)(LONG lMode);
+
+public:
+    //IAVSDocxRenderer Methods
+	STDMETHOD(Initialize)(BSTR bsXMLOptions);
+    STDMETHOD(Save)();
+
+public:
+	//IAVSDocxRenderer2 Methods
+	STDMETHOD(CreateOfficeFile)(BSTR bsFileName);
+    STDMETHOD(CloseFile)();
+
+private:
+	AVSGraphics::IASCFontManager*	m_pFontManager;
+	
+	NSDocxRenderer::CDocument m_oDocument;
+
+	CRITICAL_SECTION m_oCS;
+
+	CString m_strDstFilePath;
+	CString m_strTempFileDir;
+	CString m_strTempFileName;
+
+	void BaseInitialize(BSTR bsXMLOptions)
+	{
+		m_oDocument.m_oCurrentPage.m_eTextAssociationType = NSDocxRenderer::TextAssociationTypeNoFrames;
+		XmlUtils::CXmlReader oXmlReader;
+
+		if( TRUE == oXmlReader.OpenFromXmlString( bsXMLOptions ) )
+		{
+			if( TRUE == oXmlReader.ReadRootNode( _T( "DocxRenderer" ) ) )
+			{
+				m_strTempFileDir = oXmlReader.ReadNodeAttributeOrValue( _T( "destinationpath" ) );
+
+				CString textFormatting = oXmlReader.ReadNodeAttributeOrValue( _T( "textformatting" ) );
+
+				if ( !textFormatting.IsEmpty() )
+				{
+					m_oDocument.m_oCurrentPage.m_eTextAssociationType = (NSDocxRenderer::TextAssociationType)XmlUtils::GetInteger(textFormatting);
+				}
+			}
+		}
+	}
+};
+