/*
 * (c) Copyright Ascensio System SIA 2010-2017
 *
 * 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
 *
 */
#include "ShapeWriter.h"
#include "StylesWriter.h"

#include "../../../ASCOfficeXlsFile2/source/XlsXlsxConverter/ShapeType.h"
#include "../../../Common/MS-LCID.h"

#ifndef EMU_MM
#define EMU_MM 36000.0
#endif

void CStylesWriter::ConvertStyleLevel(NSPresentationEditor::CTextStyleLevel& oLevel,	NSPresentationEditor::CMetricInfo& oMetricInfo,
										NSPresentationEditor::CStringWriter& oWriter, const int& nLevel)
{//дублирование CTextPFRun и  CTextCFRun с ShapeWriter - todooo  - вынести отдельно
    std::wstring str1;
	if (nLevel == 9)
		str1 = _T("<a:defPPr");
	else
	{
		str1 = L"<a:lvl" + std::to_wstring(nLevel + 1) + L"pPr";
	}

	oWriter.WriteString(str1);

	NSPresentationEditor::CTextPFRun* pPF = &oLevel.m_oPFRun;

	if (pPF->textDirection.is_init())
	{
		if (pPF->textDirection.get() == 1)	oWriter.WriteString(L" rtl=\"1\"");
		else								oWriter.WriteString(L" rtl=\"0\"");
	}
	if (pPF->fontAlign.is_init())
	{
		std::wstring strProp = GetFontAlign(pPF->fontAlign.get());
		oWriter.WriteString(L" fontAlgn=\"" + strProp + L"\"");
	}
	if (pPF->leftMargin.is_init())
	{
		std::wstring strProp = std::to_wstring(pPF->leftMargin.get());
		oWriter.WriteString(L" marL=\"" + strProp + L"\"");

		if (pPF->indent.is_init() == false)
            pPF->indent = (LONG)0;
	}
	if (pPF->indent.is_init())
	{
		std::wstring strProp = std::to_wstring(pPF->indent.get());
		oWriter.WriteString(L" indent=\"" + strProp + L"\"");
	}
	if (pPF->textAlignment.is_init())
	{
		std::wstring strProp = GetTextAlign(pPF->textAlignment.get());
		oWriter.WriteString(L" algn=\"" + strProp + L"\"");
	}
	if (pPF->defaultTabSize.is_init())
	{
        std::wstring strProp = std::to_wstring(pPF->defaultTabSize.get());
		oWriter.WriteString(L" defTabSz=\"" + strProp + L"\"");
	}
	oWriter.WriteString(L">");

	if (pPF->tabStops.size() > 0)
	{
		oWriter.WriteString(L"<a:tabLst>");
		for (int t = 0 ; t < pPF->tabStops.size(); t++)
		{
			std::wstring strTabPos = std::to_wstring(pPF->tabStops[t].first);
			oWriter.WriteString(L"<a:tab pos=\"" + strTabPos + L"\"");

			if		(pPF->tabStops[t].second == 1)	oWriter.WriteString(L" algn=\"ctr\"/>");
			else if (pPF->tabStops[t].second == 2)	oWriter.WriteString(L" algn=\"r\"/>");
			else if (pPF->tabStops[t].second == 3)	oWriter.WriteString(L" algn=\"dec\"/>");
			else									oWriter.WriteString(L" algn=\"l\"/>");
		}
		oWriter.WriteString(L"</a:tabLst>");
	}

	if (pPF->hasBullet.is_init())
	{
		if (pPF->hasBullet.get())
		{
			if (pPF->bulletColor.is_init())
			{
				oWriter.WriteString(L"<a:buClr>");
				oWriter.WriteString(NSPresentationEditor::CShapeWriter::ConvertColor(pPF->bulletColor.get(), 255));
				oWriter.WriteString(L"</a:buClr>");
			}	
			if (pPF->bulletSize.is_init())
			{
				if (pPF->bulletSize.get() > 24 && pPF->bulletSize.get() < 401)
				{
					std::wstring strProp = std::to_wstring(pPF->bulletSize.get() * 1000 );
					oWriter.WriteString(L"<a:buSzPct val=\"" + strProp + L"\"/>");
				}
				if (pPF->bulletSize.get() < 0 && pPF->bulletSize.get() > -4001)
				{
					std::wstring strProp = std::to_wstring(- pPF->bulletSize.get() );
					oWriter.WriteString(L"<a:buSzPts val=\"" + strProp + L"\"/>");
				}
			}
			if (pPF->bulletFontProperties.is_init())
			{
				oWriter.WriteString(L"<a:buFont typeface=\"" + pPF->bulletFontProperties->strFontName + L"\"/>");
			}
			if (pPF->bulletChar.is_init())
			{
				wchar_t bu = pPF->bulletChar.get();
				
				oWriter.WriteString(L"<a:buChar char=\"");
				oWriter.WriteStringXML(std::wstring(&bu, 1));
				oWriter.WriteString(L"\"/>");	
			}
		}
		else
		{
			oWriter.WriteString(L"<a:buNone/>");
		}
	}

	double dKoef1 = 3.52777778;
	if (pPF->lineSpacing.is_init())
	{
        LONG val = pPF->lineSpacing.get();
		if (val > 0)
		{
			std::wstring str = std::to_wstring( (int)(val * 0.125 * 100/*/ dKoef1*/));
			oWriter.WriteString(L"<a:lnSpc><a:spcPts val=\"" + str + L"\"/></a:lnSpc>");
		}
		else if (val < 0 && val > -13200)
		{
			std::wstring str = std::to_wstring(-val * 1000);
			oWriter.WriteString(L"<a:lnSpc><a:spcPct val=\"" + str + L"\"/></a:lnSpc>");
		}
	}
	if (pPF->spaceAfter.is_init())
	{
        LONG val = pPF->spaceAfter.get();
		if (val > 0)
		{
			std::wstring str = std::to_wstring((int)(val * 0.125 * 100/*/ dKoef1*/));
			oWriter.WriteString(L"<a:spcAft><a:spcPts val=\"" + str + L"\"/></a:spcAft>");
		}
		else if (val < 0 && val > -13200)
		{
			std::wstring str = std::to_wstring(-val * 1000);
			oWriter.WriteString(L"<a:spcAft><a:spcPct val=\"" + str + L"\"/></a:spcAft>");
		}
	}
	if (pPF->spaceBefore.is_init())
	{
        LONG val = pPF->spaceBefore.get();
		if (val > 0)
		{
			std::wstring str = std::to_wstring((int)(val * 0.125 * 100/*/ dKoef1*/));
			oWriter.WriteString(L"<a:spcBef><a:spcPts val=\"" + str + L"\"/></a:spcBef>");
		}
		else if (val < 0 && val > -13200)
		{
			std::wstring str = std::to_wstring(-val * 1000);
			oWriter.WriteString(L"<a:spcBef><a:spcPct val=\"" + str + L"\"/></a:spcBef>");
		}
	}

	oWriter.WriteString(L"<a:defRPr");

	NSPresentationEditor::CTextCFRun* pCF = &oLevel.m_oCFRun;
	
	if (pCF->Size.is_init())
	{
		std::wstring str = std::to_wstring((int)(100 * pCF->Size.get()));
		oWriter.WriteString(L" sz=\"" + str + L"\"");
	}
	if (pCF->FontBold.is_init())
	{
		if (pCF->FontBold.get())
			oWriter.WriteString(L" b=\"1\"");
		else
			oWriter.WriteString(L" b=\"0\"");
	}
	if (pCF->FontItalic.is_init())
	{
		if (pCF->FontItalic.get())
			oWriter.WriteString(std::wstring(L" i=\"1\""));
		else
			oWriter.WriteString(std::wstring(L" i=\"0\""));
	}
	if (pCF->Language.is_init())
	{
		std::wstring str_lang = msLCID2wstring(pCF->Language.get());

		if (str_lang.length() > 0)
			oWriter.WriteString(std::wstring(L" lang=\"") + str_lang + _T("\""));
	}
	oWriter.WriteString(std::wstring(L">"));

	if (pCF->Color.is_init())
	{
		if (pCF->Color->m_lSchemeIndex != -1)
		{
			oWriter.WriteString(L"<a:solidFill><a:schemeClr val=\"" + GetColorInScheme(pCF->Color->m_lSchemeIndex) + L"\"/></a:solidFill>");
		}
		else
		{
            std::wstring strColor = XmlUtils::IntToString(pCF->Color->GetLONG_RGB(), L"%06x");

			oWriter.WriteString(L"<a:solidFill><a:srgbClr val=\"" + strColor + L"\"/></a:solidFill>");
		}
	}
	if (pCF->Typeface.is_init())
	{
		if (0 == pCF->Typeface.get())
		{
			oWriter.WriteString(L"<a:latin typeface=\"+mj-lt\"/>");
		}
		else
		{
			oWriter.WriteString(L"<a:latin typeface=\"+mn-lt\"/>");
		}
	}
	else if ((pCF->FontProperties.is_init()) && (!pCF->FontProperties->strFontName.empty()))
	{
		oWriter.WriteString(L"<a:latin typeface=\"" + pCF->FontProperties->strFontName + L"\"/>");
	}
	if (pCF->FontPropertiesEA.is_init())
	{
		oWriter.WriteString(L"<a:ea typeface=\"" + pCF->FontPropertiesEA->strFontName + L"\"/>");
	}
	if (pCF->FontPropertiesSym.is_init())
	{
		oWriter.WriteString(L"<a:sym typeface=\"" + pCF->FontPropertiesSym->strFontName + L"\"/>");
	}
	oWriter.WriteString(L"</a:defRPr>");		

    std::wstring str3;
	if (nLevel == 9)
		str3 = L"</a:defPPr>";
	else
		str3 = L"</a:lvl" + std::to_wstring(nLevel + 1) + L"pPr>";

	oWriter.WriteString(str3);
}
NSPresentationEditor::CShapeWriter::CShapeWriter()
{
	m_pRels			= NULL;
	m_lNextShapeID	= 1000;

	m_bWordArt		= false;
	m_bTextBox		= false;
	
//////////////////////////////////////////////////////////////////////
	m_dDpiX = 96.0;
	m_dDpiY	= 96.0;

	m_lClipMode = c_nClipRegionTypeWinding;

	m_pSimpleGraphicsConverter = new Aggplus::CGraphicsPathSimpleConverter();
	m_pSimpleGraphicsConverter->SetRenderer(this);

	m_dTransformAngle = 0.0;

	m_dWidth	= 100;
	m_dHeight	= 100;

	m_pFontManager = NULL;

	m_pImageElement = NULL;
	m_pShapeElement = NULL;
}
std::wstring	NSPresentationEditor::CShapeWriter::ConvertLine(CPen & pen)
{
	NSPresentationEditor::CStringWriter line_writer;

	std::wstring str = std::to_wstring(	(int)(pen.Size * 36000));
	line_writer.WriteString(L"<a:ln w=\"" + str + L"\">");

	line_writer.WriteString(L"<a:solidFill>");
		line_writer.WriteString(ConvertColor(pen.Color, pen.Alpha));
	line_writer.WriteString(L"</a:solidFill>");

	line_writer.WriteString(L"<a:round/><a:headEnd/><a:tailEnd/></a:ln>");

	return line_writer.GetData();
}
std::wstring	NSPresentationEditor::CShapeWriter::ConvertBrush(CBrush & brush)
{
	NSPresentationEditor::CStringWriter brush_writer;
	
	if (brush.Type == c_BrushTypeTexture)
	{
		if (m_pImageElement)//фон для картинки с празрачностью
		{
			brush_writer.WriteString(L"<a:noFill/>");
		}
		else
		{
			std::wstring strRid = m_pRels->WriteImage(brush.TexturePath);

			brush_writer.WriteString(L"<a:blipFill dpi=\"0\" rotWithShape=\"1\"><a:blip r:embed=\"" + strRid + L"\"/><a:srcRect/>");
				
			if (	brush.TextureMode == c_BrushTextureModeTile)
				brush_writer.WriteString(L"<a:tile/>");
			else
				brush_writer.WriteString(L"<a:stretch><a:fillRect/></a:stretch>");

			brush_writer.WriteString(L"</a:blipFill>");
		}
	}
	else if (	brush.Type == c_BrushTypeNoFill) 
	{
		brush_writer.WriteString(L"<a:noFill/>");
	}
	else if (	brush.Type == c_BrushTypePathGradient1	||
				brush.Type == c_BrushTypePathGradient2	||
				brush.Type == c_BrushTypeCenter			||
				brush.Type == c_BrushTypeHorizontal		||
				brush.Type == c_BrushTypeVertical		) 
	{
		brush_writer.WriteString(L"<a:gradFill><a:gsLst>");
		if (brush.ColorsPosition.empty() == false)
		{
			for (int i = 0; i < brush.ColorsPosition.size(); i++)
			{
				std::wstring str = std::to_wstring( (int)(brush.ColorsPosition[i].second * 1000));
				
				brush_writer.WriteString(L"<a:gs pos=\"" + str + L"\">");
					brush_writer.WriteString(ConvertColor(brush.ColorsPosition[i].first, 255));
				brush_writer.WriteString(L"</a:gs>");	
			}
		}
		else
		{
			brush_writer.WriteString(L"<a:gs pos=\"0\">");
				brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
			brush_writer.WriteString(L"</a:gs>");
			
			brush_writer.WriteString(L"<a:gs pos=\"100000\">");
				brush_writer.WriteString(ConvertColor(brush.Color2, brush.Alpha2));
			brush_writer.WriteString(L"</a:gs>");
		}
		brush_writer.WriteString(L"</a:gsLst>");
		brush_writer.WriteString(L"<a:lin ang=\"");
		{
			if (brush.LinearAngle < -180)	brush.LinearAngle += 180;
			if (brush.LinearAngle > 180)	brush.LinearAngle -= 180;

			int val = (90 - brush.LinearAngle) ;
			if (val < 0)	val = 0;
			if (val > 360)	val -= 360;
			
			std::wstring str = std::to_wstring(val * 60000);
			brush_writer.WriteString(str);
		}
		brush_writer.WriteString(L"\" scaled=\"1\"/>");
		brush_writer.WriteString(L"</a:gradFill>");
	}
	else if(brush.Type == c_BrushTypePattern)
	{//типов нету в ппт - вместо них шаблон-картинка
		brush_writer.WriteString(L"<a:pattFill prst=\"pct80\">");
			brush_writer.WriteString(L"<a:fgClr>");
				brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
			brush_writer.WriteString(L"</a:fgClr>");
			brush_writer.WriteString(L"<a:bgClr>");
				brush_writer.WriteString(ConvertColor(brush.Color2, brush.Alpha2));
			brush_writer.WriteString(L"</a:bgClr>");
		brush_writer.WriteString(L"</a:pattFill>");
	}
	else
	{
		brush_writer.WriteString(std::wstring(L"<a:solidFill>"));
			brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
		brush_writer.WriteString(std::wstring(L"</a:solidFill>"));
	}
	return brush_writer.GetData();
}

