/*
 * (c) Copyright Ascensio System SIA 2010-2023
 *
 * 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 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * 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 "docx_drawing.h"
#include <xml/simple_xml_writer.h>
#include "../../DataTypes/custom_shape_types_convert.h"

namespace cpdoccore {

namespace oox {


namespace {

}
void serialize_wrap_top_bottom(std::wostream & strm,  _docx_drawing const & val)
{
    CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"wp:wrapTopAndBottom")
		{
			if (val.margin_rect[3])CP_XML_ATTR(L"distB",val.margin_rect[3]);
			if (val.margin_rect[1])CP_XML_ATTR(L"distT",val.margin_rect[1]);
		}
	}
}

void serialize_wrap_square(std::wostream & strm, _docx_drawing const & val)
{
    std::wstring wrapText;
    if (val.styleWrap)
    {
        switch(val.styleWrap->get_type())
        {
		case odf_types::style_wrap::Parallel:
            wrapText = L"bothSides";
            break;
		case odf_types::style_wrap::Dynamic:
            wrapText = L"largest";
            break;
        default:
            wrapText = boost::lexical_cast<std::wstring>(*(val.styleWrap));
            break;
        }
    }
    CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"wp:wrapSquare")
		{
			if (!wrapText.empty())	CP_XML_ATTR(L"wrapText", wrapText);

			if (val.margin_rect[3])CP_XML_ATTR(L"distB",val.margin_rect[3]);
			if (val.margin_rect[1])CP_XML_ATTR(L"distT",val.margin_rect[1]);
		}
	}   
}
void serialize_null_extent(std::wostream & strm)
{
	 CP_XML_WRITER(strm)    
	{
		CP_XML_NODE(L"wp:effectExtent")
		{
			CP_XML_ATTR(L"l",0); CP_XML_ATTR(L"t",0);CP_XML_ATTR(L"r",0);CP_XML_ATTR(L"b",0);
		}
	 }
}
void serialize_wrap_extent(std::wostream & strm, _docx_drawing const & val)
{
    if (!val.styleWrap)return;

	 CP_XML_WRITER(strm)    
	{
		switch(val.styleWrap->get_type())
		{
			case odf_types::style_wrap::Parallel:
			case odf_types::style_wrap::Left:
			case odf_types::style_wrap::Right:
			case odf_types::style_wrap::Dynamic:
			case odf_types::style_wrap::None:
			{
				CP_XML_NODE(L"wp:effectExtent")
				{
					_CP_OPT(int) iVal;
					if (odf_reader::GetProperty(val.additional,L"border_width_left",iVal))		CP_XML_ATTR(L"l",iVal.get());
					if (odf_reader::GetProperty(val.additional,L"border_width_top",iVal))		CP_XML_ATTR(L"t",iVal.get());
					if (odf_reader::GetProperty(val.additional,L"border_width_right",iVal))		CP_XML_ATTR(L"r",iVal.get());
					if (odf_reader::GetProperty(val.additional,L"border_width_bottom",iVal))	CP_XML_ATTR(L"b",iVal.get());   
				}
			}break;
			default:
				serialize_null_extent( strm);  
		}
    }
//error case
}

void serialize_wrap(std::wostream & strm, _docx_drawing const & val)
{
	if (!val.styleWrap || val.styleWrap->get_type() != odf_types::style_wrap::Parallel)
	{
		serialize_wrap_extent(strm, val);
	}
	CP_XML_WRITER(strm)    
	{
		if (val.styleWrap)
		{
			switch(val.styleWrap->get_type())
			{
			case odf_types::style_wrap::Parallel: 
				{
					if (val.number_wrapped_paragraphs== 1)
					{
						serialize_null_extent(strm);
						CP_XML_NODE(L"wp:wrapNone");
					}   
					else
					{
						serialize_wrap_extent(strm, val);
						serialize_wrap_square(strm, val);
					}
				}
				break;
			case odf_types::style_wrap::Left:
			case odf_types::style_wrap::Right:
				serialize_wrap_square(strm, val);
				break;
			case odf_types::style_wrap::RunThrough:
				CP_XML_NODE(L"wp:wrapNone");
				break;
			case odf_types::style_wrap::None:
				serialize_wrap_top_bottom(strm, val);
				break;
			case odf_types::style_wrap::Dynamic: 
			{
				//if (val.styleWrapContour && *val.styleWrapContour == false)
				//{
				//	CP_XML_NODE(L"wp:wrapTopAndBottom");
				//}
				//else
				{
					serialize_wrap_square(strm, val);
				}
			}break;
			default:
				CP_XML_NODE(L"wp:wrapTopAndBottom");
				break;
			}
		}
		else
		{
			CP_XML_NODE(L"wp:wrapTopAndBottom");
		}
	}
}

void _docx_drawing::serialize_text(std::wostream & strm)
{
	_CP_OPT(std::wstring) strTextContent;
	odf_reader::GetProperty(additional, L"text-content", strTextContent);

	CP_XML_WRITER(strm)
	{			
		if (strTextContent && !strTextContent->empty())
		{
			CP_XML_NODE(L"wps:txbx")
			{  
				CP_XML_NODE(L"w:txbxContent")
				{				
					const std::wstring & test_string = strTextContent.get();
					CP_XML_STREAM() << test_string;
				}
			}
		}
	}	

	serialize_bodyPr(strm, L"wps");
}

//--------------------------------------------------------------------
void docx_serialize_media_child(std::wostream & strm, _docx_drawing & val)
{
    CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"pic:pic")
		{
			CP_XML_ATTR(L"xmlns:pic",L"http://schemas.openxmlformats.org/drawingml/2006/picture");
			{
				CP_XML_NODE(L"pic:nvPicPr")
				{
					CP_XML_NODE(L"pic:cNvPr")
					{
						CP_XML_ATTR(L"id", val.id + 1);
						CP_XML_ATTR(L"name", val.name);
					
						//oox_serialize_action(CP_XML_STREAM(), val.action);
					}
					CP_XML_NODE(L"pic:cNvPicPr")
					{
						CP_XML_NODE(L"a:picLocks") CP_XML_ATTR(L"noChangeAspect",1);
					}
					CP_XML_NODE(L"pic:nvPr")
					{
						std::wstring strNode; 
						
						if		(val.type == typeVideo)	strNode = L"a:videoFile"; 
						else if (val.type == typeAudio) strNode = L"a:audioFile"; 

						if (false == strNode.empty())
						{
							CP_XML_NODE(strNode)
							{
								CP_XML_ATTR(L"r:link",	val.objectId);
							}
						}
						if (false == val.extId.empty())
						{
							CP_XML_NODE(L"a:extLst")
							{
								CP_XML_NODE(L"a:ext")
								{
									CP_XML_ATTR(L"uri",	L"{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}");
									CP_XML_NODE(L"wp15:media")
									{	
										CP_XML_ATTR(L"xmlns:wp15", L"http://schemas.microsoft.com/office/word/2012/wordprocessingDrawing");
										if (val.extExternal)
										{
											CP_XML_ATTR(L"r:link",	val.extId);
										}
										else
										{
											CP_XML_ATTR(L"r:embed",	val.extId);
										}
									}
								}
							}
						}
					}
				}    
			}
			val.fill.bitmap->name_space = L"pic";
			oox_serialize_fill(CP_XML_STREAM(), val.fill);

			CP_XML_NODE(L"pic:spPr")
			{
				val.serialize_xfrm(CP_XML_STREAM());

				CP_XML_NODE(L"a:prstGeom")
				{
					CP_XML_ATTR(L"prst", L"rect");
					CP_XML_NODE(L"a:avLst");
				}

				oox_serialize_ln(CP_XML_STREAM(), val.additional);
				oox_serialize_effects(CP_XML_STREAM(), val.additional);
			}
		}
	}
}
//--------------------------------------------------------------------
void docx_serialize_image_child(std::wostream & strm, _docx_drawing & val)
{
    CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"pic:pic")
		{
			CP_XML_ATTR(L"xmlns:pic",L"http://schemas.openxmlformats.org/drawingml/2006/picture");
			{
				CP_XML_NODE(L"pic:nvPicPr")
				{
					CP_XML_NODE(L"pic:cNvPr")
					{
						_CP_OPT(std::wstring) title, descr;
						GetProperty(val.additional, L"svg:title", title);
						GetProperty(val.additional, L"svg:desc", descr);

						//CP_XML_ATTR(L"desc text",L"");
						CP_XML_ATTR(L"id", val.id + 1);
						CP_XML_ATTR(L"name", val.name);

						CP_XML_ATTR_OPT_ENCODE_STRING(L"title", title);
						CP_XML_ATTR_OPT_ENCODE_STRING(L"descr", descr);
					
						//oox_serialize_action(CP_XML_STREAM(), val.action);
					}
					CP_XML_NODE(L"pic:cNvPicPr")
					{
						CP_XML_NODE(L"a:picLocks") CP_XML_ATTR(L"noChangeAspect",1);
					}
				}    
			}
			val.fill.bitmap->name_space = L"pic";
			oox_serialize_fill(CP_XML_STREAM(), val.fill);

			CP_XML_NODE(L"pic:spPr")
			{
				val.serialize_xfrm(CP_XML_STREAM());

				CP_XML_NODE(L"a:prstGeom")
				{
					CP_XML_ATTR(L"prst", L"rect");
					CP_XML_NODE(L"a:avLst");
				}

				oox_serialize_ln(CP_XML_STREAM(), val.additional);
				oox_serialize_effects(CP_XML_STREAM(), val.additional);
			}
		}
	}
}
void docx_serialize_shape_child(std::wostream & strm, _docx_drawing & val)
{
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"wps:wsp")
		{
			CP_XML_NODE(L"wps:cNvPr")
			{
				CP_XML_ATTR(L"id",	val.id + 1);
				CP_XML_ATTR(L"name",val.name);
			}
			CP_XML_NODE(L"wps:cNvSpPr")
			{
				if (val.sub_type==1 || val.sub_type==0)//frame
				{
					CP_XML_ATTR(L"txBox", 1);
				}
				if (val.inGroup == false)
				{
					CP_XML_NODE(L"a:spLocks")
					{
						CP_XML_ATTR(L"noChangeAspect", 1);
					}
				}
			}		
			CP_XML_NODE(L"wps:spPr")
			{
				val.serialize_xfrm	(CP_XML_STREAM());
				val.serialize_shape	(CP_XML_STREAM());

				oox_serialize_ln(CP_XML_STREAM(), val.additional);
				oox_serialize_effects(CP_XML_STREAM(), val.additional);
			} 
			val.serialize_text(CP_XML_STREAM());
		}
	}
}
void docx_serialize_group_child(std::wostream & strm, _docx_drawing & val)
{
	std::wstring	node_name = L"wpg:wgp";
	if (val.inGroup)node_name = L"wpg:grpSp";
	
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(node_name)
		{
			CP_XML_NODE(L"wpg:cNvGrpSpPr")
			{
				CP_XML_ATTR(L"bwMode", L"auto");
			}

			CP_XML_NODE(L"wpg:grpSpPr")
			{
				val.serialize_xfrm(CP_XML_STREAM());

			} 
			CP_XML_STREAM() << val.content_group_;
		}
	}
}

void docx_serialize_chart_child(std::wostream & strm, _docx_drawing & val)
{	 
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"c:chart")
		{
			CP_XML_ATTR(L"xmlns:c", L"http://schemas.openxmlformats.org/drawingml/2006/chart");
			CP_XML_ATTR(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships");
			CP_XML_ATTR(L"r:id", val.objectId);
		}
	}
}

void docx_serialize_common(std::wostream & strm, _docx_drawing & val)
{
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"wp:docPr")
		{
			_CP_OPT(std::wstring) title, descr;
			GetProperty(val.additional, L"svg:title", title);
			GetProperty(val.additional, L"svg:desc", descr);

			CP_XML_ATTR(L"name",	val.name);
			CP_XML_ATTR(L"id",		0xf000 + val.id + 1);

			CP_XML_ATTR_OPT_ENCODE_STRING(L"title", title);
			CP_XML_ATTR_OPT_ENCODE_STRING(L"descr", descr);
			
			oox_serialize_action(CP_XML_STREAM(), val.action);
		}

		CP_XML_NODE(L"wp:cNvGraphicFramePr")
		{
			//CP_XML_NODE(L"a:graphicFrameLocks")
			//{
			//	CP_XML_ATTR(L"xmlns:a",L"http://schemas.openxmlformats.org/drawingml/2006/main");
			//	CP_XML_ATTR(L"noChangeAspect",1);
			//}
		}
		CP_XML_NODE(L"a:graphic")
		{
			CP_XML_ATTR(L"xmlns:a",L"http://schemas.openxmlformats.org/drawingml/2006/main");
			CP_XML_NODE(L"a:graphicData")
			{
				if (val.type == typeShape)
				{
					CP_XML_ATTR(L"uri",L"http://schemas.microsoft.com/office/word/2010/wordprocessingShape");
					docx_serialize_shape_child(CP_XML_STREAM(), val);
				}
				else if (val.type == typeGroupShape)
				{
					CP_XML_ATTR(L"uri", L"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup");
					docx_serialize_group_child(CP_XML_STREAM(), val);
				}				
				else if (val.type == typeAudio || val.type == typeVideo || val.type == typeMedia)
				{
					CP_XML_ATTR(L"uri",L"http://schemas.openxmlformats.org/drawingml/2006/picture");
					docx_serialize_media_child(CP_XML_STREAM(), val);
				}
				else if (val.type == typeImage)
				{
					CP_XML_ATTR(L"uri",L"http://schemas.openxmlformats.org/drawingml/2006/picture");
					docx_serialize_image_child(CP_XML_STREAM(), val);
				}
				else if (val.type == typeChart)
				{
					CP_XML_ATTR(L"uri", L"http://schemas.openxmlformats.org/drawingml/2006/chart");
					docx_serialize_chart_child(CP_XML_STREAM(), val);
				}
	        } 
		}
	}
}
void docx_serialize_child(std::wostream & strm, _docx_drawing & val)
{
	if (val.type == typeShape)
	{
		docx_serialize_shape_child(strm,val);
	}
	else if (val.type == typeImage)
	{
		docx_serialize_image_child(strm,val);
	}
	else if (val.type == typeChart)
	{
		docx_serialize_chart_child(strm,val);
	}
	else if (val.type == typeGroupShape)
	{
		docx_serialize_group_child(strm,val);
	}
}

void docx_serialize_wps(std::wostream & strm, _docx_drawing & val)
{
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"w:drawing")
		{
			std::wstring	 strWp = L"wp:anchor";
			if (val.isInline)strWp = L"wp:inline";
			CP_XML_NODE(strWp)
			{		
				if (val.isInline)
				{
					CP_XML_NODE(L"wp:extent")
					{
						if (val.cx > 0 || val.cy > 0)
						{
							CP_XML_ATTR(L"cx", val.cx);
							CP_XML_ATTR(L"cy", val.cy);
						}

					}
					serialize_null_extent(CP_XML_STREAM());
				}
				else//anchor
				{
					CP_XML_ATTR(L"simplePos", 0);
					CP_XML_ATTR(L"locked", 0);
					CP_XML_ATTR(L"layoutInCell", 1);
					CP_XML_ATTR(L"allowOverlap", 1);

					CP_XML_ATTR(L"relativeHeight" ,val.relativeHeight);
					CP_XML_ATTR(L"behindDoc" , val.behindDoc);
			        
					CP_XML_ATTR(L"distL", val.margin_rect[0]);
					CP_XML_ATTR(L"distT", val.margin_rect[1]);
					CP_XML_ATTR(L"distR", val.margin_rect[2]);
					CP_XML_ATTR(L"distB", val.margin_rect[3]);

					CP_XML_NODE(L"wp:simplePos")
					{
						CP_XML_ATTR(L"x",0);
						CP_XML_ATTR(L"y",0);
					}

					CP_XML_NODE(L"wp:positionH")
					{
						std::wstring relativeFrom = L"margin";
						if (val.styleHorizontalRel) relativeFrom =val.styleHorizontalRel->get_type_str();
						
						CP_XML_ATTR(L"relativeFrom", relativeFrom);

						if (val.styleHorizontalPos &&
							val.styleHorizontalPos->get_type() != odf_types::horizontal_pos::FromLeft &&
							val.styleHorizontalPos->get_type() != odf_types::horizontal_pos::Outside)
						{
							CP_XML_NODE(L"wp:align") {CP_XML_STREAM() << (*val.styleHorizontalPos);}

						}
						else
						{
							CP_XML_NODE(L"wp:posOffset") {CP_XML_STREAM() << val.posOffsetH;}
						}			     
					}

					CP_XML_NODE(L"wp:positionV")
					{
						std::wstring relativeFrom = L"margin";
						if (val.styleVerticalRel)relativeFrom = val.styleVerticalRel->get_type_str();    

						CP_XML_ATTR(L"relativeFrom", relativeFrom);

						if (val.styleVerticalPos && 
							val.styleVerticalPos->get_type() != odf_types::vertical_pos::FromTop &&
							val.styleVerticalPos->get_type() != odf_types::vertical_pos::Below)
						{
							CP_XML_NODE(L"wp:align")
							{
								CP_XML_STREAM() << val.styleVerticalPos->get_type_str();
							}
						}
						else
						{
							CP_XML_NODE(L"wp:posOffset")
							{
								CP_XML_STREAM() << val.posOffsetV;                    
							}
						}
					}
					if (val.cx > 0 || val.cy > 0)
					{
						CP_XML_NODE(L"wp:extent")
						{
							CP_XML_ATTR(L"cx", val.cx); 
							CP_XML_ATTR(L"cy", val.cy);
						}
					}

					serialize_wrap(CP_XML_STREAM(), val);
				}
					
				docx_serialize_common(CP_XML_STREAM(), val);

				if (val.pctWidth)
				{
					std::wstring relativeFrom = L"margin";
					if (val.styleHorizontalRel) relativeFrom =val.styleHorizontalRel->get_type_str();

					if (relativeFrom == L"column") relativeFrom = L"margin";
					
					CP_XML_NODE(L"wp14:sizeRelH")
					{
						CP_XML_ATTR(L"relativeFrom", relativeFrom);
						CP_XML_NODE(L"wp14:pctWidth")
						{
							CP_XML_STREAM() << (val.pctWidth.get() * 1000);
						}
					}				
				}
				if (val.pctHeight)
				{
					std::wstring relativeFrom = L"paragraph";
					if (val.styleVerticalRel)relativeFrom = val.styleVerticalRel->get_type_str();					
					
					if (relativeFrom == L"paragraph") relativeFrom = L"margin";     

					CP_XML_NODE(L"wp14:sizeRelV")
					{
						CP_XML_ATTR(L"relativeFrom", relativeFrom);
						CP_XML_NODE(L"wp14:pctHeight")
						{
							CP_XML_STREAM() << (val.pctHeight.get() * 1000);
						}
					}
				}
			}
		}
	}
}

void docx_serialize_vml(std::wostream & strm, _docx_drawing & val)
{
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"w:pict")
		{
			CP_XML_NODE(L"v:rect")
			{
				std::wstring strStyle =	  L"position:absolute;\
visibility:visible;\
mso-wrap-style:square;\
mso-position-horizontal:absolute;\
mso-position-horizontal-relative:text;\
mso-position-vertical:absolute;\
mso-position-vertical-relative:text;";
				strStyle += L"margin-left:" + boost::lexical_cast<std::wstring>(val.x / 12700.) + L"pt;";
				strStyle += L"margin-top:"  + boost::lexical_cast<std::wstring>(val.y / 12700.) + L"pt;";
				strStyle += L"width:"		+ boost::lexical_cast<std::wstring>(val.cx / 12700.) + L"pt;"; 
				strStyle += L"height:"		+ boost::lexical_cast<std::wstring>(val.cy / 12700.) + L"pt;"; 
				strStyle += L"z-index:"		+ std::to_wstring(0xF000800 - val.id);
			
				CP_XML_ATTR(L"id",				L"Rect"		+ std::to_wstring(val.id));
				CP_XML_ATTR(L"o:spid",			L"_x0000_s" + std::to_wstring(1024 + val.id));
				CP_XML_ATTR(L"style",			strStyle);
				CP_XML_ATTR(L"fillcolor",		L"#4f81bd [3204]");
				CP_XML_ATTR(L"strokecolor",		L"#243f60 [1604]");
				CP_XML_ATTR(L"strokeweight",	L"1pt");
			}
		}
	}
}

void docx_serialize_alt_content(std::wostream & strm, _docx_drawing & val)
{
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"mc:AlternateContent")
		{
			CP_XML_NODE(L"mc:Choice")
			{
				CP_XML_ATTR(L"Requires", L"wps"); 
				docx_serialize_wps(CP_XML_STREAM(), val);
			}
			CP_XML_NODE(L"mc:Fallback")
			{
				docx_serialize_vml(CP_XML_STREAM(), val);
			}
		}
	}
}
void docx_serialize_object(std::wostream & strm, _docx_drawing & val)
{
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"w:object")
		{
			CP_XML_NODE(L"v:shape")
			{
				CP_XML_ATTR(L"id", L"ole_" + val.objectId); 

				CP_XML_ATTR(L"o:ole", "");
				std::wstring style_str;	// = L"width:730.6pt; height:261.8pt";

				style_str += L"width:"	+ boost::lexical_cast<std::wstring>(val.cx / 12700.) + L"pt;";
				style_str += L"height:" + boost::lexical_cast<std::wstring>(val.cy / 12700.) + L"pt;";

				CP_XML_ATTR(L"style", style_str);

				if (val.fill.bitmap)
				{
					CP_XML_NODE(L"v:imagedata")
					{
						CP_XML_ATTR(L"o:title", val.name);
						CP_XML_ATTR(L"r:id",	val.fill.bitmap->rId);
					}
				}
			}
			CP_XML_NODE(L"o:OLEObject")
			{
				CP_XML_ATTR(L"Type",		L"Embed");
				CP_XML_ATTR(L"ProgID",		val.objectProgId);
				CP_XML_ATTR(L"ShapeID",		L"ole_" + val.objectId); 
				CP_XML_ATTR(L"DrawAspect",	L"Content" );
				CP_XML_ATTR(L"ObjectID",	0x583A3000 + val.id );
				CP_XML_ATTR(L"r:id",		val.objectId); 
			}
		}
	}
}

void docx_serialize_control(std::wostream & strm, _docx_drawing & val)
{
	CP_XML_WRITER(strm)    
    {
		CP_XML_NODE(L"w:pict")
		{
			CP_XML_NODE(L"v:shape")
			{
				CP_XML_ATTR(L"id", L"control_" + val.objectId); 

				std::wstring style_str;	// = L"width:730.6pt; height:261.8pt";

				style_str += L"width:"	+ boost::lexical_cast<std::wstring>(val.cx / 12700.) + L"pt;";
				style_str += L"height:" + boost::lexical_cast<std::wstring>(val.cy / 12700.) + L"pt;";

				CP_XML_ATTR(L"style", style_str);

				if (val.fill.bitmap)
				{
					CP_XML_NODE(L"v:imagedata")
					{
						CP_XML_ATTR(L"o:title", val.name);
						CP_XML_ATTR(L"r:id",	val.fill.bitmap->rId);
					}
				}
			}
			CP_XML_NODE(L"w:control")
			{
				CP_XML_ATTR(L"w:name",		val.name);
				CP_XML_ATTR(L"w:shapeid",	L"control_" + val.objectId); 
				CP_XML_ATTR(L"r:id",		val.objectId); 
			}
		}
	}
}

void _docx_drawing::serialize(std::wostream & strm/*, bool insideOtherDrawing*/)
{
	if (type == typeUnknown) return;

	if (inGroup)
		return docx_serialize_child(strm, *this);
	
	if (type == typeMsObject ||
		type == typeOleObject ||
		type == typePDF)
	{
		docx_serialize_object(strm, *this);
	}
	else if (type == typeControl)
	{
		docx_serialize_control(strm, *this);
	}
	else
	{
		//if (insideOtherDrawing)
			docx_serialize_wps(strm, *this);
		//else
		//	docx_serialize_alt_content(strm, val);
	}

}



}
}