mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 03:42:47 +08:00
1441 lines
55 KiB
C++
1441 lines
55 KiB
C++
/*
|
||
* (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
|
||
*
|
||
*/
|
||
#include "RtfShape.h"
|
||
#include "Writer/OOXWriter.h"
|
||
#include "RtfOle.h"
|
||
|
||
#include "../../../UnicodeConverter/UnicodeConverter.h"
|
||
|
||
#include "../../../ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/PPTShape.h"
|
||
|
||
void RtfShape::SetDefault()
|
||
{
|
||
m_eAnchorTypeShape = st_none;
|
||
|
||
//Common
|
||
DEFAULT_PROPERTY( m_nLeft )
|
||
DEFAULT_PROPERTY( m_nTop )
|
||
DEFAULT_PROPERTY( m_nBottom )
|
||
DEFAULT_PROPERTY( m_nRight )
|
||
DEFAULT_PROPERTY( m_nID )
|
||
DEFAULT_PROPERTY( m_nZOrder )
|
||
DEFAULT_PROPERTY( m_nHeader )
|
||
DEFAULT_PROPERTY( m_nWrapType )
|
||
DEFAULT_PROPERTY( m_nWrapSideType )
|
||
DEFAULT_PROPERTY( m_nZOrderRelative )
|
||
DEFAULT_PROPERTY( m_bLockAnchor )
|
||
DEFAULT_PROPERTY_DEF( m_eXAnchor, ax_column ) //по умолчанию - привязка к тексту
|
||
DEFAULT_PROPERTY_DEF( m_eYAnchor, ay_Para )//по умолчанию - привязка к тексту
|
||
|
||
//Position absolute
|
||
DEFAULT_PROPERTY( m_nPositionH )
|
||
DEFAULT_PROPERTY( m_nPositionHRelative )
|
||
DEFAULT_PROPERTY( m_nPositionV )
|
||
DEFAULT_PROPERTY( m_nPositionVRelative )
|
||
DEFAULT_PROPERTY( m_bLayoutInCell )
|
||
DEFAULT_PROPERTY( m_bAllowOverlap )
|
||
|
||
//Position relative
|
||
DEFAULT_PROPERTY( m_nPositionHPct )
|
||
DEFAULT_PROPERTY( m_nPositionVPct )
|
||
DEFAULT_PROPERTY( m_nPctWidth )
|
||
DEFAULT_PROPERTY( m_nPctHeight )
|
||
DEFAULT_PROPERTY( m_nPctWidthRelative )
|
||
DEFAULT_PROPERTY( m_nPctHeightRelative )
|
||
DEFAULT_PROPERTY( m_nColStart )
|
||
DEFAULT_PROPERTY( m_nColSpan )
|
||
|
||
//Object Type
|
||
DEFAULT_PROPERTY( m_bIsBullet )
|
||
DEFAULT_PROPERTY( m_nRotation )
|
||
DEFAULT_PROPERTY( m_bFlipV )
|
||
DEFAULT_PROPERTY( m_bFlipH )
|
||
DEFAULT_PROPERTY( m_nShapeType )
|
||
DEFAULT_PROPERTY( m_nWrapDistLeft )
|
||
DEFAULT_PROPERTY( m_nWrapDistTop )
|
||
DEFAULT_PROPERTY( m_nWrapDistRight )
|
||
DEFAULT_PROPERTY( m_nWrapDistBottom )
|
||
|
||
DEFAULT_PROPERTY( m_bHidden )
|
||
|
||
//Text box
|
||
DEFAULT_PROPERTY( m_nAnchorText )
|
||
DEFAULT_PROPERTY_DEF( m_nTexpLeft, 91440 )
|
||
DEFAULT_PROPERTY_DEF( m_nTexpTop, 45720 )
|
||
DEFAULT_PROPERTY_DEF( m_nTexpRight, 91440 )
|
||
DEFAULT_PROPERTY_DEF( m_nTexpBottom, 45720 )
|
||
DEFAULT_PROPERTY( m_nTexpLeft )
|
||
DEFAULT_PROPERTY( m_nTexpTop )
|
||
DEFAULT_PROPERTY( m_nTexpRight )
|
||
DEFAULT_PROPERTY( m_nTexpBottom )
|
||
DEFAULT_PROPERTY( m_bFitShapeToText )
|
||
DEFAULT_PROPERTY( m_bFitTextToShape )
|
||
DEFAULT_PROPERTY( m_nCcol )
|
||
DEFAULT_PROPERTY( m_nTxdir )
|
||
DEFAULT_PROPERTY( m_nWrapText )
|
||
//Geometry
|
||
for (int i = 0; i < 10; i++)
|
||
DEFAULT_PROPERTY( m_nAdjustValue[i] )
|
||
//Custom
|
||
DEFAULT_PROPERTY( m_nGeoLeft)
|
||
DEFAULT_PROPERTY( m_nGeoTop)
|
||
DEFAULT_PROPERTY( m_nGeoRight)
|
||
DEFAULT_PROPERTY( m_nGeoBottom)
|
||
DEFAULT_PROPERTY( m_nShapePath)
|
||
//Picture Effects
|
||
DEFAULT_PROPERTY( m_nCropFromTop )
|
||
DEFAULT_PROPERTY( m_nCropFromBottom )
|
||
DEFAULT_PROPERTY( m_nCropFromLeft )
|
||
DEFAULT_PROPERTY( m_nCropFromRight )
|
||
|
||
//Grouped Shapes
|
||
DEFAULT_PROPERTY( m_nGroupBottom )
|
||
DEFAULT_PROPERTY( m_nGroupLeft )
|
||
DEFAULT_PROPERTY( m_nGroupRight )
|
||
DEFAULT_PROPERTY( m_nGroupTop )
|
||
|
||
DEFAULT_PROPERTY( m_nRelBottom )
|
||
DEFAULT_PROPERTY( m_nRelLeft )
|
||
DEFAULT_PROPERTY( m_nRelRight )
|
||
DEFAULT_PROPERTY( m_nRelTop )
|
||
DEFAULT_PROPERTY( m_nRelRotation )
|
||
DEFAULT_PROPERTY( m_nRelZOrder )
|
||
|
||
//Rehydration
|
||
m_sMetroBlob = L"";
|
||
m_sMetroBlobRels = L"";
|
||
m_sMetroBlobData = L"";
|
||
//Connectors
|
||
DEFAULT_PROPERTY( m_nConnectionType )
|
||
DEFAULT_PROPERTY( m_nConnectorStyle )
|
||
|
||
//Fill
|
||
DEFAULT_PROPERTY_DEF( m_bFilled, true )
|
||
DEFAULT_PROPERTY( m_nFillType )
|
||
DEFAULT_PROPERTY( m_nFillColor )
|
||
DEFAULT_PROPERTY( m_nFillColor2 )
|
||
DEFAULT_PROPERTY( m_nFillOpacity )
|
||
DEFAULT_PROPERTY( m_nFillFocus )
|
||
DEFAULT_PROPERTY( m_nFillAngle )
|
||
//Line
|
||
DEFAULT_PROPERTY_DEF( m_bLine, true )
|
||
DEFAULT_PROPERTY( m_nLineColor )
|
||
DEFAULT_PROPERTY( m_nLineStartArrow )
|
||
DEFAULT_PROPERTY( m_nLineStartArrowWidth )
|
||
DEFAULT_PROPERTY( m_nLineStartArrowLength )
|
||
DEFAULT_PROPERTY( m_nLineEndArrow )
|
||
DEFAULT_PROPERTY( m_nLineEndArrowWidth )
|
||
DEFAULT_PROPERTY( m_nLineEndArrowLength )
|
||
DEFAULT_PROPERTY( m_nLineWidth )
|
||
DEFAULT_PROPERTY( m_nLineDashing )
|
||
|
||
DEFAULT_PROPERTY( m_nGtextSize )
|
||
DEFAULT_PROPERTY( m_bGtext )
|
||
DEFAULT_PROPERTY( m_bGtextFVertical )
|
||
DEFAULT_PROPERTY( m_bGtextFKern )
|
||
DEFAULT_PROPERTY( m_bGtextFStretch )
|
||
DEFAULT_PROPERTY( m_bGtextFShrinkFit )
|
||
DEFAULT_PROPERTY( m_bGtextFBestFit )
|
||
|
||
m_aTextItems = TextItemContainerPtr();
|
||
m_oPicture = RtfPicturePtr();
|
||
|
||
m_bIsOle = false;
|
||
m_bInGroup = false;
|
||
|
||
m_oCharProperty.SetDefault();
|
||
}
|
||
|
||
std::wstring RtfShape::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
if( PROP_DEF == m_nShapeType) return L"";
|
||
|
||
std::wstring sResult;
|
||
//запоминаем координаты и если нужно поворачиваем
|
||
int nLeft = m_nLeft;
|
||
int nTop = m_nTop;
|
||
int nRight = m_nRight;
|
||
int nBottom = m_nBottom;
|
||
int nRotate = m_nRotation;
|
||
|
||
int nRelLeft = m_nRelLeft;
|
||
int nRelTop = m_nRelTop;
|
||
int nRelRight = m_nRelRight;
|
||
int nRelBottom = m_nRelBottom;
|
||
int nRelRotate = m_nRelRotation;
|
||
|
||
if( PROP_DEF != m_nRotation && PROP_DEF != m_nLeft && PROP_DEF != m_nTop &&
|
||
PROP_DEF != m_nRight && PROP_DEF != m_nBottom )
|
||
ToRtfRotation( m_nRotation, m_nLeft, m_nTop, m_nRight, m_nBottom );
|
||
|
||
if( PROP_DEF != m_nRelRotation && PROP_DEF != m_nRelLeft && PROP_DEF != m_nRelTop &&
|
||
PROP_DEF != m_nRelRight && PROP_DEF != m_nRelBottom )
|
||
ToRtfRotation( m_nRelRotation, m_nRelLeft, m_nRelTop, m_nRelRight, m_nRelBottom );
|
||
|
||
sResult += m_oCharProperty.RenderToRtf( oRenderParameter );
|
||
|
||
if( st_inline == m_eAnchorTypeShape || st_none == m_eAnchorTypeShape)
|
||
{
|
||
if( NULL != m_oPicture && m_nShapeType == NSOfficeDrawing::sptPictureFrame)
|
||
{
|
||
if (m_oPicture->m_nWidth == PROP_DEF)
|
||
{
|
||
m_oPicture->m_nWidth = m_nRight;
|
||
m_oPicture->m_nHeight = m_nBottom;
|
||
}
|
||
if (m_oPicture->m_nWidthGoal == PROP_DEF)
|
||
{
|
||
m_oPicture->m_nWidthGoal = m_oPicture->m_nWidth;
|
||
m_oPicture->m_nHeightGoal = m_oPicture->m_nHeight;
|
||
}
|
||
if( RtfPicture::dt_wmf == m_oPicture->eDataType )
|
||
{
|
||
sResult += m_oPicture->RenderToRtf( oRenderParameter );
|
||
}
|
||
else
|
||
{
|
||
sResult += L"{\\*\\shppict";
|
||
sResult += m_oPicture->RenderToRtf( oRenderParameter );
|
||
sResult += L"}";
|
||
sResult += L"{\\nonshppict";
|
||
sResult += m_oPicture->GenerateWMF( oRenderParameter );
|
||
|
||
sResult += L"}";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sResult += L"{\\shp";
|
||
sResult += L"{\\*\\shpinst";
|
||
|
||
RENDER_RTF_INT( m_nID , sResult, L"shplid" );
|
||
|
||
if (!m_bInGroup)
|
||
{
|
||
m_bAllowOverlap = 1;
|
||
m_bLayoutInCell = 1;
|
||
m_nWrapType = 3;
|
||
m_nWrapSideType = 0;
|
||
m_bLockAnchor = 0;
|
||
m_nZOrder = PROP_DEF;
|
||
m_nZOrderRelative = PROP_DEF;
|
||
m_nLeft = m_nTop = 0;
|
||
m_nRelBottom = m_nRelRight = PROP_DEF;
|
||
m_nPositionV = m_nPositionH = PROP_DEF;
|
||
|
||
RENDER_RTF_INT ( m_nLeft , sResult, L"shpleft" );
|
||
RENDER_RTF_INT ( m_nTop , sResult, L"shptop" );
|
||
RENDER_RTF_INT ( m_nRight , sResult, L"shpright" );
|
||
RENDER_RTF_INT ( m_nBottom , sResult, L"shpbottom" );
|
||
|
||
RENDER_RTF_INT ( m_nHeader , sResult, L"shpfhdr" );
|
||
|
||
//sResult += L"\\shpbxcolumn";
|
||
sResult += L"\\shpbxignore";
|
||
//sResult += L"\\shpbypara";
|
||
sResult += L"\\shpbyignore";
|
||
|
||
RENDER_RTF_INT ( m_nWrapType , sResult, L"shpwr" );
|
||
RENDER_RTF_INT ( m_nWrapSideType , sResult, L"shpwrk" );
|
||
|
||
//sResult += L"\\shpfblwtxt0";
|
||
sResult += L"\\shplockanchor";
|
||
|
||
RENDER_RTF_INT ( m_nZOrder , sResult, L"shpz" );
|
||
|
||
sResult += L"{\\sp{\\sn fUseShapeAnchor}{\\sv 0}}";
|
||
sResult += L"{\\sp{\\sn fPseudoInline}{\\sv 1}}";
|
||
}
|
||
sResult += RenderToRtfShapeProperty( oRenderParameter );
|
||
|
||
sResult += L"{\\sp{\\sn fLockPosition}{\\sv 1}}";
|
||
sResult += L"{\\sp{\\sn fLockRotation}{\\sv 1}}";
|
||
|
||
//picture
|
||
if( 0 != m_oPicture && m_nFillType == 1 || m_nFillType == 2 || m_nFillType == 9)
|
||
{
|
||
sResult += L"{\\sp{\\sn fillBlip}{\\sv ";
|
||
sResult += m_oPicture->RenderToRtf( oRenderParameter );
|
||
sResult += L"}}";
|
||
}
|
||
//textbox
|
||
if( 0 != m_aTextItems )
|
||
{
|
||
sResult += L"{\\shptxt ";
|
||
sResult += m_aTextItems->RenderToRtf( oRenderParameter );
|
||
sResult += L"}";
|
||
}
|
||
sResult += L"}";
|
||
sResult += L"}";
|
||
}
|
||
}
|
||
else // anchor
|
||
{
|
||
sResult += L"{\\shp";
|
||
sResult += L"{\\*\\shpinst";
|
||
|
||
RENDER_RTF_INT( m_nID , sResult, L"shplid" );
|
||
|
||
if (!m_bInGroup)
|
||
{
|
||
RENDER_RTF_INT ( m_nLeft , sResult, L"shpleft" );
|
||
RENDER_RTF_INT ( m_nTop , sResult, L"shptop" );
|
||
RENDER_RTF_INT ( m_nBottom , sResult, L"shpbottom" );
|
||
RENDER_RTF_INT ( m_nRight , sResult, L"shpright" );
|
||
RENDER_RTF_INT ( m_nZOrder , sResult, L"shpz" );
|
||
RENDER_RTF_INT ( m_nHeader , sResult, L"shpfhdr" );
|
||
RENDER_RTF_INT ( m_nWrapType , sResult, L"shpwr" );
|
||
RENDER_RTF_INT ( m_nWrapSideType , sResult, L"shpwrk" );
|
||
RENDER_RTF_BOOL ( m_bLockAnchor , sResult, L"shplockanchor" );
|
||
|
||
switch(m_eXAnchor)
|
||
{
|
||
case ax_page: sResult += L"\\shpbxpage"; break;
|
||
case ax_margin: sResult += L"\\shpbxmargin"; break;
|
||
case ax_column: sResult += L"\\shpbxcolumn"; break;
|
||
}
|
||
sResult += L"\\shpbxignore";
|
||
switch(m_eYAnchor)
|
||
{
|
||
case ay_page: sResult += L"\\shpbypage"; break;
|
||
case ay_margin: sResult += L"\\shpbymargin"; break;
|
||
case ay_Para: sResult += L"\\shpbypara"; break;
|
||
}
|
||
sResult += L"\\shpbyignore";
|
||
RENDER_RTF_INT( m_nZOrderRelative, sResult, L"shpfblwtxt");
|
||
}
|
||
|
||
sResult += RenderToRtfShapeProperty( oRenderParameter );
|
||
|
||
//picture
|
||
if( 0 != m_oPicture)
|
||
{
|
||
if (m_nShapeType == NSOfficeDrawing::sptPictureFrame)
|
||
{
|
||
sResult += L"{\\sp{\\sn pib}{\\sv ";
|
||
sResult += m_oPicture->RenderToRtf( oRenderParameter );
|
||
sResult += L"}}";
|
||
}
|
||
else if (m_nFillType == 1 || m_nFillType == 2 || m_nFillType == 9)
|
||
{
|
||
sResult += L"{\\sp{\\sn fillType}{\\sv 2}}";
|
||
sResult += L"{\\sp{\\sn fillBlip}{\\sv ";
|
||
sResult += m_oPicture->RenderToRtf( oRenderParameter );
|
||
sResult += L"}}";
|
||
}
|
||
}
|
||
//textbox
|
||
if( m_aTextItems )
|
||
{
|
||
sResult += L"{\\shptxt ";
|
||
sResult += m_aTextItems->RenderToRtf( oRenderParameter );
|
||
sResult += L"}";
|
||
}
|
||
sResult += L"}";
|
||
if( m_oPicture && m_nShapeType == NSOfficeDrawing::sptPictureFrame )
|
||
{
|
||
sResult += L"{\\shprslt\\par\\plain";
|
||
sResult += m_oPicture->GenerateWMF( oRenderParameter );
|
||
sResult += L"\\par}";
|
||
}
|
||
sResult += L"}";
|
||
}
|
||
//восстанавливаем координаты и если нужно поворачиваем
|
||
m_nLeft = nLeft;
|
||
m_nTop = nTop;
|
||
m_nRight = nRight;
|
||
m_nBottom = nBottom;
|
||
m_nRotation = nRotate;
|
||
|
||
m_nRelLeft = nRelLeft;
|
||
m_nRelTop = nRelTop;
|
||
m_nRelRight = nRelRight;
|
||
m_nRelBottom = nRelBottom;
|
||
m_nRelRotation = nRelRotate;
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfShape::RenderToRtfShapeProperty(RenderParameter oRenderParameter)
|
||
{
|
||
RtfDocument* pDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
|
||
|
||
std::wstring sResult;
|
||
|
||
//Position absolute
|
||
RENDER_RTF_SHAPE_PROP(L"posh", sResult, m_nPositionH);
|
||
RENDER_RTF_SHAPE_PROP(L"posrelh", sResult, m_nPositionHRelative);
|
||
RENDER_RTF_SHAPE_PROP(L"posv", sResult, m_nPositionV);
|
||
|
||
RENDER_RTF_SHAPE_PROP(L"posrelv", sResult, m_nPositionVRelative);
|
||
RENDER_RTF_SHAPE_PROP(L"fLayoutInCell", sResult, m_bLayoutInCell);
|
||
RENDER_RTF_SHAPE_PROP(L"fAllowOverlap", sResult, m_bAllowOverlap);
|
||
|
||
//Position relative
|
||
RENDER_RTF_SHAPE_PROP(L"pctHorizPos", sResult, m_nPositionHPct);
|
||
RENDER_RTF_SHAPE_PROP(L"pctVertPos", sResult, m_nPositionVPct);
|
||
RENDER_RTF_SHAPE_PROP(L"pctHoriz", sResult, m_nPctWidth);
|
||
RENDER_RTF_SHAPE_PROP(L"pctVert", sResult, m_nPctHeight);
|
||
RENDER_RTF_SHAPE_PROP(L"sizerelh", sResult, m_nPctWidthRelative);
|
||
RENDER_RTF_SHAPE_PROP(L"sizerelv", sResult, m_nPctHeightRelative);
|
||
RENDER_RTF_SHAPE_PROP(L"colStart", sResult, m_nColStart);
|
||
RENDER_RTF_SHAPE_PROP(L"colSpan", sResult, m_nColSpan);
|
||
//Rehydration
|
||
//RENDER_RTF_SHAPE_PROP(L"metroBlob", sResult, m_sMetroBlob);
|
||
|
||
//Object Type
|
||
RENDER_RTF_SHAPE_PROP(L"fIsBullet", sResult, m_bIsBullet);
|
||
RENDER_RTF_SHAPE_PROP(L"rotation", sResult, m_nRotation);
|
||
RENDER_RTF_SHAPE_PROP(L"fFlipV", sResult, m_bFlipV);
|
||
RENDER_RTF_SHAPE_PROP(L"fFlipH", sResult, m_bFlipH);
|
||
RENDER_RTF_SHAPE_PROP(L"shapeType", sResult, m_nShapeType);
|
||
RENDER_RTF_SHAPE_PROP(L"fBehindDocument", sResult, m_nZOrderRelative);
|
||
RENDER_RTF_SHAPE_PROP(L"fHidden", sResult, m_bHidden);
|
||
//Text
|
||
//sResult += L"{\\sp{\\sn fLockText}{\\sv 0}}";
|
||
|
||
RENDER_RTF_SHAPE_PROP(L"dxTextLeft", sResult, m_nTexpLeft);
|
||
RENDER_RTF_SHAPE_PROP(L"dyTextTop", sResult, m_nTexpTop);
|
||
RENDER_RTF_SHAPE_PROP(L"dxTextRight", sResult, m_nTexpRight);
|
||
RENDER_RTF_SHAPE_PROP(L"dyTextBottom", sResult, m_nTexpBottom);
|
||
|
||
RENDER_RTF_SHAPE_PROP(L"anchorText", sResult, m_nAnchorText);
|
||
//else
|
||
{
|
||
RENDER_RTF_SHAPE_PROP(L"dxWrapDistLeft", sResult, RtfUtility::Twips2Emu( m_nWrapDistLeft ));
|
||
RENDER_RTF_SHAPE_PROP(L"dyWrapDistTop", sResult, RtfUtility::Twips2Emu( m_nWrapDistTop ));
|
||
RENDER_RTF_SHAPE_PROP(L"dxWrapDistRight", sResult, RtfUtility::Twips2Emu( m_nWrapDistRight ));
|
||
RENDER_RTF_SHAPE_PROP(L"dyWrapDistBottom", sResult, RtfUtility::Twips2Emu( m_nWrapDistBottom ));
|
||
}
|
||
RENDER_RTF_SHAPE_PROP(L"fFitShapeToText", sResult, m_bFitShapeToText);
|
||
RENDER_RTF_SHAPE_PROP(L"fFitTextToShape", sResult, m_bFitTextToShape);
|
||
RENDER_RTF_SHAPE_PROP(L"ccol", sResult, m_nCcol);
|
||
RENDER_RTF_SHAPE_PROP(L"txdir", sResult, m_nTxdir);
|
||
RENDER_RTF_SHAPE_PROP(L"WrapText", sResult, m_nWrapText);
|
||
//Geometry
|
||
RENDER_RTF_SHAPE_PROP(L"adjustValue", sResult, m_nAdjustValue[0] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust2Value", sResult, m_nAdjustValue[1] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust3Value", sResult, m_nAdjustValue[2] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust4Value", sResult, m_nAdjustValue[3] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust5Value", sResult, m_nAdjustValue[4] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust6Value", sResult, m_nAdjustValue[5] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust7Value", sResult, m_nAdjustValue[6] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust8Value", sResult, m_nAdjustValue[7] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust9Value", sResult, m_nAdjustValue[8] );
|
||
RENDER_RTF_SHAPE_PROP(L"adjust10Value", sResult, m_nAdjustValue[9] );
|
||
//custom
|
||
RENDER_RTF_SHAPE_PROP(L"geoLeft", sResult, m_nGeoLeft );
|
||
RENDER_RTF_SHAPE_PROP(L"geoTop", sResult, m_nGeoTop);
|
||
RENDER_RTF_SHAPE_PROP(L"geoRight", sResult, m_nGeoRight );
|
||
RENDER_RTF_SHAPE_PROP(L"geoBottom", sResult, m_nGeoBottom );
|
||
RENDER_RTF_SHAPE_PROP(L"shapePath", sResult, m_nShapePath );
|
||
if( !m_aPVerticles.empty())
|
||
{
|
||
sResult += L"{\\sp{\\sn pVerticies}{\\sv 8;" + std::to_wstring( m_aPVerticles.size() );
|
||
for( int i = 0; i < m_aPVerticles.size(); i ++ )
|
||
sResult += L";(" + std::to_wstring(m_aPVerticles[i].first) + L","+ std::to_wstring(m_aPVerticles[i].second) + L")";
|
||
sResult += L"}}";
|
||
}
|
||
if( !m_aPSegmentInfo.empty())
|
||
{
|
||
sResult += L"{\\sp{\\sn pSegmentInfo}{\\sv ";
|
||
sResult += L"{\\sp{\\sn pSegmentInfo}{\\sv 2;" + std::to_wstring( m_aPSegmentInfo.size() );
|
||
for( int i = 0; i < m_aPSegmentInfo.size(); i ++ )
|
||
sResult += L";" + std::to_wstring( m_aPSegmentInfo[i] );
|
||
sResult += L"}}";
|
||
}
|
||
//Connectors
|
||
RENDER_RTF_SHAPE_PROP(L"cxk", sResult, m_nConnectionType );
|
||
RENDER_RTF_SHAPE_PROP(L"cxstyle", sResult, m_nConnectorStyle );
|
||
//Picture Effects
|
||
RENDER_RTF_SHAPE_PROP(L"cropFromTop", sResult, m_nCropFromTop );
|
||
RENDER_RTF_SHAPE_PROP(L"cropFromBottom", sResult, m_nCropFromBottom );
|
||
RENDER_RTF_SHAPE_PROP(L"cropFromLeft", sResult, m_nCropFromLeft );
|
||
RENDER_RTF_SHAPE_PROP(L"cropFromRight", sResult, m_nCropFromRight );
|
||
//Grouped Shapes
|
||
RENDER_RTF_SHAPE_PROP(L"groupBottom", sResult, m_nGroupBottom );
|
||
RENDER_RTF_SHAPE_PROP(L"groupLeft", sResult, m_nGroupLeft );
|
||
RENDER_RTF_SHAPE_PROP(L"groupRight", sResult, m_nGroupRight );
|
||
RENDER_RTF_SHAPE_PROP(L"groupTop", sResult, m_nGroupTop );
|
||
RENDER_RTF_SHAPE_PROP(L"relBottom", sResult, m_nRelBottom );
|
||
RENDER_RTF_SHAPE_PROP(L"relLeft", sResult, m_nRelLeft );
|
||
RENDER_RTF_SHAPE_PROP(L"relRight", sResult, m_nRelRight );
|
||
RENDER_RTF_SHAPE_PROP(L"relTop", sResult, m_nRelTop );
|
||
RENDER_RTF_SHAPE_PROP(L"relRotation", sResult, m_nRelRotation );
|
||
RENDER_RTF_SHAPE_PROP(L"dhgt", sResult, m_nRelZOrder );
|
||
//Fill
|
||
if( 0 == m_bFilled )
|
||
sResult += L"{\\sp{\\sn fFilled}{\\sv 0}}";
|
||
RENDER_RTF_SHAPE_PROP(L"fillType", sResult, m_nFillType );
|
||
RENDER_RTF_SHAPE_PROP(L"fillColor", sResult, m_nFillColor );
|
||
RENDER_RTF_SHAPE_PROP(L"fillBackColor", sResult, m_nFillColor2 );
|
||
RENDER_RTF_SHAPE_PROP(L"fillOpacity", sResult, ( m_nFillOpacity * 65536 /100 ) );
|
||
RENDER_RTF_SHAPE_PROP(L"fillFocus", sResult, m_nFillFocus );
|
||
RENDER_RTF_SHAPE_PROP(L"fillAngle", sResult, m_nFillAngle * 65536 );
|
||
//Line
|
||
if( 0 == m_bLine )
|
||
sResult += L"{\\sp{\\sn fLine}{\\sv 0}}";
|
||
RENDER_RTF_SHAPE_PROP(L"lineColor", sResult, m_nLineColor );
|
||
RENDER_RTF_SHAPE_PROP(L"lineStartArrowhead", sResult, m_nLineStartArrow );
|
||
RENDER_RTF_SHAPE_PROP(L"lineEndArrowhead", sResult, m_nLineEndArrow );
|
||
RENDER_RTF_SHAPE_PROP(L"lineStartArrowWidth", sResult, m_nLineStartArrowWidth );
|
||
RENDER_RTF_SHAPE_PROP(L"lineStartArrowLength", sResult, m_nLineStartArrowLength );
|
||
RENDER_RTF_SHAPE_PROP(L"lineEndArrowWidth", sResult, m_nLineEndArrowWidth );
|
||
RENDER_RTF_SHAPE_PROP(L"lineEndArrowLength", sResult, m_nLineEndArrowLength );
|
||
RENDER_RTF_SHAPE_PROP(L"lineWidth", sResult, m_nLineWidth );
|
||
RENDER_RTF_SHAPE_PROP(L"lineDashing", sResult, m_nLineDashing );
|
||
|
||
//pWrapPolygonVertices Points of the text wrap polygon.
|
||
if( !m_aWrapPoints.empty())
|
||
{
|
||
sResult += L"{\\sp{\\sn pWrapPolygonVertices}{\\sv 8;" + std::to_wstring(m_aWrapPoints.size());
|
||
for( int i = 0; i < m_aWrapPoints.size(); i ++ )
|
||
sResult += L";(" + std::to_wstring(m_aWrapPoints[i].first) + L"," + std::to_wstring(m_aWrapPoints[i].second) + L")";
|
||
sResult += L"}}";
|
||
}
|
||
//WordArt
|
||
if( PROP_DEF != m_bGtext )
|
||
{
|
||
RENDER_RTF_SHAPE_PROP(L"fGtext", sResult, m_bGtext );
|
||
|
||
int nCodePage = -1;
|
||
|
||
if( !m_sGtextFont.empty() )
|
||
{
|
||
sResult += L"{\\sp{\\sn gtextFont}{\\sv ";
|
||
sResult += m_sGtextFont + L"}}";
|
||
|
||
//---------------------------------
|
||
RtfFont oFont;
|
||
if( true == pDocument->m_oFontTable.GetFont( m_sGtextFont, oFont ) )
|
||
{
|
||
if( PROP_DEF != oFont.m_nCharset )
|
||
nCodePage = RtfUtility::CharsetToCodepage( oFont.m_nCharset );
|
||
else if( PROP_DEF != oFont.m_nCodePage )
|
||
nCodePage = oFont.m_nCodePage;
|
||
}
|
||
}
|
||
|
||
if( !m_sGtextUNICODE.empty() )
|
||
{
|
||
sResult += L"{\\sp{\\sn gtextUNICODE}{\\sv ";
|
||
sResult += RtfChar::renderRtfText(m_sGtextUNICODE, oRenderParameter.poDocument, nCodePage);
|
||
sResult += L"}}";
|
||
}
|
||
|
||
RENDER_RTF_SHAPE_PROP(L"gtextSize", sResult, m_nGtextSize );
|
||
RENDER_RTF_SHAPE_PROP(L"gtextFVertical", sResult, m_bGtextFVertical);
|
||
RENDER_RTF_SHAPE_PROP(L"gtextFKern", sResult, m_bGtextFKern);
|
||
RENDER_RTF_SHAPE_PROP(L"gtextFStretch", sResult, m_bGtextFStretch);
|
||
RENDER_RTF_SHAPE_PROP(L"gtextFShrinkFit", sResult, m_bGtextFShrinkFit);
|
||
RENDER_RTF_SHAPE_PROP(L"gtextFBestFit", sResult, m_bGtextFBestFit);
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfShape::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
if( PROP_DEF == m_nShapeType )
|
||
return L"";
|
||
|
||
std::wstring sResult;
|
||
RtfDocument* poDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
|
||
|
||
TextItemContainerPtr aTempTextItems;
|
||
|
||
if( NSOfficeDrawing::sptPictureFrame == m_nShapeType && 0 != m_aTextItems )
|
||
{//Значит это Ole обьект с anchor, для него все также только TextBox надо делать по-другому
|
||
aTempTextItems = m_aTextItems;
|
||
m_aTextItems = TextItemContainerPtr();
|
||
m_bIsOle = true;
|
||
}
|
||
|
||
sResult = RenderToOOXBegin(oRenderParameter);
|
||
|
||
if( !sResult.empty() )
|
||
sResult += RenderToOOXEnd(oRenderParameter);
|
||
|
||
std::wstring sOle;
|
||
if( 0 != aTempTextItems )
|
||
{//пишем только Ole обьект
|
||
//ищем первый ole обьект
|
||
RtfOlePtr poFirstOle;
|
||
int nTempTextItemsCount = aTempTextItems->GetCount();
|
||
for( int i = 0; i < nTempTextItemsCount; i++ )
|
||
{
|
||
ITextItemPtr piCurTextItem;
|
||
aTempTextItems->GetItem( piCurTextItem, i );
|
||
if( NULL != piCurTextItem && TYPE_RTF_PARAGRAPH == piCurTextItem->GetType() )
|
||
{
|
||
RtfParagraphPtr poCurParagraph = boost::static_pointer_cast< RtfParagraph, ITextItem >( piCurTextItem );
|
||
if( NULL != poCurParagraph )
|
||
{
|
||
bool bBreak = false;
|
||
for( int j = 0; j < poCurParagraph->GetCount(); j++ )
|
||
{
|
||
IDocumentElementPtr piCurIDocumentElement;
|
||
poCurParagraph->GetItem( piCurIDocumentElement, j );
|
||
if( NULL != piCurIDocumentElement && TYPE_RTF_OLE == piCurIDocumentElement->GetType() )
|
||
{
|
||
//рендерим только Ole часть
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_OLE_ONLY;
|
||
oNewParam.nValue = m_nID;
|
||
|
||
RtfOlePtr poCurOle = boost::static_pointer_cast< RtfOle, IDocumentElement >( piCurIDocumentElement );
|
||
if( NULL != poCurOle )
|
||
{
|
||
sOle += poCurOle->RenderToOOX( oNewParam );
|
||
bBreak = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if( true == bBreak )
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//возвращаем text box на место
|
||
m_aTextItems = aTempTextItems;
|
||
}
|
||
|
||
if( !sOle.empty() && !sResult.empty())
|
||
{
|
||
boost::algorithm::replace_all(sResult, L"</w:pict>", sOle + L"</w:pict>" );//todooo переписать
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfShape::GetShapeNodeName(int type)
|
||
{
|
||
switch(type)
|
||
{
|
||
case NSOfficeDrawing::sptRectangle: return L"v:rect";
|
||
case NSOfficeDrawing::sptEllipse: return L"v:oval";
|
||
case NSOfficeDrawing::sptRoundRectangle: return L"v:roundrect";
|
||
case NSOfficeDrawing::sptLine: return L"v:line";
|
||
case NSOfficeDrawing::sptArc: return L"v:arc";
|
||
default: return L"v:shape";
|
||
}
|
||
}
|
||
std::wstring RtfShape::RenderToOOXBegin(RenderParameter oRenderParameter)
|
||
{
|
||
if( !IsValid() ) return L"";
|
||
|
||
std::wstring sResult;
|
||
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*> (oRenderParameter.poDocument);
|
||
OOXWriter* poOOXWriter = static_cast<OOXWriter*> (oRenderParameter.poWriter);
|
||
|
||
m_bInsert = false;
|
||
m_bDelete = false;
|
||
|
||
if( RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2 == oRenderParameter.nType )
|
||
;//child shape
|
||
else if( RENDER_TO_OOX_PARAM_SHAPE_WSHAPE == oRenderParameter.nType )
|
||
{//pic bullets
|
||
sResult += L"<w:pict>";
|
||
}
|
||
else
|
||
{//работает по умолчанию
|
||
if (m_oCharProperty.m_nRevised != PROP_DEF)
|
||
{
|
||
m_bInsert = true;
|
||
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oCharProperty.m_nRevauth);
|
||
std::wstring sDate(RtfUtility::convertDateTime(m_oCharProperty.m_nRevdttm).c_str());
|
||
|
||
sResult += L"<w:ins w:date=\"" + sDate + L"\" w:author=\"" + sAuthor + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
||
m_oCharProperty.m_nRevised = PROP_DEF;
|
||
}
|
||
if (m_oCharProperty.m_nDeleted != PROP_DEF)
|
||
{
|
||
m_bDelete = true;
|
||
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oCharProperty.m_nRevauthDel);
|
||
std::wstring sDate(RtfUtility::convertDateTime(m_oCharProperty.m_nRevdttmDel).c_str());
|
||
|
||
sResult += L"<w:del w:date=\"" + sDate + L"\" w:author=\"" + sAuthor + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
||
m_oCharProperty.m_nDeleted = PROP_DEF;
|
||
}
|
||
std::wstring sCharProp = m_oCharProperty.RenderToOOX(oRenderParameter);
|
||
sResult += L"<w:r>";
|
||
if (!sCharProp .empty())
|
||
{
|
||
sResult += L"<w:rPr>";
|
||
sResult += sCharProp;
|
||
sResult += L"</w:rPr>";
|
||
}
|
||
sResult += L"<w:pict>";
|
||
}
|
||
|
||
if (oRenderParameter.sValue.empty())
|
||
oRenderParameter.sValue = GetShapeNodeName(m_nShapeType);
|
||
|
||
sResult += L"<" + oRenderParameter.sValue;
|
||
|
||
if (m_sName.empty())
|
||
{
|
||
RtfDocument* poDocument = static_cast<RtfDocument*>( oRenderParameter.poDocument );
|
||
m_sName += L"_x0000_s " + std::to_wstring(poDocument->GetShapeId( m_nID )) + L"";
|
||
}
|
||
sResult += L" id=\"" + m_sName + L"\"";
|
||
|
||
if( PROP_DEF != m_nShapeType && 0 != m_nShapeType)
|
||
{
|
||
sResult += L" type=\"#_x0000_t " + std::to_wstring(m_nShapeType) + L"\"";
|
||
sResult += L" o:spt=\" " + std::to_wstring(m_nShapeType) + L"\"";
|
||
}
|
||
|
||
if( 0 == m_bFilled) sResult += L" filled=\"f\"";
|
||
else sResult += L" filled=\"t\"";
|
||
|
||
if( 0 == m_bLine) sResult += L" stroked=\"f\"";
|
||
else sResult += L" stroked=\"t\"";
|
||
|
||
if( PROP_DEF != m_nFillColor)
|
||
{
|
||
RtfColor color(m_nFillColor);
|
||
sResult += L" fillcolor=\"#" + color.ToHexColor(true) + L"\"";
|
||
}
|
||
if( PROP_DEF != m_nLineColor)
|
||
{
|
||
RtfColor color(m_nLineColor);
|
||
sResult += L" strokecolor=\"#" + color.ToHexColor(true) + L"\"";
|
||
}
|
||
if(PROP_DEF != m_nLineWidth)
|
||
sResult += L" strokeweight=\"" + XmlUtils::DoubleToString(RtfUtility::Emu2Pt(m_nLineWidth), L"%.2f") + L"pt\"";
|
||
//path
|
||
switch( m_nConnectionType )
|
||
{
|
||
case 0: sResult += L" o:connecttype=\"custom\""; break;
|
||
case 1: sResult += L" o:connecttype=\"none\""; break;
|
||
case 2: sResult += L" o:connecttype=\"rect\""; break;
|
||
case 3: sResult += L" o:connecttype=\"segments\""; break;
|
||
}
|
||
//Connectors
|
||
switch( m_nConnectorStyle )
|
||
{
|
||
case 0: sResult += L" o:connectortype=\"straight\""; break;
|
||
case 1: sResult += L" o:connectortype=\"elbow\""; break;
|
||
case 2: sResult += L" o:connectortype=\"curved\""; break;
|
||
case 3: sResult += L" o:connectortype=\"none\""; break;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------------------------------------------
|
||
std::wstring sStyle ;
|
||
if( PROP_DEF != m_nLeft && PROP_DEF != m_nRight && PROP_DEF != m_nTop && PROP_DEF != m_nBottom )
|
||
{
|
||
//не пишем если inline
|
||
if( 3 != m_nPositionHRelative || 3 != m_nPositionVRelative )
|
||
{
|
||
sStyle += L"position:absolute;";
|
||
if (oRenderParameter.nType != RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2)
|
||
{
|
||
sStyle += L"margin-left:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(m_nLeft), L"%.2f") + L"pt;";
|
||
sStyle += L"margin-top:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(m_nTop), L"%.2f") + L"pt;";
|
||
sStyle += L"margin-bottom:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(m_nBottom), L"%.2f") + L"pt;";
|
||
sStyle += L"margin-right:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(m_nRight), L"%.2f") + L"pt;";
|
||
}
|
||
}
|
||
int nWidth = m_nRight - m_nLeft;
|
||
int nHeight = m_nBottom - m_nTop;
|
||
|
||
if (oRenderParameter.nType == RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2)
|
||
sStyle += L"width:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nWidth), L"%.2f") + L";height:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nHeight), L"%.2f");
|
||
else
|
||
sStyle += L"width:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nWidth), L"%.2f") + L"pt;height:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nHeight), L"%.2f") + L"pt;";
|
||
}
|
||
else if( PROP_DEF != m_nRelLeft && PROP_DEF != m_nRelRight && PROP_DEF != m_nRelTop && PROP_DEF != m_nRelBottom )
|
||
{
|
||
int nWidth = m_nRelRight - m_nRelLeft;
|
||
int nHeight = m_nRelBottom - m_nRelTop;
|
||
|
||
sStyle += L"position:absolute;";
|
||
sStyle += L"left: " + std::to_wstring(m_nRelLeft) + L";";
|
||
sStyle += L"top: " + std::to_wstring(m_nRelTop) + L";";
|
||
//sStyle += L"bottom: " + std::to_wstring() + L";" , m_nRelBottom );
|
||
//sStyle += L"right: " + std::to_wstring() + L";" , m_nRelRight);
|
||
sStyle += L"width: " + std::to_wstring(nWidth) + L";height: " + std::to_wstring(nHeight) + L";";
|
||
}
|
||
else if( 0 != m_oPicture && PROP_DEF != m_oPicture->m_nWidthGoal && PROP_DEF != m_oPicture->m_nHeightGoal && PROP_DEF != (int)m_oPicture->m_dScaleX && PROP_DEF != (int)m_oPicture->m_dScaleY )
|
||
{
|
||
float nWidth = (int)(m_oPicture->m_nWidthGoal * m_oPicture->m_dScaleX / 100.);
|
||
if( PROP_DEF != m_oPicture->m_nCropL )
|
||
nWidth -= m_oPicture->m_nCropL;
|
||
if( PROP_DEF != m_oPicture->m_nCropR )
|
||
nWidth -= m_oPicture->m_nCropR;
|
||
|
||
float nHeight = (int)(m_oPicture->m_nHeightGoal * m_oPicture->m_dScaleY / 100.);
|
||
if( PROP_DEF != m_oPicture->m_nCropT )
|
||
nHeight -= m_oPicture->m_nCropT;
|
||
if( PROP_DEF != m_oPicture->m_nCropB )
|
||
nHeight -= m_oPicture->m_nCropB;
|
||
|
||
if (oRenderParameter.nType == RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2)
|
||
sStyle += L"width:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nWidth), L"%.2f") + L";height:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nHeight), L"%.2f") + L";";
|
||
else
|
||
sStyle += L"width:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nWidth), L"%.2f") + L"pt;height:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt(nHeight), L"%.2f") + L"pt;";
|
||
}
|
||
|
||
switch( m_nPositionH )
|
||
{
|
||
case 0: sStyle += L"mso-position-horizontal:absolute;"; break;
|
||
case 1: sStyle += L"mso-position-horizontal:left;"; break;
|
||
case 2: sStyle += L"mso-position-horizontal:center;"; break;
|
||
case 3: sStyle += L"mso-position-horizontal:right;"; break;
|
||
case 4: sStyle += L"mso-position-horizontal:inside;"; break;
|
||
case 5: sStyle += L"mso-position-horizontal:outside;"; break;
|
||
}
|
||
if( PROP_DEF != m_nPositionHPct )//todo
|
||
{
|
||
sStyle += L"mso-left-percent: " + std::to_wstring(m_nPositionHPct) + L";";
|
||
}
|
||
if( PROP_DEF != m_nPositionH && PROP_DEF == m_nPositionHRelative )
|
||
m_nPositionHRelative = 2;
|
||
if( PROP_DEF != m_nPositionHRelative )
|
||
{
|
||
switch( m_nPositionHRelative )
|
||
{
|
||
case 0: sStyle += L"mso-position-horizontal-relative:margin;"; break;
|
||
case 1: sStyle += L"mso-position-horizontal-relative:page;"; break;
|
||
case 2: sStyle += L"mso-position-horizontal-relative:text;"; break;
|
||
case 3: sStyle += L"mso-position-horizontal-relative:char;"; break;
|
||
case 4: sStyle += L"mso-position-horizontal-relative:left-margin-area;"; break;
|
||
case 5: sStyle += L"mso-position-horizontal-relative:right-margin-area;"; break;
|
||
case 6: sStyle += L"mso-position-horizontal-relative:inner-margin-area;"; break;
|
||
case 7: sStyle += L"mso-position-horizontal-relative:outer-margin-area;"; break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
switch( m_eXAnchor )
|
||
{
|
||
case ax_page: sStyle += L"mso-position-horizontal-relative:page;"; break;
|
||
case ax_margin: sStyle += L"mso-position-horizontal-relative:margin;"; break;
|
||
//case ax_column: sStyle += L"mso-position-horizontal-relative:text;"); break;
|
||
}
|
||
}
|
||
|
||
switch( m_nPositionV )
|
||
{
|
||
case 0: sStyle += L"mso-position-vertical:absolute;"; break;
|
||
case 1: sStyle += L"mso-position-vertical:top;"; break;
|
||
case 2: sStyle += L"mso-position-vertical:center;"; break;
|
||
case 3: sStyle += L"mso-position-vertical:bottom;"; break;
|
||
case 4: sStyle += L"mso-position-vertical:inside;"; break;
|
||
case 5: sStyle += L"mso-position-vertical:outside;"; break;
|
||
}
|
||
if( PROP_DEF != m_nPositionVPct )
|
||
sStyle += L"mso-top-percent: " + std::to_wstring(m_nPositionVPct) + L";";
|
||
|
||
if( PROP_DEF != m_nPositionV && PROP_DEF == m_nPositionVRelative )
|
||
m_nPositionVRelative =2;
|
||
if( PROP_DEF != m_nPositionVRelative )
|
||
{
|
||
switch( m_nPositionVRelative )
|
||
{
|
||
case 0: sStyle += L"mso-position-vertical-relative:margin;"; break;
|
||
case 1: sStyle += L"mso-position-vertical-relative:page;"; break;
|
||
case 2: sStyle += L"mso-position-vertical-relative:text;"; break;
|
||
case 3: sStyle += L"mso-position-vertical-relative:line;"; break;
|
||
case 4: sStyle += L"mso-position-vertical-relative:top-margin-area;"; break;
|
||
case 5: sStyle += L"mso-position-vertical-relative:bottom-margin-area;";break;
|
||
case 6: sStyle += L"mso-position-vertical-relative:inner-margin-area;"; break;
|
||
case 7: sStyle += L"mso-position-vertical-relative:outer-margin-area;"; break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
switch( m_eYAnchor )
|
||
{
|
||
case ay_page: sStyle += L"mso-position-vertical-relative:page;"; break;
|
||
case ay_margin: sStyle += L"mso-position-vertical-relative:margin;"; break;
|
||
//case ay_Para: sStyle += L"mso-position-vertical-relative:text;"; break;
|
||
}
|
||
}
|
||
if( PROP_DEF != m_nPctWidth )
|
||
sStyle += L"mso-width-percent: " + std::to_wstring(m_nPctWidth) + L";";
|
||
switch( m_nPctWidthRelative )
|
||
{
|
||
case 0: sStyle += L"mso-width-relative:margin;"; break;
|
||
case 1: sStyle += L"mso-width-relative:page;"; break;
|
||
case 2: sStyle += L"mso-width-relative:left-margin-area;"; break;
|
||
case 3: sStyle += L"mso-width-relative:right-margin-area;"; break;
|
||
case 4: sStyle += L"mso-width-relative:inner-margin-area;"; break;
|
||
case 5: sStyle += L"mso-width-relative:outer-margin-area;"; break;
|
||
}
|
||
|
||
if( PROP_DEF != m_nPctHeight )
|
||
sStyle += L"mso-height-percent: " + std::to_wstring(m_nPctHeight) + L";";
|
||
|
||
switch( m_nPctHeightRelative )
|
||
{
|
||
case 0: sStyle += L"mso-height-relative:margin;"; break;
|
||
case 1: sStyle += L"mso-height-relative:page;"; break;
|
||
case 2: sStyle += L"mso-height-relative:top-margin-area;"; break;
|
||
case 3: sStyle += L"mso-height-relative:bottom-margin-area;"; break;
|
||
case 4: sStyle += L"mso-height-relative:inner-margin-area;"; break;
|
||
case 5: sStyle += L"mso-height-relative:outer-margin-area;"; break;
|
||
}
|
||
|
||
if( PROP_DEF != m_nRotation )
|
||
sStyle += L"rotation: " + std::to_wstring(m_nRotation / 65536) + L";";
|
||
else if( PROP_DEF != m_nRelRotation )
|
||
sStyle += L"rotation: " + std::to_wstring(m_nRelRotation / 65536) + L";";
|
||
|
||
int nZIndex = PROP_DEF;
|
||
if( PROP_DEF != m_nRelZOrder )
|
||
nZIndex = m_nRelZOrder;
|
||
else if( PROP_DEF != m_nZOrder )
|
||
nZIndex = m_nZOrder;
|
||
else if (oRenderParameter.nType != RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2)
|
||
nZIndex = 100; //на свое усмотрение ставлю 100
|
||
|
||
if( PROP_DEF != m_nZOrderRelative && PROP_DEF != nZIndex)
|
||
{
|
||
//берем большое значение чтобы сделать строго выше или ниже текста
|
||
if( 0 == m_nZOrderRelative ) nZIndex += 10000;
|
||
else nZIndex -= 10000;
|
||
}
|
||
if (PROP_DEF != nZIndex)
|
||
sStyle += L"z-index: " + std::to_wstring(nZIndex) + L";";
|
||
|
||
if( PROP_DEF != m_nWrapDistLeft )
|
||
sStyle += L"mso-wrap-distance-left:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt( m_nWrapDistLeft ), L"%.2f") + L"pt;";
|
||
if( PROP_DEF != m_nWrapDistTop )
|
||
sStyle += L"mso-wrap-distance-top:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt( m_nWrapDistTop ), L"%.2f") + L"pt;";
|
||
if( PROP_DEF != m_nWrapDistRight )
|
||
sStyle += L"mso-wrap-distance-right:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt( m_nWrapDistRight ), L"%.2f") + L"pt;";
|
||
if( PROP_DEF != m_nWrapDistBottom )
|
||
sStyle += L"mso-wrap-distance-bottom:" + XmlUtils::DoubleToString(RtfUtility::Twip2pt( m_nWrapDistBottom ), L"%.2f") + L"pt;";
|
||
|
||
switch( m_nAnchorText)
|
||
{
|
||
case 0: sStyle += L"v-text-anchor:top;"; break;
|
||
case 1: sStyle += L"v-text-anchor:middle;"; break;
|
||
case 2: sStyle += L"v-text-anchor:bottom;"; break;
|
||
case 3: sStyle += L"v-text-anchor:topcenter;"; break;
|
||
case 4: sStyle += L"v-text-anchor:middle-center;"; break;
|
||
case 5: sStyle += L"v-text-anchor:bottom-center;"; break;
|
||
case 6: sStyle += L"v-text-anchor:top-baseline;"; break;
|
||
case 7: sStyle += L"v-text-anchor:bottom-baseline;"; break;
|
||
case 8: sStyle += L"v-text-anchor:top-center-baseline;"; break;
|
||
case 9: sStyle += L"v-text-anchor:bottom-center-baseline;"; break;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------------------------------------------------------
|
||
if( false == sStyle.empty() )
|
||
{
|
||
sStyle.erase( sStyle.length() - 1 );
|
||
sResult += L" style=\"" + sStyle + L"\"";
|
||
}
|
||
//----------------------------------------------------------------------------------------------------------------------------
|
||
if( true == m_bIsOle ) sResult += L" o:ole=\"\"";
|
||
|
||
if( PROP_DEF != m_nGroupLeft && PROP_DEF != m_nGroupTop )
|
||
sResult += L" coordorigin=\" " + std::to_wstring(m_nGroupLeft) + L", " + std::to_wstring(m_nGroupTop) + L"\"";
|
||
|
||
if( PROP_DEF != m_nGroupLeft && PROP_DEF != m_nGroupTop && PROP_DEF != m_nGroupRight && PROP_DEF != m_nGroupBottom)
|
||
sResult += L" coordsize=\" " + std::to_wstring(m_nGroupRight - m_nGroupLeft) + L", " + std::to_wstring(m_nGroupBottom - m_nGroupTop) + L"\"";
|
||
else if ( PROP_DEF != m_nGeoLeft && PROP_DEF != m_nGeoTop && PROP_DEF != m_nGeoRight && PROP_DEF != m_nGeoBottom)
|
||
sResult += L" coordsize=\" " + std::to_wstring(m_nGeoRight - m_nGeoLeft) + L", " + std::to_wstring(m_nGeoBottom - m_nGeoTop) + L"\"";
|
||
|
||
if (oRenderParameter.nType != RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2)
|
||
{
|
||
if( PROP_DEF != m_bLayoutInCell )
|
||
{
|
||
if( 0 == m_bLayoutInCell )
|
||
sResult += L" o:allowincell=\"false\"";
|
||
else
|
||
sResult += L" o:allowincell=\"true\"";
|
||
}
|
||
if( PROP_DEF != m_bAllowOverlap )
|
||
{
|
||
if( 0 == m_bAllowOverlap )
|
||
sResult += L" o:allowoverlap=\"false\"";
|
||
else
|
||
sResult += L" o:allowoverlap=\"true\"";
|
||
}
|
||
}
|
||
//Geometry
|
||
if( PROP_DEF != m_nAdjustValue[0] )
|
||
{
|
||
std::wstring sAdjust;
|
||
sAdjust += L" " + std::to_wstring(m_nAdjustValue[0]) + L"";
|
||
for (int i = 1 ; i < 10; i++)
|
||
{
|
||
if (PROP_DEF != m_nAdjustValue[i])
|
||
sAdjust += L", " + std::to_wstring(m_nAdjustValue[i]) + L"";
|
||
else
|
||
sAdjust += L",";
|
||
}
|
||
sResult +=L" adj=\"" + sAdjust + L"\"";
|
||
}
|
||
//Custom
|
||
if (!m_aPVerticles.empty() || !m_aPSegmentInfo.empty())
|
||
{
|
||
CPPTShape * custom_shape = CPPTShape::CreateByType((PPTShapes::ShapeType)m_nShapeType);
|
||
if (custom_shape)
|
||
{
|
||
custom_shape->m_bCustomShape = true;
|
||
|
||
custom_shape->m_oPath.SetCoordsize(m_nGeoRight - m_nGeoLeft, m_nGeoBottom - m_nGeoTop);
|
||
|
||
for (int i = 0 ; i < 10; i++)
|
||
{
|
||
if (PROP_DEF != m_nAdjustValue[i])
|
||
custom_shape->m_oCustomVML.LoadAdjusts(i + 1, m_nAdjustValue[i]);
|
||
}
|
||
|
||
if (PROP_DEF != m_nShapePath)
|
||
custom_shape->m_oCustomVML.SetPath((NSPresentationEditor::RulesType)m_nShapePath);
|
||
|
||
custom_shape->m_oCustomVML.LoadVertices(m_aPVerticles);
|
||
custom_shape->m_oCustomVML.LoadSegments(m_aPSegmentInfo);
|
||
|
||
custom_shape->m_oCustomVML.ToCustomShape(custom_shape, custom_shape->m_oManager);
|
||
|
||
sResult +=L" path=\"" + custom_shape->m_strPath + L"\"";
|
||
}
|
||
}
|
||
//Wrap Geometry
|
||
if( !m_aWrapPoints.empty())
|
||
{
|
||
sResult += L" wrapcoords=\"";
|
||
sResult += L" " + std::to_wstring(m_aWrapPoints[0].first) + L", " + std::to_wstring(m_aWrapPoints[0].second) + L"";
|
||
|
||
for( int i = 0; i < (int)m_aWrapPoints.size(); i++ )
|
||
{
|
||
sResult += L", " + std::to_wstring(m_aWrapPoints[i].first) + L", " + std::to_wstring(m_aWrapPoints[i].second) + L"";
|
||
}
|
||
|
||
sResult += L"\"";
|
||
}
|
||
|
||
sResult += L">";
|
||
//-------------------------------------------------------------------------------------------------------------- nodes
|
||
if( PROP_DEF != m_nWrapType && 3 != m_nWrapType)
|
||
{
|
||
sResult += L"<w10:wrap";
|
||
|
||
switch( m_nWrapType )
|
||
{
|
||
case 1:sResult += L" type=\"topAndBottom\"";break;
|
||
case 2:sResult += L" type=\"square\""; break;
|
||
case 3:sResult += L" type=\"none\""; break;
|
||
case 4:sResult += L" type=\"tight\""; break;
|
||
case 5:sResult += L" type=\"through\""; break;
|
||
}
|
||
switch( m_nWrapSideType )
|
||
{
|
||
case 0:sResult += L" side=\"both\""; break;
|
||
case 1:sResult += L" side=\"left\""; break;
|
||
case 2:sResult += L" side=\"right\""; break;
|
||
case 3:sResult += L" side=\"largest\""; break;
|
||
}
|
||
sResult += L"/>";
|
||
}
|
||
|
||
//Line
|
||
if( 0 != m_bLine)
|
||
{
|
||
std::wstring sStroke;
|
||
switch( m_nLineDashing )
|
||
{
|
||
case 1: sStroke += L" dashstyle=\"shortdash\""; break;
|
||
case 2: sStroke += L" dashstyle=\"shortdot\""; break;
|
||
case 3: sStroke += L" dashstyle=\"shortdashdot\""; break;
|
||
case 4: sStroke += L" dashstyle=\"shortdashdotdot\"";break;
|
||
case 5: sStroke += L" dashstyle=\"dot\""; break;
|
||
case 6: sStroke += L" dashstyle=\"dash\""; break;
|
||
case 7: sStroke += L" dashstyle=\"longdash\""; break;
|
||
case 8: sStroke += L" dashstyle=\"dashdot\""; break;
|
||
case 9: sStroke += L" dashstyle=\"longdashdot\""; break;
|
||
case 10: sStroke += L" dashstyle=\"longdashdotdot\"";break;
|
||
}
|
||
switch( m_nLineStartArrow )
|
||
{
|
||
case 0: sStroke += L" startarrow=\"none\""; break;
|
||
case 1: sStroke += L" startarrow=\"block\""; break;
|
||
case 2: sStroke += L" startarrow=\"classic\""; break;
|
||
case 3: sStroke += L" startarrow=\"diamond\""; break;
|
||
case 4: sStroke += L" startarrow=\"oval\""; break;
|
||
case 5: sStroke += L" startarrow=\"open\""; break;
|
||
case 6: sStroke += L" startarrow=\"block\""; break;
|
||
case 7: sStroke += L" startarrow=\"block\""; break;
|
||
}
|
||
switch( m_nLineStartArrowLength )
|
||
{
|
||
case 0: sStroke += L" startarrowlength=\"short\""; break;
|
||
case 1: sStroke += L" startarrowlength=\"medium\""; break;
|
||
case 2: sStroke += L" startarrowlength=\"long\""; break;
|
||
}
|
||
switch( m_nLineStartArrowWidth )
|
||
{
|
||
case 0: sStroke += L" startarrowwidth=\"narrow\""; break;
|
||
case 1: sStroke += L" startarrowwidth=\"medium\""; break;
|
||
case 2: sStroke += L" startarrowwidth=\"wide\""; break;
|
||
}
|
||
switch( m_nLineEndArrow )
|
||
{
|
||
case 0: sStroke += L" endarrow=\"none\""; break;
|
||
case 1: sStroke += L" endarrow=\"block\""; break;
|
||
case 2: sStroke += L" endarrow=\"classic\"";break;
|
||
case 3: sStroke += L" endarrow=\"diamond\"";break;
|
||
case 4: sStroke += L" endarrow=\"oval\""; break;
|
||
case 5: sStroke += L" endarrow=\"open\""; break;
|
||
case 6: sStroke += L" endarrow=\"block\""; break;
|
||
case 7: sStroke += L" endarrow=\"block\""; break;
|
||
}
|
||
switch( m_nLineEndArrowLength )
|
||
{
|
||
case 0: sStroke += L" endarrowlength=\"short\""; break;
|
||
case 1: sStroke += L" endarrowlength=\"medium\""; break;
|
||
case 2: sStroke += L" endarrowlength=\"long\""; break;
|
||
}
|
||
switch( m_nLineEndArrowWidth )
|
||
{
|
||
case 0: sStroke += L" endarrowwidth=\"narrow\""; break;
|
||
case 1: sStroke += L" endarrowwidth=\"medium\""; break;
|
||
case 2: sStroke += L" endarrowwidth=\"wide\""; break;
|
||
}
|
||
|
||
if( false == sStroke.empty())
|
||
{
|
||
sResult += L"<v:stroke " + sStroke + L"/>";
|
||
}
|
||
}
|
||
|
||
if( 0 != m_aTextItems )
|
||
{
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
|
||
sResult += L"<v:textbox";
|
||
if (m_nTexpLeft != PROP_DEF && m_nTexpTop != PROP_DEF && m_nTexpRight != PROP_DEF && m_nTexpBottom != PROP_DEF)
|
||
{
|
||
sResult += L" inset=\" " + std::to_wstring((int)RtfUtility::Emu2Pt(m_nTexpLeft)) + L"pt, "
|
||
+ std::to_wstring((int)RtfUtility::Emu2Pt(m_nTexpTop)) + L"pt, "
|
||
+ std::to_wstring((int)RtfUtility::Emu2Pt(m_nTexpRight)) + L"pt, "
|
||
+ std::to_wstring((int)RtfUtility::Emu2Pt(m_nTexpBottom)) + L"pt\">";
|
||
}
|
||
else
|
||
sResult += L">";
|
||
|
||
sResult += L"<w:txbxContent>";
|
||
sResult += m_aTextItems->RenderToOOX(oNewParam);
|
||
sResult += L"</w:txbxContent>";
|
||
sResult += L"</v:textbox>";
|
||
}
|
||
|
||
std::wstring sPicture;
|
||
if( m_oPicture )
|
||
{
|
||
sPicture = m_oPicture->RenderToOOX(oRenderParameter);
|
||
|
||
if (m_nShapeType == PROP_DEF || m_nShapeType == 75)
|
||
{
|
||
if( sPicture.empty() )//если не сохранилась картинка, то весь shape-picture будет бесполезным
|
||
return L"";
|
||
|
||
int nCropLeft = PROP_DEF;
|
||
int nCropTop = PROP_DEF;
|
||
int nCropRight = PROP_DEF;
|
||
int nCropBottom = PROP_DEF;
|
||
|
||
if( PROP_DEF != m_nCropFromLeft )
|
||
nCropLeft = m_nCropFromLeft;
|
||
else if( PROP_DEF != m_oPicture->m_nWidthGoal && PROP_DEF != m_oPicture->m_nCropL )
|
||
nCropLeft = (int)( 65536 * ( 1.0 * m_oPicture->m_nCropL / m_oPicture->m_nWidthGoal) ); //This numeric value can also be specified in 1/65536-ths if a trailing "f" is supplied
|
||
if( PROP_DEF != m_nCropFromTop )
|
||
nCropTop = m_nCropFromTop;
|
||
else if( PROP_DEF != m_oPicture->m_nHeightGoal && PROP_DEF != m_oPicture->m_nCropT )
|
||
nCropTop = (int)( 65536 * ( 1.0 * m_oPicture->m_nCropT / m_oPicture->m_nHeightGoal) );
|
||
if( PROP_DEF != m_nCropFromRight )
|
||
nCropRight = m_nCropFromRight;
|
||
else if( PROP_DEF != m_oPicture->m_nWidthGoal && PROP_DEF != m_oPicture->m_nCropR )
|
||
nCropRight = (int)( 65536 * ( 1.0 * m_oPicture->m_nCropR / m_oPicture->m_nWidthGoal) );
|
||
if( PROP_DEF != m_nCropFromBottom )
|
||
nCropBottom = m_nCropFromBottom;
|
||
else if( PROP_DEF != m_oPicture->m_nHeightGoal && PROP_DEF != m_oPicture->m_nCropB )
|
||
nCropBottom = (int)( 65536 * ( 1.0 * m_oPicture->m_nCropB / m_oPicture->m_nHeightGoal) );
|
||
|
||
sResult += L"<v:imagedata r:id=\"" + sPicture + L"\"";
|
||
|
||
if( PROP_DEF != nCropLeft )
|
||
sResult += L" cropleft=\" " + std::to_wstring(nCropLeft) + L"f\"";
|
||
if( PROP_DEF != nCropTop )
|
||
sResult += L" croptop=\" " + std::to_wstring(nCropTop) + L"f\"";
|
||
if( PROP_DEF != nCropRight )
|
||
sResult += L" cropright=\" " + std::to_wstring(nCropRight) + L"f\"";
|
||
if( PROP_DEF != nCropBottom )
|
||
sResult += L" cropbottom=\" " + std::to_wstring(nCropBottom) + L"f\"";
|
||
|
||
sResult += L" o:title=\"\"/>";
|
||
}
|
||
}
|
||
//-----------------------------------------------------------------------------------------------
|
||
if( 0 != m_bFilled)
|
||
{
|
||
sResult += L"<v:fill";
|
||
|
||
if (!sPicture.empty() && m_nShapeType != 75)
|
||
{
|
||
sResult += L" r:id=\"" + sPicture + L"\"";
|
||
|
||
if( PROP_DEF == m_nFillType) m_nFillType = 2;
|
||
}
|
||
switch(m_nFillType)
|
||
{
|
||
case 1: sResult += L" type=\"pattern\""; break;
|
||
case 2: sResult += L" type=\"tile\""; break;
|
||
case 3: sResult += L" type=\"frame\""; break;
|
||
case 4: sResult += L" type=\"gradient\""; break;
|
||
case 5: sResult += L" type=\"gradient\""; break;
|
||
case 6: sResult += L" type=\"gradient\""; break;
|
||
case 7: sResult += L" type=\"gradient\""; break;
|
||
case 8: sResult += L" type=\"gradient\""; break;
|
||
case 9: sResult += L" type=\"gradient\""; break;
|
||
}//todooo center radial ...
|
||
|
||
if ( PROP_DEF != m_nFillOpacity)
|
||
{
|
||
std::wstring sOpacity = std::to_wstring( /*100 - */m_nFillOpacity);
|
||
sResult += L" opacity=\"" + sOpacity +L"%\"";
|
||
//sResult += L" opacity=\" " + std::to_wstring(m_nFillOpacity) + L"f\"";
|
||
}
|
||
if ( PROP_DEF != m_nFillColor2)
|
||
{
|
||
RtfColor color(m_nFillColor2);
|
||
sResult += L" color2=\"#" + color.ToHexColor(true) + L"\"";
|
||
}
|
||
if ( PROP_DEF != m_nFillFocus)
|
||
{
|
||
sResult += L" focus=\""+ std::to_wstring(m_nFillFocus) + L"%\"";
|
||
}
|
||
|
||
if ( PROP_DEF != m_nFillAngle)
|
||
sResult += L" angle=\"" + std::to_wstring(m_nFillAngle) + L"\"";
|
||
|
||
sResult += L"/>";
|
||
}
|
||
//---------------------------------------------------------------------------------------------------------------------------
|
||
if( false == m_sGtextUNICODE.empty())
|
||
{
|
||
sResult += L"<v:textpath";
|
||
|
||
std::wstring sTextStyle;
|
||
|
||
if ( !m_sGtextFont.empty() )
|
||
{
|
||
sTextStyle += L"font-family:" + XmlUtils::EncodeXmlString(m_sGtextFont) + L";";//todooo значения как в кавычках так и без - проверить как без
|
||
}
|
||
|
||
if (!sTextStyle.empty())
|
||
sResult += L" style=\"" + sTextStyle + L"\"";
|
||
|
||
if ( PROP_DEF != m_nGtextSize )
|
||
sTextStyle += L"font-size: " + std::to_wstring(m_nGtextSize) + L"pt;";
|
||
|
||
sResult += L" string=\"" + XmlUtils::EncodeXmlString(m_sGtextUNICODE) + L"\"";
|
||
sResult += L"/>";
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfShape::RenderToOOXEnd(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if (oRenderParameter.sValue.empty())
|
||
oRenderParameter.sValue = GetShapeNodeName(m_nShapeType);
|
||
|
||
sResult += L"</" + oRenderParameter.sValue + L">";
|
||
|
||
if( RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2 == oRenderParameter.nType )
|
||
;
|
||
else if( RENDER_TO_OOX_PARAM_SHAPE_WSHAPE == oRenderParameter.nType )
|
||
sResult += L"</w:pict>";
|
||
else
|
||
{
|
||
sResult += L"</w:pict></w:r>";//работает по умолчанию
|
||
|
||
if (m_bDelete) sResult += L"</w:del>";
|
||
if (m_bInsert) sResult += L"</w:ins>";
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfShapeGroup::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
//запоминаем координаты и если нужно поворачиваем
|
||
int nLeft = m_nLeft;
|
||
int nTop = m_nTop;
|
||
int nRight = m_nRight;
|
||
int nBottom = m_nBottom;
|
||
int nRotate = m_nRotation;
|
||
|
||
int nRelLeft = m_nRelLeft;
|
||
int nRelTop = m_nRelTop;
|
||
int nRelRight = m_nRelRight;
|
||
int nRelBottom = m_nRelBottom;
|
||
int nRelRotate = m_nRelRotation;
|
||
|
||
if( PROP_DEF != m_nRotation && PROP_DEF != m_nLeft && PROP_DEF != m_nTop &&
|
||
PROP_DEF != m_nRight && PROP_DEF != m_nBottom )
|
||
ToRtfRotation( m_nRotation, m_nLeft, m_nTop, m_nRight, m_nBottom );
|
||
|
||
if( PROP_DEF != m_nRelRotation && PROP_DEF != m_nRelLeft && PROP_DEF != m_nRelTop &&
|
||
PROP_DEF != m_nRelRight && PROP_DEF != m_nRelBottom )
|
||
ToRtfRotation( m_nRelRotation, m_nRelLeft, m_nRelTop, m_nRelRight, m_nRelBottom );
|
||
|
||
sResult += m_oCharProperty.RenderToRtf( oRenderParameter );
|
||
|
||
if( st_inline == m_eAnchorTypeShape )
|
||
{
|
||
sResult += L"{\\shpgrp";
|
||
sResult += L"{\\*\\shpinst";
|
||
|
||
RENDER_RTF_INT( m_nID , sResult, L"shplid" );
|
||
|
||
if (!m_bInGroup)
|
||
{
|
||
RENDER_RTF_INT( m_nLeft , sResult, L"shpleft" );
|
||
RENDER_RTF_INT( m_nTop , sResult, L"shptop" );
|
||
RENDER_RTF_INT( m_nBottom , sResult, L"shpbottom" );
|
||
RENDER_RTF_INT( m_nRight , sResult, L"shpright" );
|
||
RENDER_RTF_INT( m_nHeader , sResult, L"shpfhdr" );
|
||
|
||
sResult += L"\\shpbxignore";
|
||
sResult += L"\\shpbyignore";
|
||
|
||
RENDER_RTF_INT( m_nWrapType , sResult, L"shpwr" );
|
||
RENDER_RTF_INT( m_nWrapSideType , sResult, L"shpwrk" );
|
||
RENDER_RTF_BOOL( m_bLockAnchor , sResult, L"shplockanchor" );
|
||
|
||
//sResult += L"{\\sp{\\sn fUseShapeAnchor}{\\sv 0}}";
|
||
//sResult += L"{\\sp{\\sn fPseudoInline}{\\sv 1}}";
|
||
}
|
||
|
||
|
||
sResult += RenderToRtfShapeProperty( oRenderParameter );
|
||
|
||
for (int i = 0 ; i < m_aArray.size(); i++)
|
||
{
|
||
sResult += m_aArray[i]->RenderToRtf( oRenderParameter );
|
||
}
|
||
sResult += L"}";
|
||
sResult += L"}";
|
||
}
|
||
else
|
||
{
|
||
sResult += L"{\\shpgrp";
|
||
sResult += L"{\\*\\shpinst";
|
||
|
||
RENDER_RTF_INT( m_nID , sResult, L"shplid" );
|
||
|
||
if (!m_bInGroup)
|
||
{
|
||
RENDER_RTF_INT( m_nLeft , sResult, L"shpleft" );
|
||
RENDER_RTF_INT( m_nTop , sResult, L"shptop" );
|
||
RENDER_RTF_INT( m_nBottom , sResult, L"shpbottom" );
|
||
RENDER_RTF_INT( m_nRight , sResult, L"shpright" );
|
||
RENDER_RTF_INT( m_nZOrder , sResult, L"shpz" );
|
||
RENDER_RTF_INT( m_nHeader , sResult, L"shpfhdr" );
|
||
RENDER_RTF_INT( m_nWrapType , sResult, L"shpwr" );
|
||
RENDER_RTF_INT( m_nWrapSideType , sResult, L"shpwrk" );
|
||
RENDER_RTF_BOOL( m_bLockAnchor , sResult, L"shplockanchor" );
|
||
|
||
switch(m_eXAnchor)
|
||
{
|
||
case ax_page: sResult += L"\\shpbxpage"; break;
|
||
case ax_margin: sResult += L"\\shpbxmargin"; break;
|
||
case ax_column: sResult += L"\\shpbxcolumn"; break;
|
||
}
|
||
sResult += L"\\shpbxignore";
|
||
switch(m_eYAnchor)
|
||
{
|
||
case ay_page: sResult += L"\\shpbypage"; break;
|
||
case ay_margin: sResult += L"\\shpbymargin"; break;
|
||
case ay_Para: sResult += L"\\shpbypara"; break;
|
||
}
|
||
sResult += L"\\shpbyignore";
|
||
RENDER_RTF_INT( m_nZOrderRelative, sResult, L"shpfblwtxt");
|
||
}
|
||
sResult += L"{\\sp{\\sn lidRegroup}{\\sv 0}}";
|
||
|
||
sResult += RenderToRtfShapeProperty( oRenderParameter );
|
||
|
||
for (int i = 0 ; i < m_aArray.size(); i++)
|
||
{
|
||
sResult += m_aArray[i]->RenderToRtf( oRenderParameter );
|
||
}
|
||
|
||
sResult += L"}";
|
||
sResult += L"}";
|
||
}
|
||
//восстанавливаем координаты и если нужно поворачиваем
|
||
m_nLeft = nLeft;
|
||
m_nTop = nTop;
|
||
m_nRight = nRight;
|
||
m_nBottom = nBottom;
|
||
m_nRotation = nRotate;
|
||
|
||
m_nRelLeft = nRelLeft;
|
||
m_nRelTop = nRelTop;
|
||
m_nRelRight = nRelRight;
|
||
m_nRelBottom = nRelBottom;
|
||
m_nRelRotation = nRelRotate;
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfShapeGroup::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RenderParameter oNewParamGroup = oRenderParameter;
|
||
oNewParamGroup.sValue = L"v:group";
|
||
|
||
sResult = RenderToOOXBegin( oNewParamGroup );
|
||
|
||
for( int i = 0; i < (int)m_aArray.size(); i++ )
|
||
{
|
||
RenderParameter oNewParamShape = oRenderParameter;
|
||
oNewParamShape.sValue = L"";
|
||
oNewParamShape.nType = RENDER_TO_OOX_PARAM_SHAPE_WSHAPE2; //in group
|
||
|
||
sResult += m_aArray[i]->RenderToOOX( oNewParamShape );
|
||
}
|
||
|
||
sResult += RenderToOOXEnd( oNewParamGroup );
|
||
return sResult;
|
||
}
|