std::wstring	NSPresentationEditor::CShapeWriter::ConvertShadow(CShadow	& shadow)
{
	std::wstring	Preset;
	bool			Inner = false;

	if (shadow.Visible == false)		return _T("");

	double dist = sqrt(shadow.DistanceY * shadow.DistanceY  + shadow.DistanceX * shadow.DistanceX);
	double dir	= 0;
	
	if (fabs(shadow.DistanceY) > 0)
	{
		dir = 180 * atan(shadow.DistanceX / shadow.DistanceY) / 3.1415926;

		if (dir < 0) dir += 180;

		if (shadow.DistanceX < 0 && shadow.DistanceY < 0) dir *= 10;
	}

	if (shadow.Type == 1) Preset = L"shdw13";

	if (shadow.Type == 5)
	{
		if (shadow.DistanceX < 0 && shadow.DistanceY < 0)	Preset = L"shdw18";
		else												Preset = L"shdw17";
	}
	if (shadow.Type == 2 && shadow.OriginX < 0) 
	{
		if (shadow.OriginX < -1.4)
		{
			if (shadow.ScaleYToY < 0)	Preset = L"shdw15";
			else						Preset = L"shdw11";
		}
		else
		{
			if (shadow.ScaleYToY < 0)	Preset = L"shdw16";
			else						Preset = L"shdw12";
		}
	}

	std::wstring strDir;
	std::wstring strDist;

	if (shadow.DistanceY != 0 && shadow.DistanceX != 0)
	{
		if (shadow.DistanceY < 0 && shadow.DistanceX < 0) dir /=2;

		strDir	= L" dir=\"" + std::to_wstring((int)(dir * 60000)) + L"\"";
		strDist	= L" dist=\"" + std::to_wstring((int)(dist * 36000)) + L"\"";	
	}

	std::wstring strSY;
	if (shadow.ScaleYToY < 1 || shadow.ScaleYToY > 1)
	{
		if (shadow.ScaleYToX < 1)shadow.ScaleYToY = -shadow.ScaleYToY;

		strSY = L" sy=\"" + std::to_wstring((int)(shadow.ScaleYToY * 100000)) + L"\"";	
	}
	std::wstring strSX;
	if (shadow.ScaleYToX < 1 || shadow.ScaleYToX > 1)
	{
		strSX = L" kx=\"" + std::to_wstring((int)((shadow.ScaleYToX + 0.5) * 360000)) + L"\"";
	}
	NSPresentationEditor::CStringWriter shadow_writer;
	
	shadow_writer.WriteString(L"<a:effectLst>");

	if (!Preset.empty())
	{
		shadow_writer.WriteString(L"<a:prstShdw");
			shadow_writer.WriteString(L" prst=\"" + Preset + L"\"");
			//shadow_writer.WriteString(std::wstring(L" rotWithShape=\"0\" algn=\"ctr\""));
			shadow_writer.WriteString(strDir);
			shadow_writer.WriteString(strDist);
		shadow_writer.WriteString(L">");

		shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
		shadow_writer.WriteString(L"</a:prstShdw>");
	}
	else if (Inner)
	{
		shadow_writer.WriteString(L"<a:innerShdw");
			shadow_writer.WriteString(L" rotWithShape=\"0\"");
			if (strSX.empty() && strSY.empty())
			{
				shadow_writer.WriteString(L" algn=\"ctr\"");
			}
			shadow_writer.WriteString(strSX);
			shadow_writer.WriteString(strSY);
			shadow_writer.WriteString(strDir);
			shadow_writer.WriteString(strDist);
		shadow_writer.WriteString(L">");

		shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
		shadow_writer.WriteString(L"</a:innerShdw>");
	}
	else
	{
		shadow_writer.WriteString(L"<a:outerShdw");
			shadow_writer.WriteString(L" rotWithShape=\"0\"");
			if (strSX.empty() && strSY.empty())
			{
				shadow_writer.WriteString(L" algn=\"ctr\"");
			}
			shadow_writer.WriteString(strSX);
			shadow_writer.WriteString(strSY);
			shadow_writer.WriteString(strDir);
			shadow_writer.WriteString(strDist);
		shadow_writer.WriteString(L">");

		shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
		shadow_writer.WriteString(L"</a:outerShdw>");
	}
	shadow_writer.WriteString(L"</a:effectLst>");
	return shadow_writer.GetData();
}

