Yajbir Singh
528 lines
18 KiB
C++
528 lines
18 KiB
C++
/*
|
|
* (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 "RtfChar.h"
|
|
#include "RtfDocument.h"
|
|
|
|
#include "../OOXml/Writer/OOXWriter.h"
|
|
|
|
RtfAbsPosTab::RtfAbsPosTab()
|
|
{
|
|
}
|
|
bool RtfAbsPosTab::IsValid()
|
|
{
|
|
return a_none != m_eAlignment && r_none != m_eRelative;
|
|
}
|
|
std::wstring RtfAbsPosTab::RenderToRtf(RenderParameter oRenderParameter)
|
|
{
|
|
std::wstring sResult;
|
|
switch( m_eLeader )
|
|
{
|
|
case l_ptablnone: sResult += L"\\ptablnone"; break;
|
|
case l_ptabldot: sResult += L"\\ptabldot"; break;
|
|
case l_ptablminus: sResult += L"\\ptablminus"; break;
|
|
case l_ptabluscore: sResult += L"\\ptabluscore"; break;
|
|
case l_ptablmdot: sResult += L"\\ptablmdo"; break;
|
|
}
|
|
switch( m_eRelative )
|
|
{
|
|
case r_margin: sResult += L"\\pmartabq"; break;
|
|
case r_indent: sResult += L"\\pindtabq"; break;
|
|
}
|
|
switch( m_eAlignment )
|
|
{
|
|
case a_left: sResult += L"l"; break;
|
|
case a_center: sResult += L"c"; break;
|
|
case a_right: sResult += L"r"; break;
|
|
}
|
|
if( false == sResult.empty() )
|
|
sResult = L"{" + sResult + L"}";
|
|
return sResult;
|
|
}
|
|
std::wstring RtfAbsPosTab::RenderToOOX(RenderParameter oRenderParameter)
|
|
{
|
|
std::wstring sResult;
|
|
switch( m_eLeader )
|
|
{
|
|
case l_ptablnone: sResult += L" w:leader=\"none\""; break;
|
|
case l_ptabldot: sResult += L" w:leader=\"dot\""; break;
|
|
case l_ptablminus: sResult += L" w:leader=\"hyphen\""; break;
|
|
case l_ptabluscore: sResult += L" w:leader=\"underscore\""; break;
|
|
case l_ptablmdot: sResult += L" w:leader=\"middleDot\""; break;
|
|
}
|
|
switch( m_eRelative )
|
|
{
|
|
case r_margin: sResult += L" w:relativeTo=\"margin\""; break;
|
|
case r_indent: sResult += L" w:relativeTo=\"indent\""; break;
|
|
}
|
|
switch( m_eAlignment )
|
|
{
|
|
case a_left: sResult += L" w:alignment=\"left\""; break;
|
|
case a_center: sResult += L" w:alignment=\"center\""; break;
|
|
case a_right: sResult += L" w:alignment=\"right\""; break;
|
|
}
|
|
if( !sResult.empty() )
|
|
sResult = L"<w:ptab" + sResult + L"/>";
|
|
return sResult;
|
|
}
|
|
|
|
RtfChar::RtfChar()
|
|
{
|
|
m_bRtfEncode = true;
|
|
}
|
|
int RtfChar::GetType()
|
|
{
|
|
return TYPE_RTF_CHAR;
|
|
}
|
|
void RtfChar::AddText(std::wstring text)
|
|
{
|
|
m_sChars += text;
|
|
}
|
|
void RtfChar::setText(std::wstring text)
|
|
{
|
|
m_sChars = text;
|
|
}
|
|
std::wstring RtfChar::GetText()
|
|
{
|
|
return m_sChars;
|
|
}
|
|
std::wstring RtfChar::RenderToOOX(RenderParameter oRenderParameter)
|
|
{
|
|
RtfDocument* poRtfDocument = static_cast<RtfDocument*> (oRenderParameter.poDocument);
|
|
OOXWriter* poOOXWriter = static_cast<OOXWriter*> (oRenderParameter.poWriter);
|
|
|
|
std::wstring sResult;
|
|
if (RENDER_TO_OOX_PARAM_RUN == oRenderParameter.nType ||
|
|
RENDER_TO_OOX_PARAM_FIELD == oRenderParameter.nType)
|
|
{
|
|
bool bInsert = false;
|
|
bool bDelete = false;
|
|
|
|
if (m_oProperty.m_nRevised != PROP_DEF)
|
|
{
|
|
bInsert = true;
|
|
|
|
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oProperty.m_nRevauth);
|
|
std::wstring sDate(RtfUtility::convertDateTime(m_oProperty.m_nRevdttm).c_str());
|
|
|
|
sResult += L"<w:ins w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
|
m_oProperty.m_nRevised = PROP_DEF;
|
|
}
|
|
if (m_oProperty.m_nDeleted != PROP_DEF)
|
|
{
|
|
bDelete = true;
|
|
|
|
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oProperty.m_nRevauthDel);
|
|
std::wstring sDate(RtfUtility::convertDateTime(m_oProperty.m_nRevdttmDel).c_str());
|
|
|
|
sResult += L"<w:del w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
|
m_oProperty.m_nDeleted = PROP_DEF;
|
|
}
|
|
sResult += L"<w:r>";
|
|
sResult += L"<w:rPr>";
|
|
sResult += m_oProperty.RenderToOOX(oRenderParameter);
|
|
sResult += L"</w:rPr>";
|
|
|
|
sResult += renderTextToXML((RENDER_TO_OOX_PARAM_FIELD == oRenderParameter.nType ? L"Field" : L"Text"), bDelete );
|
|
sResult += L"</w:r>";
|
|
|
|
if (bDelete)sResult += L"</w:del>";
|
|
if (bInsert)sResult += L"</w:ins>";
|
|
}
|
|
else if(RENDER_TO_OOX_PARAM_TEXT == oRenderParameter.nType)
|
|
{
|
|
sResult = renderTextToXML( L"Text" );
|
|
}
|
|
else if( RENDER_TO_OOX_PARAM_MATH == oRenderParameter.nType)
|
|
{
|
|
sResult += L"<m:r>";
|
|
bool bInsert = false;
|
|
bool bDelete = false;
|
|
|
|
if (m_oProperty.m_nRevised != PROP_DEF)
|
|
{
|
|
bInsert = true;
|
|
|
|
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oProperty.m_nRevauth);
|
|
std::wstring sDate(RtfUtility::convertDateTime(m_oProperty.m_nRevdttm).c_str());
|
|
|
|
sResult += L"<w:ins w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
|
m_oProperty.m_nRevised = PROP_DEF;
|
|
}
|
|
if (m_oProperty.m_nDeleted != PROP_DEF)
|
|
{
|
|
bDelete = true;
|
|
|
|
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oProperty.m_nRevauthDel);
|
|
std::wstring sDate(RtfUtility::convertDateTime(m_oProperty.m_nRevdttmDel).c_str());
|
|
|
|
sResult += L"<w:del w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
|
m_oProperty.m_nDeleted = PROP_DEF;
|
|
}
|
|
sResult += m_oProperty.RenderToOOX(oRenderParameter);//w:rPr внутри
|
|
sResult += renderTextToXML( L"Math" );
|
|
|
|
if (bDelete)sResult += L"</w:del>";
|
|
if (bInsert)sResult += L"</w:ins>";
|
|
sResult += L"</m:r>";
|
|
}
|
|
else if( RENDER_TO_OOX_PARAM_PLAIN == oRenderParameter.nType)
|
|
sResult = m_sChars;
|
|
return sResult;
|
|
}
|
|
std::wstring RtfChar::renderTextToXML( std::wstring sParam, bool bDelete )
|
|
{
|
|
std::wstring sResult;
|
|
if( L"Text" == sParam )
|
|
{
|
|
if (bDelete == false)
|
|
{
|
|
sResult += L"<w:t xml:space= \"preserve\">";
|
|
sResult += XmlUtils::EncodeXmlString( m_sChars, true );
|
|
sResult += L"</w:t>";
|
|
}
|
|
else
|
|
{
|
|
sResult += L"<w:delText>";
|
|
sResult += XmlUtils::EncodeXmlString( m_sChars, true );
|
|
sResult += L"</w:delText>";
|
|
}
|
|
}
|
|
else if( L"Math" == sParam && !m_sChars.empty())
|
|
{
|
|
sResult += L"<m:t>";
|
|
sResult += XmlUtils::EncodeXmlString( m_sChars, true );
|
|
sResult += L"</m:t>";
|
|
}
|
|
else if (L"Field" == sParam && !m_sChars.empty())
|
|
{
|
|
sResult += L"<w:instrText xml:space=\"preserve\">";
|
|
sResult += XmlUtils::EncodeXmlString(m_sChars, true);
|
|
sResult += L"</w:instrText>";
|
|
}
|
|
return sResult;
|
|
}
|
|
std::wstring RtfChar::renderRtfText( std::wstring& sText, void* poDocument, RtfCharProperty* oCharProperty, bool bMarker)
|
|
{
|
|
RtfDocument* pDocument = static_cast<RtfDocument*>(poDocument);
|
|
|
|
int iFont = 0;
|
|
if (oCharProperty) iFont = oCharProperty->m_nFont;
|
|
|
|
int nCodePage = -1;
|
|
//применяем параметры codepage от текущего шрифта todo associated fonts.
|
|
//todooo разобраться со шрифтами и их подбором
|
|
RtfFont oFont;
|
|
if( NULL != oCharProperty && true == pDocument->m_oFontTable.GetFont( oCharProperty->m_nFont, oFont ) )
|
|
{
|
|
if( PROP_DEF != oFont.m_nCharset )
|
|
nCodePage = RtfUtility::CharsetToCodepage( oFont.m_nCharset );
|
|
else if( PROP_DEF != oFont.m_nCodePage )
|
|
nCodePage = oFont.m_nCodePage;
|
|
}
|
|
|
|
return renderRtfText(sText, pDocument, nCodePage, bMarker);
|
|
}
|
|
std::wstring RtfChar::renderRtfText(const std::wstring& sText)
|
|
{
|
|
std::wstring sResult;
|
|
for (size_t i = 0; i < sText.length(); i++)
|
|
{
|
|
int nUnicode = (int)sText[i];
|
|
|
|
if (0 < nUnicode && nUnicode <= 0x8000)
|
|
{
|
|
sResult += L"\\u" + std::to_wstring(nUnicode) + L"*";
|
|
}
|
|
else if (0x8000 < nUnicode && nUnicode <= 0xffff) {
|
|
sResult += L"\\u" + std::to_wstring(nUnicode - 0x10000) + L"*"; //??? font alt name china ALL FONTS NEW.docx (Mekanik LET)
|
|
}
|
|
else {
|
|
sResult += L"\\u9633*";
|
|
}
|
|
}
|
|
return sResult;
|
|
}
|
|
std::wstring RtfChar::renderRtfText( std::wstring& sText, void* poDocument, int nCodePage, bool bMarker)
|
|
{
|
|
RtfDocument* pDocument = static_cast<RtfDocument*>(poDocument);
|
|
std::wstring sResult;
|
|
|
|
if (sText.empty())
|
|
{
|
|
return sResult;
|
|
}
|
|
//от настроек документа
|
|
if( -1 == nCodePage && RtfDocumentProperty::cp_none != pDocument->m_oProperty.m_eCodePage )
|
|
{
|
|
switch ( pDocument->m_oProperty.m_eCodePage )
|
|
{
|
|
case RtfDocumentProperty::cp_ansi:
|
|
{
|
|
if( PROP_DEF != pDocument->m_oProperty.m_nAnsiCodePage )
|
|
nCodePage = pDocument->m_oProperty.m_nAnsiCodePage;
|
|
else
|
|
nCodePage = CP_ACP;
|
|
break;
|
|
}
|
|
case RtfDocumentProperty::cp_mac: nCodePage = CP_MACCP; break;
|
|
case RtfDocumentProperty::cp_pc: nCodePage = 437; break;
|
|
case RtfDocumentProperty::cp_pca: nCodePage = 850; break;
|
|
}
|
|
}
|
|
//если ничего нет ставим ANSI или default from user
|
|
if( -1 == nCodePage )
|
|
{
|
|
nCodePage = CP_ACP;
|
|
}
|
|
|
|
if ((nCodePage == CP_ACP || nCodePage == 1252) && pDocument->m_nUserLCID > 0)
|
|
{
|
|
nCodePage = pDocument->m_lcidConverter.get_codepage(pDocument->m_nUserLCID);
|
|
}
|
|
|
|
if (bMarker)
|
|
sResult += L"{\\uc1";
|
|
|
|
sResult += renderRtfText(sText);
|
|
|
|
if (bMarker)
|
|
sResult += L"}";
|
|
return sResult;
|
|
}
|
|
std::wstring RtfChar::RenderToRtf(RenderParameter oRenderParameter)
|
|
{
|
|
std::wstring result;
|
|
|
|
if( RENDER_TO_RTF_PARAM_CHAR == oRenderParameter.nType )
|
|
{
|
|
if( true == m_bRtfEncode )
|
|
result += renderRtfText( m_sChars, oRenderParameter.poDocument, &m_oProperty );
|
|
else
|
|
result += m_sChars;
|
|
}
|
|
else
|
|
{
|
|
std::wstring sText;
|
|
if( true == m_bRtfEncode )
|
|
sText = renderRtfText( m_sChars, oRenderParameter.poDocument, &m_oProperty );
|
|
else
|
|
sText = m_sChars;
|
|
|
|
std::wstring sTextProp = m_oProperty.RenderToRtf( oRenderParameter ) ;
|
|
|
|
if( !sText.empty() || !sTextProp.empty())
|
|
{
|
|
if (oRenderParameter.nType != RENDER_TO_RTF_PARAM_NESTED)
|
|
result += L"{";
|
|
|
|
result += sTextProp;
|
|
result += L" ";
|
|
result += sText;
|
|
|
|
if (oRenderParameter.nType != RENDER_TO_RTF_PARAM_NESTED)
|
|
result += L"}";
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
RtfCharSpecial::RtfCharSpecial()
|
|
{
|
|
m_eType = rsc_none;
|
|
m_nTextWrapBreak = PROP_DEF;
|
|
m_nSoftHeight = PROP_DEF;
|
|
}
|
|
std::wstring RtfCharSpecial::_RenderToOOX(RenderParameter oRenderParameter)
|
|
{
|
|
std::wstring sResult;
|
|
switch( m_eType )
|
|
{
|
|
case rsc_chdate: sResult += L""; break;
|
|
case rsc_chdpl: sResult += L""; break;
|
|
case rsc_chdpa: sResult += L""; break;
|
|
case rsc_chtime: sResult += L""; break;
|
|
case rsc_chpgn: sResult += L"<w:pgNum />"; break;
|
|
case rsc_sectnum: sResult += L""; break;
|
|
case rsc_chftn: sResult += L"<w:footnoteRef/>"; break;
|
|
case rsc_chftnEnd: sResult += L"<w:endnoteRef/>"; break;
|
|
case rsc_chatn: sResult += L"<w:annotationRef />"; break;
|
|
case rsc_chftnsep: sResult += L"<w:separator />"; break;
|
|
case rsc_chftnsepc: sResult += L"<w:continuationSeparator/>"; break;
|
|
case rsc_page: sResult += L"<w:br w:type=\"page\"/>"; break;
|
|
case rsc_column: sResult += L"<w:br w:type=\"column\"/>"; break;
|
|
case rsc_line: sResult += L"<w:br w:type=\"textWrapping\" w:clear=\"none\"/>";break;
|
|
case rsc_softpage: sResult += L""; break;
|
|
case rsc_softcol: sResult += L""; break;
|
|
case rsc_softline: sResult += L""; break;
|
|
case rsc_tab: sResult += L"<w:tab/>"; break;
|
|
case rsc_emspace: sResult += L""; break;
|
|
case rsc_qmspace: sResult += L""; break;
|
|
case rsc_Formula: sResult += L""; break;
|
|
case rsc_zwbo: sResult += L""; break;
|
|
case rsc_zwnbo: sResult += L""; break;
|
|
case rsc_zwj: sResult += L""; break;
|
|
case rsc_zwnj: sResult += L""; break;
|
|
case rsc_OptHyphen: sResult += L"<w:t xml:space=\"preserve\">-</w:t>"; break;//<w:softHyphen/>
|
|
case rsc_NonBrHyphen: sResult += L"<w:t xml:space=\"preserve\">-</w:t>"; break;//<w:nonBreakHyphen/>
|
|
case rsc_NonBrSpace: sResult += L"<w:t xml:space=\"preserve\"> </w:t>"; break;
|
|
}
|
|
switch ( m_nTextWrapBreak )
|
|
{
|
|
case 0: sResult += L"<w:br w:type=\"textWrapping\" w:clear=\"none\"/>"; break;
|
|
case 1: sResult += L"<w:br w:type=\"textWrapping\" w:clear=\"left\"/>"; break;
|
|
case 2: sResult += L"<w:br w:type=\"textWrapping\" w:clear=\"right\"/>"; break;
|
|
case 3: sResult += L"<w:br w:type=\"textWrapping\" w:clear=\"all\"/>"; break;
|
|
}
|
|
return sResult;
|
|
}
|
|
std::wstring RtfCharSpecial::RenderToOOX(RenderParameter oRenderParameter)
|
|
{
|
|
RtfDocument* poRtfDocument = static_cast<RtfDocument*> (oRenderParameter.poDocument);
|
|
OOXWriter* poOOXWriter = static_cast<OOXWriter*> (oRenderParameter.poWriter);
|
|
|
|
std::wstring sResult;
|
|
if (RENDER_TO_OOX_PARAM_RUN == oRenderParameter.nType ||
|
|
RENDER_TO_OOX_PARAM_FIELD == oRenderParameter.nType)
|
|
{
|
|
bool bInsert = false;
|
|
bool bDelete = false;
|
|
|
|
if (m_oProperty.m_nRevised != PROP_DEF)
|
|
{
|
|
bInsert = true;
|
|
|
|
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oProperty.m_nRevauth);
|
|
std::wstring sDate(RtfUtility::convertDateTime(m_oProperty.m_nRevdttm).c_str());
|
|
|
|
sResult += L"<w:ins w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
|
m_oProperty.m_nRevised = PROP_DEF;
|
|
}
|
|
if (m_oProperty.m_nDeleted != PROP_DEF)
|
|
{
|
|
bDelete = true;
|
|
|
|
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_oProperty.m_nRevauthDel);
|
|
std::wstring sDate(RtfUtility::convertDateTime(m_oProperty.m_nRevdttmDel).c_str());
|
|
|
|
sResult += L"<w:del w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
|
m_oProperty.m_nDeleted = PROP_DEF;
|
|
}
|
|
sResult += L"<w:r>";
|
|
sResult += L"<w:rPr>";
|
|
sResult += m_oProperty.RenderToOOX(oRenderParameter);
|
|
sResult += L"</w:rPr>";
|
|
sResult += _RenderToOOX(oRenderParameter);
|
|
sResult += L"</w:r>";
|
|
|
|
if (bDelete)sResult += L"</w:del>";
|
|
if (bInsert)sResult += L"</w:ins>";
|
|
}
|
|
else if(RENDER_TO_OOX_PARAM_TEXT == oRenderParameter.nType ||
|
|
RENDER_TO_OOX_PARAM_MATH == oRenderParameter.nType ||
|
|
RENDER_TO_OOX_PARAM_PLAIN == oRenderParameter.nType)
|
|
{
|
|
sResult += _RenderToOOX(oRenderParameter);
|
|
}
|
|
return sResult;
|
|
}
|
|
std::wstring RtfCharSpecial::RenderToRtf(RenderParameter oRenderParameter)
|
|
{
|
|
std::wstring sResult;
|
|
sResult += L"{";
|
|
sResult += m_oProperty.RenderToRtf( oRenderParameter );
|
|
switch( m_eType )
|
|
{
|
|
case rsc_chdate: sResult += L"\\chdate"; break;
|
|
case rsc_chdpl: sResult += L"\\chdpl"; break;
|
|
case rsc_chdpa: sResult += L"\\chdpa"; break;
|
|
case rsc_chtime: sResult += L"\\chtime"; break;
|
|
case rsc_chpgn: sResult += L"\\chpgn"; break;
|
|
case rsc_sectnum: sResult += L"\\sectnum"; break;
|
|
case rsc_chftn: sResult += L"\\chftn"; break;
|
|
case rsc_chftnEnd: sResult += L"\\chftn"; break;
|
|
case rsc_chatn: sResult += L"\\chatn"; break;
|
|
case rsc_chftnsep: sResult += L"\\chftnsep"; break;
|
|
case rsc_chftnsepc: sResult += L"\\chftnsepc"; break;
|
|
case rsc_page: sResult += L"\\page"; break;
|
|
case rsc_column: sResult += L"\\column"; break;
|
|
case rsc_line: sResult += L"\\line"; break;
|
|
case rsc_softpage: sResult += L"\\softpage"; break;
|
|
case rsc_softcol: sResult += L"\\softcol"; break;
|
|
case rsc_softline: sResult += L"\\softline"; break;
|
|
case rsc_tab: sResult += L"\\tab"; break;
|
|
case rsc_Formula: sResult += L"\\|"; break;
|
|
case rsc_OptHyphen: sResult += L"\\-"; break;
|
|
case rsc_NonBrHyphen: sResult += L"\\_"; break;
|
|
case rsc_NonBrSpace: sResult += L"\\~"; break;
|
|
case rsc_zwbo: sResult += L"\\zwbo"; break;
|
|
case rsc_zwnbo: sResult += L"\\zwnbo"; break;
|
|
case rsc_zwj: sResult += L"\\zwj"; break;
|
|
case rsc_zwnj: sResult += L"\\zwnj"; break;
|
|
}
|
|
if( PROP_DEF != m_nTextWrapBreak )
|
|
sResult += L"\\par";
|
|
//switch ( m_nTextWrapBreak ) //не воспринимается word
|
|
//{
|
|
// case 0: sResult += L"\\lbr0";break;
|
|
// case 1: sResult += L"\\lbr1";break;
|
|
// case 2: sResult += L"\\lbr2";break;
|
|
// case 3: sResult += L"\\lbr3";break;
|
|
//}
|
|
if( PROP_DEF != m_nSoftHeight )
|
|
{
|
|
sResult += L"\\softlheight" + std::to_wstring( m_nSoftHeight );
|
|
}
|
|
sResult += L"}";
|
|
return sResult;
|
|
}
|
|
|
|
std::wstring RtfCharNative::RenderToRtf(RenderParameter oRenderParameter)
|
|
{
|
|
std::wstring result;
|
|
if( RENDER_TO_RTF_PARAM_CHAR == oRenderParameter.nType )
|
|
{
|
|
result = m_sChars;
|
|
}
|
|
else
|
|
{
|
|
std::wstring sText = m_sChars;
|
|
if( L"" != sText )
|
|
{
|
|
result += L"{";
|
|
result += m_oProperty.RenderToRtf( oRenderParameter );
|
|
result += L" " + sText;
|
|
result += L"}";
|
|
}
|
|
}
|
|
return result;
|
|
}
|