std::wstring  NSPresentationEditor::CShapeWriter::ConvertColor(CColor & color, long alpha)
{
	NSPresentationEditor::CStringWriter color_writer;
	if (color.m_lSchemeIndex == -1)
    {
		if (255 == alpha)
		{
            color_writer.WriteString(L"<a:srgbClr val=\"" + XmlUtils::IntToString(color.GetLONG_RGB(), L"%06X") + L"\"/>");
		}
		else
		{
            color_writer.WriteString(L"<a:srgbClr val=\"" + XmlUtils::IntToString(color.GetLONG_RGB(), L"%06X") + L"\">" +
                                     L"<a:alpha val=\"" + std::to_wstring((int)(alpha * 100000 / 255)) + L"\"/></a:srgbClr>");
		}
	}
	else
	{
		if (255 == alpha)
		{
			color_writer.WriteString(L"<a:schemeClr val=\"" + CStylesWriter::GetColorInScheme(color.m_lSchemeIndex) + L"\"/>");
		}
		else
		{
			std::wstring strAlpha = std::to_wstring((int)(alpha * 100000 / 255));
			color_writer.WriteString(L"<a:schemeClr val=\"" + CStylesWriter::GetColorInScheme(color.m_lSchemeIndex) + L"\"><a:alpha val=\"" + strAlpha + L"\"/></a:schemeClr>");
		}
	}
	return color_writer.GetData();
}
void NSPresentationEditor::CShapeWriter::WriteImageInfo()
{
	m_oWriter.WriteString(std::wstring(L"<p:nvPicPr>"));

	std::wstring strShapeID = std::to_wstring(m_lNextShapeID);	
	
	m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + strShapeID + L"\"" );
	
	if (m_pImageElement->m_sName.empty()) 
		m_pImageElement->m_sName = std::wstring(L"Image ") + strShapeID;
	
	if (m_pImageElement->m_bHidden)	m_oWriter.WriteString(std::wstring(L" hidden=\"1\""));

	m_oWriter.WriteString(std::wstring(L" name=\""));
		m_oWriter.WriteStringXML(m_pImageElement->m_sName);
	m_oWriter.WriteString(std::wstring(L"\""));
	
	//if (!m_pImageElement->m_sDescription.empty())
	//{//бывает всякая разная бяка сохранена 
	//	m_oWriter.WriteString(std::wstring(L" descr=\""));
	//		m_oWriter.WriteStringXML(m_pImageElement->m_sDescription);
	//	m_oWriter.WriteString(std::wstring(L"\""));
	//}

	m_oWriter.WriteString(std::wstring(L"></p:cNvPr><p:cNvPicPr><a:spLocks noGrp=\"1\" noChangeAspect=\"1\"/></p:cNvPicPr>"));

	++m_lNextShapeID;

	if (-1 != m_pImageElement->m_lPlaceholderType)
	{
		m_oWriter.WriteString(std::wstring(L"<p:nvPr><p:ph"));
		if (m_pImageElement->m_lPlaceholderType > 0)
			m_oWriter.WriteString(std::wstring(L" type=\"") + GetPhType(m_pImageElement->m_lPlaceholderType) + L"\"");
		
		if (-1 != m_pImageElement->m_lPlaceholderID)
		{
			std::wstring strIdx = std::to_wstring(m_pImageElement->m_lPlaceholderID );
			m_oWriter.WriteString(std::wstring(L" idx=\"") + strIdx + L"\"");

		}
		m_oWriter.WriteString(std::wstring(L"/></p:nvPr>"));
	}
	else
	{
		m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
	}
	
    std::wstring str2 = _T("</p:nvPicPr>");
	m_oWriter.WriteString(str2);
}

void NSPresentationEditor::CShapeWriter::WriteShapeInfo()
{
	m_oWriter.WriteString(std::wstring(L"<p:nvSpPr>"));

	if (m_pShapeElement->m_lID < 0) 
		m_pShapeElement->m_lID = m_lNextShapeID;

	std::wstring strShapeID = std::to_wstring(m_pShapeElement->m_lID);

	m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + strShapeID + L"\"");

	if (m_pShapeElement->m_sName.empty()) m_pShapeElement->m_sName = std::wstring(L"Shape ") +  strShapeID;

	if (m_pShapeElement->m_bHidden)	m_oWriter.WriteString(std::wstring(L" hidden=\"1\""));
	
	m_oWriter.WriteString(std::wstring(L" name=\""));
		m_oWriter.WriteStringXML(m_pShapeElement->m_sName);
	m_oWriter.WriteString(std::wstring(L"\""));

	if (!m_pShapeElement->m_sDescription.empty())
	{
		m_oWriter.WriteString(std::wstring(L" descr=\""));
			m_oWriter.WriteStringXML(m_pShapeElement->m_sDescription);
		m_oWriter.WriteString(std::wstring(L"\""));
	}
	m_oWriter.WriteString(std::wstring(L">"));
	if (!m_pShapeElement->m_sHyperlink.empty())
	{
        std::wstring rId = m_pRels->WriteHyperlink(m_pShapeElement->m_sHyperlink);

		m_oWriter.WriteString(std::wstring(L"<a:hlinkClick"));
			m_oWriter.WriteString(std::wstring(L" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\""));					
			m_oWriter.WriteString(std::wstring(L" r:id=\"" + rId ));
		m_oWriter.WriteString(std::wstring(L"\"></a:hlinkClick>"));
	}		
	m_oWriter.WriteString(std::wstring(L"</p:cNvPr>"));
	
	m_oWriter.WriteString(std::wstring(L"<p:cNvSpPr"));
		if (m_bTextBox)
			m_oWriter.WriteString(std::wstring(L" txBox=\"1\""));
	m_oWriter.WriteString(std::wstring(L"><a:spLocks noGrp=\"1\" noChangeArrowheads=\"1\"/>"));
	m_oWriter.WriteString(std::wstring(L"</p:cNvSpPr>"));

	++m_lNextShapeID;

	if (-1 != m_pShapeElement->m_lPlaceholderType)
	{
		m_oWriter.WriteString(std::wstring(L"<p:nvPr><p:ph"));
		
		if (m_pShapeElement->m_lPlaceholderType > 0 /*&& !isBodyPlaceholder(m_pShapeElement->m_lPlaceholderType)*/)
			m_oWriter.WriteString(std::wstring(L" type=\"") + GetPhType(m_pShapeElement->m_lPlaceholderType) + _T("\""));
		
		if ( m_pShapeElement->m_lPlaceholderID != -1)
		{
			std::wstring strIdx = std::to_wstring( m_pShapeElement->m_lPlaceholderID );			 
			m_oWriter.WriteString(std::wstring(L" idx=\"") + strIdx + L"\"");
		}
		
		if (m_pShapeElement->m_lPlaceholderSizePreset > 1 && !isTitlePlaceholder(m_pShapeElement->m_lPlaceholderType))
		{
			if (m_pShapeElement->m_lPlaceholderSizePreset == 1)
				m_oWriter.WriteString(std::wstring(L" size=\"half\""));
			if (m_pShapeElement->m_lPlaceholderSizePreset == 2)
				m_oWriter.WriteString(std::wstring(L" size=\"quarter\""));
			if (m_pShapeElement->m_lPlaceholderSizePreset == 3)
			{
				if (isBodyPlaceholder(m_pShapeElement->m_lPlaceholderType))
					m_oWriter.WriteString(std::wstring(L" size=\"half\""));
				else 
					m_oWriter.WriteString(std::wstring(L" size=\"quarter\""));
			}
		}		
		m_oWriter.WriteString(std::wstring(L"/></p:nvPr>"));
	}
	else
	{
		m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
	}
	
    std::wstring str2 = _T("</p:nvSpPr>");
	m_oWriter.WriteString(str2);
}
void NSPresentationEditor::CShapeWriter::WriteTextInfo()
{
	size_t nCount = m_pShapeElement->m_oShape.m_oText.m_arParagraphs.size();

	m_oWriter.WriteString(std::wstring(L"<p:txBody>"));

	m_oWriter.WriteString(std::wstring(L"<a:bodyPr" ));

	int __l = (int)((-	m_oBounds.left		+ m_oTextRect.left	)* EMU_MM);
	int __t = (int)((-	m_oBounds.top		+ m_oTextRect.top	)* EMU_MM);
	int __r = (int)((	m_oBounds.right		- m_oTextRect.right	)* EMU_MM);
	int __b = (int)((	m_oBounds.bottom	- m_oTextRect.bottom)* EMU_MM);

    std::wstring str =  L" lIns=\"" + std::to_wstring(__l) + L"\" tIns=\"" + std::to_wstring(__t) +
                        L"\" rIns=\"" + std::to_wstring(__r) + L"\" bIns=\"" + std::to_wstring(__b) + L"\"";
	m_oWriter.WriteString(str);
	
//	m_oWriter.WriteString(std::wstring(L" lIns=\"0\" tIns=\"0\" rIns=\"0\" bIns=\"0\""));

	if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 0 )			
		m_oWriter.WriteString(L" anchor=\"t\"");
	else if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 2 )	
		m_oWriter.WriteString(L" anchor=\"b\"");
	else if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 1 )	
	{
		m_oWriter.WriteString(L" anchor=\"ctr\"");
		m_oWriter.WriteString(L" anchorCtr=\"0\"");
	}
	if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_dTextRotate > 0)
	{
		std::wstring strProp = std::to_wstring((int)(m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_dTextRotate * 60000));
		m_oWriter.WriteString(L" rot=\"" + strProp + L"\"");
	}
	if (m_pShapeElement->m_oShape.m_oText.m_bVertical)
	{
		m_oWriter.WriteString(L" vert=\"eaVert\"");
	}
	m_oWriter.WriteString(L">");

	if (m_bWordArt)
	{
		std::wstring prstTxWarp = oox::Spt2WordArtShapeType((oox::MSOSPT)m_pShapeElement->m_lShapeType);				
		m_oWriter.WriteString(std::wstring(L"<a:prstTxWarp"));
			m_oWriter.WriteString(std::wstring(L" prst=\"") + prstTxWarp + _T("\">"));
			m_oWriter.WriteString(std::wstring(L"<a:avLst>"));//модификаторы

			CPPTShape *pPPTShape = dynamic_cast<CPPTShape *>(m_pShapeElement->m_oShape.m_pShape);
            std::wstring strVal;

			for (int i = 0 ; (pPPTShape) && (i < pPPTShape->m_arAdjustments.size()); i++)
			{
				switch(m_pShapeElement->m_lShapeType)
				{
					case oox::msosptTextFadeUp:
					{
						double kf = 4.63; //"волшебный"
						std::wstring strVal = std::to_wstring((int)(kf * pPPTShape->m_arAdjustments[i]));
						
						m_oWriter.WriteString(L"<a:gd name=\"adj\" fmla=\"val ");
						m_oWriter.WriteString(strVal + L"\"/>");
					}break;
				}
				
			}

			m_oWriter.WriteString(L"</a:avLst>");
		m_oWriter.WriteString(L"</a:prstTxWarp>");
	}
	if (m_pShapeElement->m_oShape.m_oText.m_bAutoFit)
	{
		m_oWriter.WriteString(L"<a:spAutoFit/>");
	}
	m_oWriter.WriteString(L"</a:bodyPr>");
	
	if (0 == nCount)
	{
		m_oWriter.WriteString(L"<a:lstStyle/><a:p><a:endParaRPr dirty=\"0\"/></a:p></p:txBody>");
		return;
	}
	m_oWriter.WriteString(L"<a:lstStyle>");

	if (!m_bWordArt)
	{
		CStylesWriter::ConvertStyles(m_pShapeElement->m_oShape.m_oText.m_oStyles, m_oMetricInfo, m_oWriter);
	}

	m_oWriter.WriteString(std::wstring(L"</a:lstStyle>"));

	for (size_t nIndexPar = 0; nIndexPar < nCount; ++nIndexPar)
	{
		NSPresentationEditor::CParagraph* pParagraph = &m_pShapeElement->m_oShape.m_oText.m_arParagraphs[nIndexPar];

		//if (m_bWordArt && nIndexPar == nCount-1)
		//{
		//	if (pParagraph->m_arSpans.size() < 1) break;
		//	if (pParagraph->m_arSpans.size() == 1 && pParagraph->m_arSpans[0].m_strText.empty()) break;
		//}

		std::wstring _str1 = std::to_wstring(pParagraph->m_lTextLevel);
		m_oWriter.WriteString(L"<a:p><a:pPr lvl=\"" + _str1 + L"\"");

		NSPresentationEditor::CTextPFRun* pPF = &pParagraph->m_oPFRun;

		if (pPF->textDirection.is_init())
		{
			if (pPF->textDirection.get() == 1)	m_oWriter.WriteString(std::wstring(L" rtl=\"1\""));
			else								m_oWriter.WriteString(std::wstring(L" rtl=\"0\""));
		}
		if (pPF->fontAlign.is_init())
		{
			std::wstring strProp = CStylesWriter::GetFontAlign(pPF->fontAlign.get());
			m_oWriter.WriteString(std::wstring(L" fontAlgn=\"") + strProp + L"\"");
		}
		if (pPF->leftMargin.is_init())
		{
            std::wstring strProp = std::to_wstring( pPF->leftMargin.get() );
			m_oWriter.WriteString(L" marL=\"" + strProp + L"\"");
			
			if (pPF->indent.is_init() == false)
				pPF->indent = (LONG)0;

		}
		if (pPF->indent.is_init())
		{
			std::wstring strProp = std::to_wstring(pPF->indent.get());
			m_oWriter.WriteString(L" indent=\"" + strProp + L"\"");
		}
		if (pPF->textAlignment.is_init())
		{
            std::wstring strProp = CStylesWriter::GetTextAlign(pPF->textAlignment.get());
			m_oWriter.WriteString(L" algn=\"" + strProp + L"\"");
		}
		if (pPF->defaultTabSize.is_init())
		{
			std::wstring strProp= std::to_wstring( pPF->defaultTabSize.get());
			m_oWriter.WriteString(L" defTabSz=\"" + strProp + L"\"");
		}
		m_oWriter.WriteString(L">");

		double dKoef1 = 3.52777778; // :-) чё это не понятно ...
		if (pPF->lineSpacing.is_init())
		{
			LONG val = pPF->lineSpacing.get();
			//1/1024 master unit or 1/589824 inch.
			//1 inch = 576 master unit -> 1 master unit = 0.125 pt
			if (val > 0)//The absolute value specifies spacing in master units.
			{
				std::wstring strProp = std::to_wstring( (int)(val* 0.125 * 100/*/ dKoef1*/));
				m_oWriter.WriteString(L"<a:lnSpc><a:spcPts val=\"" + strProp + L"\"/></a:lnSpc>");
			}
			else if (val < 0 && val > -13200)
			{//0 to 13200, inclusive - The value specifies spacing as a percentage of the text line height.
				std::wstring strProp = std::to_wstring( -val * 1000);
				m_oWriter.WriteString(L"<a:lnSpc><a:spcPct val=\"" + strProp + L"\"/></a:lnSpc>");
			}
		}
		if (pPF->spaceAfter.is_init())
		{
			LONG val = pPF->spaceAfter.get();
			if (val > 0)
			{
				std::wstring strProp = std::to_wstring((int)(val * 0.125 * 100/*/ dKoef1*/));
				m_oWriter.WriteString(L"<a:spcAft><a:spcPts val=\"" + strProp + L"\"/></a:spcAft>");
			}
			else if (val < 0 && val > -13200)
			{
				std::wstring strProp = std::to_wstring(-val * 1000);
				m_oWriter.WriteString(L"<a:spcAft><a:spcPct val=\"" + strProp + L"\"/></a:spcAft>");
			}
		}
		if (pPF->spaceBefore.is_init())
		{
			LONG val = pPF->spaceBefore.get();
			if (val > 0)
			{
				std::wstring strProp = std::to_wstring((int)(val * 0.125 * 100/*/ dKoef1*/));
				m_oWriter.WriteString(L"<a:spcBef><a:spcPts val=\"" + strProp + L"\"/></a:spcBef>");
			}
			else if (val < 0 && val > -13200)
			{
				std::wstring strProp = std::to_wstring(-val * 1000);
				m_oWriter.WriteString(L"<a:spcBef><a:spcPct val=\"" + strProp + L"\"/></a:spcBef>");
			}
		}

		if (pPF->hasBullet.is_init())
		{
			if (pPF->hasBullet.get())
			{
				if (pPF->bulletColor.is_init())
				{
					m_oWriter.WriteString(std::wstring(L"<a:buClr>"));
						m_oWriter.WriteString(ConvertColor(pPF->bulletColor.get(), 255));
					m_oWriter.WriteString(std::wstring(L"</a:buClr>"));
				}	
				if (pPF->bulletSize.is_init())
				{
					if (pPF->bulletSize.get() > 24 && pPF->bulletSize.get() < 401)
					{
						std::wstring strProp = std::to_wstring(pPF->bulletSize.get() * 1000 );
						m_oWriter.WriteString(L"<a:buSzPct val=\"" + strProp + L"\"/>");
					}
					if (pPF->bulletSize.get() < 0 && pPF->bulletSize.get() > -4001)
					{
						std::wstring strProp = std::to_wstring(- pPF->bulletSize.get() );
						m_oWriter.WriteString(L"<a:buSzPts val=\"" + strProp + L"\"/>");
					}
				}
				if (pPF->bulletFontProperties.is_init())
				{
					m_oWriter.WriteString(std::wstring(L"<a:buFont typeface=\"") + pPF->bulletFontProperties->strFontName + _T("\"/>"));
				}

				bool set = true;
				if (pPF->bulletFontProperties.is_init() == false && pPF->bulletSize.is_init() == false)
				{
					m_oWriter.WriteString(std::wstring(L"<a:buFontTx/>"));
					if (pPF->bulletColor.is_init() == false)
						set = false;
				}

				if (pPF->bulletChar.is_init())
				{
					wchar_t bu = pPF->bulletChar.get();
					m_oWriter.WriteString(std::wstring(L"<a:buChar char=\""));
					m_oWriter.WriteStringXML(std::wstring(&bu, 1));
					m_oWriter.WriteString(std::wstring(L"\"/>"));
					set = true;
				}
				
				if (!set)
				{
					wchar_t bu = 0x2022;
					m_oWriter.WriteString(std::wstring(L"<a:buChar char=\""));
					m_oWriter.WriteStringXML(std::wstring(&bu, 1));
					m_oWriter.WriteString(std::wstring(L"\"/>"));
				}
			}
			else
			{
				m_oWriter.WriteString(std::wstring(L"<a:buNone/>"));
			}
		}

		m_oWriter.WriteString(std::wstring(L"</a:pPr>"));

		std::wstring typeRun = L"a:r";

		size_t nCountSpans = pParagraph->m_arSpans.size();
		for (size_t nSpan = 0; nSpan < nCountSpans; ++nSpan)
		{
			if (true)
			{
				if ((nSpan == (nCountSpans - 1)) && (_T("\n") == pParagraph->m_arSpans[nSpan].m_strText || pParagraph->m_arSpans[nSpan].m_strText.empty()) )
				{
					NSPresentationEditor::CTextCFRun* pCF = &pParagraph->m_arSpans[nSpan].m_oRun;
					if ((pCF->Size.is_init()) && (pCF->Size.get() > 0) && (pCF->Size.get() < 4001))
					{
                        m_oWriter.WriteString(L"<a:endParaRPr lang=\"en-US\" sz=\"" + std::to_wstring((int)(100 * pCF->Size.get())) + L"\"/>");
					}
					else
					{
						m_oWriter.WriteString(std::wstring(L"<a:endParaRPr lang=\"en-US\"/>"));
					}
					continue;
				}
			}

			NSPresentationEditor::CTextCFRun* pCF = &pParagraph->m_arSpans[nSpan].m_oRun;
			int span_sz = pParagraph->m_arSpans[nSpan].m_strText.length() ;

            if	((span_sz==1 && ( pParagraph->m_arSpans[nSpan].m_strText[0] == (wchar_t)13 )) ||
                ((span_sz==2 && ( pParagraph->m_arSpans[nSpan].m_strText[0] == (wchar_t)13 ) && ( pParagraph->m_arSpans[nSpan].m_strText[1] == (wchar_t)13 ))))
			{
				continue;
			}

			if (pParagraph->m_arSpans[nSpan].m_strText.empty() && !pParagraph->m_arSpans[nSpan].m_bBreak) continue;
			
			if (pParagraph->m_arSpans[nSpan].m_bBreak)
			{
				m_oWriter.WriteString(std::wstring(L"<a:br><a:rPr"));
			}
			else
			{
				if (m_pShapeElement->m_lPlaceholderType == PT_MasterSlideNumber && pParagraph->m_arSpans[nSpan].m_bField)
				{
					m_oWriter.WriteString(std::wstring(L"<a:fld id=\"{D038279B-FC19-497E-A7D1-5ADD9CAF016F}\" type=\"slidenum\"><a:rPr"));
				}
				else if (m_pShapeElement->m_lPlaceholderType == PT_MasterDate && m_pShapeElement->m_nFormatDate == 1 && pParagraph->m_arSpans[nSpan].m_bField)
				{
					m_oWriter.WriteString(std::wstring(L"<a:fld id=\"{D7E01130-044F-4930-9A27-C729C70D8524}\" type=\"datetime1\"><a:rPr"));
				}
				else
				{						
					m_oWriter.WriteString(std::wstring(L"<a:r><a:rPr"));
				}
			}					
			
			if ((pCF->Size.is_init()) && (pCF->Size.get() > 0) && (pCF->Size.get() < 4001))
			{
                m_oWriter.WriteString(L" sz=\"" + std::to_wstring((int)(100 * pCF->Size.get())) + L"\"");
			}		
			if (pCF->BaseLineOffset.is_init())
			{
                m_oWriter.WriteString(L" baseline=\"" + std::to_wstring((int)(1000 * pCF->BaseLineOffset.get())) + L"\"");
			}
			if (pCF->FontBold.is_init())
			{
				if (pCF->FontBold.get())
					m_oWriter.WriteString(std::wstring(L" b=\"1\""));
				else
					m_oWriter.WriteString(std::wstring(L" b=\"0\""));
			}
			if (pCF->FontItalic.is_init())
			{
				if (pCF->FontItalic.get())
					m_oWriter.WriteString(std::wstring(L" i=\"1\""));
				else
					m_oWriter.WriteString(std::wstring(L" i=\"0\""));
			}

			if (pCF->FontUnderline.is_init())
			{
				if (pCF->FontUnderline.get())
					m_oWriter.WriteString(std::wstring(L" u=\"sng\""));
				else
					m_oWriter.WriteString(std::wstring(L" u=\"none\""));
			}
			if (pCF->Language.is_init())
			{
				std::wstring str_lang = msLCID2wstring(pCF->Language.get());

				if (str_lang.length() > 0)
					m_oWriter.WriteString(std::wstring(L" lang=\"") + str_lang + _T("\""));
			}
			m_oWriter.WriteString(std::wstring(L">"));

			if (m_bWordArt)
			{//порядок важен - линия, заливка, тень !!!			
				if (m_pShapeElement->m_bLine)
				{
					m_oWriter.WriteString(ConvertLine(m_pShapeElement->m_oPen));
				}
				m_oWriter.WriteString(ConvertBrush(m_pShapeElement->m_oBrush));
				m_oWriter.WriteString(ConvertShadow(m_pShapeElement->m_oShadow));
			}
		else
			{
				if (pCF->Color.is_init())
				{
					if (pCF->Color->m_lSchemeIndex != -1)
					{
                        std::wstring strProp = _T("<a:solidFill><a:schemeClr val=\"") + CStylesWriter::GetColorInScheme(pCF->Color->m_lSchemeIndex) + _T("\"/></a:solidFill>");
						m_oWriter.WriteString(strProp);
					}
					else
					{
                        std::wstring strColor = XmlUtils::IntToString(pCF->Color->GetLONG_RGB(), L"%06x");

                        m_oWriter.WriteString(L"<a:solidFill><a:srgbClr val=\"" + strColor + L"\"/></a:solidFill>");
					}
				}
			}

			if (pCF->Typeface.is_init())
			{
				if (0 == pCF->Typeface.get())
				{
                    std::wstring strProp = _T("<a:latin typeface=\"+mj-lt\"/>");
					m_oWriter.WriteString(strProp);
				}
				else
				{
                    std::wstring strProp = _T("<a:latin typeface=\"+mn-lt\"/>");
					m_oWriter.WriteString(strProp);
				}
			}
			else if (pCF->FontProperties.is_init())
			{
				m_oWriter.WriteString(std::wstring(L"<a:latin typeface=\"") + pCF->FontProperties->strFontName + _T("\"/>"));
			}
			if (pCF->FontPropertiesEA.is_init())
			{
				m_oWriter.WriteString(std::wstring(L"<a:ea typeface=\"") + pCF->FontPropertiesEA->strFontName + _T("\"/>"));
			}
			if (pCF->FontPropertiesSym.is_init())
			{
				m_oWriter.WriteString(std::wstring(L"<a:sym typeface=\"") + pCF->FontPropertiesSym->strFontName + _T("\"/>"));
			}
			m_oWriter.WriteString(std::wstring(L"</a:rPr>"));

			if (pParagraph->m_arSpans[nSpan].m_bBreak)
			{
				m_oWriter.WriteString(std::wstring(L"</a:br>"));
			}
			else
			{
                std::wstring strT1 = _T("<a:t>");
				m_oWriter.WriteString(strT1);

				std::wstring strT = pParagraph->m_arSpans[nSpan].m_strText;
				NSPresentationEditor::CorrectXmlString(strT);
				m_oWriter.WriteString(strT);

                std::wstring strT2 = _T("</a:t>");
				m_oWriter.WriteString(strT2);
				
				if ((m_pShapeElement->m_lPlaceholderType == PT_MasterSlideNumber || 
					(m_pShapeElement->m_lPlaceholderType == PT_MasterDate && m_pShapeElement->m_nFormatDate == 1)) &&  pParagraph->m_arSpans[nSpan].m_bField)
				{
					m_oWriter.WriteString(std::wstring(L"</a:fld>"));
				}
				else
					m_oWriter.WriteString(std::wstring(L"</a:r>"));
			}
		}

        std::wstring strEndPar = _T("</a:p>");
		m_oWriter.WriteString(strEndPar);
	}

    std::wstring str5 = _T("</p:txBody>");
	m_oWriter.WriteString(str5);
}

std::wstring NSPresentationEditor::CShapeWriter::ConvertShape()
{
	if (m_pImageElement) return ConvertImage();

	if (m_pShapeElement == NULL) return _T("");

	std::wstring prstTxWarp;
	std::wstring prstGeom	= oox::Spt2ShapeType_mini((oox::MSOSPT)m_pShapeElement->m_lShapeType);
//rect, ellipse, line

	if (prstGeom.empty())
	{
		prstTxWarp = oox::Spt2WordArtShapeType((oox::MSOSPT)m_pShapeElement->m_lShapeType);
		if (prstTxWarp.empty() == false)
		{
			m_bWordArt = true;
			m_bTextBox = true;
			prstGeom = L"rect";
			m_oBrush.Type = c_BrushTypeNoFill;
		}
	}
	else
	{
		if (oox::msosptTextBox == (oox::MSOSPT)m_pShapeElement->m_lShapeType)	
			m_bTextBox = true;
		if (oox::msosptLine == (oox::MSOSPT)m_pShapeElement->m_lShapeType)	
			m_pShapeElement->m_bLine = true;
	}

	m_oWriter.WriteString(std::wstring(L"<p:sp>"));

	WriteShapeInfo();

	CGeomShapeInfo oInfo;
	oInfo.SetBounds(m_oBounds);

	oInfo.m_dRotate = m_pShapeElement->m_dRotate;
	oInfo.m_bFlipH	= m_pShapeElement->m_bFlipH;
	oInfo.m_bFlipV	= m_pShapeElement->m_bFlipV;

    oInfo.m_lOriginalWidth	= (LONG)m_pShapeElement->m_rcBoundsOriginal.GetWidth();
    oInfo.m_lOriginalHeight	= (LONG)m_pShapeElement->m_rcBoundsOriginal.GetHeight();

	m_oWriter.WriteString(std::wstring(L"<p:spPr>"));

	if (m_pShapeElement->m_bBoundsEnabled)
	{
        std::wstring str;
		
		m_oWriter.WriteString(std::wstring(L"<a:xfrm"));	
			if (0 != m_pShapeElement->m_dRotate)
			{
				if (m_pShapeElement->m_bFlipH && m_pShapeElement->m_dRotate < 180)
					m_pShapeElement->m_dRotate += 180; //Тікбұрышты үшбұрыштарды.ppt slide-7

                m_oWriter.WriteString(L" rot=\"" + std::to_wstring((int)(m_pShapeElement->m_dRotate * 60000)) + L"\"");
			}
			if (m_pShapeElement->m_bFlipH)
			{
				m_oWriter.WriteString(std::wstring(L" flipH=\"1\""));
			}
			if (m_pShapeElement->m_bFlipV)
			{
				m_oWriter.WriteString(std::wstring(L" flipV=\"1\""));
			}
		m_oWriter.WriteString(std::wstring(L">"));

        m_oWriter.WriteString(L"<a:off x=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.left) + L"\" y=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.top) + L"\"/>");

		int width	= m_pShapeElement->m_rcBoundsOriginal.right - m_pShapeElement->m_rcBoundsOriginal.left;
		int height	= m_pShapeElement->m_rcBoundsOriginal.bottom - m_pShapeElement->m_rcBoundsOriginal.top;
		if ( width > 0 || height > 0 )
		{
            m_oWriter.WriteString(L"<a:ext cx=\"" + std::to_wstring(width) + L"\" cy=\"" + std::to_wstring(height) + L"\"/>");
		}
		m_oWriter.WriteString(std::wstring(L"</a:xfrm>"));
	}

	if (m_pShapeElement->m_oShape.m_lDrawType & c_ShapeDrawType_Graphic || m_pShapeElement->m_oShape.m_pShape->m_bCustomShape)
	{
		m_pShapeElement->m_oShape.ToRenderer(dynamic_cast<IRenderer*>(this), oInfo, m_oMetricInfo, 0.0, 1.0);
	}

	if ((prstGeom.empty() == false || m_pShapeElement->m_bShapePreset) && prstTxWarp.empty() && !m_pShapeElement->m_oShape.m_pShape->m_bCustomShape)
	{
		if (prstGeom.empty()) prstGeom = L"rect";
		m_oWriter.WriteString(std::wstring(L"<a:prstGeom"));
		{
			m_oWriter.WriteString(std::wstring(L" prst=\"") + prstGeom + std::wstring(L"\">"));
			if (!m_bWordArt)	
			{
				m_oWriter.WriteString(std::wstring(L"<a:avLst/>"));
			}
		}
		m_oWriter.WriteString(std::wstring(L"</a:prstGeom>"));	
	}
	else if (prstTxWarp.empty())
	{
		m_oWriter.WriteString(m_pShapeElement->ConvertPPTShapeToPPTX());
	}
	else
	{
		//word art
		m_oWriter.WriteString(std::wstring(L"<a:prstGeom prst=\"rect\"/>"));
	}

	if (!m_bWordArt)
	{
		m_oWriter.WriteString(ConvertBrush(m_pShapeElement->m_oBrush));
		if (m_pShapeElement->m_bLine)
		{
			m_oWriter.WriteString(ConvertLine(m_pShapeElement->m_oPen));
		}
		m_oWriter.WriteString(ConvertShadow(m_pShapeElement->m_oShadow));
	}

	m_oWriter.WriteString(std::wstring(L"</p:spPr>"));			

	WriteTextInfo();
	m_oWriter.WriteString(std::wstring(L"</p:sp>"));

	m_pShapeElement = NULL;

	return m_oWriter.GetData();
}

std::wstring NSPresentationEditor::CShapeWriter::ConvertImage()
{
	if (m_pImageElement->m_bImagePresent == false)
	{
		if (m_pImageElement->m_sName.empty()) return _T("");
		//ppt_presentation.ppt - ссылка на файл на диске 

		m_pImageElement->m_strImageFileName.clear();
		m_pImageElement->m_bImagePresent = true;
	}
    std::wstring strRid;
	if (!m_pImageElement->m_strImageFileName.empty())
	{
		strRid = m_pRels->WriteImage(m_pImageElement->m_strImageFileName);
	}	
	else if (!m_pImageElement->m_sImageName.empty())
	{
		strRid = m_pRels->WriteHyperlinkImage(CorrectXmlString3(m_pImageElement->m_sImageName));
	}	
	
    if (strRid.empty()) return _T("");

	m_oWriter.WriteString(std::wstring(L"<p:pic>"));

	WriteImageInfo();

	CGeomShapeInfo oInfo;
	oInfo.SetBounds(m_oBounds);

	oInfo.m_dRotate = m_pImageElement->m_dRotate;
	oInfo.m_bFlipH	= m_pImageElement->m_bFlipH;
	oInfo.m_bFlipV	= m_pImageElement->m_bFlipV;

    oInfo.m_lOriginalWidth	= (LONG)m_pImageElement->m_rcBoundsOriginal.GetWidth();
    oInfo.m_lOriginalHeight	= (LONG)m_pImageElement->m_rcBoundsOriginal.GetHeight();

	m_oWriter.WriteString(std::wstring(L"<p:blipFill>"));
		
        std::wstring strWrite = _T("<a:blip r:embed=\"") + strRid + _T("\"/>");
		m_oWriter.WriteString(strWrite);

		m_oWriter.WriteString(std::wstring(L"<a:srcRect"));
		if (m_pImageElement->m_bCropEnabled)
		{
            m_oWriter.WriteString(L" l=\"" + std::to_wstring((size_t)(m_pImageElement->m_lcropFromLeft  *1.5)) + L"\"");
            m_oWriter.WriteString(L" t=\"" + std::to_wstring((size_t)(m_pImageElement->m_lcropFromTop   *1.5)) + L"\"");
            m_oWriter.WriteString(L" r=\"" + std::to_wstring((size_t)(m_pImageElement->m_lcropFromRight *1.5)) + L"\"");
            m_oWriter.WriteString(L" b=\"" + std::to_wstring((size_t)(m_pImageElement->m_lcropFromBottom*1.5)) + L"\"");
		}
		m_oWriter.WriteString(std::wstring(L"/>"));
		
		if (m_pImageElement->m_bTile)
		{
			m_oWriter.WriteString(std::wstring(L"<a:tile/>"));
		}
		else if (m_pImageElement->m_bStretch)
		{
			m_oWriter.WriteString(std::wstring(L"<a:stretch><a:fillRect/></a:stretch>"));
		}

	m_oWriter.WriteString(std::wstring(L"</p:blipFill>"));

	m_oWriter.WriteString(std::wstring(L"<p:spPr>"));

	if (m_pImageElement->m_bBoundsEnabled)
	{
        std::wstring str;
		
		m_oWriter.WriteString(std::wstring(L"<a:xfrm"));	
			if (0 != m_pImageElement->m_dRotate)
			{
                m_oWriter.WriteString(L" rot=\"" + std::to_wstring(m_pImageElement->m_dRotate * 60000) + L"\"");
			}
			if (m_pImageElement->m_bFlipH)
			{
				m_oWriter.WriteString(std::wstring(L" flipH=\"1\""));
			}
			if (m_pImageElement->m_bFlipV)
			{
				m_oWriter.WriteString(std::wstring(L" flipV=\"1\""));
			}
		m_oWriter.WriteString(std::wstring(L">"));

        m_oWriter.WriteString(L"<a:off x=\"" + std::to_wstring((int)m_pImageElement->m_rcBoundsOriginal.left) + L"\" y=\"" + std::to_wstring((int)m_pImageElement->m_rcBoundsOriginal.top) + L"\"/>");

		int width	= m_pImageElement->m_rcBoundsOriginal.right - m_pImageElement->m_rcBoundsOriginal.left;
		int height	= m_pImageElement->m_rcBoundsOriginal.bottom - m_pImageElement->m_rcBoundsOriginal.top;
		if ( width > 0 || height > 0 )
		{
            m_oWriter.WriteString(L"<a:ext cx=\"" + std::to_wstring(width) + L"\" cy=\"" + std::to_wstring(height) + L"\"/>");
		}
		m_oWriter.WriteString(std::wstring(L"</a:xfrm>"));
	}
	m_oWriter.WriteString(std::wstring(L"<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>"));

	m_oWriter.WriteString(ConvertBrush(m_pImageElement->m_oBrush));

	if (m_pImageElement->m_bLine)
	{
		m_oWriter.WriteString(ConvertLine(m_pImageElement->m_oPen));
	}

	m_oWriter.WriteString(std::wstring(L"</p:spPr>"));			

	m_oWriter.WriteString(std::wstring(L"</p:pic>"));
	
	m_pImageElement = NULL;
	return m_oWriter.GetData();
}

HRESULT NSPresentationEditor::CShapeWriter::get_Type(LONG* lType)
{
	if (NULL == lType)
        return S_FALSE;

	*lType = c_nSVGConverter;
	return S_OK;
}
//-------- Функции для работы со страницей --------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::NewPage()
{
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_Height(double* dHeight)
{
	if (NULL != dHeight)
		*dHeight = m_dHeight;	
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_Height(const double& dHeight)
{
	m_dHeight = dHeight;

	m_oBaseTransform.Reset();
    double dScaleX = 43200 / (std::max)(m_oBounds.GetWidth(), 0.01);
    double dScaleY = 43200 / (std::max)(m_oBounds.GetHeight(), 0.01);
	m_oBaseTransform.Translate(-m_oBounds.left, -m_oBounds.top, Aggplus::MatrixOrderAppend);
	m_oBaseTransform.Scale(dScaleX, dScaleY, Aggplus::MatrixOrderAppend);
	
	CalculateFullTransform();

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_Width(double* dWidth)
{
	if (NULL != dWidth)
		*dWidth = m_dWidth;	
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_Width(const double& dWidth)
{
	m_dWidth = dWidth;

	m_oBaseTransform.Reset();
    double dScaleX = 43200 / (std::max)(m_oBounds.GetWidth(), 0.01);
    double dScaleY = 43200 / (std::max)(m_oBounds.GetHeight(), 0.01);
	m_oBaseTransform.Translate(-m_oBounds.left, -m_oBounds.top, Aggplus::MatrixOrderAppend);
	m_oBaseTransform.Scale(dScaleX, dScaleY, Aggplus::MatrixOrderAppend);

	CalculateFullTransform();

	return S_OK;
}

HRESULT NSPresentationEditor::CShapeWriter::get_DpiX(double* dDpiX)
{
	if (NULL != dDpiX)
		*dDpiX = m_dDpiX;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_DpiY(double* dDpiY)
{
	if (NULL != dDpiY)
		*dDpiY = m_dDpiY;
	return S_OK;
}
// pen --------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetPen(std::wstring bsXML)
{
    //m_oPen.FromXmlString((std::wstring)bsXML);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenColor(LONG* lColor)
{
	*lColor = m_oPen.Color.GetLONG();
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenColor(const LONG&  lColor)
{
	BYTE lScheme = ((DWORD)(lColor)) >> 24;

	if (0xFF != lScheme)
		m_oPen.Color.SetBGR(lColor);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenAlpha(LONG* lAlpha)
{
	*lAlpha = m_oPen.Alpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenAlpha(const LONG& lAlpha)
{
	m_oPen.Alpha = lAlpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenSize(double* dSize)
{
	*dSize = m_oPen.Size;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenSize(const double& dSize)
{
	m_oPen.Size = dSize * 25.4 / 96.0;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenDashStyle(BYTE* val)
{
	*val = m_oPen.DashStyle;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenDashStyle(const BYTE& val)
{
	m_oPen.DashStyle = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenLineStartCap(BYTE* val)
{
	*val = m_oPen.LineStartCap;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenLineStartCap(const BYTE& val)
{
	m_oPen.LineStartCap = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenLineEndCap(BYTE* val)
{
	*val = m_oPen.LineEndCap;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenLineEndCap(const BYTE& val)
{
	m_oPen.LineEndCap = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenLineJoin(BYTE* val)
{
	*val = m_oPen.LineJoin;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenLineJoin(const BYTE& val)
{
	m_oPen.LineJoin = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenDashOffset(double* val)
{
	*val = m_oPen.DashOffset;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenDashOffset(const double&  val)
{
	m_oPen.DashOffset = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenAlign(LONG* val)
{
	*val = m_oPen.Align;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenAlign(const LONG& val)
{
	m_oPen.Align = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_PenMiterLimit(double* val)
{
	*val = m_oPen.MiterLimit;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_PenMiterLimit(const double& val)
{
	m_oPen.MiterLimit = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PenDashPattern(double* pPattern, LONG lCount)
{
	if (NULL != pPattern)
	{
		m_oPen.SetDashPattern(pPattern, lCount);
	}

	return S_OK;
}
// brush ------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetBrush(std::wstring bsXML)
{
    //m_oBrush.FromXmlString((std::wstring)bsXML);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushType(LONG* lType)
{
	*lType = m_oBrush.Type;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushType(const LONG& lType)
{
	m_oBrush.Type = lType;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushColor1(LONG* lColor)
{
	*lColor = m_oBrush.Color1.GetLONG();
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushColor1(const LONG& lColor)
{
	BYTE lScheme = ((DWORD)(lColor)) >> 24;

	if (0xFF != lScheme)
		m_oBrush.Color1.SetBGR(lColor);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushAlpha1(LONG* lAlpha)
{
	*lAlpha = m_oBrush.Alpha1;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushAlpha1(const LONG& lAlpha)
{
	m_oBrush.Alpha1 = lAlpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushColor2(LONG* lColor)
{
	*lColor = m_oBrush.Color2.GetLONG();
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushColor2(const LONG& lColor)
{
	m_oBrush.Color2.SetBGR(lColor);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushAlpha2(LONG* lAlpha)
{
	*lAlpha = m_oBrush.Alpha2;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushAlpha2(const LONG& lAlpha)
{
	m_oBrush.Alpha2 = lAlpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushTexturePath(std::wstring* bsPath)
{
	if (bsPath == NULL) return S_OK;
	*bsPath = m_oBrush.TexturePath;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushTexturePath(const std::wstring& bsPath)
{
	m_oBrush.TexturePath = bsPath;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushTextureMode(LONG* lMode)
{
	*lMode = m_oBrush.TextureMode;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushTextureMode(const LONG& lMode)
{
	m_oBrush.TextureMode = lMode;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushTextureAlpha(LONG* lTxAlpha)
{
	*lTxAlpha = m_oBrush.TextureAlpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushTextureAlpha(const LONG& lTxAlpha)
{
	m_oBrush.TextureAlpha = lTxAlpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_BrushLinearAngle(double* dAngle)
{
	*dAngle = m_oBrush.LinearAngle;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_BrushLinearAngle(const double& dAngle)
{
	m_oBrush.LinearAngle = dAngle;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::BrushRect(const INT& val, const double& left, const double& top, const double& width, const 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;
}
HRESULT NSPresentationEditor::CShapeWriter::BrushBounds(const double& left, const double& top, const double& width, const double& height)
{
	return S_OK;
}

HRESULT NSPresentationEditor::CShapeWriter::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount)
{

	return S_OK;
}
// font -------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetFont(std::wstring bsXML)
{
    //m_oFont.FromXmlString((std::wstring)bsXML);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontName(std::wstring* bsName)
{
	if (bsName == NULL) return S_OK;
	*bsName = m_oFont.Name;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontName(const std::wstring& bsName)
{
	m_oFont.Name = bsName;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontPath(std::wstring* bsName)
{
	if (bsName == NULL) return S_OK;
	*bsName = m_oFont.Path;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontPath(const std::wstring& bsName)
{
	m_oFont.Path = bsName;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontSize(double* dSize)
{
	*dSize = m_oFont.Size;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontSize(const double& dSize)
{
	m_oFont.Size = dSize;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontStyle(LONG* lStyle)
{
	*lStyle = m_oFont.GetStyle();
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontStyle(const LONG& lStyle)
{
	m_oFont.SetStyle(lStyle);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontStringGID(INT* bGID)
{
	*bGID = m_oFont.StringGID;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontStringGID(const INT& bGID)
{
	m_oFont.StringGID = bGID;
	m_pFontManager->SetStringGID(bGID);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontCharSpace(double* dSpace)
{
	*dSpace = m_oFont.CharSpace;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontCharSpace(const double& dSpace)
{
	m_oFont.CharSpace = dSpace;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_FontFaceIndex(int* lFaceIndex)
{
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_FontFaceIndex(const int& lFaceIndex)
{
	return S_OK;
}
// shadow -----------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetShadow(std::wstring bsXML)
{
    //m_oShadow.FromXmlString((std::wstring)bsXML);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowDistanceX(double* val)
{
	*val = m_oShadow.DistanceX;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowDistanceX(double val)
{
	m_oShadow.DistanceX = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowDistanceY(double* val)
{
	*val = m_oShadow.DistanceY;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowDistanceY(double val)
{
	m_oShadow.DistanceY = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowBlurSize(double* val)
{
	*val = m_oShadow.BlurSize;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowBlurSize(double val)
{
	m_oShadow.BlurSize = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowColor(LONG* val)
{
	*val = m_oShadow.Color.GetLONG();
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowColor(LONG val)
{
	m_oShadow.Color.SetBGR(val);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowAlpha(LONG* val)
{
	*val = m_oShadow.Alpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowAlpha(LONG val)
{
	m_oShadow.Alpha = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_ShadowVisible(bool* val)
{
	*val = m_oShadow.Visible;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ShadowVisible(bool val)
{
	m_oShadow.Visible = val;
	return S_OK;
}
// edge -------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::SetEdgeText(std::wstring bsXML)
{
    //m_oEdge.FromXmlString((std::wstring)bsXML);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeVisible(LONG* val)
{
	*val = m_oEdge.Visible;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeVisible(LONG val)
{
	m_oEdge.Visible = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeColor(LONG* val)
{
	*val = m_oEdge.Color.GetLONG();
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeColor(LONG val)
{
	m_oEdge.Color.SetBGR(val);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeAlpha(LONG* val)
{
	*val = m_oEdge.Alpha;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeAlpha(LONG val)
{
	m_oEdge.Alpha = val;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::get_EdgeDist(double* val)
{
	*val = m_oEdge.Dist;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_EdgeDist(double val)
{
	m_oEdge.Dist = val;
	return S_OK;
}
//-------- Функции для вывода текста --------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
{
	if (c_nHyperlinkType == m_lCurrentCommandType)
		return S_OK;

    if (true)
	{
		PathCommandEnd();
		BeginCommand(c_nPathType);
		PathCommandText(bsText, x, y, w, h);
		DrawPath(c_nWindingFillMode);
		EndCommand(c_nPathType);
		PathCommandEnd();
		return S_OK;
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
{

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
{

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
{

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
{

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandLong(const LONG& lType, const LONG& lCommand)
{

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandDouble(const LONG& lType, const double& dCommand)
{

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::CommandString(const LONG& lType, const std::wstring& sCommand)
{

	return S_OK;
}

HRESULT NSPresentationEditor::CShapeWriter::CommandDrawTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
{
    if (true)
	{
		PathCommandEnd();
		BeginCommand(c_nPathType);
		PathCommandTextEx(bsUnicodeText, pGids, nGidsCount ,x, y, w, h);
		DrawPath(c_nWindingFillMode);
		EndCommand(c_nPathType);
		PathCommandEnd();
		return S_OK;
	}
	return S_OK;
}
//-------- Маркеры для команд ---------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::BeginCommand(const DWORD& lType)
{
	if (c_nPathType == lType)
	{
		m_pSimpleGraphicsConverter->PathCommandEnd();
	}

	m_lCurrentCommandType = lType;

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::EndCommand(const DWORD& lType)
{
	m_lCurrentCommandType = -1;
	return S_OK;
}
//-------- Функции для работы с Graphics Path -----------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::PathCommandMoveTo(const double& x, const double& y)
{
	if (c_nSimpleGraphicType == m_lCurrentCommandType)
	{
		MoveTo(x, y);
	}
	else
	{
		m_pSimpleGraphicsConverter->PathCommandMoveTo(x, y);
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandLineTo(const double& x, const double& y)
{
	if (c_nSimpleGraphicType == m_lCurrentCommandType)
	{
		LineTo(x, y);
	}
	else
	{
		m_pSimpleGraphicsConverter->PathCommandLineTo(x, y);
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandLinesTo(double* points, const int& count)
{
	m_pSimpleGraphicsConverter->PathCommandLinesTo(points, count);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandCurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
{
	if (c_nSimpleGraphicType == m_lCurrentCommandType)
	{
		CurveTo(x1, y1, x2, y2, x3, y3);
	}
	else
	{
		m_pSimpleGraphicsConverter->PathCommandCurveTo(x1, y1, x2, y2, x3, y3);
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandCurvesTo(double* points, const int& count)
{
	m_pSimpleGraphicsConverter->PathCommandCurvesTo(points, count);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandArcTo(const double& x, const double& y, const double& w, const double& h, const double& startAngle, const double& sweepAngle)
{
	m_pSimpleGraphicsConverter->PathCommandArcTo(x, y, w, h, startAngle, sweepAngle);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandClose()
{
	if (c_nSimpleGraphicType == m_lCurrentCommandType)
	{
		Close();
	}
	else
	{
		m_pSimpleGraphicsConverter->PathCommandClose();
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandEnd()
{
	if (c_nSimpleGraphicType == m_lCurrentCommandType)
	{
		End();
	}
	else
	{
		m_pSimpleGraphicsConverter->PathCommandEnd();
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::DrawPath(const LONG& nType)
{
	bool bIsStroke	= ((0x01 == (nType & 0x01)) && (0 != m_oPen.Alpha));
	bool bIsFill	= ((0xFF < nType) && (0 != m_oBrush.Alpha1));

	if (bIsStroke && bIsFill)
	{
        m_oWriterVML.WriteString(L"<a:path w=\"43200\" h=\"43200\">");
		m_oWriterVML.Write(m_oWriterPath);
		m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
	}
	else if (bIsStroke)
	{
        m_oWriterVML.WriteString(L"<a:path w=\"43200\" h=\"43200\" fill=\"none\">");
		m_oWriterVML.Write(m_oWriterPath);
		m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
	}
	else if (bIsFill)
	{
        m_oWriterVML.WriteString(L"<a:path w=\"43200\" h=\"43200\" stroke=\"0\">");
		m_oWriterVML.Write(m_oWriterPath);
		m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandStart()
{
	if (c_nSimpleGraphicType == m_lCurrentCommandType)
	{
		Start();
	}
	else
	{
		m_pSimpleGraphicsConverter->PathCommandEnd();
		m_pSimpleGraphicsConverter->PathCommandStart();
	}

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandGetCurrentPoint(double* fX, double* fY)
{
	m_pSimpleGraphicsConverter->PathCommandGetCurrentPoint(fX, fY);	
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
{
	_SetFont();
	m_pSimpleGraphicsConverter->PathCommandText(bsText, m_pFontManager, x, y, w, h, 0);
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::PathCommandTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
{
    bool bGid = m_oFont.StringGID;
	//TODOO
	//if (NULL != bsGidText)
	//{
 //       m_oFont.StringGID = true;
	//	PathCommandText(bsUnicodeText, x, y, w, h, baselineOffset);
	//}
	
    m_oFont.StringGID = false;
	PathCommandText(bsUnicodeText, x, y, w, h);

	m_oFont.StringGID = bGid;
	return S_OK;
}
//-------- Функции для вывода изображений ---------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h)
{
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::DrawImageFromFile(const std::wstring&, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha)
{
	return S_OK;
}
// transform --------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::GetCommandParams(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags)
{
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::SetCommandParams(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;
	
	Aggplus::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;
	CalculateFullTransform();

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::SetTransform(const double& m1, const double& m2, const double& m3, const double& m4, const double& m5, const double& m6)
{
	Aggplus::CMatrix oTrans(m1, m2, m3, m4, m5, m6);
	m_oTransform = oTrans;

	CalculateFullTransform();

	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
{
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::ResetTransform(void)
{
	m_oTransform.Reset();
	CalculateFullTransform();
	return S_OK;
}
// -----------------------------------------------------------------------------------------
HRESULT NSPresentationEditor::CShapeWriter::get_ClipMode(LONG* plMode)
{
	*plMode = m_lClipMode;
	return S_OK;
}
HRESULT NSPresentationEditor::CShapeWriter::put_ClipMode(const LONG& lMode)
{
	m_lClipMode = lMode;
	return S_OK;
}
// --------------------------------------------------------------------------------------------