5642 lines
187 KiB
C++
5642 lines
187 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 "RtfWriter.h"
|
||
#include "../OOXml/Writer/OOXWriter.h"
|
||
#include "RtfProperty.h"
|
||
#include "RtfDocument.h"
|
||
|
||
#include "../../OOXML/DocxFormat/FileTypes.h"
|
||
#include "../../OOXML/DocxFormat/App.h"
|
||
#include "../../OOXML/DocxFormat/Core.h"
|
||
#include "../../DesktopEditor/common/SystemUtils.h"
|
||
|
||
#include <boost/algorithm/string.hpp>
|
||
|
||
RtfFont::RtfFont()
|
||
{
|
||
SetDefault();
|
||
}
|
||
int RtfFont::GetType()
|
||
{
|
||
return TYPE_RTF_FONT;
|
||
}
|
||
bool RtfFont::operator==( const RtfFont& oFont)
|
||
{
|
||
return m_eFontTheme == oFont.m_eFontTheme && m_eFontFamily == oFont.m_eFontFamily &&
|
||
m_sPanose == oFont.m_sPanose && m_nID == oFont.m_nID &&
|
||
m_sName == oFont.m_sName && m_sAltName == oFont.m_sAltName &&
|
||
m_nCharset == oFont.m_nCharset && m_nCodePage == oFont.m_nCodePage &&
|
||
m_nPitch == oFont.m_nPitch;
|
||
}
|
||
bool RtfFont::IsValid()
|
||
{
|
||
return PROP_DEF != m_nID;
|
||
}
|
||
void RtfFont::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
m_nPitch = 0;
|
||
}
|
||
void RtfFont::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfFont::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY_DEF( m_eFontTheme, ft_none )
|
||
DEFAULT_PROPERTY_DEF( m_eFontFamily, ff_fnil )
|
||
DEFAULT_PROPERTY_DEF( m_sPanose, L"" )
|
||
DEFAULT_PROPERTY ( m_nID )
|
||
DEFAULT_PROPERTY_DEF( m_sName, L"" )
|
||
DEFAULT_PROPERTY_DEF( m_sAltName, L"" )
|
||
DEFAULT_PROPERTY ( m_nCharset )
|
||
DEFAULT_PROPERTY ( m_nCodePage )
|
||
DEFAULT_PROPERTY_DEF( m_nPitch, 2 )
|
||
}
|
||
std::wstring RtfFont::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
if ( IsValid() == false) return L"";
|
||
|
||
std::wstring sResult;
|
||
if( RENDER_TO_RTF_PARAM_FONT_TBL == oRenderParameter.nType )
|
||
{
|
||
sResult += L"{";
|
||
switch( m_eFontTheme )
|
||
{
|
||
case ft_flomajor: sResult += L"\\flomajor"; break;
|
||
case ft_fhimajor: sResult += L"\\fhimajor"; break;
|
||
case ft_fdbmajor: sResult += L"\\fdbmajor"; break;
|
||
case ft_fbimajor: sResult += L"\\fbimajor"; break;
|
||
case ft_flominor: sResult += L"\\flominor"; break;
|
||
case ft_fhiminor: sResult += L"\\fhiminor"; break;
|
||
case ft_fdbminor: sResult += L"\\fdbminor"; break;
|
||
case ft_fbiminor: sResult += L"\\fbiminor"; break;
|
||
default:
|
||
break;
|
||
}
|
||
sResult += L"\\f" + std::to_wstring(m_nID);
|
||
|
||
switch( m_eFontFamily )
|
||
{
|
||
case ff_fnil: sResult += L"\\fnil"; break;
|
||
case ff_froman: sResult += L"\\froman"; break;
|
||
case ff_fswiss: sResult += L"\\fswiss"; break;
|
||
case ff_fmodern: sResult += L"\\fmodern"; break;
|
||
case ff_fscript: sResult += L"\\fscript"; break;
|
||
case ff_fdecor: sResult += L"\\fdecor"; break;
|
||
case ff_ftech: sResult += L"\\ftech"; break;
|
||
case ff_fbidi: sResult += L"\\fbidi"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nCharset, sResult, L"fcharset" )
|
||
RENDER_RTF_INT( m_nPitch, sResult, L"fprq" )
|
||
|
||
if( L"" != m_sPanose )
|
||
sResult += L"{\\*\\panose " + m_sPanose + L"}";
|
||
|
||
RENDER_RTF_INT( m_nCodePage, sResult, L"cpg" )
|
||
|
||
RtfCharProperty oFontNameCharProp;
|
||
sResult += L" " + RtfChar::renderRtfText( m_sName, oRenderParameter.poDocument, &oFontNameCharProp, true );
|
||
|
||
//ALL FONTS NEW.docx
|
||
// if(!m_sAltName.empty() )
|
||
// sResult += L"{\\*\\falt " + RtfChar::renderRtfText( m_sAltName, oRenderParameter.poDocument, &oFontNameCharProp ) + L"}";
|
||
|
||
sResult += L";}";
|
||
}
|
||
else
|
||
sResult += L"\\f" + std::to_wstring(m_nID);
|
||
return sResult;
|
||
}
|
||
std::wstring RtfFont::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
if ( IsValid() == false) return L"";
|
||
|
||
std::wstring sResult;
|
||
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
|
||
std::wstring sFontName = m_sName;
|
||
|
||
if( sFontName.empty() )
|
||
{
|
||
if( PROP_DEF != poRtfDocument->m_oProperty.m_nDefFont )
|
||
{
|
||
RtfFont oDefFont;
|
||
poRtfDocument->m_oFontTable.GetFont( poRtfDocument->m_oProperty.m_nDefFont, oDefFont );
|
||
sFontName = oDefFont.m_sName;
|
||
}
|
||
if (sFontName.empty())
|
||
{
|
||
sFontName = poRtfDocument->m_oProperty.m_sDefFontName;
|
||
}
|
||
}
|
||
if( RENDER_TO_OOX_PARAM_MINOR_FONT == oRenderParameter.nType )
|
||
{
|
||
std::wstring sTag;
|
||
switch(m_eFontTheme)
|
||
{
|
||
case ft_flominor:
|
||
case ft_fhiminor: sTag = L"latin"; break;
|
||
case ft_fdbminor: sTag = L"ea"; break;
|
||
case ft_fbiminor: sTag = L"cs"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( !sTag.empty() )
|
||
{
|
||
sResult += L"<" ;
|
||
sResult += sTag;
|
||
sResult += L" typeface=\"";
|
||
sResult += XmlUtils::EncodeXmlString( sFontName );
|
||
sResult += L"\"/>";
|
||
}
|
||
}
|
||
else if( RENDER_TO_OOX_PARAM_MAJOR_FONT == oRenderParameter.nType )
|
||
{
|
||
std::wstring sTag;
|
||
switch(m_eFontTheme)
|
||
{
|
||
case ft_flomajor:
|
||
case ft_fhiminor: sTag = L"latin"; break;
|
||
case ft_fdbmajor: sTag = L"ea"; break;
|
||
case ft_fbimajor: sTag = L"cs"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( !sTag.empty() )
|
||
{
|
||
sResult += L"<";
|
||
sResult += sTag;
|
||
sResult += L" typeface=\"";
|
||
sResult += XmlUtils::EncodeXmlString( sFontName );
|
||
sResult += L"\"/>";
|
||
}
|
||
}
|
||
else if( RENDER_TO_OOX_PARAM_FONTTABLE == oRenderParameter.nType )
|
||
{
|
||
sResult += L"<w:font w:name=\"";
|
||
sResult += XmlUtils::EncodeXmlString( sFontName, true );
|
||
sResult += L"\">";
|
||
|
||
if( !m_sAltName.empty() )
|
||
{
|
||
sResult += L"<w:altName w:val=\"";
|
||
sResult += XmlUtils::EncodeXmlString( m_sAltName, true );
|
||
sResult += L"\"/>";
|
||
}
|
||
if( !m_sPanose.empty() )
|
||
{
|
||
sResult += L"<w:panose1 w:val=\"";
|
||
sResult += m_sPanose;
|
||
sResult += L"\"/>";
|
||
}
|
||
|
||
std::wstring sFamily = L"";
|
||
switch( m_eFontFamily )
|
||
{
|
||
case ff_fnil: sFamily = L"auto"; break;
|
||
case ff_froman: sFamily = L"roman"; break;
|
||
case ff_fswiss: sFamily = L"swiss"; break;
|
||
case ff_fmodern: sFamily = L"modern"; break;
|
||
case ff_fscript: sFamily = L"script"; break;
|
||
case ff_fdecor: sFamily = L"decorative"; break;
|
||
case ff_ftech: sFamily = L"auto"; break;
|
||
case ff_fbidi: sFamily = L"auto"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( !sFamily.empty() )
|
||
{
|
||
sResult += L"<w:family w:val=\"";
|
||
sResult += sFamily;
|
||
sResult += L"\"/>";
|
||
}
|
||
if( PROP_DEF != m_nCharset )
|
||
{
|
||
sResult += L"<w:charset w:val=\"";
|
||
sResult += Convert::ToStringHex( m_nCharset, 2 );
|
||
sResult += L"\"/>";
|
||
}
|
||
|
||
if( PROP_DEF != m_nPitch )
|
||
{
|
||
std::wstring sPitch;
|
||
switch( m_nPitch )
|
||
{
|
||
case 0: sPitch = L"default"; break;
|
||
case 1: sPitch = L"fixed"; break;
|
||
case 2: sPitch = L"variable"; break;
|
||
default:
|
||
break;
|
||
}
|
||
sResult += L"<w:pitch w:val=\"";
|
||
sResult += sPitch;
|
||
sResult += L"\"/>";
|
||
}
|
||
sResult += L"</w:font>";
|
||
}
|
||
else
|
||
{
|
||
RtfFont oCurFont;
|
||
if( true == poRtfDocument->m_oFontTable.GetFont(m_nID, oCurFont) )
|
||
{
|
||
std::wstring sHint;
|
||
switch(oCurFont.m_nCharset)
|
||
{
|
||
//case 128://Japanese //vedomost.rtf ????
|
||
case 129://Korean
|
||
case 130://Korean
|
||
case 134://China
|
||
case 136://China
|
||
case 163://Vietnamese
|
||
case 222://Thai
|
||
{
|
||
sHint = L" w:hint=\"eastAsia\"";
|
||
}break;
|
||
case 177://Hebrew
|
||
case 178://Arabic
|
||
case 179://Arabic
|
||
case 180://Arabic
|
||
case 181://Hebrew
|
||
{
|
||
sHint = L" w:hint=\"cs\"";
|
||
}break;
|
||
//?? нужно ли описывать default??? todooo
|
||
default:
|
||
break;
|
||
}
|
||
sResult += L"<w:rFonts w:ascii=\"";
|
||
sResult += XmlUtils::EncodeXmlString( sFontName, true );
|
||
sResult += L"\" w:eastAsia=\"";
|
||
sResult += XmlUtils::EncodeXmlString( sFontName, true );
|
||
sResult += L"\" w:hAnsi=\"";
|
||
sResult += XmlUtils::EncodeXmlString( sFontName, true );
|
||
sResult += L"\" w:cs=\"";
|
||
sResult += XmlUtils::EncodeXmlString( sFontName, true );
|
||
sResult += L"\"";
|
||
sResult += sHint;
|
||
sResult += L"/>";
|
||
}
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
|
||
RtfColor::RtfColor()
|
||
{
|
||
SetDefault();
|
||
}
|
||
RtfColor::RtfColor(_UINT32 nHex)
|
||
{
|
||
SetHEX( nHex );
|
||
}
|
||
RtfColor::RtfColor(BYTE r, BYTE g, BYTE b)
|
||
{
|
||
SetRGB( r, g, b );
|
||
}
|
||
void RtfColor::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfColor::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfColor::SetAuto()
|
||
{
|
||
m_bAuto = true;
|
||
}
|
||
void RtfColor::SetDefault()
|
||
{
|
||
m_bAuto = false;
|
||
|
||
m_byteRed = 0;
|
||
m_byteGreen = 0;
|
||
m_byteBlue = 0;
|
||
|
||
m_byteShade = 0;
|
||
m_byteTint = 255;
|
||
m_eTheme = RtfColor::TC_NONE;
|
||
m_index = -1;
|
||
}
|
||
BYTE RtfColor::GetR()
|
||
{
|
||
return m_byteRed;
|
||
}
|
||
BYTE RtfColor::GetG()
|
||
{
|
||
return m_byteGreen;
|
||
}
|
||
BYTE RtfColor::GetB()
|
||
{
|
||
return m_byteBlue;
|
||
}
|
||
bool RtfColor::operator==(const RtfColor& oColor)
|
||
{
|
||
return m_byteRed == oColor.m_byteRed && m_byteGreen == oColor.m_byteGreen && m_byteBlue == oColor.m_byteBlue &&
|
||
m_eTheme == oColor.m_eTheme && m_byteTint == oColor.m_byteTint && m_byteShade == oColor.m_byteShade;
|
||
}
|
||
const RtfColor& RtfColor::operator=( const RtfColor& oColor )
|
||
{
|
||
m_byteRed = oColor.m_byteRed;
|
||
m_byteGreen = oColor.m_byteGreen;
|
||
m_byteBlue = oColor.m_byteBlue;
|
||
|
||
m_eTheme = oColor.m_eTheme;
|
||
m_byteShade = oColor.m_byteShade;
|
||
m_byteTint = oColor.m_byteTint;
|
||
|
||
m_bAuto = oColor.m_bAuto;
|
||
return (*this);
|
||
}
|
||
void RtfColor::SetHEX(_UINT32 color)
|
||
{
|
||
SetDefault();
|
||
|
||
m_byteRed = (color&0xFF0000) >> 16;
|
||
m_byteGreen = (color&0xFF00) >> 8;
|
||
m_byteBlue = (color&0xFF);
|
||
}
|
||
_UINT32 RtfColor::GetRGB()const
|
||
{
|
||
return (m_byteRed << 16) | (m_byteGreen << 8) | m_byteBlue;
|
||
}
|
||
void RtfColor::SetRGB(_UINT32 color)
|
||
{
|
||
SetDefault();
|
||
|
||
m_byteRed = (color & 0xFF);
|
||
m_byteGreen = (color & 0xFF00) >> 8;
|
||
m_byteBlue = (color & 0xFF0000) >> 16;
|
||
}
|
||
void RtfColor::SetRGB(BYTE red, BYTE green, BYTE blue)
|
||
{
|
||
SetDefault();
|
||
|
||
m_byteRed = red;
|
||
m_byteGreen = green;
|
||
m_byteBlue = blue;
|
||
}
|
||
void RtfColor::GetHSL(double &dH, double &dS,double &dL)
|
||
{
|
||
RGB2HSL(m_byteRed, m_byteGreen, m_byteBlue, dH, dS, dL);
|
||
}
|
||
void RtfColor::SetHSL(double dH, double dS,double dL)
|
||
{
|
||
HSL2RGB(dH, dS, dL, m_byteRed, m_byteGreen, m_byteBlue);
|
||
}
|
||
void RtfColor::SetRGBPercent(_INT32 nRedPer, _INT32 nGreenPer, _INT32 nBluePer)
|
||
{
|
||
m_byteRed = (BYTE)(nRedPer * 255 / 100);
|
||
m_byteGreen = (BYTE)(nGreenPer * 255 / 100);
|
||
m_byteBlue = (BYTE)(nBluePer * 255 / 100);
|
||
}
|
||
void RtfColor::SetHEXString(std::wstring hex)
|
||
{
|
||
if ( L"auto" != hex )
|
||
{
|
||
_UINT32 color = Strings::ToColor(hex);
|
||
|
||
SetRGB(color);
|
||
}
|
||
else
|
||
SetDefault();
|
||
}
|
||
std::wstring RtfColor::ToHexColor(bool bBGR)
|
||
{
|
||
if (m_bAuto) return L"auto";
|
||
|
||
std::wstring sRed = XmlUtils::ToString(m_byteRed, L"%02X");
|
||
std::wstring sGreen = XmlUtils::ToString(m_byteGreen, L"%02X");;
|
||
std::wstring sBlue = XmlUtils::ToString(m_byteBlue, L"%02X");
|
||
|
||
if (bBGR) return sBlue + sGreen + sRed ;
|
||
else return sRed + sGreen + sBlue ;
|
||
}
|
||
std::wstring RtfColor::RenderToRtf(RenderParameter oRenderParameter )
|
||
{
|
||
RtfWriter* poRtfWriter = static_cast<RtfWriter*>( oRenderParameter.poWriter );
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*>( oRenderParameter.poDocument );
|
||
std::wstring sResult;
|
||
if( RENDER_TO_RTF_PARAM_COLOR_TBL == oRenderParameter.nType )
|
||
{
|
||
sResult += L"\\red" + std::to_wstring(m_byteRed) + L"\\green" + std::to_wstring(m_byteGreen) + L"\\blue" + std::to_wstring(m_byteBlue);
|
||
sResult += L";";
|
||
}
|
||
else
|
||
{
|
||
_INT32 nColor;
|
||
if( true == poRtfDocument->m_oColorTable.GetColor(*this, nColor) )
|
||
sResult += L"\\c" + std::to_wstring(nColor); //todo
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfColor::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
oRenderParameter.sValue = ToHexColor();
|
||
|
||
if( RENDER_TO_OOX_PARAM_COLOR_VALUE == oRenderParameter.nType )
|
||
{
|
||
sResult += oRenderParameter.sValue;
|
||
}
|
||
else if( RENDER_TO_OOX_PARAM_COLOR_ATTRIBUTE == oRenderParameter.nType )
|
||
{
|
||
sResult += L"w:color=\"" + oRenderParameter.sValue + L"\"";
|
||
}
|
||
else if( RENDER_TO_OOX_PARAM_COLOR_TAG == oRenderParameter.nType )
|
||
{
|
||
sResult += L"<w:color " + WriteOOXAttribute(oRenderParameter.sValue) + L"/>";
|
||
}
|
||
else if (m_bAuto)
|
||
{
|
||
sResult += L"<w:color w:val=\"auto\"/>";
|
||
}
|
||
else
|
||
{
|
||
sResult += L"<w:color w:val=\"" + oRenderParameter.sValue + L"\"/>";
|
||
}
|
||
return sResult;
|
||
}
|
||
BYTE RtfColor::SetShade(BYTE bShade)
|
||
{
|
||
m_byteShade = bShade;
|
||
double dH, dS, dL;
|
||
GetHSL(dH, dS, dL);
|
||
dL = dL * bShade / 255.;
|
||
SetHSL(dH, dS, dL);
|
||
return bShade;
|
||
}
|
||
BYTE RtfColor::SetTint(BYTE bTint)
|
||
{
|
||
m_byteTint = bTint;
|
||
|
||
double dH, dS, dL;
|
||
GetHSL(dH, dS,dL);
|
||
dL = dL * bTint / 255. + (1 - bTint / 255.);
|
||
SetHSL(dH, dS, dL);
|
||
return bTint;
|
||
}
|
||
bool RtfColor::GetHighlightByColor( RtfColor oOutputColor,std::wstring& oStr ) //todo
|
||
{
|
||
if ( oOutputColor == RtfColor(0x000000) ) {oStr = L"black"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x0000FF) ) {oStr = L"blue"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x00FFFF) ) {oStr = L"cyan"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x00008B) ) {oStr = L"darkBlue"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x008B8B) ) {oStr = L"darkCyan"; return true;}
|
||
else if ( oOutputColor == RtfColor(0xA9A9A9) ) {oStr = L"darkGray"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x006400) ) {oStr = L"darkGreen"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x800080) ) {oStr = L"darkMagenta"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x8B0000) ) {oStr = L"darkRed"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x808000) ) {oStr = L"darkYellow"; return true;}
|
||
else if ( oOutputColor == RtfColor(0x00FF00) ) {oStr = L"green"; return true;}
|
||
else if ( oOutputColor == RtfColor(0xD3D3D3) ) {oStr = L"lightGray"; return true;}
|
||
else if ( oOutputColor == RtfColor(0xFF00FF) ) {oStr = L"magenta"; return true;}
|
||
else if ( oOutputColor == RtfColor(0xFF0000) ) {oStr = L"red"; return true;}
|
||
else if ( oOutputColor == RtfColor(0xFFFFFF) ) {oStr = L"white"; return true;}
|
||
else if ( oOutputColor == RtfColor(0xFFFF00) ) {oStr = L"yellow"; return true;}
|
||
return false;
|
||
}
|
||
RtfColor RtfColor::GetColorByPreset( std::wstring oStr )
|
||
{
|
||
if ( oStr == L"aliceBlue" ) return RtfColor(240,248,255);
|
||
else if ( oStr == L"aniqueWhite" ) return RtfColor(250,235,215);
|
||
else if ( oStr == L"aqua" ) return RtfColor(0,255,255);
|
||
else if ( oStr == L"aquamarine" ) return RtfColor(127,255,212);
|
||
else if ( oStr == L"azure" ) return RtfColor(240,255,255);
|
||
else if ( oStr == L"beige" ) return RtfColor(245,245,220);
|
||
else if ( oStr == L"bisque" ) return RtfColor(255,228,196);
|
||
else if ( oStr == L"black" ) return RtfColor(0,0,0);
|
||
else if ( oStr == L"blanchedAlmond" ) return RtfColor(255,235,205);
|
||
else if ( oStr == L"blueViolet" ) return RtfColor(138,43,226);
|
||
else if ( oStr == L"brown" ) return RtfColor(165,42,42);
|
||
else if ( oStr == L"burlyWood" ) return RtfColor(222,184,135);
|
||
|
||
else if ( oStr == L"cyan" ) return RtfColor(0,255,255);
|
||
else if ( oStr == L"gold" ) return RtfColor(255,215,0);
|
||
else if ( oStr == L"green" ) return RtfColor(0,128,0);
|
||
else if ( oStr == L"grey" ) return RtfColor(128,128,128);
|
||
else if ( oStr == L"red" ) return RtfColor(255,0,0);
|
||
else if ( oStr == L"yellow" ) return RtfColor(255,255,0);
|
||
|
||
return RtfColor(0,0,0);
|
||
}
|
||
std::wstring RtfColor::GetPresetByColor( RtfColor oCol ) //стр. 3320
|
||
{
|
||
if ( oCol == RtfColor(240,248,255)) return L"aliceBlue";
|
||
else if ( oCol == RtfColor(250,235,215)) return L"aniqueWhite";
|
||
else if ( oCol == RtfColor(0,255,255)) return L"aqua";
|
||
else if ( oCol == RtfColor(127,255,212)) return L"aquamarine";
|
||
else if ( oCol == RtfColor(240,255,255)) return L"azure";
|
||
else if ( oCol == RtfColor(245,245,220)) return L"beige";
|
||
else if ( oCol == RtfColor(255,228,196)) return L"bisque";
|
||
else if ( oCol == RtfColor(0,0,0)) return L"black";
|
||
else if ( oCol == RtfColor(255,235,205)) return L"blanchedAlmond";
|
||
else if ( oCol == RtfColor(138,43,226)) return L"blueViolet";
|
||
else if ( oCol == RtfColor(165,42,42)) return L"brown";
|
||
else if ( oCol == RtfColor(222,184,135)) return L"burlyWood";
|
||
|
||
else if ( oCol == RtfColor(0,255,255)) return L"cyan";
|
||
else if ( oCol == RtfColor(255,215,0)) return L"gold";
|
||
else if ( oCol == RtfColor(0,128,0)) return L"green";
|
||
else if ( oCol == RtfColor(128,128,128)) return L"grey";
|
||
else if ( oCol == RtfColor(255,0,0)) return L"red";
|
||
else if ( oCol == RtfColor(255,255,0)) return L"yellow";
|
||
|
||
return L"black";
|
||
}
|
||
bool RtfColor::GetThemeByString( std::wstring sTheme, _ThemeColor & oOutTheme )
|
||
{
|
||
if ( sTheme == L"accent1" ) {oOutTheme = caccentone; return true;}
|
||
else if ( sTheme == L"accent2" ) {oOutTheme = caccenttwo; return true;}
|
||
else if ( sTheme == L"accent3" ) {oOutTheme = caccentthree; return true;}
|
||
else if ( sTheme == L"accent4" ) {oOutTheme = caccentfour; return true;}
|
||
else if ( sTheme == L"accent5" ) {oOutTheme = caccentfive; return true;}
|
||
else if ( sTheme == L"accent6" ) {oOutTheme = caccentsix; return true;}
|
||
else if ( sTheme == L"bg1" ) {oOutTheme = cbackgroundone; return true;}
|
||
else if ( sTheme == L"bg2" ) {oOutTheme = cbackgroundtwo; return true;}
|
||
else if ( sTheme == L"dk1" ) {oOutTheme = cmaindarkone; return true;}
|
||
else if ( sTheme == L"dk2" ) {oOutTheme = cmaindarktwo; return true;}
|
||
else if ( sTheme == L"folHlink" ) {oOutTheme = cfollowedhyperlink;return true;}
|
||
else if ( sTheme == L"hlink" ) {oOutTheme = chyperlink; return true;}
|
||
else if ( sTheme == L"lt1" ) {oOutTheme = cmainlightone; return true;}
|
||
else if ( sTheme == L"lt2" ) {oOutTheme = cmainlighttwo; return true;}
|
||
else if ( sTheme == L"phClr" ) {oOutTheme = cmainlighttwo; return true;}
|
||
else if ( sTheme == L"tx1" ) {oOutTheme = ctextone; return true;}
|
||
else if ( sTheme == L"tx2" ) {oOutTheme = ctexttwo; return true;}
|
||
return false;
|
||
}
|
||
bool RtfColor::GetThemeByOOX( SimpleTypes::EShemeColorVal val, _ThemeColor & oOutTheme )
|
||
{
|
||
switch(val)
|
||
{
|
||
case SimpleTypes::shemecolorvalAccent1: {oOutTheme = caccentone; return true;}
|
||
case SimpleTypes::shemecolorvalAccent2: {oOutTheme = caccenttwo; return true;}
|
||
case SimpleTypes::shemecolorvalAccent3: {oOutTheme = caccentthree; return true;}
|
||
case SimpleTypes::shemecolorvalAccent4: {oOutTheme = caccentfour; return true;}
|
||
case SimpleTypes::shemecolorvalAccent5: {oOutTheme = caccentfive; return true;}
|
||
case SimpleTypes::shemecolorvalAccent6: {oOutTheme = caccentsix; return true;}
|
||
case SimpleTypes::shemecolorvalBg1: {oOutTheme = cbackgroundone; return true;}
|
||
case SimpleTypes::shemecolorvalBg2: {oOutTheme = cbackgroundtwo; return true;}
|
||
case SimpleTypes::shemecolorvalDk1: {oOutTheme = cmaindarkone; return true;}
|
||
case SimpleTypes::shemecolorvalDk2: {oOutTheme = cmaindarktwo; return true;}
|
||
case SimpleTypes::shemecolorvalFolHlink: {oOutTheme = cfollowedhyperlink; return true;}
|
||
case SimpleTypes::shemecolorvalHlink: {oOutTheme = chyperlink; return true;}
|
||
case SimpleTypes::shemecolorvalLt1: {oOutTheme = cmainlightone; return true;}
|
||
case SimpleTypes::shemecolorvalLt2: {oOutTheme = cmainlighttwo; return true;}
|
||
case SimpleTypes::shemecolorvalPhClr: {oOutTheme = cmainlighttwo; return true;} //???
|
||
case SimpleTypes::shemecolorvalTx1: {oOutTheme = ctextone; return true;}
|
||
case SimpleTypes::shemecolorvalTx2: {oOutTheme = ctexttwo; return true;}
|
||
default : {oOutTheme = caccentone; return true;}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
bool RtfColor::GetStringByTheme( std::wstring sTheme , _ThemeColor& oOutTheme )
|
||
{
|
||
if ( L"accent1" == sTheme ) {oOutTheme = caccentone; return true;}
|
||
else if ( L"accent2" == sTheme ) {oOutTheme = caccenttwo; return true;}
|
||
else if ( L"accent3" == sTheme ) {oOutTheme = caccentthree; return true;}
|
||
else if ( L"accent4" == sTheme ) {oOutTheme = caccentfour; return true;}
|
||
else if ( L"accent5" == sTheme ) {oOutTheme = caccentfive; return true;}
|
||
else if ( L"accent6" == sTheme ) {oOutTheme = caccentsix; return true;}
|
||
else if ( L"bg1" == sTheme ) {oOutTheme = cbackgroundone; return true;}
|
||
else if ( L"bg2" == sTheme ) {oOutTheme = cbackgroundtwo; return true;}
|
||
else if ( L"dk1" == sTheme ) {oOutTheme = cmaindarkone; return true;}
|
||
else if ( L"dk2" == sTheme ) {oOutTheme = cmaindarktwo; return true;}
|
||
else if ( L"folHlink" == sTheme ) {oOutTheme = cfollowedhyperlink;return true;}
|
||
else if ( L"hlink" == sTheme ) {oOutTheme = chyperlink; return true;}
|
||
else if ( L"lt1" == sTheme ) {oOutTheme = cmainlightone; return true;}
|
||
else if ( L"lt2" == sTheme ) {oOutTheme = cmainlighttwo; return true;}
|
||
else if ( L"phClr" == sTheme ) {oOutTheme = cmainlighttwo; return true;}
|
||
else if ( L"tx1" == sTheme ) {oOutTheme = ctextone; return true;}
|
||
else if ( L"tx2" == sTheme ) {oOutTheme = ctexttwo; return true;}
|
||
return false;
|
||
}
|
||
std::wstring RtfColor::GetHighLight()
|
||
{
|
||
if (m_bAuto) return L"auto";
|
||
|
||
std::vector< RtfColor > sColors;
|
||
|
||
sColors.push_back( RtfColor( 0x000000 ) );
|
||
sColors.push_back( RtfColor( 0x0000FF ) );
|
||
sColors.push_back( RtfColor( 0x00FFFF ) );
|
||
sColors.push_back( RtfColor( 0x00008B ) );
|
||
sColors.push_back( RtfColor( 0x008B8B ) );
|
||
sColors.push_back( RtfColor( 0xA9A9A9 ) );
|
||
sColors.push_back( RtfColor( 0x006400 ) );
|
||
sColors.push_back( RtfColor( 0x800080 ) );
|
||
sColors.push_back( RtfColor( 0x8B0000 ) );
|
||
sColors.push_back( RtfColor( 0x808000 ) );
|
||
sColors.push_back( RtfColor( 0x00FF00 ) );
|
||
sColors.push_back( RtfColor( 0xD3D3D3 ) );
|
||
sColors.push_back( RtfColor( 0xFF00FF ) );
|
||
sColors.push_back( RtfColor( 0xFF0000 ) );
|
||
sColors.push_back( RtfColor( 0xFFFFFF ) );
|
||
sColors.push_back( RtfColor( 0xFFFF00 ) );
|
||
|
||
long nMinDelta = 0x7FFFFFFF; //MAXLONG;
|
||
int nIndex = -1;
|
||
for (int i = 0; i < (int)sColors.size(); i++ )
|
||
{
|
||
int nCurDelta = ( sColors[i].GetR() - GetR() ) * ( sColors[i].GetR() - GetR() ) +
|
||
( sColors[i].GetG() - GetG() ) * ( sColors[i].GetG() - GetG() ) +
|
||
( sColors[i].GetB() - GetB() ) * ( sColors[i].GetB() - GetB() );
|
||
if ( nCurDelta < nMinDelta )
|
||
{
|
||
nIndex = i;
|
||
nMinDelta = nCurDelta;
|
||
}
|
||
}
|
||
switch ( nIndex )
|
||
{
|
||
case 0: return L"black";
|
||
case 1: return L"blue";
|
||
case 2: return L"cyan";
|
||
case 3: return L"darkBlue";
|
||
case 4: return L"darkCyan";
|
||
case 5: return L"darkGray";
|
||
case 6: return L"darkGreen";
|
||
case 7: return L"darkMagenta";
|
||
case 8: return L"darkRed";
|
||
case 9: return L"darkYellow";
|
||
case 10: return L"green";
|
||
case 11: return L"lightGray";
|
||
case 12: return L"magenta";
|
||
case 13: return L"red";
|
||
case 14: return L"white";
|
||
case 15: return L"yellow";
|
||
default: break;
|
||
}
|
||
return L"none";
|
||
}
|
||
void RtfColor::RGB2HSL(unsigned char unR, unsigned char unG, unsigned char unB, double& dH, double& dS, double& dL)
|
||
{
|
||
int nmin = (std::min)( unR, (std::min)( unG, unB ) );
|
||
int nmax = (std::max)( unR, (std::max)( unG, unB ) );
|
||
int nDelta = nmax - nmin;
|
||
double dmax = ( nmax + nmin ) / 255.0;
|
||
double dDelta = nDelta / 255.0;
|
||
|
||
dL = dmax / 2.0;
|
||
|
||
if ( 0 == nDelta ) //This is a gray, no chroma...
|
||
{
|
||
dH = 0.0;
|
||
dS = 0.0;
|
||
}
|
||
else //Chromatic data...
|
||
{
|
||
if ( dL < 0.5 ) dS = dDelta / dmax;
|
||
else dS = dDelta / ( 2.0 - dmax );
|
||
|
||
dDelta = dDelta * 1530.0;
|
||
|
||
double dR = ( nmax - unR ) / dDelta;
|
||
double dG = ( nmax - unG ) / dDelta;
|
||
double dB = ( nmax - unB ) / dDelta;
|
||
|
||
if ( unR == nmax ) dH = dB - dG;
|
||
else if ( unG == nmax ) dH = c_d_1_3 + dR - dB;
|
||
else if ( unB == nmax ) dH = c_d_2_3 + dG - dR;
|
||
|
||
if ( dH < 0.0 ) dH += 1.0;
|
||
if ( dH > 1.0 ) dH -= 1.0;
|
||
}
|
||
}
|
||
void RtfColor::HSL2RGB(double dH, double dS, double dL, unsigned char &unR, unsigned char& unG, unsigned char& unB)
|
||
{
|
||
if ( 0 == dS )
|
||
{
|
||
unR = static_cast<unsigned char>(255 * dL);
|
||
unG = static_cast<unsigned char>(255 * dL);
|
||
unB = static_cast<unsigned char>(255 * dL);
|
||
}
|
||
else
|
||
{
|
||
double dV2;
|
||
if ( dL < 0.5 ) dV2 = dL * ( 1.0 + dS );
|
||
else dV2 = dL + dS - dS * dL;
|
||
|
||
double dV1 = 2.0 * dL - dV2;
|
||
|
||
unR = static_cast<unsigned char>(255 * Hue2RGB( dV1, dV2, dH + c_d_1_3 ) );
|
||
unG = static_cast<unsigned char>(255 * Hue2RGB( dV1, dV2, dH ) );
|
||
unB = static_cast<unsigned char>(255 * Hue2RGB( dV1, dV2, dH - c_d_1_3 ) );
|
||
}
|
||
}
|
||
double RtfColor::Hue2RGB(double dV1, double dV2, double dH)
|
||
{
|
||
if ( dH < 0.0 ) dH += 1.0;
|
||
if ( dH > 1.0 ) dH -= 1.0;
|
||
if ( dH < c_d_1_6 ) return dV1 + ( dV2 - dV1 ) * 6.0 * dH;
|
||
if ( dH < 0.5 ) return dV2;
|
||
if ( dH < c_d_2_3 ) return dV1 + ( dV2 - dV1 ) * ( c_d_2_3 - dH ) * 6.0;
|
||
return dV1;
|
||
}
|
||
std::wstring RtfColor::WriteOOXAttribute( std::wstring sParam )
|
||
{
|
||
std::wstring sResult;
|
||
if ( m_eTheme == TC_NONE )
|
||
{
|
||
if ( L"" == sParam )
|
||
{
|
||
sResult = L"color = \"";
|
||
sResult += ToHexColor();
|
||
sResult += L"\"";
|
||
}
|
||
else if ( L"Fill" == sParam )
|
||
{
|
||
sResult = L"fill = \"";
|
||
sResult += ToHexColor();
|
||
sResult += L"\"";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::wstring sTheme;
|
||
if ( true == GetStringByTheme( sTheme, m_eTheme ) )
|
||
{
|
||
sResult += L"theme" + sParam + L"Color=\"" + sTheme + L"\"";
|
||
sResult += L" theme" + sParam + L"Shade=\"" + std::to_wstring(m_byteShade) + L"\"";
|
||
sResult += L" theme" + sParam + L"Tint=\"" + std::to_wstring(m_byteTint) + L"\"";
|
||
}
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
int RtfShadingChar::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_SHADING_CHAR;
|
||
}
|
||
std::wstring RtfShadingChar::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT( m_nValue, sResult, L"chshdng" )
|
||
switch( m_eType )
|
||
{
|
||
case st_chbghoriz: sResult += L"\\chbghoriz"; break;
|
||
case st_chbgvert: sResult += L"\\chbgvert"; break;
|
||
case st_chbgfdiag: sResult += L"\\chbgfdiag"; break;
|
||
case st_chbgbdiag: sResult += L"\\chbgbdiag"; break;
|
||
case st_chbgcross: sResult += L"\\chbgcross"; break;
|
||
case st_chbgdcross: sResult += L"\\chbgdcross"; break;
|
||
case st_chbgdkhoriz: sResult += L"\\chbgdkhoriz"; break;
|
||
case st_chbgdkvert: sResult += L"\\chbgdkvert"; break;
|
||
case st_chbgdkfdiag: sResult += L"\\chbgdkfdiag"; break;
|
||
case st_chbgdkbdiag: sResult += L"\\chbgdkbdiag"; break;
|
||
case st_chbgdkcross: sResult += L"\\chbgdkcross"; break;
|
||
case st_chbgdkdcross: sResult += L"\\chbgdkdcross"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nForeColor, sResult, L"chcfpat" )
|
||
RENDER_RTF_INT( m_nBackColor, sResult, L"chcbpat" )
|
||
return sResult;
|
||
}
|
||
|
||
int RtfShadingParGetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_SHADING_PARAGRAPH;
|
||
}
|
||
std::wstring RtfShadingPar::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT( m_nValue, sResult, L"shading" )
|
||
switch( m_eType )
|
||
{
|
||
case st_chbghoriz: sResult += L"\\bghoriz"; break;
|
||
case st_chbgvert: sResult += L"\\bgvert"; break;
|
||
case st_chbgfdiag: sResult += L"\\bgfdiag"; break;
|
||
case st_chbgbdiag: sResult += L"\\bgbdiag"; break;
|
||
case st_chbgcross: sResult += L"\\bgcross"; break;
|
||
case st_chbgdcross: sResult += L"\\bgdcross"; break;
|
||
case st_chbgdkhoriz: sResult += L"\\bgdkhoriz"; break;
|
||
case st_chbgdkvert: sResult += L"\\bgdkvert"; break;
|
||
case st_chbgdkfdiag: sResult += L"\\bgdkfdiag"; break;
|
||
case st_chbgdkbdiag: sResult += L"\\bgdkbdiag"; break;
|
||
case st_chbgdkcross: sResult += L"\\bgdkcross"; break;
|
||
case st_chbgdkdcross: sResult += L"\\bgdkdcross"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nForeColor, sResult, L"cfpat" )
|
||
RENDER_RTF_INT( m_nBackColor, sResult, L"cbpat" )
|
||
return sResult;
|
||
}
|
||
|
||
int RtfShadingCell::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_SHADING_CELL;
|
||
}
|
||
std::wstring RtfShadingCell::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT( m_nValue, sResult, L"clshdng" )
|
||
switch( m_eType )
|
||
{
|
||
case st_clshdrawnil: sResult += L"\\clshdrawnil"; break;
|
||
case st_chbghoriz: sResult += L"\\clbghoriz"; break;
|
||
case st_chbgvert: sResult += L"\\clbgvert"; break;
|
||
case st_chbgfdiag: sResult += L"\\clbgfdiag"; break;
|
||
case st_chbgbdiag: sResult += L"\\clbgbdiag"; break;
|
||
case st_chbgcross: sResult += L"\\clbgcross"; break;
|
||
case st_chbgdcross: sResult += L"\\clbgdcross"; break;
|
||
case st_chbgdkhoriz: sResult += L"\\clbgdkhor"; break;
|
||
case st_chbgdkvert: sResult += L"\\clbgdkvert"; break;
|
||
case st_chbgdkfdiag: sResult += L"\\clbgdkfdiag"; break;
|
||
case st_chbgdkbdiag: sResult += L"\\clbgdkbdiag"; break;
|
||
case st_chbgdkcross: sResult += L"\\clbgdkcross"; break;
|
||
case st_chbgdkdcross: sResult += L"\\clbgdkdcross"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nForeColor, sResult, L"clcfpat" )
|
||
if( PROP_DEF != m_nBackColor )
|
||
{
|
||
sResult += L"\\clcbpat" + std::to_wstring(m_nBackColor);
|
||
sResult += L"\\clcfpatraw" + std::to_wstring(m_nBackColor);
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
int RtfShadingRow::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_SHADING_CELL;
|
||
}
|
||
std::wstring RtfShadingRow::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT( m_nValue, sResult, L"trshdng" )
|
||
switch( m_eType )
|
||
{
|
||
case st_chbghoriz: sResult += L"\\trbghoriz"; break;
|
||
case st_chbgvert: sResult += L"\\trbgvert"; break;
|
||
case st_chbgfdiag: sResult += L"\\trbgfdiag"; break;
|
||
case st_chbgbdiag: sResult += L"\\trbgbdiag"; break;
|
||
case st_chbgcross: sResult += L"\\trbgcross"; break;
|
||
case st_chbgdcross: sResult += L"\\trbgdcross"; break;
|
||
case st_chbgdkhoriz: sResult += L"\\trbgdkhor"; break;
|
||
case st_chbgdkvert: sResult += L"\\trbgdkvert"; break;
|
||
case st_chbgdkfdiag: sResult += L"\\trbgdkfdiag"; break;
|
||
case st_chbgdkbdiag: sResult += L"\\trbgdkbdiag"; break;
|
||
case st_chbgdkcross: sResult += L"\\trbgdkcross"; break;
|
||
case st_chbgdkdcross: sResult += L"\\trbgdkdcross"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nForeColor, sResult, L"trcfpat" )
|
||
RENDER_RTF_INT( m_nBackColor, sResult, L"trcbpat" )
|
||
return sResult;
|
||
}
|
||
|
||
int RtfShadingTableStyle::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_SHADING_TABLESTYLE;
|
||
}
|
||
std::wstring RtfShadingTableStyle::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT( m_nValue, sResult, L"tscellpct" )
|
||
switch( m_eType )
|
||
{
|
||
case st_chbghoriz: sResult += L"\\tsbghoriz"; break;
|
||
case st_chbgvert: sResult += L"\\tsbgvert"; break;
|
||
case st_chbgfdiag: sResult += L"\\tsbgfdiag"; break;
|
||
case st_chbgbdiag: sResult += L"\\tsbgbdiag"; break;
|
||
case st_chbgcross: sResult += L"\\tsbgcross"; break;
|
||
case st_chbgdcross: sResult += L"\\tsbgdcross"; break;
|
||
case st_chbgdkhoriz: sResult += L"\\tsbgdkhor"; break;
|
||
case st_chbgdkvert: sResult += L"\\tsbgdkvert"; break;
|
||
case st_chbgdkfdiag: sResult += L"\\tsbgdkfdiag"; break;
|
||
case st_chbgdkbdiag: sResult += L"\\tsbgdkbdiag"; break;
|
||
case st_chbgdkcross: sResult += L"\\tsbgdkcross"; break;
|
||
case st_chbgdkdcross: sResult += L"\\tsbgdkdcross"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nForeColor, sResult, L"tscellcfpat" )
|
||
RENDER_RTF_INT( m_nBackColor, sResult, L"tscellcbpat" )
|
||
return sResult;
|
||
}
|
||
|
||
RtfShading::RtfShading()
|
||
{
|
||
SetDefault();
|
||
}
|
||
bool RtfShading::operator==( const RtfShading& oChar )
|
||
{
|
||
return m_eType == oChar.m_eType && m_nValue == oChar.m_nValue && m_nForeColor == oChar.m_nForeColor && m_nBackColor == oChar.m_nBackColor;
|
||
}
|
||
bool RtfShading::IsValid()
|
||
{
|
||
return true;
|
||
}
|
||
int RtfShading::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_SHADING;
|
||
}
|
||
void RtfShading::SetDefaultRtf( )
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfShading::SetDefaultOOX( )
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfShading::SetDefault( )
|
||
{
|
||
DEFAULT_PROPERTY_DEF( m_eType, st_none )
|
||
DEFAULT_PROPERTY( m_nValue )
|
||
DEFAULT_PROPERTY( m_nForeColor )
|
||
DEFAULT_PROPERTY( m_nBackColor )
|
||
}
|
||
void RtfShading::Merge( RtfShading& oParPr )
|
||
{
|
||
//свойство должно быть как единое целое, поэтому если oBorPr задано, то переписыватся целиком
|
||
if ( st_none != oParPr.m_eType || PROP_DEF != oParPr.m_nValue || PROP_DEF != oParPr.m_nForeColor || PROP_DEF != oParPr.m_nBackColor )
|
||
{
|
||
m_eType = oParPr.m_eType;
|
||
m_nValue = oParPr.m_nValue;
|
||
m_nForeColor = oParPr.m_nForeColor;
|
||
m_nBackColor = oParPr.m_nBackColor;
|
||
}
|
||
}
|
||
std::wstring RtfShading::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
RtfWriter* poRtfWriter = static_cast<RtfWriter*>(oRenderParameter.poWriter);
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
|
||
std::wstring sResult;
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_COLOR_VALUE;
|
||
|
||
if(PROP_DEF != m_nBackColor && PROP_DEF == m_nValue && st_none == m_eType)
|
||
m_nValue = 0;
|
||
|
||
std::wstring sShading;
|
||
if (PROP_DEF != m_nValue)
|
||
{
|
||
std::wstring sValue;
|
||
if (0 <= m_nValue && m_nValue <= 2) sShading += L" w:val=\"clear\"";
|
||
else if (2 < m_nValue && m_nValue <= 7) sShading += L" w:val=\"pct5\"";
|
||
else if (7 < m_nValue && m_nValue <= 11) sShading += L" w:val=\"pct10\"";
|
||
else if (11 < m_nValue && m_nValue <= 13) sShading += L" w:val=\"pct12\"";
|
||
else if (13 < m_nValue && m_nValue <= 17) sShading += L" w:val=\"pct15\"";
|
||
else if (17 < m_nValue && m_nValue <= 22) sShading += L" w:val=\"pct20\"";
|
||
else if (22 < m_nValue && m_nValue <= 27) sShading += L" w:val=\"pct25\"";
|
||
else if (27 < m_nValue && m_nValue <= 32) sShading += L" w:val=\"pct30\"";
|
||
else if (32 < m_nValue && m_nValue <= 36) sShading += L" w:val=\"pct35\"";
|
||
else if (36 < m_nValue && m_nValue <= 38) sShading += L" w:val=\"pct37\"";
|
||
else if (38 < m_nValue && m_nValue <= 42) sShading += L" w:val=\"pct40\"";
|
||
else if (42 < m_nValue && m_nValue <= 47) sShading += L" w:val=\"pct45\"";
|
||
else if (47 < m_nValue && m_nValue <= 52) sShading += L" w:val=\"pct50\"";
|
||
else if (52 < m_nValue && m_nValue <= 57) sShading += L" w:val=\"pct55\"";
|
||
else if (57 < m_nValue && m_nValue <= 61) sShading += L" w:val=\"pct60\"";
|
||
else if (61 < m_nValue && m_nValue <= 63) sShading += L" w:val=\"pct62\"";
|
||
else if (63 < m_nValue && m_nValue <= 70) sShading += L" w:val=\"pct65\"";
|
||
else if (70 < m_nValue && m_nValue <= 80) sShading += L" w:val=\"pct75\"";
|
||
else if (80 < m_nValue && m_nValue <= 86) sShading += L" w:val=\"pct85\"";
|
||
else if (86 < m_nValue && m_nValue <= 88) sShading += L" w:val=\"pct87\"";
|
||
else if (88 < m_nValue && m_nValue <= 92) sShading += L" w:val=\"pct90\"";
|
||
else if (92 < m_nValue && m_nValue <= 97) sShading += L" w:val=\"pct95\"";
|
||
else if (97 < m_nValue && m_nValue <= 100) sShading += L" w:val=\"solid\"";
|
||
}
|
||
else
|
||
{
|
||
switch (m_eType)
|
||
{
|
||
case st_clshdrawnil: sShading += L" w:val=\"nil\""; break;
|
||
case st_chbghoriz: sShading += L" w:val=\"thinHorzStripehorzStripe\""; break;
|
||
case st_chbgvert: sShading += L" w:val=\"thinVertStripe\""; break;
|
||
case st_chbgfdiag: sShading += L" w:val=\"thinReverseDiagStripe\""; break;
|
||
case st_chbgbdiag: sShading += L" w:val=\"thinDiagStripe\""; break;
|
||
case st_chbgcross: sShading += L" w:val=\"thinHorzCross\""; break;
|
||
case st_chbgdcross: sShading += L" w:val=\"thinDiagCross\""; break;
|
||
case st_chbgdkhoriz: sShading += L" w:val=\"horzStripe\""; break;
|
||
case st_chbgdkvert: sShading += L" w:val=\"vertStripe\""; break;
|
||
case st_chbgdkfdiag: sShading += L" w:val=\"reverseDiagStripe\""; break;
|
||
case st_chbgdkbdiag: sShading += L" w:val=\"diagStripe\""; break;
|
||
case st_chbgdkcross: sShading += L" w:val=\"horzCross\""; break;
|
||
case st_chbgdkdcross: sShading += L" w:val=\"diagCross\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
if( PROP_DEF != m_nForeColor )
|
||
{
|
||
RtfColor oForeColor;
|
||
if( true == poRtfDocument->m_oColorTable.GetColor( m_nForeColor, oForeColor ) )
|
||
sShading += L" w:color=\"" + oForeColor.RenderToOOX(oNewParam) + L"\"";
|
||
}
|
||
if( PROP_DEF != m_nBackColor )
|
||
{
|
||
RtfColor oBackColor;
|
||
if( true == poRtfDocument->m_oColorTable.GetColor( m_nBackColor, oBackColor ) )
|
||
sShading += L" w:fill=\"" + oBackColor.RenderToOOX(oNewParam) + L"\"";
|
||
}
|
||
if( false == sShading.empty() )
|
||
sResult = L"<w:shd " + sShading + L"/>";
|
||
return sResult;
|
||
}
|
||
|
||
RtfBorder::RtfBorder()
|
||
{
|
||
SetDefault();
|
||
}
|
||
bool RtfBorder::operator==( const RtfBorder& oChar )
|
||
{
|
||
return m_eType == oChar.m_eType && m_nWidth == oChar.m_nWidth && m_nSpace == oChar.m_nSpace && m_nColor == oChar.m_nColor;
|
||
}
|
||
bool RtfBorder::IsValid()
|
||
{
|
||
return PROP_DEF != m_eType;
|
||
}
|
||
int RtfBorder::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_BORDER;
|
||
}
|
||
void RtfBorder::SetDefaultRtf( )
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfBorder::SetDefaultOOX( )
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfBorder::SetDefault( )
|
||
{
|
||
DEFAULT_PROPERTY (m_eType)
|
||
//DEFAULT_PROPERTY_DEF( m_eType, bt_none )
|
||
DEFAULT_PROPERTY ( m_nWidth )
|
||
DEFAULT_PROPERTY ( m_nSpace )
|
||
DEFAULT_PROPERTY ( m_nColor )
|
||
}
|
||
void RtfBorder::SetEmpty( )
|
||
{
|
||
m_eType = bt_brdrnone;
|
||
m_nWidth = 0;
|
||
m_nSpace = 0;
|
||
m_nColor = -1; //auto
|
||
}
|
||
void RtfBorder::Merge( RtfBorder& oBorPr )
|
||
{
|
||
//свойство должно быть как единое целое, поэтому если oBorPr задано, то переписыватся целиком
|
||
if (PROP_DEF != oBorPr.m_eType || PROP_DEF != oBorPr.m_nWidth || PROP_DEF != oBorPr.m_nSpace || PROP_DEF != oBorPr.m_nColor )
|
||
{
|
||
m_eType = oBorPr.m_eType;
|
||
m_nWidth = oBorPr.m_nWidth;
|
||
m_nSpace = oBorPr.m_nSpace;
|
||
m_nColor = oBorPr.m_nColor;
|
||
}
|
||
}
|
||
bool RtfBorder::GetStringRtfByType( _BorderType nValue, std::wstring& sValue )
|
||
{
|
||
sValue = L"\\brdrs";
|
||
//switch( nValue )
|
||
//{
|
||
//default: sResult = L"\\brdrs"; break;
|
||
////}
|
||
return false;
|
||
}
|
||
std::wstring RtfBorder::GetStringOOXByType( _BorderType nValue, std::wstring& sValue )
|
||
{
|
||
std::wstring sResult;
|
||
sResult = L"single";
|
||
//switch( nValue )
|
||
//{
|
||
//default: sResult = L"single"; break;
|
||
//}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfBorder::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
switch( m_eType )
|
||
{
|
||
case bt_brdrs: sResult = L"\\brdrs"; break;
|
||
case bt_brdrth: sResult = L"\\brdrth"; break;
|
||
case bt_brdrsh: sResult = L"\\brdrsh"; break;
|
||
case bt_brdrdb: sResult = L"\\brdrdb"; break;
|
||
case bt_brdrdot: sResult = L"\\brdrdot"; break;
|
||
case bt_brdrdash: sResult = L"\\brdrdash"; break;
|
||
case bt_brdrhair: sResult = L"\\brdrhair"; break;
|
||
case bt_brdrinset: sResult = L"\\brdrinset"; break;
|
||
case bt_brdrdashsm: sResult = L"\\brdrdashsm"; break;
|
||
case bt_brdrdashd: sResult = L"\\brdrdashd"; break;
|
||
case bt_brdrdashdd: sResult = L"\\brdrdashdd"; break;
|
||
case bt_brdrdashdot: sResult = L"\\brdrdashdot"; break;
|
||
case bt_brdrtriple: sResult = L"\\brdrtriple"; break;
|
||
case bt_brdrtnthsg: sResult = L"\\brdrtnthsg"; break;
|
||
case bt_brdrthtnsg: sResult = L"\\brdrthtnsg"; break;
|
||
case bt_brdrtnthtnsg: sResult = L"\\brdrtnthtnsg"; break;
|
||
case bt_brdrtnthtnmg: sResult = L"\\brdrtnthtnmg"; break;
|
||
case bt_brdrtnthlg: sResult = L"\\brdrtnthlg"; break;
|
||
case bt_brdrthtnlg: sResult = L"\\brdrthtnlg"; break;
|
||
case bt_brdrtnthtnlg: sResult = L"\\brdrtnthtnlg"; break;
|
||
case bt_brdrwavy: sResult = L"\\brdrwavy"; break;
|
||
case bt_brdrwavydb: sResult = L"\\brdrwavydb"; break;
|
||
case bt_brdrdashdotstr: sResult = L"\\brdrdashdotstr"; break;
|
||
case bt_brdremboss: sResult = L"\\brdremboss"; break;
|
||
case bt_brdrengrave: sResult = L"\\brdrengrave"; break;
|
||
case bt_brdroutset: sResult = L"\\brdroutset"; break;
|
||
case bt_brdrnone: sResult = L"\\brdrnone"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( PROP_DEF != m_nWidth && m_nWidth > 0)
|
||
sResult += L"\\brdrw" + std::to_wstring(m_nWidth );
|
||
if( PROP_DEF != m_nSpace && m_nSpace > 0)
|
||
sResult += L"\\brsp" + std::to_wstring(m_nSpace );
|
||
if( PROP_DEF != m_nColor )
|
||
sResult += L"\\brdrcf" + std::to_wstring(m_nColor );
|
||
return sResult;
|
||
}
|
||
std::wstring RtfBorder::GetBorderType()
|
||
{
|
||
std::wstring val;
|
||
switch (m_eType)
|
||
{
|
||
case bt_brdrs: val = L"single"; break;
|
||
case bt_brdrth: val = L"thick"; break;
|
||
case bt_brdrsh: val = L"thin"; break;
|
||
case bt_brdrdb: val = L"double"; break;
|
||
case bt_brdrdot: val = L"dotted"; break;
|
||
case bt_brdrdash: val = L"dashed"; break;
|
||
case bt_brdrhair: val = L"hair"; break;
|
||
case bt_brdrdashsm: val = L"dashSmallGap"; break;
|
||
case bt_brdrdashd: val = L"dotDash"; break;
|
||
case bt_brdrdashdd: val = L"dotDotDash"; break;
|
||
case bt_brdrinset: val = L"inset"; break;
|
||
case bt_brdrnone: val = L"nil"; break;
|
||
case bt_brdroutset: val = L"outset"; break;
|
||
case bt_brdrtriple: val = L"triple"; break;
|
||
case bt_brdrtnthsg: val = L"thinThickSmallGap"; break;
|
||
case bt_brdrthtnsg: val = L"thickThinSmallGap"; break;
|
||
case bt_brdrtnthtnsg: val = L"thinThickThinSmallGap"; break;
|
||
case bt_brdrtnthtnmg: val = L"thinThickThinMediumGap"; break;
|
||
case bt_brdrtnthmg: val = L"thinThickMediumGap"; break;
|
||
case bt_brdrthtnmg: val = L"thickThinMediumGap"; break;
|
||
case bt_brdrtnthlg: val = L"thinThickLargeGap"; break;
|
||
case bt_brdrthtnlg: val = L"thickThinLargeGap"; break;
|
||
case bt_brdrtnthtnlg: val = L"thinThickThinLargeGap"; break;
|
||
case bt_brdrwavy: val = L"wave"; break;
|
||
case bt_brdrwavydb: val = L"doubleWave"; break;
|
||
case bt_brdrdashdotstr: val = L"dashDotStroked"; break;
|
||
case bt_brdremboss: val = L"threeDEmboss"; break;
|
||
case bt_brdrengrave: val = L"threeDEngrave"; break;
|
||
default:
|
||
break;
|
||
}
|
||
return val;
|
||
}
|
||
std::wstring RtfBorder::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
|
||
|
||
std::wstring val = GetBorderType();
|
||
if (false == val.empty())
|
||
{
|
||
sResult += L" w:val=\"" + val + L"\"";
|
||
val.clear();
|
||
}
|
||
if ( PROP_DEF != m_nColor )
|
||
{
|
||
RtfColor oColor;
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_COLOR_VALUE;
|
||
|
||
if (m_nColor == -1)
|
||
{
|
||
oColor.m_bAuto = true;
|
||
val = L"auto";
|
||
}
|
||
else if (true == poRtfDocument->m_oColorTable.GetColor(m_nColor, oColor))
|
||
{
|
||
val = oColor.RenderToOOX(oNewParam);
|
||
}
|
||
}
|
||
if (false == val.empty())
|
||
{
|
||
sResult += L" w:color=\"" + val + L"\"";
|
||
val.clear();
|
||
}
|
||
if ( PROP_DEF != m_nWidth ) //w:sz 1/8 twips (equivalent to 1/576th of an inch)
|
||
{
|
||
sResult += L" w:sz=\"" + std::to_wstring(2 * m_nWidth / 5) + L"\"";
|
||
}
|
||
if ( PROP_DEF != m_nSpace )
|
||
{
|
||
sResult += L" w:space=\"" + std::to_wstring((int)RtfUtility::Twip2pt(m_nSpace)) + L"\"";
|
||
}
|
||
if ( false == sResult.empty() )
|
||
{
|
||
if ( RENDER_TO_OOX_PARAM_BORDER_ATTRIBUTE == oRenderParameter.nType)
|
||
;
|
||
else if ( RENDER_TO_OOX_PARAM_BORDER_TAG == oRenderParameter.nType )
|
||
sResult = L"<" + oRenderParameter.sValue + sResult + L"/>";
|
||
else
|
||
sResult = L"<w:bdr" + sResult + L"/>";
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfBorder::RenderToShapeOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
|
||
|
||
std::wstring val = GetBorderType();
|
||
if (false == val.empty())
|
||
{
|
||
sResult += L" type=\"" + val + L"\"";
|
||
val.clear();
|
||
}
|
||
if (PROP_DEF != m_nColor)
|
||
{
|
||
RtfColor oColor;
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_COLOR_VALUE;
|
||
|
||
if (m_nColor == -1)
|
||
{
|
||
oColor.m_bAuto = true;
|
||
val = L"auto";
|
||
}
|
||
else if (true == poRtfDocument->m_oColorTable.GetColor(m_nColor, oColor))
|
||
{
|
||
val = oColor.RenderToOOX(oNewParam);
|
||
}
|
||
}
|
||
if (false == val.empty())
|
||
{
|
||
sResult += L" color=\"" + val + L"\"";
|
||
val.clear();
|
||
}
|
||
if (PROP_DEF != m_nWidth) //w:sz 1/8 twips (equivalent to 1/576th of an inch)
|
||
{
|
||
sResult += L" width=\"" + std::to_wstring(2 * m_nWidth / 5) + L"\"";
|
||
}
|
||
|
||
if (false == sResult.empty())
|
||
{
|
||
sResult = L"<" + oRenderParameter.sValue + sResult + L"/>";
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfCharProperty::RtfCharProperty()
|
||
{
|
||
m_bListLevel = false;
|
||
SetDefault();
|
||
}
|
||
bool RtfCharProperty::operator==( const RtfCharProperty& oChar )
|
||
{
|
||
return m_nAnimated == oChar.m_nAnimated && m_bBold == oChar.m_bBold && m_bCaps == oChar.m_bCaps && m_nScalex == oChar.m_nScalex &&
|
||
m_nCharStyle == oChar.m_nCharStyle && m_nDown == oChar.m_nDown && m_bEmbo == oChar.m_bEmbo && m_nCharacterSpacing == oChar.m_nCharacterSpacing &&
|
||
m_nFitText == oChar.m_nFitText && m_nFont == oChar.m_nFont && m_nFont2 == oChar.m_nFont2 && m_nFont3 == oChar.m_nFont3 &&
|
||
m_nFontSize == oChar.m_nFontSize && m_bItalic == oChar.m_bItalic && m_bImprint == oChar.m_bImprint && m_nKerning == oChar.m_nKerning &&
|
||
m_bRightToLeft == oChar.m_bRightToLeft && m_nComplexScript == oChar.m_nComplexScript && m_bOutline == oChar.m_bOutline && m_bScaps == oChar.m_bScaps &&
|
||
m_bShadow == oChar.m_bShadow && m_bStrike == oChar.m_bStrike && m_bSub == oChar.m_bSub && m_bSuper == oChar.m_bSuper &&
|
||
m_bHidden == oChar.m_bHidden && m_nHightlited == oChar.m_nHightlited && m_nForeColor == oChar.m_nForeColor &&
|
||
m_eUnderStyle == oChar.m_eUnderStyle && m_nUnderlineColor == oChar.m_nUnderlineColor && m_nUp == oChar.m_nUp &&
|
||
m_poBorder == oChar.m_poBorder && m_poShading == oChar.m_poShading && m_nDeleted == oChar.m_nDeleted &&
|
||
m_nRevised == oChar.m_nRevised && m_nCrAuth == oChar.m_nCrAuth && m_nRevauthDel == oChar.m_nRevauthDel &&
|
||
m_nRevdttm == oChar.m_nRevdttm && m_nRevdttmDel == oChar.m_nRevdttmDel && m_nCrDate == oChar.m_nCrDate;
|
||
}
|
||
int RtfCharProperty::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_CHAR;
|
||
}
|
||
void RtfCharProperty::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
|
||
m_poShading.SetDefaultRtf();
|
||
m_poBorder.SetDefaultRtf();
|
||
|
||
//if (false == m_bListLevel)
|
||
//{
|
||
//m_nFontSize = DefaultStyle::FontSize;
|
||
//}
|
||
}
|
||
void RtfCharProperty::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
|
||
m_poShading.SetDefaultOOX();
|
||
m_poBorder.SetDefaultOOX();
|
||
|
||
if (false == m_bListLevel)
|
||
m_nFontSize = 20;
|
||
}
|
||
void RtfCharProperty::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY ( m_nAnimated )
|
||
DEFAULT_PROPERTY ( m_bBold )
|
||
DEFAULT_PROPERTY ( m_bCaps )
|
||
DEFAULT_PROPERTY ( m_nScalex )
|
||
DEFAULT_PROPERTY ( m_nCharStyle )
|
||
DEFAULT_PROPERTY ( m_nDown )
|
||
DEFAULT_PROPERTY ( m_bEmbo )
|
||
DEFAULT_PROPERTY ( m_nCharacterSpacing )
|
||
DEFAULT_PROPERTY ( m_nFitText )
|
||
DEFAULT_PROPERTY ( m_nFont )
|
||
DEFAULT_PROPERTY ( m_nFont2 )
|
||
DEFAULT_PROPERTY ( m_nFont3 )
|
||
DEFAULT_PROPERTY ( m_nFontSize )
|
||
DEFAULT_PROPERTY ( m_bItalic )
|
||
DEFAULT_PROPERTY ( m_bImprint )
|
||
DEFAULT_PROPERTY ( m_nKerning )
|
||
DEFAULT_PROPERTY ( m_bRightToLeft )
|
||
DEFAULT_PROPERTY ( m_bOutline )
|
||
DEFAULT_PROPERTY ( m_bScaps )
|
||
DEFAULT_PROPERTY ( m_bShadow )
|
||
DEFAULT_PROPERTY ( m_bStrike )
|
||
DEFAULT_PROPERTY ( m_nStriked )
|
||
DEFAULT_PROPERTY ( m_bSub )
|
||
DEFAULT_PROPERTY ( m_bSuper )
|
||
DEFAULT_PROPERTY ( m_bHidden )
|
||
DEFAULT_PROPERTY ( m_nHightlited )
|
||
DEFAULT_PROPERTY ( m_nForeColor )
|
||
DEFAULT_PROPERTY_DEF( m_eUnderStyle, uls_none )
|
||
DEFAULT_PROPERTY ( m_nUnderlineColor )
|
||
DEFAULT_PROPERTY ( m_nUp )
|
||
DEFAULT_PROPERTY ( m_nComplexScript )
|
||
DEFAULT_PROPERTY ( m_nLanguage )
|
||
DEFAULT_PROPERTY ( m_nLanguageAsian )
|
||
|
||
DEFAULT_PROPERTY ( m_nCrAuth)
|
||
DEFAULT_PROPERTY ( m_nCrDate)
|
||
|
||
DEFAULT_PROPERTY ( m_nDeleted)
|
||
DEFAULT_PROPERTY ( m_nRevised)
|
||
DEFAULT_PROPERTY ( m_nRevauth)
|
||
DEFAULT_PROPERTY ( m_nRevdttm)
|
||
DEFAULT_PROPERTY ( m_nRevauthDel)
|
||
DEFAULT_PROPERTY ( m_nRevdttmDel)
|
||
|
||
DEFAULT_PROPERTY ( m_nInsrsid)
|
||
|
||
m_poShading.SetDefault();
|
||
m_poBorder.SetDefault();
|
||
|
||
m_pOldCharProp = RtfCharPropertyPtr();
|
||
}
|
||
void RtfCharProperty::Merge( RtfCharProperty& oCharPr, bool bAll )
|
||
{
|
||
MERGE_PROPERTY( m_nAnimated, oCharPr )
|
||
MERGE_PROPERTY( m_bBold, oCharPr )
|
||
MERGE_PROPERTY( m_bCaps, oCharPr )
|
||
MERGE_PROPERTY( m_nScalex, oCharPr )
|
||
MERGE_PROPERTY( m_nDown, oCharPr )
|
||
MERGE_PROPERTY( m_bEmbo, oCharPr )
|
||
MERGE_PROPERTY( m_nCharacterSpacing, oCharPr )
|
||
MERGE_PROPERTY( m_nFitText, oCharPr )
|
||
MERGE_PROPERTY( m_nFont, oCharPr )
|
||
MERGE_PROPERTY( m_nFont2, oCharPr )
|
||
MERGE_PROPERTY( m_nFont3, oCharPr )
|
||
MERGE_PROPERTY( m_nFontSize, oCharPr )
|
||
MERGE_PROPERTY( m_bItalic, oCharPr )
|
||
MERGE_PROPERTY( m_bImprint, oCharPr )
|
||
MERGE_PROPERTY( m_nKerning, oCharPr )
|
||
MERGE_PROPERTY( m_bRightToLeft, oCharPr )
|
||
MERGE_PROPERTY( m_nLanguage, oCharPr )
|
||
MERGE_PROPERTY( m_nLanguageAsian,oCharPr )
|
||
MERGE_PROPERTY( m_bOutline, oCharPr )
|
||
MERGE_PROPERTY( m_bScaps, oCharPr )
|
||
MERGE_PROPERTY( m_bShadow, oCharPr )
|
||
MERGE_PROPERTY( m_bSub, oCharPr )
|
||
MERGE_PROPERTY( m_bSuper, oCharPr )
|
||
MERGE_PROPERTY( m_bHidden, oCharPr )
|
||
MERGE_PROPERTY( m_nForeColor, oCharPr )
|
||
MERGE_PROPERTY( m_nCrAuth, oCharPr )
|
||
MERGE_PROPERTY( m_nCrDate, oCharPr )
|
||
MERGE_PROPERTY( m_nDeleted, oCharPr )
|
||
MERGE_PROPERTY( m_nRevised, oCharPr )
|
||
MERGE_PROPERTY( m_nRevauth, oCharPr )
|
||
MERGE_PROPERTY( m_nRevdttm, oCharPr )
|
||
MERGE_PROPERTY( m_nRevauthDel, oCharPr )
|
||
MERGE_PROPERTY( m_nRevdttmDel, oCharPr )
|
||
MERGE_PROPERTY( m_nInsrsid, oCharPr )
|
||
|
||
if (bAll)
|
||
{
|
||
MERGE_PROPERTY( m_nCharStyle, oCharPr )
|
||
MERGE_PROPERTY( m_bStrike, oCharPr )
|
||
MERGE_PROPERTY( m_nStriked, oCharPr )
|
||
MERGE_PROPERTY( m_nHightlited, oCharPr )
|
||
//свойство должно быть как единое целое, поэтому если oBorPr задано, то переписыватся целиком
|
||
if ( uls_none != oCharPr.m_eUnderStyle || PROP_DEF != oCharPr.m_nUnderlineColor )
|
||
{
|
||
m_eUnderStyle = oCharPr.m_eUnderStyle;
|
||
m_nUnderlineColor = oCharPr.m_nUnderlineColor;
|
||
}
|
||
}
|
||
MERGE_PROPERTY_DEF ( m_bSub, oCharPr, uls_none )
|
||
MERGE_PROPERTY ( m_nUp, oCharPr )
|
||
MERGE_PROPERTY ( m_nComplexScript, oCharPr )
|
||
|
||
m_poBorder.Merge( oCharPr.m_poBorder );
|
||
m_poShading.Merge( oCharPr.m_poShading );
|
||
}
|
||
std::wstring RtfCharProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT( m_nAnimated, sResult, L"animtext" )
|
||
RENDER_RTF_BOOL( m_bBold, sResult, L"b" )
|
||
RENDER_RTF_BOOL( m_bCaps, sResult, L"caps" )
|
||
RENDER_RTF_INT( m_nScalex, sResult, L"charscalex" )
|
||
//RENDER_RTF_INT( m_nCharStyle, sResult, L"cs" )
|
||
RENDER_RTF_INT( m_nDown, sResult, L"dn" )
|
||
RENDER_RTF_BOOL( m_bEmbo, sResult, L"embo" )
|
||
RENDER_RTF_INT( m_nCharacterSpacing, sResult, L"expndtw" )
|
||
|
||
if( PROP_DEF != m_nCharacterSpacing )
|
||
sResult += L"\\expnd" + std::to_wstring( m_nCharacterSpacing / 5 );
|
||
if( PROP_DEF != m_nFitText )
|
||
sResult += L"\\fittext" + std::to_wstring( m_nFitText / 5 );
|
||
|
||
RENDER_RTF_INT( m_nFont, sResult, L"f" )
|
||
//RENDER_RTF_INT( m_nFont2, sResult, L"fittext" )
|
||
//RENDER_RTF_INT( m_nFont3, sResult, L"fittext" )
|
||
RENDER_RTF_INT( m_nFontSize, sResult, L"fs" )
|
||
RENDER_RTF_BOOL( m_bItalic, sResult, L"i" )
|
||
RENDER_RTF_BOOL( m_bImprint, sResult, L"impr" )
|
||
RENDER_RTF_INT( m_nKerning, sResult, L"kerning" )
|
||
|
||
if (m_bRightToLeft != PROP_DEF )
|
||
{
|
||
if( m_bRightToLeft !=0) sResult += L"\\rtlch";
|
||
else sResult += L"\\ltrch";
|
||
}
|
||
|
||
if( PROP_DEF != m_nComplexScript )
|
||
sResult += L"\\fcs" + std::to_wstring( m_nComplexScript);
|
||
|
||
RENDER_RTF_BOOL ( m_bOutline, sResult, L"outl" )
|
||
RENDER_RTF_BOOL ( m_bScaps , sResult, L"scaps" )
|
||
RENDER_RTF_BOOL ( m_bShadow , sResult, L"shad" )
|
||
RENDER_RTF_BOOL ( m_bStrike , sResult, L"strike" )
|
||
RENDER_RTF_INT ( m_nStriked, sResult, L"striked" )
|
||
RENDER_RTF_BOOL ( m_bSub , sResult, L"sub" )
|
||
RENDER_RTF_BOOL ( m_bSuper , sResult, L"super" )
|
||
RENDER_RTF_INT ( m_bHidden , sResult, L"v" )
|
||
RENDER_RTF_INT ( m_nHightlited, sResult, L"highlight" )
|
||
RENDER_RTF_INT ( m_nForeColor, sResult, L"cf" )
|
||
RENDER_RTF_INT ( m_nLanguage, sResult, L"lang" )
|
||
RENDER_RTF_INT ( m_nLanguageAsian, sResult, L"langfe" )
|
||
|
||
switch( m_eUnderStyle )
|
||
{
|
||
case uls_Single: sResult += L"\\ul"; break;
|
||
case uls_Dotted: sResult += L"\\uld"; break;
|
||
case uls_Dashed: sResult += L"\\uldash"; break;
|
||
case uls_Dash_dotted: sResult += L"\\uldashd"; break;
|
||
case uls_Dash_dot_dotted: sResult += L"\\uldashdd"; break;
|
||
case uls_Double: sResult += L"\\uldb"; break;
|
||
case uls_Heavy_wave: sResult += L"\\ulhwave"; break;
|
||
case uls_Long_dashe: sResult += L"\\ulldash"; break;
|
||
case uls_Stops_all: sResult += L"\\ulnone"; break;
|
||
case uls_Thick: sResult += L"\\ulth"; break;
|
||
case uls_Thick_dotted: sResult += L"\\ulthd"; break;
|
||
case uls_Thick_dashed: sResult += L"\\ulthdash"; break;
|
||
case uls_Thick_dash_dotted: sResult += L"\\ulthdashd"; break;
|
||
case uls_Thick_dash_dot_dotted: sResult += L"\\ulthdashdd"; break;
|
||
case uls_Thick_long_dashed: sResult += L"\\ulthldash"; break;
|
||
case uls_Double_wave: sResult += L"\\ululdbwave"; break;
|
||
case uls_Word: sResult += L"\\ulw"; break;
|
||
case uls_Wave: sResult += L"\\ulwave"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nUnderlineColor, sResult, L"ulc" )
|
||
RENDER_RTF_INT( m_nUp, sResult, L"up" )
|
||
|
||
if( m_poBorder.IsValid() == true )
|
||
{
|
||
sResult += L"\\chbrdr";
|
||
sResult += m_poBorder.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( m_poShading.IsValid() == true )
|
||
sResult += m_poShading.RenderToRtf( oRenderParameter );
|
||
|
||
|
||
if ( m_nDeleted != PROP_DEF)
|
||
{
|
||
sResult += L"\\deleted";
|
||
RENDER_RTF_INT( m_nRevauthDel, sResult, L"revauthdel" )
|
||
RENDER_RTF_INT( m_nRevdttmDel, sResult, L"revdttmdel" )
|
||
}
|
||
|
||
if ( m_nRevised != PROP_DEF)
|
||
{
|
||
sResult += L"\\revised";
|
||
RENDER_RTF_INT( m_nRevauth, sResult, L"revauth" )
|
||
RENDER_RTF_INT( m_nRevdttm, sResult, L"revdttm" )
|
||
}
|
||
|
||
if (m_pOldCharProp)
|
||
{
|
||
RENDER_RTF_INT( m_nCrAuth, sResult, L"crauth" )
|
||
RENDER_RTF_INT( m_nCrDate, sResult, L"crdate" )
|
||
|
||
sResult += L"{\\*\\oldcprops";
|
||
sResult += L"\\plain";
|
||
sResult += m_pOldCharProp->RenderToRtf(oRenderParameter);
|
||
sResult += L"}";
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfCharProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RtfDocument * poRtfDocument = static_cast<RtfDocument*> (oRenderParameter.poDocument);
|
||
OOXWriter * poOOXWriter = static_cast<OOXWriter*> (oRenderParameter.poWriter);
|
||
|
||
bool bInsert = false;
|
||
bool bDelete = false;
|
||
|
||
if (m_nFontSize == PROP_DEF)
|
||
{
|
||
m_nFontSize = poRtfDocument->m_oProperty.m_nDefFontSize;
|
||
}
|
||
if( RENDER_TO_OOX_PARAM_MATH == oRenderParameter.nType)
|
||
{//w:rPr в m:ctrlPr
|
||
if (m_nRevised != PROP_DEF)
|
||
{
|
||
bInsert = true;
|
||
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_nRevauth);
|
||
std::wstring sDate(RtfUtility::convertDateTime( 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_nRevised = PROP_DEF;
|
||
}
|
||
if (m_nDeleted != PROP_DEF)
|
||
{
|
||
bDelete = true;
|
||
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_nRevauthDel);
|
||
std::wstring sDate(RtfUtility::convertDateTime( 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_nDeleted = PROP_DEF;
|
||
}
|
||
sResult += L"<w:rPr>";
|
||
}
|
||
|
||
if ( PROP_DEF != m_nDeleted )//для rPr в pPr
|
||
{
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_nRevauthDel);
|
||
std::wstring sDate(RtfUtility::convertDateTime(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"\"/>";
|
||
}
|
||
if ( PROP_DEF != m_nRevised )
|
||
{
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_nRevauth);
|
||
std::wstring sDate(RtfUtility::convertDateTime(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"\"/>";
|
||
}
|
||
if( PROP_DEF != m_nCharStyle )
|
||
{
|
||
RtfStylePtr oStyle;
|
||
if( true == poRtfDocument->m_oStyleTable.GetStyle( m_nCharStyle, oStyle ) )
|
||
{
|
||
sResult += L"<w:rStyle w:val=\"";
|
||
sResult += L"Style_" + std::to_wstring(m_nCharStyle); //oStyle->m_sName;
|
||
sResult += L"\"/>";
|
||
}
|
||
}
|
||
switch( m_nAnimated )
|
||
{
|
||
case 0: sResult += L"<w:effect w:val=\"none\"/>"; break;
|
||
case 1: sResult += L"<w:effect w:val=\"lights\"/>"; break;
|
||
case 2: sResult += L"<w:effect w:val=\"blinkBackground\"/>";break;
|
||
case 3: sResult += L"<w:effect w:val=\"sparkle\"/>"; break;
|
||
case 4: sResult += L"<w:effect w:val=\"antsBlack\"/>"; break;
|
||
case 5: sResult += L"<w:effect w:val=\"antsRed\"/>"; break;
|
||
case 6: sResult += L"<w:effect w:val=\"shimmer\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_OOX_BOOL ( m_bBold, sResult, L"w:b" )
|
||
RENDER_OOX_BOOL ( m_bCaps, sResult, L"w:caps" )
|
||
RENDER_OOX_INT ( (int)m_nScalex, sResult, L"w:w" )
|
||
|
||
if( PROP_DEF != m_nDown )
|
||
{
|
||
sResult += L"<w:position w:val=\"-" + std::to_wstring(m_nDown) + L"\"/>";
|
||
}
|
||
RENDER_OOX_BOOL( m_bEmbo, sResult, L"w:emboss" )
|
||
RENDER_OOX_INT( m_nCharacterSpacing, sResult, L"w:spacing" )
|
||
|
||
if( PROP_DEF != m_nFitText )
|
||
{
|
||
if( -1 == m_nFitText )
|
||
{
|
||
sResult += L"<w:fitText w:id=\"" + poOOXWriter->m_nCurFitId + L"\" w:val=\"" + std::to_wstring(poOOXWriter->m_nCurFitWidth) + L"\"/>";
|
||
}
|
||
else
|
||
{
|
||
poOOXWriter->m_nCurFitId = poRtfDocument->m_oIdGenerator.Generate_FitTextId();
|
||
poOOXWriter->m_nCurFitWidth = m_nFitText;
|
||
sResult += L"<w:fitText w:id=\"" + poOOXWriter->m_nCurFitId + L"\" w:val=\"" + std::to_wstring(poOOXWriter->m_nCurFitWidth) + L"\"/>";
|
||
}
|
||
}
|
||
if (RENDER_TO_OOX_PARAM_UNKNOWN != oRenderParameter.nType)
|
||
{
|
||
if (PROP_DEF == m_nFont)
|
||
{
|
||
if (RENDER_TO_OOX_PARAM_MATH == oRenderParameter.nType)
|
||
m_nFont = poRtfDocument->m_oProperty.m_nDefMathFont;
|
||
else
|
||
m_nFont = poRtfDocument->m_oProperty.m_nDefFont;
|
||
}
|
||
if (PROP_DEF == m_nLanguage)
|
||
{
|
||
m_nLanguage = poRtfDocument->m_oProperty.m_nDefLang;
|
||
}
|
||
if (PROP_DEF == m_nLanguageAsian)
|
||
{
|
||
m_nLanguageAsian = poRtfDocument->m_oProperty.m_nDefLangAsian;
|
||
}
|
||
}
|
||
if (PROP_DEF != m_nFont)
|
||
{
|
||
RtfFont oCurFont;
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
if( true == poRtfDocument->m_oFontTable.GetFont(m_nFont, oCurFont) )
|
||
{
|
||
sResult += oCurFont.RenderToOOX(oNewParam);
|
||
}
|
||
}
|
||
if (m_bHidden == 1)
|
||
{
|
||
sResult += L"<w:vanish/>";
|
||
}
|
||
RENDER_OOX_INT( m_nFontSize, sResult, L"w:sz" )
|
||
RENDER_OOX_BOOL( m_bItalic, sResult, L"w:i" )
|
||
|
||
if (m_nComplexScript != PROP_DEF || m_nLanguageAsian != PROP_DEF )
|
||
{
|
||
RENDER_OOX_INT( m_nFontSize, sResult, L"w:szCs" )
|
||
RENDER_OOX_INT( m_bItalic, sResult, L"w:iCs" )
|
||
RENDER_OOX_INT( m_bBold, sResult, L"w:bCs" )
|
||
}
|
||
RENDER_OOX_BOOL( m_bImprint, sResult, L"w:imprint" )
|
||
RENDER_OOX_INT( m_nKerning, sResult, L"w:kern" )
|
||
|
||
if(m_bRightToLeft !=0 && m_bRightToLeft != PROP_DEF)
|
||
sResult += L"<w:rtl/>";
|
||
|
||
RENDER_OOX_BOOL( m_nComplexScript, sResult, L"w:cs" )
|
||
RENDER_OOX_BOOL( m_bOutline, sResult, L"w:outline" )
|
||
RENDER_OOX_BOOL( m_bScaps, sResult, L"w:smallCaps" )
|
||
RENDER_OOX_BOOL( m_bShadow, sResult, L"w:shadow" )
|
||
RENDER_OOX_BOOL( m_bStrike, sResult, L"w:strike" )
|
||
RENDER_OOX_BOOL( m_nStriked, sResult, L"w:dstrike" )
|
||
|
||
if( 1 == m_bSub )
|
||
sResult += L"<w:vertAlign w:val=\"subscript\"/>";
|
||
if( 1 == m_bSuper )
|
||
sResult += L"<w:vertAlign w:val=\"superscript\"/>";
|
||
|
||
if( PROP_DEF != m_nHightlited )
|
||
{
|
||
RtfColor oCurColor;
|
||
if( true == poRtfDocument->m_oColorTable.GetColor( m_nHightlited, oCurColor ) )
|
||
{
|
||
if (!oCurColor.m_bAuto)
|
||
{
|
||
sResult += L"<w:highlight w:val=\"" + oCurColor.GetHighLight() + L"\"/>";
|
||
}
|
||
}
|
||
}
|
||
|
||
if( PROP_DEF != m_nForeColor )
|
||
{
|
||
RtfColor oCurColor;
|
||
if( true == poRtfDocument->m_oColorTable.GetColor( m_nForeColor, oCurColor ) )
|
||
{
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
sResult += oCurColor.RenderToOOX(oNewParam);
|
||
}
|
||
}
|
||
|
||
std::wstring sUnderColor;
|
||
if( PROP_DEF != m_nUnderlineColor )
|
||
{
|
||
RtfColor oCurColor;
|
||
if ( true == poRtfDocument->m_oColorTable.GetColor( m_nUnderlineColor, oCurColor ) )
|
||
{
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_COLOR_ATTRIBUTE;
|
||
sUnderColor += oCurColor.RenderToOOX(oNewParam);
|
||
}
|
||
}
|
||
if( uls_none != m_eUnderStyle )
|
||
{
|
||
sResult += L"<w:u " + sUnderColor;
|
||
switch( m_eUnderStyle )
|
||
{
|
||
case uls_Single: sResult += L" w:val=\"single\"/>"; break;
|
||
case uls_Dotted: sResult += L" w:val=\"dotted\"/>"; break;
|
||
case uls_Dashed: sResult += L" w:val=\"dash\"/>"; break;
|
||
case uls_Dash_dotted: sResult += L" w:val=\"dotDash\"/>"; break;
|
||
case uls_Dash_dot_dotted: sResult += L" w:val=\"dotDotDash\"/>"; break;
|
||
case uls_Double: sResult += L" w:val=\"double\"/>"; break;
|
||
case uls_Heavy_wave: sResult += L" w:val=\"wavyHeavy\"/>"; break;
|
||
case uls_Long_dashe: sResult += L" w:val=\"dashLong\"/>"; break;
|
||
case uls_Stops_all: sResult += L" w:val=\"single\"/>"; break;
|
||
case uls_Thick: sResult += L" w:val=\"thick\"/>"; break;
|
||
case uls_Thick_dotted: sResult += L" w:val=\"dottedHeavy\"/>"; break;
|
||
case uls_Thick_dashed: sResult += L" w:val=\"dashedHeavy\"/>"; break;
|
||
case uls_Thick_dash_dotted: sResult += L" w:val=\"dashDotHeavy\"/>"; break;
|
||
case uls_Thick_dash_dot_dotted: sResult += L" w:val=\"dashDotDotHeavy\"/>"; break;
|
||
case uls_Thick_long_dashed: sResult += L" w:val=\"dashLongHeavy\"/>"; break;
|
||
case uls_Double_wave: sResult += L" w:val=\"wavyDouble\"/>"; break;
|
||
case uls_Word: sResult += L" w:val=\"words\"/>"; break;
|
||
case uls_Wave: sResult += L" w:val=\"wave\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sResult += L"<w:u w:val=\"none\"/>";
|
||
}
|
||
|
||
RENDER_OOX_INT( m_nUp, sResult, L"w:position" )
|
||
|
||
if ((m_nLanguage != PROP_DEF || m_nLanguageAsian != PROP_DEF) && RENDER_TO_OOX_PARAM_MATH != oRenderParameter.nType)
|
||
//todooo сделаь map для используемых в доке
|
||
{
|
||
std::wstring str_lang, str_lang_asian;
|
||
#if defined(_WIN32) || defined(_WIN64)
|
||
if (m_nLanguage != PROP_DEF)
|
||
{
|
||
wchar_t buf[29] = {};
|
||
int ccBuf = GetLocaleInfo(m_nLanguage, LOCALE_SISO639LANGNAME, buf, 29);
|
||
|
||
if (ccBuf > 0)
|
||
{
|
||
str_lang += buf;
|
||
str_lang += L"-";
|
||
}
|
||
|
||
ccBuf = GetLocaleInfo(m_nLanguage, LOCALE_SISO3166CTRYNAME, buf, 29);
|
||
|
||
if (ccBuf > 0) str_lang.append(buf);
|
||
}
|
||
if (m_nLanguageAsian != PROP_DEF)
|
||
{
|
||
wchar_t buf[29] = {};
|
||
int ccBuf = GetLocaleInfo(m_nLanguageAsian, LOCALE_SISO639LANGNAME, buf, 29);
|
||
|
||
if (ccBuf > 0)
|
||
{
|
||
str_lang_asian += buf;
|
||
str_lang_asian += L"-";
|
||
}
|
||
|
||
ccBuf = GetLocaleInfo(m_nLanguageAsian, LOCALE_SISO3166CTRYNAME, buf, 29);
|
||
|
||
if (ccBuf > 0) str_lang_asian.append(buf);
|
||
}
|
||
#else
|
||
MS_LCID_converter lcidConverter;
|
||
|
||
str_lang = (m_nLanguage != PROP_DEF) ? lcidConverter.get_wstring(m_nLanguage) : L"";
|
||
str_lang_asian = (m_nLanguageAsian != PROP_DEF) ? lcidConverter.get_wstring(m_nLanguageAsian) : L"";
|
||
#endif
|
||
if (false == str_lang.empty() || false == str_lang_asian.empty() )
|
||
{
|
||
sResult += std::wstring(L"<w:lang");
|
||
if (false == str_lang.empty())
|
||
{
|
||
sResult += L" w:val=\"" + str_lang + L"\"";
|
||
}
|
||
if (false == str_lang_asian.empty())
|
||
{
|
||
sResult += L" w:bidi=\"" + str_lang_asian + L"\"";
|
||
}
|
||
sResult += L"/>";
|
||
}
|
||
}
|
||
|
||
sResult += m_poBorder.RenderToOOX( oRenderParameter );
|
||
sResult += m_poShading.RenderToOOX( oRenderParameter );
|
||
|
||
if (m_pOldCharProp)
|
||
{
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_nCrAuth);
|
||
std::wstring sDate(RtfUtility::convertDateTime(m_nCrDate).c_str());
|
||
|
||
RenderParameter oRenderParameterNew = oRenderParameter;
|
||
oRenderParameterNew.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
|
||
sResult += L"<w:rPrChange w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
||
sResult += L"<w:rPr>";
|
||
sResult += m_pOldCharProp->RenderToOOX(oRenderParameterNew);
|
||
sResult += L"</w:rPr>";
|
||
sResult += L"</w:rPrChange>";
|
||
}
|
||
|
||
if( RENDER_TO_OOX_PARAM_MATH == oRenderParameter.nType)
|
||
{
|
||
sResult += L"</w:rPr>";
|
||
|
||
if (bDelete)sResult += L"</w:del>";
|
||
if (bInsert)sResult += L"</w:ins>";
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfListLevelProperty::RtfListLevelProperty()
|
||
{
|
||
m_oCharProp.m_bListLevel = true;
|
||
|
||
SetDefault();
|
||
}
|
||
bool RtfListLevelProperty::IsValid()
|
||
{
|
||
//return -1 != m_nFollow && -1 != m_nStart && -1 != m_nNumberType && -1 != m_nJustification &&
|
||
// false == m_sText.empty() && false == m_sNumber.empty();
|
||
return PROP_DEF != m_nNumberType && false == m_sLevelText.empty();
|
||
}
|
||
std::wstring RtfListLevelProperty::GenerateListText()
|
||
{//заменяем на булеты
|
||
std::wstring sResult;
|
||
|
||
char cBullet[1]; cBullet[0] = (char)149;
|
||
|
||
std::string sBullet = cBullet;
|
||
std::wstring swBullet(sBullet.begin(), sBullet.end());
|
||
|
||
sResult += swBullet.c_str();
|
||
//std::wstring sOOXNumber = GetLevelTextOOX();
|
||
//for (size_t i = 0; i < sOOXNumber.length(); i++ )
|
||
// if ( sOOXNumber[i] == '%' && i != sOOXNumber.length() - 1 )
|
||
// {
|
||
// sResult += swBullet;
|
||
// i++;
|
||
// }
|
||
// else
|
||
// sResult.AppendChar( sOOXNumber[i] );
|
||
return sResult;
|
||
}
|
||
void RtfListLevelProperty::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY ( m_nSpace )
|
||
DEFAULT_PROPERTY ( m_nLevel )
|
||
DEFAULT_PROPERTY ( m_nNumberType )
|
||
DEFAULT_PROPERTY ( m_bTentative )
|
||
DEFAULT_PROPERTY ( m_nJustification )
|
||
DEFAULT_PROPERTY ( m_nFollow )
|
||
DEFAULT_PROPERTY ( m_nStart )
|
||
DEFAULT_PROPERTY_DEF(m_sLevelText, L"" )
|
||
DEFAULT_PROPERTY_DEF( m_sNumber, L"" )
|
||
DEFAULT_PROPERTY ( m_nNoRestart )
|
||
DEFAULT_PROPERTY ( m_nLegal )
|
||
DEFAULT_PROPERTY ( m_nPictureIndex )
|
||
DEFAULT_PROPERTY ( m_nFirstIndent )
|
||
DEFAULT_PROPERTY ( m_nIndent )
|
||
DEFAULT_PROPERTY ( m_nIndentStart )
|
||
|
||
m_oTabs.SetDefault();
|
||
m_oCharProp.SetDefault();
|
||
}
|
||
void RtfListLevelProperty::Merge(RtfListLevelProperty& oListLevel)
|
||
{
|
||
MERGE_PROPERTY( m_nSpace, oListLevel)
|
||
MERGE_PROPERTY( m_nLevel, oListLevel)
|
||
MERGE_PROPERTY( m_nNumberType, oListLevel)
|
||
MERGE_PROPERTY( m_bTentative, oListLevel)
|
||
MERGE_PROPERTY( m_nJustification, oListLevel)
|
||
MERGE_PROPERTY( m_nFollow, oListLevel)
|
||
MERGE_PROPERTY( m_nStart, oListLevel)
|
||
|
||
if (!oListLevel.m_sLevelText.empty())
|
||
m_sLevelText = oListLevel.m_sLevelText;
|
||
|
||
if (!oListLevel.m_sNumber.empty())
|
||
m_sNumber = oListLevel.m_sNumber;
|
||
|
||
MERGE_PROPERTY( m_nNoRestart, oListLevel)
|
||
MERGE_PROPERTY( m_nLegal, oListLevel)
|
||
MERGE_PROPERTY( m_nPictureIndex, oListLevel)
|
||
MERGE_PROPERTY( m_nFirstIndent, oListLevel)
|
||
MERGE_PROPERTY( m_nIndent, oListLevel)
|
||
MERGE_PROPERTY( m_nIndentStart, oListLevel)
|
||
|
||
m_oTabs.Merge(oListLevel.m_oTabs);
|
||
m_oCharProp.Merge(oListLevel.m_oCharProp);
|
||
}
|
||
std::wstring RtfListLevelProperty::GetFormat( int nNumFormat)
|
||
{
|
||
std::wstring sResult;
|
||
switch(nNumFormat)
|
||
{
|
||
case 0: sResult = L"decimal"; break;
|
||
case 1: sResult = L"upperRoman"; break;
|
||
case 2: sResult = L"lowerRoman"; break;
|
||
case 3: sResult = L"upperLetter"; break;
|
||
case 4: sResult = L"lowerLetter"; break;
|
||
case 5: sResult = L"ordinal"; break;
|
||
case 6: sResult = L"cardinalText"; break;
|
||
case 7: sResult = L"ordinalText"; break;
|
||
case 8: sResult = L"hex"; break;
|
||
case 9: sResult = L"chicago"; break;
|
||
case 10: sResult = L"ideographDigital"; break;
|
||
case 11: sResult = L"japaneseCounting"; break;
|
||
case 12: sResult = L"aiueo"; break;
|
||
case 13: sResult = L"iroha"; break;
|
||
case 14: sResult = L"decimalFullWidth"; break;
|
||
case 15: sResult = L"decimalHalfWidth"; break;
|
||
case 16: sResult = L"japaneseLegal"; break;
|
||
case 17: sResult = L"japaneseDigitalTenThousand"; break;
|
||
case 18: sResult = L"decimalEnclosedCircle"; break;
|
||
case 19: sResult = L"decimalFullWidth2"; break;
|
||
case 20: sResult = L"aiueoFullWidth"; break;
|
||
case 21: sResult = L"irohaFullWidth"; break;
|
||
case 22: sResult = L"decimalZero"; break;
|
||
case 23: sResult = L"bullet"; break;
|
||
case 24: sResult = L"ganada"; break;
|
||
case 25: sResult = L"chosung"; break;
|
||
case 26: sResult = L"decimalEnclosedFullstop"; break;
|
||
case 27: sResult = L"decimalEnclosedParen"; break;
|
||
case 28: sResult = L"decimalEnclosedCircleChinese"; break;
|
||
case 29: sResult = L"ideographEnclosedCircle"; break;
|
||
case 30: sResult = L"ideographTraditional"; break;
|
||
case 31: sResult = L"ideographZodiac"; break;
|
||
case 32: sResult = L"ideographZodiacTraditional"; break;
|
||
case 33: sResult = L"taiwaneseCounting"; break;
|
||
case 34: sResult = L"ideographLegalTraditional"; break;
|
||
case 35: sResult = L"taiwaneseCountingThousand"; break;
|
||
case 36: sResult = L"taiwaneseDigital"; break;
|
||
case 37: sResult = L"chineseCounting"; break;
|
||
case 38: sResult = L"chineseLegalSimplified"; break;
|
||
case 39: sResult = L"chineseCountingThousand"; break;
|
||
case 40: sResult = L"chineseCounting"; break;
|
||
case 41: sResult = L"koreanDigital"; break;
|
||
case 42: sResult = L"koreanCounting"; break;
|
||
case 43: sResult = L"koreanLegal"; break;
|
||
case 44: sResult = L"koreanDigital2"; break;
|
||
case 45: sResult = L"hebrew1"; break;
|
||
case 46: sResult = L"arabicAlpha"; break;
|
||
case 47: sResult = L"hebrew2"; break;
|
||
case 48: sResult = L"arabicAbjad"; break;
|
||
case 49: sResult = L"hindiVowels"; break;
|
||
case 50: sResult = L"hindiConsonants"; break;
|
||
case 51: sResult = L"hindiNumbers"; break;
|
||
case 52: sResult = L"hindiCounting"; break;
|
||
case 53: sResult = L"thaiLetters"; break;
|
||
case 54: sResult = L"thaiNumbers"; break;
|
||
case 55: sResult = L"thaiCounting"; break;
|
||
case 56: sResult = L"vietnameseCounting"; break;
|
||
case 57: sResult = L"numberInDash"; break;
|
||
case 58: sResult = L"russianLower"; break;
|
||
case 59: sResult = L"russianUpper"; break;
|
||
|
||
case 70: sResult = L"chicago"; break;
|
||
|
||
case 255: sResult = L"none"; break;
|
||
default: sResult = L"decimal";
|
||
}
|
||
return sResult;
|
||
}
|
||
int RtfListLevelProperty::GetFormat(const std::wstring& sFormat)
|
||
{
|
||
if ( L"aiueo" == sFormat ) return 12;
|
||
else if ( L"aiueoFullWidth" == sFormat ) return 20;
|
||
else if ( L"arabicAbjad" == sFormat ) return 48;
|
||
else if ( L"arabicAlpha" == sFormat ) return 46;
|
||
else if ( L"bahtText" == sFormat ) return 0;
|
||
else if ( L"bullet" == sFormat ) return 23;
|
||
else if ( L"cardinalText" == sFormat ) return 6;
|
||
else if ( L"chicago" == sFormat ) return 9;
|
||
else if ( L"chineseCounting" == sFormat ) return 37;
|
||
else if ( L"chineseCountingThousand" == sFormat ) return 39;
|
||
else if ( L"chineseLegalSimplified" == sFormat ) return 38;
|
||
else if ( L"chosung" == sFormat ) return 25;
|
||
else if ( L"custom" == sFormat ) return 0;
|
||
else if ( L"decimal" == sFormat ) return 0;
|
||
else if ( L"decimalEnclosedCircle" == sFormat ) return 18;
|
||
else if ( L"decimalEnclosedCircleChinese" == sFormat ) return 28;
|
||
else if ( L"decimalEnclosedFullstop" == sFormat ) return 26;
|
||
else if ( L"decimalEnclosedParen" == sFormat ) return 27;
|
||
else if ( L"decimalFullWidth" == sFormat ) return 14;
|
||
else if ( L"decimalFullWidth2" == sFormat ) return 19;
|
||
else if ( L"decimalHalfWidth" == sFormat ) return 15;
|
||
else if ( L"decimalZero" == sFormat ) return 22;
|
||
else if ( L"dollarText" == sFormat ) return 0;
|
||
else if ( L"ganada" == sFormat ) return 24;
|
||
else if ( L"hebrew1" == sFormat ) return 45;
|
||
else if ( L"hebrew1" == sFormat ) return 45;
|
||
else if ( L"hebrew2" == sFormat ) return 47;
|
||
else if ( L"hex" == sFormat ) return 8;
|
||
else if ( L"hindiConsonants" == sFormat ) return 50;
|
||
else if ( L"hindiCounting" == sFormat ) return 52;
|
||
else if ( L"hindiNumbers" == sFormat ) return 51;
|
||
else if ( L"hindiVowels" == sFormat ) return 49;
|
||
else if ( L"ideographDigital" == sFormat ) return 10;
|
||
else if ( L"ideographEnclosedCircle" == sFormat ) return 29;
|
||
else if ( L"ideographLegalTraditional" == sFormat ) return 34;
|
||
else if ( L"ideographTraditional" == sFormat ) return 30;
|
||
else if ( L"ideographZodiac" == sFormat ) return 31;
|
||
else if ( L"ideographZodiacTraditional" == sFormat ) return 32;
|
||
else if ( L"iroha" == sFormat ) return 13;
|
||
else if ( L"irohaFullWidth" == sFormat ) return 21;
|
||
else if ( L"japaneseCounting" == sFormat ) return 11;
|
||
else if ( L"japaneseDigitalTenThousand" == sFormat ) return 17;
|
||
else if ( L"japaneseLegal" == sFormat ) return 16;
|
||
else if ( L"koreanCounting" == sFormat ) return 42;
|
||
else if ( L"koreanDigital" == sFormat ) return 41;
|
||
else if ( L"koreanDigital2" == sFormat ) return 44;
|
||
else if ( L"koreanLegal" == sFormat ) return 43;
|
||
else if ( L"lowerLetter" == sFormat ) return 4;
|
||
else if ( L"lowerRoman" == sFormat ) return 2;
|
||
else if ( L"none" == sFormat ) return 255;
|
||
else if ( L"numberInDash" == sFormat ) return 57;
|
||
else if ( L"ordinal" == sFormat ) return 5;
|
||
else if ( L"ordinalText" == sFormat ) return 7;
|
||
else if ( L"russianLower" == sFormat ) return 58;
|
||
else if ( L"russianUpper" == sFormat ) return 59;
|
||
else if ( L"taiwaneseCounting" == sFormat ) return 33;
|
||
else if ( L"taiwaneseCountingThousand" == sFormat ) return 35;
|
||
else if ( L"taiwaneseDigital" == sFormat ) return 36;
|
||
else if ( L"thaiCounting" == sFormat ) return 55;
|
||
else if ( L"thaiLetters" == sFormat ) return 53;
|
||
else if ( L"thaiNumbers" == sFormat ) return 54;
|
||
else if ( L"upperLetter" == sFormat ) return 3;
|
||
else if ( L"upperRoman" == sFormat ) return 1;
|
||
else if ( L"vietnameseCounting" == sFormat ) return 56;
|
||
else if ( L"chicago" == sFormat ) return 70;
|
||
|
||
return 0; //decimal
|
||
}
|
||
std::wstring RtfListLevelProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
RtfDocument * poRtfDocument = static_cast<RtfDocument*> ( oRenderParameter.poDocument);
|
||
RtfWriter * poRtfWriter = static_cast<RtfWriter*> ( oRenderParameter.poWriter);
|
||
|
||
std::wstring sResult;
|
||
sResult += L"{\\listlevel";
|
||
|
||
RENDER_RTF_INT( m_nNumberType, sResult, L"levelnfc" )
|
||
RENDER_RTF_INT( m_nNumberType, sResult, L"levelnfcn" )
|
||
RENDER_RTF_BOOL( m_bTentative, sResult, L"lvltentative" )
|
||
RENDER_RTF_INT( m_nJustification, sResult, L"leveljc" )
|
||
RENDER_RTF_INT( m_nJustification, sResult, L"leveljcn" )
|
||
RENDER_RTF_INT( m_nFollow, sResult, L"levelfollow" )
|
||
RENDER_RTF_INT( m_nStart, sResult, L"levelstartat" )
|
||
RENDER_RTF_INT( m_nNoRestart, sResult, L"levelnorestart" )
|
||
RENDER_RTF_INT( m_nPictureIndex, sResult, L"levelpicture" )
|
||
//чтобы при последующем чтении из rtf не потерялась информация о шрифте
|
||
sResult += m_oCharProp.RenderToRtf( oRenderParameter );
|
||
|
||
sResult += L"{\\leveltext" + m_sLevelText + L";}";
|
||
sResult += L"{\\levelnumbers" + m_sNumber + L";}";
|
||
|
||
RENDER_RTF_INT( m_nFirstIndent, sResult, L"fi" )
|
||
RENDER_RTF_INT( m_nIndent, sResult, L"li" )
|
||
RENDER_RTF_INT( m_nIndentStart, sResult, L"lin" )
|
||
|
||
for (size_t i = 0 ; i < m_oTabs.m_aTabs.size(); i++ )
|
||
{
|
||
sResult += L"\\jclisttab";
|
||
sResult += m_oTabs.m_aTabs[i].RenderToRtf( oRenderParameter );
|
||
}
|
||
|
||
|
||
sResult += L"}";
|
||
return sResult;
|
||
}
|
||
std::wstring RtfListLevelProperty::GetLevelTextOOX()
|
||
{
|
||
std::wstring sResult = m_sLevelText;
|
||
if ( sResult.length() > 0 )
|
||
{
|
||
size_t nLevelTextLength = sResult[0];
|
||
nLevelTextLength--;
|
||
|
||
for (int i = (int)m_sNumber.length() - 1; i >= 0; i-- )
|
||
{
|
||
int nReplaceNumber = m_sNumber[i];
|
||
nReplaceNumber--;
|
||
if ( nReplaceNumber >= 0 && nReplaceNumber < (int)sResult.length() )
|
||
{
|
||
int nLevel = sResult[ nReplaceNumber ];
|
||
|
||
if (nLevel > 11)
|
||
{//001.rtf
|
||
nReplaceNumber++;
|
||
nLevel = sResult[ nReplaceNumber];
|
||
}
|
||
std::wstring sExt = L"%" + std::to_wstring(nLevel);
|
||
|
||
sResult.erase( nReplaceNumber, 1 );
|
||
sResult.insert(sResult.begin() + nReplaceNumber, sExt.begin(), sExt.end());
|
||
nLevelTextLength += sExt.length() - 1;
|
||
}
|
||
}
|
||
sResult = sResult.substr(1);
|
||
if ( nLevelTextLength < sResult.length() )
|
||
sResult = sResult.substr(0, nLevelTextLength );
|
||
|
||
}
|
||
return XmlUtils::EncodeXmlString( sResult );
|
||
}
|
||
|
||
void RtfListLevelProperty::SetLevelTextOOX(const std::wstring& sText)
|
||
{
|
||
m_sLevelText.clear();
|
||
m_sNumber.clear();
|
||
|
||
int nLevelOffsets = 0;
|
||
int nText = 0;
|
||
|
||
for (size_t i = 0; i < sText.length() ; i++ )
|
||
{
|
||
if ( (sText[i] == '%') && (i + 1 < sText.length()) && (isdigit( sText[ i + 1 ] )))
|
||
{
|
||
int nLevel = RtfUtility::ToByte( sText[ i + 1 ] );
|
||
|
||
m_sLevelText += L"\\'" + XmlUtils::ToString(nLevel - 1, L"%02x");
|
||
m_sNumber += L"\\'" + XmlUtils::ToString(nLevelOffsets + 1, L"%02x");
|
||
i++; //т.к. следующий симовл уже учли
|
||
|
||
nText++;
|
||
}
|
||
else
|
||
{
|
||
std::wstring s (sText.c_str() + i, 1);
|
||
m_sLevelText += RtfChar::renderRtfText(s);
|
||
nText++;
|
||
}
|
||
nLevelOffsets++;
|
||
}
|
||
m_sLevelText = L"\\'" + XmlUtils::ToString(nText, L"%02x") + m_sLevelText;
|
||
}
|
||
std::wstring RtfListLevelProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
return RenderToOOX2(oRenderParameter);
|
||
}
|
||
std::wstring RtfListLevelProperty::RenderToOOX2(RenderParameter oRenderParameter, int nLvl)
|
||
{
|
||
std::wstring sResult;
|
||
int nLevel = PROP_DEF;
|
||
|
||
if (PROP_DEF != nLvl) nLevel = nLvl;
|
||
else if (PROP_DEF != m_nLevel) nLevel = m_nLevel;
|
||
|
||
if(PROP_DEF != nLevel)
|
||
{
|
||
sResult += L"<w:lvl w:ilvl=\"" + std::to_wstring(nLevel) + L"\"";
|
||
RENDER_OOX_BOOL_ATTRIBUTE( m_bTentative, sResult, L"w:tentative")
|
||
sResult += L">";
|
||
|
||
if( PROP_DEF != m_nJustification )
|
||
{
|
||
switch( m_nJustification )
|
||
{
|
||
case 0: sResult += L"<w:lvlJc w:val=\"left\"/>"; break;
|
||
case 1: sResult += L"<w:lvlJc w:val=\"center\"/>"; break;
|
||
case 2: sResult += L"<w:lvlJc w:val=\"right\"/>"; break;
|
||
}
|
||
}
|
||
if( 1 == m_nNoRestart)
|
||
sResult += L"<w:lvlRestart w:val=\"0\"/>";
|
||
if( 1 == m_nLegal)
|
||
sResult += L"<w:isLgl/>";
|
||
|
||
std::wstring sText = GetLevelTextOOX();
|
||
if (false == sText.empty())
|
||
{
|
||
sResult += L"<w:lvlText w:val=\"" + sText + L"\"/>";
|
||
}
|
||
sResult += L"<w:numFmt w:val=\"" + GetFormat(m_nNumberType) + L"\"/>";
|
||
|
||
RENDER_OOX_INT( m_nPictureIndex, sResult, L"w:lvlPicBulletId" )
|
||
RENDER_OOX_INT( m_nStart, sResult, L"w:start" )
|
||
|
||
if( PROP_DEF != m_nFollow )
|
||
{
|
||
switch( m_nFollow )
|
||
{
|
||
case 0: sResult += L"<w:suff w:val=\"tab\"/>"; break;
|
||
case 1: sResult += L"<w:suff w:val=\"space\"/>"; break;
|
||
case 2: sResult += L"<w:suff w:val=\"nothing\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
std::wstring spPr;
|
||
std::wstring sIndent;
|
||
if( PROP_DEF != m_nFirstIndent )
|
||
{
|
||
if( m_nFirstIndent >= 0 )
|
||
sIndent += L" w:firstLine=\"" + std::to_wstring(m_nFirstIndent) + L"\"";
|
||
else
|
||
sIndent += L" w:hanging=\"" + std::to_wstring(-m_nFirstIndent) + L"\"";
|
||
}
|
||
RENDER_OOX_INT_ATTRIBUTE(m_nIndent, sIndent, L"w:left")
|
||
if (sIndent.empty())
|
||
{
|
||
RENDER_OOX_INT_ATTRIBUTE(m_nIndentStart, sIndent, L"w:start")
|
||
}
|
||
|
||
if( !sIndent.empty() )
|
||
spPr += L"<w:ind " + sIndent + L"/>";
|
||
|
||
spPr += m_oTabs.RenderToOOX( oRenderParameter );
|
||
|
||
if( !spPr.empty() )
|
||
sResult += L"<w:pPr>" + spPr + L"</w:pPr>";
|
||
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
|
||
std::wstring srPr = m_oCharProp.RenderToOOX(oNewParam);
|
||
|
||
if( !srPr.empty() )
|
||
sResult += L"<w:rPr>" + srPr + L"</w:rPr>";
|
||
|
||
sResult += L"</w:lvl>";
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfListProperty::RtfListProperty()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfListProperty::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY ( m_nID )
|
||
DEFAULT_PROPERTY ( m_nTemplateId )
|
||
DEFAULT_PROPERTY ( m_nListSimple )
|
||
DEFAULT_PROPERTY ( m_bListHybrid )
|
||
DEFAULT_PROPERTY_DEF( m_sName, L"" )
|
||
|
||
m_aArray.clear();
|
||
}
|
||
bool RtfListProperty::IsValid()
|
||
{
|
||
return (PROP_DEF != m_nID) ; //&& (L"" != m_sName);
|
||
}
|
||
std::wstring RtfListProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
sResult += L"\\list";
|
||
|
||
RENDER_RTF_INT( m_nTemplateId, sResult, L"listtemplateid" )
|
||
//RENDER_RTF_INT( m_nListSimple, sResult, L"listsimple" )
|
||
//RENDER_RTF_BOOL( m_bListHybrid, sResult, L"listhybrid" )
|
||
if( 1 == m_bListHybrid )
|
||
sResult += L"\\listhybrid";
|
||
else if( 1 == m_nListSimple )
|
||
sResult += L"\\listsimple" + std::to_wstring(m_nListSimple);
|
||
|
||
for (size_t i = 0; i < m_aArray.size(); i++ )
|
||
{
|
||
sResult += m_aArray[i].RenderToRtf( oRenderParameter );
|
||
}
|
||
sResult += L"{\\listname " + RtfChar::renderRtfText( m_sName, oRenderParameter.poDocument ) + L";}";
|
||
|
||
RENDER_RTF_INT( m_nID, sResult, L"listid" )
|
||
return sResult;
|
||
}
|
||
std::wstring RtfListProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
|
||
OOXWriter* poOOXWriter = static_cast<OOXWriter*>(oRenderParameter.poWriter);
|
||
|
||
std::wstring sResult;
|
||
|
||
sResult += L"<w:abstractNum w:abstractNumId=\"" + std::to_wstring(m_nID) + L"\">";
|
||
|
||
if( 1 == m_bListHybrid )
|
||
sResult += L"<w:multiLevelType w:val=\"hybridMultilevel\"/>";
|
||
else if( 1 == m_nListSimple )
|
||
sResult += L"<w:multiLevelType w:val=\"singleLevel\"/>";
|
||
else
|
||
sResult += L"<w:multiLevelType w:val=\"multilevel\"/>";
|
||
|
||
if( !m_sName.empty() )
|
||
sResult += L"<w:name w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>";
|
||
//if( false == m_nStyleName )
|
||
//{
|
||
// sResult += L"<w:name w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>";
|
||
// if( PROP_DEF != m_nStyleID)
|
||
// sResult += L"<w:styleLink w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>";
|
||
//}
|
||
//else
|
||
// sResult += L"<w:numStyleLink w:val=\"" + XmlUtils::EncodeXmlString( m_sName) + L"\"/>";
|
||
|
||
if( PROP_DEF != m_nTemplateId )
|
||
sResult += L"<w:tmpl w:val=\"" + XmlUtils::ToString(m_nTemplateId, L"%x") + L"\"/>";
|
||
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
|
||
for (size_t i = 0; i < m_aArray.size(); i++ )
|
||
sResult += m_aArray[i].RenderToOOX(oNewParam);
|
||
|
||
sResult += L"</w:abstractNum>";
|
||
return sResult;
|
||
}
|
||
|
||
RtfListOverrideProperty::ListOverrideLevels::ListOverrideLevels()
|
||
{
|
||
}
|
||
|
||
RtfListOverrideProperty::ListOverrideLevels& RtfListOverrideProperty::ListOverrideLevels::operator=( const ListOverrideLevels& oOverLevel )
|
||
{
|
||
m_aOverrideLevels.clear();
|
||
m_aOverrideLevels = oOverLevel.m_aOverrideLevels;
|
||
return (*this);
|
||
}
|
||
void RtfListOverrideProperty::ListOverrideLevels::SetDefault()
|
||
{
|
||
m_aOverrideLevels.clear();
|
||
}
|
||
std::wstring RtfListOverrideProperty::ListOverrideLevels::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
int nOverrideCount = (int)m_aOverrideLevels.size();
|
||
for (int i = 0; i < nOverrideCount; i++ )
|
||
if ( PROP_DEF == m_aOverrideLevels[i].m_nLevelIndex )
|
||
nOverrideCount--;
|
||
sResult += L"\\listoverridecount" + std::to_wstring( nOverrideCount );
|
||
for (int i = 0; i < nOverrideCount; i++ )
|
||
{
|
||
if ( PROP_DEF != m_aOverrideLevels[i].m_nLevelIndex )
|
||
{
|
||
sResult += L"{\\lfolevel";
|
||
|
||
if ( PROP_DEF != m_aOverrideLevels[i].m_nLevelIndex )
|
||
sResult += L"\\listoverrideformat" + std::to_wstring( m_aOverrideLevels[i].m_nLevelIndex );
|
||
if ( PROP_DEF != m_aOverrideLevels[i].m_nStart )
|
||
sResult += L"\\listoverridestartat" + std::to_wstring( m_aOverrideLevels[i].m_nStart );
|
||
|
||
sResult += m_aOverrideLevels[i].m_oLevel.RenderToRtf(oRenderParameter);
|
||
sResult += L"}";
|
||
}
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfListOverrideProperty::ListOverrideLevels::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
int index_prev = -1, index;
|
||
for (size_t i = 0; i < m_aOverrideLevels.size(); i++ )
|
||
{
|
||
ListOverrideLevel& OverrideLevel = m_aOverrideLevels[i];
|
||
if ( PROP_DEF != OverrideLevel.m_nLevelIndex )
|
||
{
|
||
index = OverrideLevel.m_nLevelIndex;
|
||
}
|
||
else
|
||
{
|
||
index = ++index_prev;
|
||
}
|
||
sResult += L"<w:lvlOverride w:ilvl=\"" + std::to_wstring(index) + L"\">";
|
||
if ( PROP_DEF != OverrideLevel.m_nStart )
|
||
sResult += L"<w:startOverride w:val=\"" + std::to_wstring(OverrideLevel.m_nStart) + L"\"/>";
|
||
if ( PROP_DEF != OverrideLevel.m_nLevelIndex )
|
||
{
|
||
sResult += OverrideLevel.m_oLevel.RenderToOOX2(oRenderParameter, OverrideLevel.m_nLevelIndex);
|
||
}
|
||
else
|
||
{
|
||
sResult += OverrideLevel.m_oLevel.RenderToOOX2(oRenderParameter, index);
|
||
}
|
||
//sResult += OverrideLevel.m_oLevel.RenderToOOX2(oRenderParameter, OverrideLevel.m_nLevelIndex);
|
||
sResult += L"</w:lvlOverride>";
|
||
|
||
index_prev = index;
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfListOverrideProperty::RtfListOverrideProperty()
|
||
{
|
||
SetDefault();
|
||
}
|
||
bool RtfListOverrideProperty::IsValid()
|
||
{
|
||
return PROP_DEF != m_nListID && PROP_DEF != m_nIndex;
|
||
}
|
||
void RtfListOverrideProperty::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY( m_nListID )
|
||
DEFAULT_PROPERTY( m_nIndex )
|
||
m_oOverrideLevels.SetDefault();
|
||
}
|
||
std::wstring RtfListOverrideProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( true == IsValid() )
|
||
{
|
||
sResult += L"\\listoverride";
|
||
RENDER_RTF_INT( m_nListID, sResult, L"listid" )
|
||
RENDER_RTF_INT( m_nIndex, sResult, L"ls" )
|
||
sResult += m_oOverrideLevels.RenderToRtf( oRenderParameter );
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfListOverrideProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( true == IsValid() )
|
||
{
|
||
sResult += L"<w:num w:numId=\"" + std::to_wstring(m_nIndex) + L"\">";
|
||
sResult += L"<w:abstractNumId w:val=\"" + std::to_wstring(m_nListID) + L"\" />";
|
||
sResult += m_oOverrideLevels.RenderToOOX( oRenderParameter );
|
||
sResult += L"</w:num>";
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfStyle::RtfStyle()
|
||
{
|
||
SetDefault();
|
||
}
|
||
bool RtfStyle::IsValid()
|
||
{
|
||
return PROP_DEF != m_nID;
|
||
}
|
||
int RtfStyle::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_STYLE;
|
||
}
|
||
void RtfStyle::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
m_eType = stParagraph;
|
||
m_nID = 0;
|
||
}
|
||
void RtfStyle::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfStyle::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY_DEF( m_eType, st_none )
|
||
DEFAULT_PROPERTY_DEF( m_sName, L"" )
|
||
DEFAULT_PROPERTY_DEF( m_sID, L"" )
|
||
DEFAULT_PROPERTY ( m_nID )
|
||
DEFAULT_PROPERTY ( m_bAdditive )
|
||
DEFAULT_PROPERTY ( m_nBasedOn )
|
||
DEFAULT_PROPERTY ( m_nNext )
|
||
DEFAULT_PROPERTY ( m_bHidden )
|
||
DEFAULT_PROPERTY ( m_nLink )
|
||
DEFAULT_PROPERTY ( m_bLocked )
|
||
DEFAULT_PROPERTY ( m_bPersonal )
|
||
DEFAULT_PROPERTY ( m_bCompose )
|
||
DEFAULT_PROPERTY ( m_bReply )
|
||
DEFAULT_PROPERTY ( m_nSemiHidden )
|
||
DEFAULT_PROPERTY ( m_bQFormat )
|
||
DEFAULT_PROPERTY ( m_nPriority )
|
||
DEFAULT_PROPERTY ( m_bUnhiddenWhenUse )
|
||
}
|
||
void RtfStyle::Merge( RtfStylePtr oStyle )
|
||
{
|
||
RtfStyle& oCurStyle = *oStyle;
|
||
|
||
MERGE_PROPERTY_DEF ( m_eType, oCurStyle, st_none )
|
||
MERGE_PROPERTY_DEF ( m_sName, oCurStyle, L"" )
|
||
MERGE_PROPERTY ( m_nID, oCurStyle )
|
||
MERGE_PROPERTY_DEF ( m_sID, oCurStyle, L"" )
|
||
|
||
MERGE_PROPERTY ( m_bAdditive, oCurStyle )
|
||
MERGE_PROPERTY ( m_nBasedOn, oCurStyle )
|
||
MERGE_PROPERTY ( m_nNext, oCurStyle )
|
||
MERGE_PROPERTY ( m_bHidden, oCurStyle )
|
||
MERGE_PROPERTY ( m_nLink, oCurStyle )
|
||
MERGE_PROPERTY ( m_bLocked, oCurStyle )
|
||
MERGE_PROPERTY ( m_bPersonal, oCurStyle )
|
||
MERGE_PROPERTY ( m_bCompose, oCurStyle )
|
||
MERGE_PROPERTY ( m_bReply, oCurStyle )
|
||
MERGE_PROPERTY ( m_nSemiHidden, oCurStyle )
|
||
MERGE_PROPERTY ( m_bQFormat, oCurStyle )
|
||
MERGE_PROPERTY ( m_nPriority, oCurStyle )
|
||
MERGE_PROPERTY ( m_bUnhiddenWhenUse, oCurStyle )
|
||
}
|
||
bool RtfStyle::operator==( const RtfStyle& oProperty )
|
||
{
|
||
return m_eType == oProperty.m_eType && m_nID == oProperty.m_nID && m_nBasedOn == oProperty.m_nBasedOn &&
|
||
m_nNext == oProperty.m_nNext && m_bHidden == oProperty.m_bHidden && m_nLink == oProperty.m_nLink &&
|
||
m_bLocked == oProperty.m_bLocked && m_bPersonal == oProperty.m_bPersonal && m_bCompose == oProperty.m_bCompose &&
|
||
m_bReply == oProperty.m_bReply && m_nSemiHidden == oProperty.m_nSemiHidden && m_bQFormat == oProperty.m_bQFormat &&
|
||
m_nPriority == oProperty.m_nPriority && m_bUnhiddenWhenUse == oProperty.m_bUnhiddenWhenUse;
|
||
}
|
||
std::wstring RtfStyle::RenderToRtfBegin( RenderParameter oRenderParameter )
|
||
{
|
||
if ( false == IsValid() )
|
||
return L"";
|
||
|
||
std::wstring sResult;
|
||
switch( m_eType )
|
||
{
|
||
case stParagraph : sResult += L"{\\s" + std::to_wstring( m_nID); break;
|
||
case stCharacter : sResult += L"{\\*\\cs" + std::to_wstring( m_nID); break;
|
||
case stSection : sResult += L"{\\*\\ds" + std::to_wstring( m_nID); break;
|
||
case stTable : sResult += L"{\\*\\ts" + std::to_wstring( m_nID) + L"\\tsrowd"; break;
|
||
default: break;
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfStyle::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
return L"";
|
||
}
|
||
std::wstring RtfStyle::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
return L"";
|
||
}
|
||
std::wstring RtfStyle::RenderToOOXBegin(RenderParameter oRenderParameter)
|
||
{
|
||
RtfDocument* poDocument = static_cast<RtfDocument*>( oRenderParameter.poDocument );
|
||
std::wstring sResult;
|
||
std::wstring sType;
|
||
switch( m_eType )
|
||
{
|
||
case stParagraph : sType = L"paragraph"; break;
|
||
case stCharacter : sType = L"character"; break;
|
||
case stSection : sType = L"numbering"; break;
|
||
case stTable : sType = L"table"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if (m_sID.empty())
|
||
{
|
||
m_sID = L"Style_" + std::to_wstring(m_nID);
|
||
}
|
||
sResult += L"<w:style w:type=\"" + sType + L"\" w:styleId=\"" + m_sID + L"\"";
|
||
|
||
if (m_nID == 0 && PROP_DEF == m_nBasedOn)
|
||
{
|
||
sResult += L" w:default=\"1\"";
|
||
}
|
||
|
||
sResult += L">";
|
||
sResult += L"<w:name w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>";
|
||
|
||
if( PROP_DEF != m_nBasedOn )
|
||
{
|
||
RtfStylePtr oBaseStyle;
|
||
if( true == poDocument->m_oStyleTable.GetStyle( m_nBasedOn, oBaseStyle ) )
|
||
{
|
||
sResult += L"<w:basedOn w:val=\"Style_" + std::to_wstring(m_nBasedOn) + L"\"/>";
|
||
//sResult += L"<w:basedOn w:val=\"" + XmlUtils::EncodeXmlString( oBaseStyle->m_sName ) + L"\"/>";
|
||
}
|
||
}
|
||
|
||
//if( PROP_DEF != m_nNext )
|
||
// sResult += L"<w:next w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>", );//Todo
|
||
//if( PROP_DEF != m_nLink )
|
||
// sResult += L"<w:link w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>", );//Todo
|
||
if( 1 == m_bHidden ) sResult += L"<w:hidden/>";
|
||
if( 1 == m_bLocked ) sResult += L"<w:locked/>";
|
||
if( 1 == m_bPersonal ) sResult += L"<w:personal w:val=\"true\" />";
|
||
if( 1 == m_bCompose ) sResult += L"<w:personalCompose w:val=\"true\" />";
|
||
if( 1 == m_bReply ) sResult += L"<w:personalReply w:val=\"true\" />";
|
||
if( 1 == m_nSemiHidden ) sResult += L"<w:semiHidden/>";
|
||
if( 1 == m_bQFormat ) sResult += L"<w:qFormat/>";
|
||
if( 1 == m_bUnhiddenWhenUse ) sResult += L"<w:unhideWhenUsed/>";
|
||
if( PROP_DEF != m_nPriority ) sResult += L"<w:uiPriority w:val=\"" + std::to_wstring(m_nPriority) + L"\"/>";
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfStyle::RenderToOOXEnd(RenderParameter oRenderParameter)
|
||
{
|
||
//if( false == IsValid() )
|
||
// return false;
|
||
std::wstring sResult;
|
||
sResult += L"</w:style>";
|
||
return sResult;
|
||
}
|
||
std::wstring RtfStyle::RenderToRtfEnd( RenderParameter oRenderParameter )
|
||
{
|
||
if( false == IsValid() ) return L"";
|
||
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT ( m_nBasedOn, sResult, L"sbasedon" )
|
||
RENDER_RTF_INT ( m_nNext, sResult, L"snext" )
|
||
RENDER_RTF_BOOL ( m_bHidden, sResult, L"shidden" )
|
||
RENDER_RTF_INT ( m_nLink, sResult, L"slink" )
|
||
RENDER_RTF_BOOL ( m_bLocked, sResult, L"slocked" )
|
||
RENDER_RTF_BOOL ( m_bPersonal, sResult, L"spersonal" )
|
||
RENDER_RTF_BOOL ( m_bCompose, sResult, L"scompose" )
|
||
RENDER_RTF_BOOL ( m_bReply, sResult, L"sreply" )
|
||
RENDER_RTF_BOOL ( m_nSemiHidden, sResult, L"ssemihidden" )
|
||
RENDER_RTF_BOOL ( m_bQFormat, sResult, L"sqformat" )
|
||
RENDER_RTF_INT ( m_nPriority, sResult, L"spriority" )
|
||
RENDER_RTF_BOOL ( m_bUnhiddenWhenUse, sResult, L"sunhideused" )
|
||
|
||
RtfCharProperty* props = NULL;
|
||
sResult += L" " + RtfChar::renderRtfText( m_sName, oRenderParameter.poDocument, props, true) + L";}";
|
||
return sResult;
|
||
}
|
||
|
||
std::wstring RtfCharStyle::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult = RenderToRtfBegin( oRenderParameter ) ;
|
||
sResult += m_oCharProp.RenderToRtf( oRenderParameter );
|
||
sResult += RenderToRtfEnd( oRenderParameter );
|
||
return sResult;
|
||
}
|
||
std::wstring RtfCharStyle::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult = RenderToOOXBegin( oRenderParameter ) ;
|
||
|
||
std::wstring sCharProp = m_oCharProp.RenderToOOX(oRenderParameter);
|
||
if( false == sCharProp.empty() )
|
||
{
|
||
sResult += L"<w:rPr>";
|
||
sResult += sCharProp;
|
||
sResult += L"</w:rPr>";
|
||
}
|
||
sResult += RenderToOOXEnd( oRenderParameter );
|
||
return sResult;
|
||
}
|
||
|
||
std::wstring RtfParagraphStyle::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult = RenderToRtfBegin( oRenderParameter );
|
||
|
||
sResult += m_oParProp.RenderToRtf( oRenderParameter ) ;
|
||
sResult += m_oCharProp.RenderToRtf( oRenderParameter );
|
||
sResult += RenderToRtfEnd( oRenderParameter );
|
||
return sResult;
|
||
}
|
||
std::wstring RtfParagraphStyle::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult = RenderToOOXBegin( oRenderParameter );
|
||
|
||
std::wstring sParProp = m_oParProp.RenderToOOX(oRenderParameter);
|
||
if( false == sParProp.empty() )
|
||
{
|
||
sResult += L"<w:pPr>";
|
||
sResult += sParProp;
|
||
sResult += L"</w:pPr>";
|
||
}
|
||
std::wstring sCharProp = m_oCharProp.RenderToOOX(oRenderParameter);
|
||
if( false == sCharProp.empty() )
|
||
{
|
||
sResult += L"<w:rPr>";
|
||
sResult += sCharProp;
|
||
sResult += L"</w:rPr>";
|
||
}
|
||
sResult += RenderToOOXEnd( oRenderParameter ) ;
|
||
return sResult;
|
||
}
|
||
|
||
//std::wstring RtfTableStyleProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
// {
|
||
// std::wstring sResult;
|
||
// if( m_oShading.IsValid() )
|
||
// sResult += m_oShading.RenderToRtf( oRenderParameter ) );
|
||
// RENDER_RTF_INT( m_nPaddingTop, sResult, L"tscellpaddt" )
|
||
// RENDER_RTF_INT( m_nPaddingLeft, sResult, L"tscellpaddl" )
|
||
// RENDER_RTF_INT( m_nPaddingRight, sResult, L"tscellpaddr" )
|
||
// RENDER_RTF_INT( m_nPaddingBottom, sResult, L"tscellpaddb" )
|
||
|
||
// RENDER_RTF_INT( m_ePaddingTopUnit, sResult, L"tscellpaddft" )
|
||
// RENDER_RTF_INT( m_ePaddingLeftUnit, sResult, L"tscellpaddfl" )
|
||
// RENDER_RTF_INT( m_ePaddingRightUnit, sResult, L"tscellpaddfr" )
|
||
// RENDER_RTF_INT( m_ePaddingBottomUnit, sResult, L"tscellpaddfb" )
|
||
//
|
||
// switch( m_eAlign )
|
||
// {
|
||
// case av_tsvertalt: sResult += L"\\tsvertalt";break;
|
||
// case av_tsvertalc: sResult += L"\\tsvertalc";break;
|
||
// case av_tsvertalb: sResult += L"\\tsvertalb";break;
|
||
//
|
||
// }
|
||
// RENDER_RTF_BOOL( m_bNoCellWrap, sResult, L"tsnowrap" )
|
||
//
|
||
// if( true == m_oCellTopBorder.IsValid() )
|
||
// {
|
||
// sResult += L"\\tsbrdrt";
|
||
// sResult += m_oCellTopBorder.RenderToRtf( oRenderParameter ) );
|
||
// }
|
||
// if( true == m_oCellBottomBorder.IsValid() )
|
||
// {
|
||
// sResult += L"\\tsbrdrb";
|
||
// sResult += m_oCellBottomBorder.RenderToRtf( oRenderParameter ) );
|
||
// }
|
||
// if( true == m_oCellLeftBorder.IsValid() )
|
||
// {
|
||
// sResult += L"\\tsbrdrl";
|
||
// sResult += m_oCellLeftBorder.RenderToRtf( oRenderParameter ) );
|
||
// }
|
||
// if( true == m_oCellRightBorder.IsValid() )
|
||
// {
|
||
// sResult += L"\\tsbrdrr";
|
||
// sResult += m_oCellRightBorder.RenderToRtf( oRenderParameter ) );
|
||
// }
|
||
// if( true == m_oCellHorBorder.IsValid() )
|
||
// {
|
||
// sResult += L"\\tsbrdrh";
|
||
// sResult += m_oCellHorBorder.RenderToRtf( oRenderParameter ) );
|
||
// }
|
||
// if( true == m_oCellVerBorder.IsValid() )
|
||
// {
|
||
// sResult += L"\\tsbrdrv";
|
||
// sResult += m_oCellVerBorder.RenderToRtf( oRenderParameter ) );
|
||
// }
|
||
// RENDER_RTF_INT( m_nRowBandNumber, sResult, L"tscbandsh" )
|
||
// RENDER_RTF_INT( m_nCellBandNumber, sResult, L"tscbandsv" )
|
||
//
|
||
// return sResult;
|
||
// }
|
||
//std::wstring RtfTableStyleProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
// {
|
||
// std::wstring sResult;
|
||
// return sResult;
|
||
// }
|
||
|
||
std::wstring RtfTableStyle::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult = RenderToRtfBegin( oRenderParameter ) ;
|
||
|
||
RenderParameter oNewParameter = oRenderParameter;
|
||
oNewParameter.nType = RENDER_TO_RTF_PARAM_NO_WROWD;
|
||
|
||
sResult += m_oTableProp.RenderToRtf( oNewParameter );
|
||
sResult += m_oRowProp.RenderToRtf( oNewParameter );
|
||
//sResult += m_oTableStyleProperty.RenderToRtf( oRenderParameter );
|
||
sResult += m_oParProp.RenderToRtf( oRenderParameter );
|
||
sResult += m_oCharProp.RenderToRtf( oRenderParameter );
|
||
sResult += RenderToRtfEnd( oRenderParameter );
|
||
|
||
if( NULL != m_oFirstRow ) sResult += m_oFirstRow->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oLastRow ) sResult += m_oLastRow->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oFirstCol ) sResult += m_oFirstCol->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oLastCol ) sResult += m_oLastCol->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oBandHorEven )sResult += m_oBandHorEven->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oBandVerEven )sResult += m_oBandVerEven->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oBandHorOdd ) sResult += m_oBandHorOdd->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oBandVerOdd ) sResult += m_oBandVerOdd->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oNWCell ) sResult += m_oNWCell->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oNECell ) sResult += m_oNECell->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oSWCell ) sResult += m_oSWCell->RenderToRtf( oRenderParameter );
|
||
if( NULL != m_oSECell ) sResult += m_oSECell->RenderToRtf( oRenderParameter );
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfTableStyle::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( RENDER_TO_OOX_PARAM_NESTED != oRenderParameter.nType )
|
||
{
|
||
sResult += RenderToOOXBegin( oRenderParameter ) ;
|
||
|
||
std::wstring sTablProp = m_oTableProp.RenderToOOX(oRenderParameter);
|
||
if( false == sTablProp.empty() )
|
||
{
|
||
sResult += L"<w:tblPr>";
|
||
sResult += sTablProp;
|
||
sResult += L"</w:tblPr>";
|
||
}
|
||
std::wstring sRowProp = m_oRowProp.RenderToOOX(oRenderParameter);
|
||
if( false == sRowProp.empty() )
|
||
{
|
||
sResult += L"<w:trPr>";
|
||
sResult += sRowProp;
|
||
sResult += L"</w:trPr>";
|
||
}
|
||
std::wstring sCellProp = m_oCellProp.RenderToOOX(oRenderParameter);
|
||
if( false == sCellProp.empty() )
|
||
{
|
||
sResult += L"<w:tcPr>";
|
||
sResult += sCellProp;
|
||
sResult += L"</w:tcPr>";
|
||
}
|
||
std::wstring sParProp = m_oParProp.RenderToOOX(oRenderParameter);
|
||
if( false == sParProp.empty() )
|
||
{
|
||
sResult += L"<w:pPr>";
|
||
sResult += sParProp;
|
||
sResult += L"</w:pPr>";
|
||
}
|
||
std::wstring sCharProp = m_oCharProp.RenderToOOX(oRenderParameter);
|
||
if( false == sCharProp.empty() )
|
||
{
|
||
sResult += L"<w:rPr>";
|
||
sResult += sCharProp;
|
||
sResult += L"</w:rPr>";
|
||
}
|
||
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_NESTED;
|
||
|
||
if( NULL != m_oFirstRow )
|
||
{
|
||
oNewParam.sValue = L"firstRow";
|
||
sResult += m_oFirstRow->RenderToOOX(oNewParam) ;
|
||
}
|
||
if( NULL != m_oLastRow )
|
||
{
|
||
oNewParam.sValue = L"lastRow";
|
||
sResult += m_oLastRow->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oFirstCol )
|
||
{
|
||
oNewParam.sValue = L"firstCol";
|
||
sResult += m_oFirstCol->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oLastCol )
|
||
{
|
||
oNewParam.sValue = L"lastCol";
|
||
sResult += m_oLastCol->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oBandHorEven )
|
||
{
|
||
oNewParam.sValue = L"band2Horz";
|
||
sResult += m_oBandHorEven->RenderToOOX(oNewParam) ;
|
||
}
|
||
if( NULL != m_oBandVerEven )
|
||
{
|
||
oNewParam.sValue = L"band2Vert";
|
||
sResult += m_oBandVerEven->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oBandHorOdd )
|
||
{
|
||
oNewParam.sValue = L"band1Horz";
|
||
sResult += m_oBandHorOdd->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oBandVerOdd )
|
||
{
|
||
oNewParam.sValue = L"band1Vert";
|
||
sResult += m_oBandVerOdd->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oNWCell )
|
||
{
|
||
oNewParam.sValue = L"nwCell";
|
||
sResult += m_oNWCell->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oNECell )
|
||
{
|
||
oNewParam.sValue = L"neCell";
|
||
sResult += m_oNECell->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oSWCell )
|
||
{
|
||
oNewParam.sValue = L"swCell";
|
||
sResult += m_oSWCell->RenderToOOX(oNewParam);
|
||
}
|
||
if( NULL != m_oSECell )
|
||
{
|
||
oNewParam.sValue = L"seCell";
|
||
sResult += m_oSECell->RenderToOOX(oNewParam);
|
||
}
|
||
sResult += RenderToOOXEnd( oRenderParameter ) ;
|
||
}
|
||
else
|
||
{
|
||
sResult += L"<w:tblStylePr w:type=\"" + oRenderParameter.sValue + L"\">";
|
||
|
||
std::wstring sTablProp = m_oTableProp.RenderToOOX(oRenderParameter);
|
||
if( false == sTablProp.empty() )
|
||
{
|
||
sResult += L"<w:tblPr>";
|
||
sResult += sTablProp;
|
||
sResult += L"</w:tblPr>";
|
||
}
|
||
std::wstring sRowProp = m_oRowProp.RenderToOOX(oRenderParameter);
|
||
if( false == sRowProp.empty() )
|
||
{
|
||
sResult += L"<w:trPr>";
|
||
sResult += sRowProp;
|
||
sResult += L"</w:trPr>";
|
||
}
|
||
std::wstring sCellProp = m_oCellProp.RenderToOOX(oRenderParameter);
|
||
if( false == sCellProp.empty() )
|
||
{
|
||
sResult += L"<w:tcPr>";
|
||
sResult += sCellProp;
|
||
sResult += L"</w:tcPr>";
|
||
}
|
||
std::wstring sParProp = m_oParProp.RenderToOOX(oRenderParameter);
|
||
if( false == sParProp.empty() )
|
||
{
|
||
sResult += L"<w:pPr>";
|
||
sResult += sParProp;
|
||
sResult += L"</w:pPr>";
|
||
}
|
||
std::wstring sCharProp = m_oCharProp.RenderToOOX(oRenderParameter);
|
||
if( false == sCharProp.empty() )
|
||
{
|
||
sResult += L"<w:rPr>";
|
||
sResult += sCharProp;
|
||
sResult += L"</w:rPr>";
|
||
}
|
||
sResult += L"</w:tblStylePr>" ;
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfTab::RtfTab()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTab::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTab::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTab::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY ( m_nTab );
|
||
DEFAULT_PROPERTY_DEF( m_eLeader, tl_none );
|
||
DEFAULT_PROPERTY_DEF( m_eKind, tk_tql );
|
||
}
|
||
std::wstring RtfTab::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( PROP_DEF != m_nTab )
|
||
{
|
||
if( tk_tqbar == m_eKind )
|
||
{
|
||
switch( m_eLeader )
|
||
{
|
||
case tl_dot: sResult += L"\\tldot"; break;
|
||
case tl_mdot: sResult += L"\\tlmdot"; break;
|
||
case tl_hyph: sResult += L"\\tlhyph"; break;
|
||
case tl_ul: sResult += L"\\tlul"; break;
|
||
default:
|
||
break;
|
||
}
|
||
sResult += L"\\tb" + std::to_wstring( m_nTab );
|
||
}
|
||
else
|
||
{
|
||
switch( m_eLeader )
|
||
{
|
||
case tl_dot: sResult += L"\\tldot"; break;
|
||
case tl_mdot: sResult += L"\\tlmdot"; break;
|
||
case tl_hyph: sResult += L"\\tlhyph"; break;
|
||
case tl_ul: sResult += L"\\tlul"; break;
|
||
default:
|
||
break;
|
||
}
|
||
switch( m_eKind )
|
||
{
|
||
case tk_tqr: sResult += L"\\tqr"; break;
|
||
case tk_tqc: sResult += L"\\tqc"; break;
|
||
case tk_tqdec: sResult += L"\\tqdec"; break;
|
||
default:
|
||
break;
|
||
}
|
||
sResult += L"\\tx" + std::to_wstring( m_nTab );
|
||
}
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfTab::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
std::wstring sTab;
|
||
switch( m_eLeader )
|
||
{
|
||
case tl_dot: sTab += L" w:leader=\"dot\""; break;
|
||
case tl_mdot: sTab += L" w:leader=\"middleDot\""; break;
|
||
case tl_hyph: sTab += L" w:leader=\"hyphen\""; break;
|
||
case tl_ul: sTab += L" w:leader=\"underscore\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
switch( m_eKind )
|
||
{
|
||
case tk_tql: sTab += L" w:val=\"left\""; break;
|
||
case tk_tqr: sTab += L" w:val=\"right\""; break;
|
||
case tk_tqc: sTab += L" w:val=\"center\""; break;
|
||
case tk_tqdec: sTab += L" w:val=\"decimal\""; break;
|
||
case tk_tqbar: sTab += L" w:val=\"bar\""; break;
|
||
case tk_tqclear:sTab += L" w:val=\"clear\""; break;
|
||
case tk_tqnum: sTab += L" w:val=\"num\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( PROP_DEF != m_nTab )
|
||
sTab += L" w:pos=\"" + std::to_wstring(m_nTab) + L"\"";
|
||
|
||
if( false == sTab.empty() )
|
||
sResult = L"<w:tab " + sTab + L"/>";
|
||
return sResult;
|
||
}
|
||
|
||
RtfTabs::RtfTabs()
|
||
{
|
||
SetDefault();
|
||
}
|
||
|
||
void RtfTabs::Merge( const RtfTabs& oTabs )
|
||
{
|
||
m_aTabs.clear();
|
||
m_aTabs = oTabs.m_aTabs ;
|
||
}
|
||
void RtfTabs::SetDefault()
|
||
{
|
||
m_aTabs.clear();
|
||
}
|
||
std::wstring RtfTabs::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
for (size_t i = 0; i < (int)m_aTabs.size(); i++ )
|
||
{
|
||
sResult += m_aTabs[i].RenderToRtf( oRenderParameter );
|
||
}
|
||
return sResult;
|
||
}
|
||
std::wstring RtfTabs::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sTabs;
|
||
for (size_t i = 0; i < m_aTabs.size(); i++ )
|
||
{
|
||
sTabs += m_aTabs[i].RenderToOOX( oRenderParameter );
|
||
}
|
||
|
||
std::wstring sResult;
|
||
if ( !sTabs.empty() )
|
||
sResult += L"<w:tabs>" + sTabs + L"</w:tabs>";
|
||
|
||
return sResult;
|
||
}
|
||
|
||
RtfFrame::RtfFrame()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfFrame::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfFrame::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfFrame::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY ( m_nWidth )
|
||
DEFAULT_PROPERTY ( m_nHeight )
|
||
DEFAULT_PROPERTY_DEF ( m_eHRef, hr_none )
|
||
DEFAULT_PROPERTY_DEF ( m_eVRef, vr_none )
|
||
DEFAULT_PROPERTY_DEF ( m_eHPos, hp_none )
|
||
DEFAULT_PROPERTY_DEF ( m_eVPos, vp_none )
|
||
DEFAULT_PROPERTY ( m_nHPos )
|
||
DEFAULT_PROPERTY ( m_nVPos )
|
||
DEFAULT_PROPERTY ( m_bLockAnchor )
|
||
DEFAULT_PROPERTY_DEF ( m_eWrap, tw_none )
|
||
DEFAULT_PROPERTY ( m_DropcapType )
|
||
DEFAULT_PROPERTY ( m_DropcapLines )
|
||
DEFAULT_PROPERTY ( m_nHorSpace )
|
||
DEFAULT_PROPERTY ( m_nVerSpace )
|
||
DEFAULT_PROPERTY ( m_nAllSpace )
|
||
}
|
||
void RtfFrame::Merge( RtfFrame& oFramePr )
|
||
{
|
||
MERGE_PROPERTY ( m_nWidth, oFramePr )
|
||
MERGE_PROPERTY ( m_nHeight, oFramePr )
|
||
MERGE_PROPERTY_DEF ( m_eHRef, oFramePr, hr_none )
|
||
MERGE_PROPERTY_DEF ( m_eVRef, oFramePr, vr_none )
|
||
MERGE_PROPERTY_DEF ( m_eHPos, oFramePr, hp_none )
|
||
MERGE_PROPERTY_DEF ( m_eVPos, oFramePr, vp_none )
|
||
MERGE_PROPERTY ( m_bLockAnchor, oFramePr )
|
||
MERGE_PROPERTY_DEF ( m_eWrap, oFramePr, tw_none )
|
||
MERGE_PROPERTY ( m_DropcapType, oFramePr )
|
||
MERGE_PROPERTY ( m_DropcapLines, oFramePr )
|
||
MERGE_PROPERTY ( m_nHorSpace, oFramePr )
|
||
MERGE_PROPERTY ( m_nVerSpace, oFramePr )
|
||
MERGE_PROPERTY ( m_nAllSpace, oFramePr )
|
||
}
|
||
void RtfFrame::ApplyParagraphProp( RtfTableProperty& oProp )
|
||
{
|
||
m_nHPos = oProp.m_nHPos;
|
||
m_nVPos = oProp.m_nVPos;
|
||
switch ( oProp.m_eHRef )
|
||
{
|
||
case RtfTableProperty::hr_phmrg: m_eHRef = hr_phmrg;break;
|
||
case RtfTableProperty::hr_phpg: m_eHRef = hr_phpg;break;
|
||
case RtfTableProperty::hr_phcol: m_eHRef = hr_phcol;break;
|
||
default: break;
|
||
}
|
||
switch ( oProp.m_eVRef )
|
||
{
|
||
case RtfTableProperty::vr_pvmrg: m_eVRef = vr_pvmrg;break;
|
||
case RtfTableProperty::vr_pvpg: m_eVRef = vr_pvpg;break;
|
||
case RtfTableProperty::vr_pvpara: m_eVRef = vr_pvpara;break;
|
||
default: break;
|
||
}
|
||
switch ( oProp.m_eHPos )
|
||
{
|
||
case RtfTableProperty::hp_posxc: m_eHPos = hp_posxc;break;
|
||
case RtfTableProperty::hp_posxi: m_eHPos = hp_posxi;break;
|
||
case RtfTableProperty::hp_posxo: m_eHPos = hp_posxo;break;
|
||
case RtfTableProperty::hp_posxl: m_eHPos = hp_posxl;break;
|
||
case RtfTableProperty::hp_posxr: m_eHPos = hp_posxr;break;
|
||
default: break;
|
||
}
|
||
switch ( oProp.m_eVPos )
|
||
{
|
||
case RtfTableProperty::vp_posyc: m_eVPos = vp_posyc;break;
|
||
case RtfTableProperty::vp_posyin: m_eVPos = vp_posyin;break;
|
||
case RtfTableProperty::vp_posyout: m_eVPos = vp_posyout;break;
|
||
case RtfTableProperty::vp_posyt: m_eVPos = vp_posyt;break;
|
||
case RtfTableProperty::vp_posyb: m_eVPos = vp_posyb;break;
|
||
default: break;
|
||
}
|
||
}
|
||
std::wstring RtfFrame::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT( m_nWidth, sResult, L"absw" )
|
||
RENDER_RTF_INT( m_nHeight, sResult, L"absh" )
|
||
switch ( m_eHRef )
|
||
{
|
||
case hr_phmrg: sResult += L"\\phmrg"; break;
|
||
case hr_phpg: sResult += L"\\phpg"; break;
|
||
case hr_phcol: sResult += L"\\phcol"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( PROP_DEF != m_nHPos )
|
||
{
|
||
if( m_nHPos > 0 )
|
||
sResult += L"\\posx" + std::to_wstring(m_nHPos);
|
||
else
|
||
sResult += L"\\posnegx" + std::to_wstring(m_nHPos);
|
||
}
|
||
switch ( m_eHPos )
|
||
{
|
||
case hp_posxc: sResult += L"\\posxc"; break;
|
||
case hp_posxi: sResult += L"\\posxi"; break;
|
||
case hp_posxo: sResult += L"\\posxo"; break;
|
||
case hp_posxl: sResult += L"\\posxl"; break;
|
||
case hp_posxr: sResult += L"\\posxr"; break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
switch ( m_eVRef )
|
||
{
|
||
case vr_pvmrg: sResult += L"\\pvmrg"; break;
|
||
case vr_pvpg: sResult += L"\\pvpg"; break;
|
||
case vr_pvpara: sResult += L"\\pvpara"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( PROP_DEF != m_nVPos )
|
||
{
|
||
if( m_nVPos > 0 )
|
||
sResult += L"\\posy" + std::to_wstring(m_nVPos);
|
||
else
|
||
sResult += L"\\posnegy" + std::to_wstring(m_nVPos);
|
||
}
|
||
switch ( m_eVPos )
|
||
{
|
||
case vp_posyt: sResult += L"\\posyt"; break;
|
||
case vp_posyil: sResult += L"\\posyil"; break;
|
||
case vp_posyb: sResult += L"\\posyb"; break;
|
||
case vp_posyc: sResult += L"\\posyc"; break;
|
||
case vp_posyin: sResult += L"\\posyin"; break;
|
||
case vp_posyout: sResult += L"\\posyout"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_bLockAnchor, sResult, L"abslock" )
|
||
|
||
switch ( m_eWrap )
|
||
{
|
||
case tw_wrapdefault: sResult += L"\\wrapdefault"; break;
|
||
case tw_wraparound: sResult += L"\\wraparound"; break;
|
||
case tw_wraptight: sResult += L"\\wraptight"; break;
|
||
case tw_wrapthrough: sResult += L"\\wrapthrough"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_DropcapType, sResult, L"dropcapt" )
|
||
RENDER_RTF_INT( m_DropcapLines, sResult, L"dropcapli" )
|
||
|
||
RENDER_RTF_INT( m_nHorSpace, sResult, L"dfrmtxtx" )
|
||
RENDER_RTF_INT( m_nVerSpace, sResult, L"dfrmtxty" )
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfFrame::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
std::wstring sFrame;
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nWidth, sFrame, L"w:w" )
|
||
if(PROP_DEF != m_nHeight)
|
||
{
|
||
if( m_nHeight > 0 )
|
||
{
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nHeight, sFrame, L"w:h" )
|
||
sFrame += L" w:hRule=\"atLeast\"";
|
||
}
|
||
else if( m_nHeight == 0 )
|
||
{
|
||
sFrame += L" w:hRule=\"auto\"";
|
||
}
|
||
else
|
||
{
|
||
m_nHeight *= -1;
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nHeight, sFrame, L"w:h" )
|
||
sFrame += L" w:hRule=\"exact\"";
|
||
}
|
||
}
|
||
|
||
switch ( m_eHRef )
|
||
{
|
||
case hr_phmrg: sFrame += L" w:hAnchor=\"margin\""; break;
|
||
case hr_phpg: sFrame += L" w:hAnchor=\"page\""; break;
|
||
case hr_phcol: sFrame += L" w:hAnchor=\"text\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nHPos, sFrame, L"w:x" )
|
||
switch ( m_eHPos )
|
||
{
|
||
case hp_posxc: sFrame += L" w:xAlign=\"center\""; break;
|
||
case hp_posxi: sFrame += L" w:xAlign=\"inside\""; break;
|
||
case hp_posxo: sFrame += L" w:xAlign=\"outside\""; break;
|
||
case hp_posxl: sFrame += L" w:xAlign=\"left\""; break;
|
||
case hp_posxr: sFrame += L" w:xAlign=\"right\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
switch ( m_eVRef )
|
||
{
|
||
case vr_pvmrg: sFrame += L" w:vAnchor=\"margin\""; break;
|
||
case vr_pvpg: sFrame += L" w:vAnchor=\"page\""; break;
|
||
case vr_pvpara: sFrame += L" w:vAnchor=\"text\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nVPos, sFrame, L"w:y" )
|
||
switch ( m_eVPos )
|
||
{
|
||
case vp_posyt: sFrame += L" w:yAlign=\"top\""; break;
|
||
case vp_posyil: sFrame += L" w:yAlign=\"inline\""; break;
|
||
case vp_posyb: sFrame += L" w:yAlign=\"bottom\""; break;
|
||
case vp_posyc: sFrame += L" w:yAlign=\"center\""; break;
|
||
case vp_posyin: sFrame += L" w:yAlign=\"inside\""; break;
|
||
case vp_posyout: sFrame += L" w:yAlign=\"outside\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_OOX_BOOL_ATTRIBUTE( m_bLockAnchor, sFrame, L"w:anchorLock" )
|
||
switch ( m_eWrap )
|
||
{
|
||
//case tw_wrapdefault: sFrame += L" w:wrap=\"auto\"");break;
|
||
case tw_wraparound: sFrame += L" w:wrap=\"around\""; break;
|
||
case tw_wraptight: sFrame += L" w:wrap=\"tight\""; break;
|
||
case tw_wrapthrough: sFrame += L" w:wrap=\"through\""; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( 1 == m_DropcapType ) sFrame += L" w:dropCap=\"drop\"";
|
||
else if( 2 == m_DropcapType ) sFrame += L" w:dropCap=\"margin\"";
|
||
|
||
RENDER_OOX_INT_ATTRIBUTE( m_DropcapLines, sFrame, L"w:lines" )
|
||
|
||
if( PROP_DEF != m_nHorSpace ) sFrame += L" w:hSpace=\"" + std::to_wstring(m_nHorSpace) + L"\"";
|
||
else if( PROP_DEF != m_nAllSpace ) sFrame += L" w:hSpace=\"" + std::to_wstring(m_nAllSpace) + L"\"";
|
||
|
||
if( PROP_DEF != m_nVerSpace ) sFrame += L" w:vSpace=\"" + std::to_wstring(m_nVerSpace) + L"\"";
|
||
else if( PROP_DEF != m_nAllSpace ) sFrame += L" w:vSpace=\"" + std::to_wstring(m_nAllSpace) + L"\"";
|
||
|
||
if( !sFrame.empty() )
|
||
{
|
||
sResult = L"<w:framePr " + sFrame + L"/>";
|
||
|
||
sResult += L"<w:widowControl w:val=\"0\"/>";
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfParagraphProperty::RtfParagraphProperty()
|
||
{
|
||
SetDefault();
|
||
}
|
||
bool RtfParagraphProperty::IsValid()
|
||
{
|
||
return true;
|
||
}
|
||
void RtfParagraphProperty::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
|
||
m_nSpaceBefore = 0; // 137.rtf
|
||
//4.1 Наряд_R7_M133.rtf
|
||
m_nSpaceAfter = 0;
|
||
m_nSpaceBetween = 240;
|
||
}
|
||
void RtfParagraphProperty::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfParagraphProperty::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY( m_bAutoHyphenation )
|
||
DEFAULT_PROPERTY( m_bInTable )
|
||
DEFAULT_PROPERTY( m_nItap )
|
||
DEFAULT_PROPERTY( m_bKeep )
|
||
DEFAULT_PROPERTY( m_bKeepNext )
|
||
DEFAULT_PROPERTY( m_bPageBB )
|
||
DEFAULT_PROPERTY( m_nOutlinelevel )
|
||
DEFAULT_PROPERTY( m_nStyle )
|
||
DEFAULT_PROPERTY( m_eAlign )
|
||
|
||
m_eFontAlign = fa_none;
|
||
|
||
DEFAULT_PROPERTY( m_nIndFirstLine )
|
||
DEFAULT_PROPERTY( m_nIndLeft)
|
||
DEFAULT_PROPERTY( m_nIndRight)
|
||
DEFAULT_PROPERTY( m_nIndStart )
|
||
DEFAULT_PROPERTY( m_nIndEnd )
|
||
DEFAULT_PROPERTY( m_bIndRightAuto )
|
||
DEFAULT_PROPERTY( m_bIndMirror )
|
||
|
||
DEFAULT_PROPERTY( m_nSpaceBefore )
|
||
|
||
DEFAULT_PROPERTY( m_nSpaceAfter )
|
||
DEFAULT_PROPERTY( m_nSpaceBeforeAuto )
|
||
DEFAULT_PROPERTY( m_nSpaceAfterAuto )
|
||
DEFAULT_PROPERTY( m_nSpaceAfterLine )
|
||
DEFAULT_PROPERTY( m_nSpaceBeforeLine )
|
||
DEFAULT_PROPERTY( m_nSpaceBetween )
|
||
DEFAULT_PROPERTY( m_nSpaceMultiLine )
|
||
DEFAULT_PROPERTY( m_bContextualSpacing )
|
||
|
||
DEFAULT_PROPERTY( m_bRtl )
|
||
DEFAULT_PROPERTY( m_bNoWordWrap )
|
||
DEFAULT_PROPERTY( m_bSnapToGrid )
|
||
|
||
m_eTextBoxWrap = tbw_none;
|
||
|
||
DEFAULT_PROPERTY( m_nListId )
|
||
DEFAULT_PROPERTY( m_nListLevel )
|
||
|
||
m_oShading.SetDefault();
|
||
|
||
m_oBorderTop.SetDefault();
|
||
m_oBorderLeft.SetDefault();
|
||
m_oBorderBottom.SetDefault();
|
||
m_oBorderRight.SetDefault();
|
||
m_oBorderBox.SetDefault();
|
||
m_oBorderBar.SetDefault();
|
||
|
||
m_oFrame.SetDefault();
|
||
DEFAULT_PROPERTY( m_bOverlap )
|
||
m_eTextFollow = tf_none;
|
||
m_oTabs.SetDefault();
|
||
|
||
DEFAULT_PROPERTY( m_nTableStyle )
|
||
DEFAULT_PROPERTY( m_bStyleFirstRow )
|
||
DEFAULT_PROPERTY( m_bStyleLastRow )
|
||
DEFAULT_PROPERTY( m_bStyleFirstCollumn )
|
||
DEFAULT_PROPERTY( m_bStyleLastCollumn )
|
||
DEFAULT_PROPERTY( m_bStyleOddRowBand )
|
||
DEFAULT_PROPERTY( m_bStyleOddColBand )
|
||
DEFAULT_PROPERTY( m_bStyleEvenRowBand )
|
||
DEFAULT_PROPERTY( m_bStyleEvenColBand )
|
||
DEFAULT_PROPERTY( m_bStyleNWCell )
|
||
DEFAULT_PROPERTY( m_bStyleNECell )
|
||
DEFAULT_PROPERTY( m_bStyleSWCell )
|
||
DEFAULT_PROPERTY( m_bStyleSECell )
|
||
|
||
DEFAULT_PROPERTY( m_nPrAuth)
|
||
DEFAULT_PROPERTY( m_nPrDate)
|
||
|
||
m_oCharProperty.SetDefault();
|
||
|
||
m_bHidden = false;
|
||
m_bList = false;
|
||
m_pOldParagraphProp = RtfParagraphPropertyPtr();
|
||
}
|
||
void RtfParagraphProperty::Merge( RtfParagraphProperty& oParPr )
|
||
{
|
||
MERGE_PROPERTY ( m_bAutoHyphenation, oParPr )
|
||
MERGE_PROPERTY ( m_bInTable, oParPr )
|
||
MERGE_PROPERTY ( m_nItap, oParPr )
|
||
MERGE_PROPERTY ( m_bKeep, oParPr )
|
||
MERGE_PROPERTY ( m_bKeepNext, oParPr )
|
||
MERGE_PROPERTY ( m_bPageBB, oParPr )
|
||
MERGE_PROPERTY ( m_nOutlinelevel, oParPr )
|
||
MERGE_PROPERTY ( m_nStyle, oParPr )
|
||
MERGE_PROPERTY ( m_eAlign, oParPr )
|
||
MERGE_PROPERTY_DEF ( m_eFontAlign, oParPr, fa_none )
|
||
MERGE_PROPERTY ( m_nIndFirstLine, oParPr )
|
||
MERGE_PROPERTY ( m_nIndLeft, oParPr )
|
||
MERGE_PROPERTY ( m_nIndRight, oParPr )
|
||
MERGE_PROPERTY ( m_nIndStart, oParPr )
|
||
MERGE_PROPERTY ( m_nIndEnd, oParPr )
|
||
MERGE_PROPERTY ( m_bIndRightAuto, oParPr )
|
||
MERGE_PROPERTY ( m_bIndMirror, oParPr )
|
||
|
||
MERGE_PROPERTY ( m_nSpaceBefore, oParPr )
|
||
MERGE_PROPERTY ( m_nSpaceAfter, oParPr )
|
||
MERGE_PROPERTY ( m_nSpaceBeforeAuto, oParPr )
|
||
MERGE_PROPERTY ( m_nSpaceAfterAuto, oParPr )
|
||
MERGE_PROPERTY ( m_nSpaceBeforeLine, oParPr )
|
||
MERGE_PROPERTY ( m_nSpaceAfterLine, oParPr )
|
||
MERGE_PROPERTY ( m_nSpaceBetween, oParPr )
|
||
MERGE_PROPERTY ( m_nSpaceMultiLine, oParPr )
|
||
MERGE_PROPERTY ( m_bSnapToGrid, oParPr )
|
||
MERGE_PROPERTY ( m_bContextualSpacing, oParPr )
|
||
|
||
MERGE_PROPERTY ( m_bRtl, oParPr )
|
||
MERGE_PROPERTY ( m_bNoWordWrap, oParPr )
|
||
MERGE_PROPERTY_DEF ( m_eTextBoxWrap, oParPr, tbw_none )
|
||
|
||
MERGE_PROPERTY ( m_nListId, oParPr )
|
||
MERGE_PROPERTY ( m_nListLevel, oParPr )
|
||
|
||
m_oShading.Merge ( oParPr.m_oShading );
|
||
m_oBorderTop.Merge ( oParPr.m_oBorderTop );
|
||
m_oBorderLeft.Merge ( oParPr.m_oBorderLeft );
|
||
m_oBorderBottom.Merge ( oParPr.m_oBorderBottom );
|
||
m_oBorderRight.Merge ( oParPr.m_oBorderRight );
|
||
m_oBorderBox.Merge ( oParPr.m_oBorderBox );
|
||
m_oBorderBar.Merge ( oParPr.m_oBorderBar );
|
||
m_oFrame.Merge ( oParPr.m_oFrame );
|
||
m_oTabs.Merge ( oParPr.m_oTabs );
|
||
|
||
MERGE_PROPERTY ( m_bOverlap, oParPr )
|
||
MERGE_PROPERTY_DEF ( m_eTextFollow, oParPr, tf_none )
|
||
|
||
MERGE_PROPERTY( m_nTableStyle, oParPr )
|
||
MERGE_PROPERTY( m_bStyleFirstRow, oParPr )
|
||
MERGE_PROPERTY( m_bStyleLastRow, oParPr )
|
||
MERGE_PROPERTY( m_bStyleFirstCollumn, oParPr )
|
||
MERGE_PROPERTY( m_bStyleLastCollumn, oParPr )
|
||
MERGE_PROPERTY( m_bStyleOddRowBand, oParPr )
|
||
MERGE_PROPERTY( m_bStyleEvenRowBand, oParPr )
|
||
MERGE_PROPERTY( m_bStyleOddColBand, oParPr )
|
||
MERGE_PROPERTY( m_bStyleEvenColBand, oParPr )
|
||
MERGE_PROPERTY( m_bStyleNWCell, oParPr )
|
||
MERGE_PROPERTY( m_bStyleNECell, oParPr )
|
||
MERGE_PROPERTY( m_bStyleSWCell, oParPr )
|
||
MERGE_PROPERTY( m_bStyleSECell, oParPr )
|
||
|
||
MERGE_PROPERTY( m_nPrAuth, oParPr )
|
||
MERGE_PROPERTY( m_nPrDate, oParPr )
|
||
|
||
//m_oCharProperty.Merge( oParPr.m_oCharProperty );
|
||
}
|
||
std::wstring RtfParagraphProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_INT ( m_nStyle , sResult, L"s" ); //test
|
||
RENDER_RTF_BOOL ( m_bAutoHyphenation , sResult, L"hyphpar" );
|
||
RENDER_RTF_BOOL ( m_bInTable , sResult, L"intbl" );
|
||
|
||
if( PROP_DEF != m_nItap && 1 != m_nItap )
|
||
sResult += L"\\itap" + std::to_wstring(m_nItap );
|
||
|
||
RENDER_RTF_BOOL ( m_bKeep , sResult, L"keep" );
|
||
RENDER_RTF_BOOL ( m_bKeepNext , sResult, L"keepn" );
|
||
RENDER_RTF_INT ( m_nOutlinelevel , sResult, L"outlinelevel" );
|
||
RENDER_RTF_BOOL ( m_bPageBB , sResult, L"pagebb" );
|
||
|
||
|
||
switch(m_eAlign)
|
||
{
|
||
case pa_qc: sResult += L"\\qc"; break;
|
||
case pa_qj: sResult += L"\\qj"; break;
|
||
case pa_ql: sResult += L"\\ql"; break;
|
||
case pa_qr: sResult += L"\\qr"; break;
|
||
case pa_qd: sResult += L"\\qd"; break;
|
||
case pa_qk0: sResult += L"\\qk0"; break;
|
||
case pa_qk10: sResult += L"\\qk10"; break;
|
||
case pa_qk20: sResult += L"\\qk20"; break;
|
||
default:
|
||
break;
|
||
}
|
||
switch( m_eFontAlign )
|
||
{
|
||
case fa_faauto: sResult += L"\\faauto"; break;
|
||
case fa_fahang: sResult += L"\\fahang"; break;
|
||
case fa_facenter: sResult += L"\\facenter"; break;
|
||
case fa_faroman: sResult += L"\\faroman"; break;
|
||
case fa_favar: sResult += L"\\favar"; break;
|
||
case fa_fafixed: sResult += L"\\fafixed"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nIndFirstLine , sResult, L"fi" );
|
||
RENDER_RTF_INT( m_nIndLeft , sResult, L"li" );
|
||
RENDER_RTF_INT( m_nIndStart , sResult, L"lin" );
|
||
RENDER_RTF_INT( m_nIndRight , sResult, L"ri" );
|
||
RENDER_RTF_INT( m_nIndEnd , sResult, L"rin" );
|
||
RENDER_RTF_BOOL( m_bIndRightAuto , sResult, L"adjustright" );
|
||
RENDER_RTF_BOOL( m_bIndMirror , sResult, L"indmirror" );
|
||
RENDER_RTF_INT( m_nSpaceBefore , sResult, L"sb" );
|
||
RENDER_RTF_INT( m_nSpaceAfter , sResult, L"sa" );
|
||
RENDER_RTF_INT( m_nSpaceBeforeAuto , sResult, L"sbauto" );
|
||
RENDER_RTF_INT( m_nSpaceAfterAuto , sResult, L"saauto" );
|
||
RENDER_RTF_INT( m_nSpaceBeforeLine , sResult, L"lisb" );
|
||
RENDER_RTF_INT( m_nSpaceAfterLine , sResult, L"lisa" );
|
||
RENDER_RTF_INT( m_nSpaceBetween , sResult, L"sl" );
|
||
RENDER_RTF_INT( m_nSpaceMultiLine , sResult, L"slmult" );
|
||
RENDER_RTF_BOOL( m_bContextualSpacing, sResult, L"contextualspace" );
|
||
|
||
if( 0 == m_bRtl ) sResult += L"\\ltrpar";
|
||
else if( PROP_DEF != m_bRtl ) sResult += L"\\rtlpar";
|
||
|
||
RENDER_RTF_BOOL( m_bNoWordWrap, sResult, L"nowwrap" );
|
||
|
||
if( 0 == m_bSnapToGrid ) sResult += L"\\nosnaplinegrid";
|
||
else if( PROP_DEF != m_bSnapToGrid ) sResult += L"\\nosnaplinegrid0";
|
||
switch ( m_eTextBoxWrap )
|
||
{
|
||
case tbw_txbxtwno: sResult += L"\\txbxtwno"; break;
|
||
case tbw_txbxtwalways: sResult += L"\\txbxtwalways"; break;
|
||
case tbw_txbxtwfirstlast: sResult += L"\\txbxtwfirstlast"; break;
|
||
case tbw_txbxtwfirst: sResult += L"\\txbxtwfirst"; break;
|
||
case tbw_txbxtwlast: sResult += L"\\txbxtwlast"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( PROP_DEF != m_nListId && PROP_DEF != m_nListLevel )
|
||
{
|
||
sResult += L"\\ls" + std::to_wstring( m_nListId );
|
||
sResult += L"\\ilvl" + std::to_wstring(m_nListLevel );
|
||
}
|
||
|
||
if( true == m_oShading.IsValid() )
|
||
sResult += m_oShading.RenderToRtf( oRenderParameter );
|
||
|
||
bool border_sides = false;
|
||
if( true == m_oBorderTop.IsValid() )
|
||
{
|
||
sResult += L"\\brdrt";
|
||
sResult += m_oBorderTop.RenderToRtf( oRenderParameter );
|
||
border_sides = true;
|
||
}
|
||
if( true == m_oBorderLeft.IsValid() )
|
||
{
|
||
sResult += L"\\brdrl";
|
||
sResult += m_oBorderLeft.RenderToRtf( oRenderParameter );
|
||
border_sides = true;
|
||
}
|
||
if( true == m_oBorderBottom.IsValid() )
|
||
{
|
||
sResult += L"\\brdrb";
|
||
sResult += m_oBorderBottom.RenderToRtf( oRenderParameter );
|
||
border_sides = true;
|
||
}
|
||
if( true == m_oBorderRight.IsValid() )
|
||
{
|
||
sResult += L"\\brdrr";
|
||
sResult += m_oBorderRight.RenderToRtf( oRenderParameter );
|
||
border_sides = true;
|
||
}
|
||
if( true == m_oBorderBar.IsValid() )
|
||
{
|
||
sResult += L"\\brdrbar";
|
||
sResult += m_oBorderBar.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( true == m_oBorderBox.IsValid() && !border_sides)
|
||
{
|
||
sResult += L"\\box";
|
||
sResult += m_oBorderBox.RenderToRtf( oRenderParameter );
|
||
}
|
||
|
||
if( true == m_oFrame.IsValid() )
|
||
sResult += m_oFrame.RenderToRtf( oRenderParameter );
|
||
|
||
RENDER_RTF_BOOL( m_bOverlap, sResult, L"absnoovrlp" );
|
||
|
||
switch ( m_eTextFollow )
|
||
{
|
||
case tf_frmtxlrtb: sResult += L"\\frmtxlrtb"; break;
|
||
case tf_frmtxtbrl: sResult += L"\\frmtxtbrl"; break;
|
||
case tf_frmtxbtlr: sResult += L"\\frmtxbtlr"; break;
|
||
case tf_frmtxlrtbv: sResult += L"\\frmtxlrtbv"; break;
|
||
case tf_frmtxtbrlv: sResult += L"\\frmtxtbrlv"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( true == m_oTabs.IsValid() )
|
||
sResult += m_oTabs.RenderToRtf( oRenderParameter );
|
||
|
||
|
||
//RENDER_RTF_INT( m_nTableStyle, sResult, L"yts" );
|
||
//RENDER_RTF_BOOL( m_bStyleFirstRow, sResult, L"tscfirstrow" );
|
||
//RENDER_RTF_BOOL( m_bStyleLastRow, sResult, L"tsclastrow" );
|
||
//RENDER_RTF_BOOL( m_bStyleFirstCollumn, sResult, L"tscfirstcol" );
|
||
//RENDER_RTF_BOOL( m_bStyleLastCollumn, sResult, L"tsclastcol" );
|
||
//RENDER_RTF_BOOL( m_bStyleOddRowBand, sResult, L"tscbandhorzodd" );
|
||
//RENDER_RTF_BOOL( m_bStyleEvenRowBand, sResult, L"tscbandhorzeven" );
|
||
//RENDER_RTF_BOOL( m_bStyleOddColBand, sResult, L"tscbandvertodd" );
|
||
//RENDER_RTF_BOOL( m_bStyleEvenColBand, sResult, L"tscbandverteven" );
|
||
//RENDER_RTF_BOOL( m_bStyleNWCell, sResult, L"tscnwcell" );
|
||
//RENDER_RTF_BOOL( m_bStyleNECell, sResult, L"tscnecell" );
|
||
//RENDER_RTF_BOOL( m_bStyleSWCell, sResult, L"tscswcell" );
|
||
//RENDER_RTF_BOOL( m_bStyleSECell, sResult, L"tscsecell" );
|
||
|
||
|
||
//дописываем текст списка (для старых reader например wordPad)
|
||
if( PROP_DEF != m_nListId && PROP_DEF != m_nListLevel )
|
||
{
|
||
RtfListProperty oListProperty;
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*>( oRenderParameter.poDocument );
|
||
RtfListOverrideProperty oListOverrideProperty;
|
||
//ищем по override table
|
||
if( true == poRtfDocument->m_oListOverrideTable.GetList( m_nListId, oListOverrideProperty ) )
|
||
{
|
||
//Ищем по List Table
|
||
if( true == poRtfDocument->m_oListTable.GetList( oListOverrideProperty.m_nListID, oListProperty) )
|
||
{
|
||
//дописываем свойства параграфа firstIndent Indent
|
||
RtfListLevelProperty poLevelProp ;
|
||
if( true == oListProperty.GetItem( poLevelProp , m_nListLevel ) )
|
||
{
|
||
sResult += L"{\\listtext\\pard\\plain";
|
||
sResult += poLevelProp.m_oCharProp.RenderToRtf( oRenderParameter );
|
||
//пишем текст
|
||
std::wstring strLevelProp = poLevelProp.GenerateListText();
|
||
|
||
RtfCharProperty* pCharProperty = NULL;
|
||
sResult += RtfChar::renderRtfText( strLevelProp, oRenderParameter.poDocument, pCharProperty );
|
||
|
||
//или картинку
|
||
if( PROP_DEF != poLevelProp.m_nPictureIndex )
|
||
{
|
||
int nIndex = poLevelProp.m_nPictureIndex;
|
||
|
||
if( 0 < nIndex && nIndex < poRtfDocument->m_oListTable.m_aPictureList.GetCount() )
|
||
sResult += poRtfDocument->m_oListTable.m_aPictureList[nIndex]->RenderToRtf( oRenderParameter );
|
||
}
|
||
//ставим tab
|
||
if( PROP_DEF != poLevelProp.m_nFollow )
|
||
{
|
||
switch( poLevelProp.m_nFollow )
|
||
{
|
||
case 0: sResult += L"\\tab"; break; // tab
|
||
case 1: sResult += L" "; break; // space
|
||
case 2:
|
||
break; // nothing
|
||
}
|
||
}
|
||
sResult += L"}";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
m_oCharProperty.RenderToRtf(oRenderParameter);
|
||
|
||
if (m_pOldParagraphProp)
|
||
{
|
||
RENDER_RTF_INT( m_nPrAuth, sResult, L"prauth" )
|
||
RENDER_RTF_INT( m_nPrDate, sResult, L"prdate" )
|
||
|
||
sResult += L"{\\*\\oldpprops\\pard";
|
||
sResult += m_pOldParagraphProp->RenderToRtf(oRenderParameter);
|
||
sResult += L"}";
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfParagraphProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
RtfDocument* poRtfDocument = static_cast<RtfDocument*> (oRenderParameter.poDocument);
|
||
OOXWriter* poOOXWriter = static_cast<OOXWriter*> (oRenderParameter.poWriter);
|
||
|
||
std::wstring sResult;
|
||
RtfTabs styleTabs;
|
||
|
||
if( PROP_DEF != m_nStyle )
|
||
{
|
||
RtfStylePtr oCurStyle;
|
||
if( true == poRtfDocument->m_oStyleTable.GetStyle( m_nStyle, oCurStyle ) )
|
||
{
|
||
RtfParagraphStyle* oCurParaStyle = dynamic_cast<RtfParagraphStyle*>(oCurStyle.get());
|
||
|
||
if (oCurParaStyle)
|
||
{
|
||
if (oCurParaStyle->m_oParProp.m_nListId != PROP_DEF &&
|
||
oCurParaStyle->m_oParProp.m_nListLevel != PROP_DEF)
|
||
{
|
||
if( PROP_DEF == m_nListId) m_nListId = 0;
|
||
if ( PROP_DEF == m_nListLevel ) m_nListLevel = 0;
|
||
}
|
||
styleTabs = oCurParaStyle->m_oParProp.m_oTabs;
|
||
|
||
if (oCurParaStyle->m_oParProp.m_nSpaceBeforeAuto == 1 && m_nSpaceBefore != PROP_DEF)
|
||
m_nSpaceBeforeAuto = 0;
|
||
|
||
if (oCurParaStyle->m_oParProp.m_nSpaceAfterAuto == 1 && m_nSpaceAfter != PROP_DEF)
|
||
m_nSpaceAfterAuto = 0;
|
||
|
||
m_bHidden = (oCurParaStyle->m_bHidden == 1);
|
||
}
|
||
sResult += L"<w:pStyle w:val=\"Style_" + std::to_wstring(m_nStyle) + L"\"/>";
|
||
}
|
||
}
|
||
|
||
if ( 0 == m_bAutoHyphenation ) sResult += L"<w:suppressAutoHyphens/>";
|
||
else if ( 1 == m_bAutoHyphenation ) sResult += L"<w:suppressAutoHyphens w:val=\"false\"/>";
|
||
|
||
RENDER_OOX_BOOL ( m_bKeep , sResult, L"w:keepLines" );
|
||
RENDER_OOX_BOOL ( m_bKeepNext , sResult, L"w:keepNext" );
|
||
RENDER_OOX_INT ( m_nOutlinelevel , sResult, L"w:outlineLvl" );
|
||
RENDER_OOX_BOOL ( m_bPageBB , sResult, L"w:pageBreakBefore" );
|
||
|
||
if (PROP_DEF == m_nStyle && PROP_DEF == m_eAlign)
|
||
m_eAlign = pa_ql;
|
||
|
||
if (m_bRtl == 1)
|
||
{
|
||
if (m_eAlign == pa_ql) m_eAlign = pa_qr;
|
||
else if (m_eAlign == pa_qr) m_eAlign = pa_ql;
|
||
}
|
||
|
||
switch(m_eAlign)
|
||
{
|
||
case pa_qc: sResult += L"<w:jc w:val=\"center\"/>" ; break;
|
||
case pa_qj: sResult += L"<w:jc w:val=\"both\"/>"; break;
|
||
case pa_ql: sResult += L"<w:jc w:val=\"left\"/>"; break;
|
||
case pa_qr: sResult += L"<w:jc w:val=\"right\"/>"; break;
|
||
case pa_qd: sResult += L"<w:jc w:val=\"distribute\"/>"; break;
|
||
case pa_qk0: sResult += L"<w:jc w:val=\"lowKashida\"/>"; break;
|
||
case pa_qk10: sResult += L"<w:jc w:val=\"mediumKashida\"/>"; break;
|
||
case pa_qk20: sResult += L"<w:jc w:val=\"highKashida\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
switch( m_eFontAlign )
|
||
{
|
||
case fa_faauto: sResult += L"<w:textAlignment w:val=\"auto\"/>"; break;
|
||
case fa_fahang: sResult += L"<w:textAlignment w:val=\"top\"/>"; break;
|
||
case fa_facenter: sResult += L"<w:textAlignment w:val=\"center\"/>"; break;
|
||
case fa_faroman: sResult += L"<w:textAlignment w:val=\"baseline\"/>";break;
|
||
case fa_favar: sResult += L"<w:textAlignment w:val=\"bottom\"/>"; break;
|
||
case fa_fafixed: sResult += L"<w:textAlignment w:val=\"bottom\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
std::wstring sIndent;
|
||
|
||
if ( PROP_DEF != m_nIndRight )
|
||
{
|
||
if (PROP_DEF == m_nIndLeft)
|
||
m_nIndLeft = 0;
|
||
sIndent += L" w:right=\"" + std::to_wstring(m_nIndRight) + L"\"";
|
||
}
|
||
RENDER_OOX_INT_ATTRIBUTE ( m_nIndLeft, sIndent, L"w:left" );
|
||
RENDER_OOX_INT_ATTRIBUTE (m_nIndStart, sIndent, L"w:start")
|
||
|
||
if( PROP_DEF != m_nIndFirstLine )
|
||
{
|
||
if( m_nIndFirstLine >= 0 ) sIndent += L" w:firstLine=\"" + std::to_wstring(m_nIndFirstLine) + L"\"";
|
||
else sIndent += L" w:hanging=\"" + std::to_wstring(-m_nIndFirstLine) + L"\"";
|
||
}
|
||
else if ((m_bList || (PROP_DEF != m_nListId && PROP_DEF != m_nListLevel)) && PROP_DEF != m_nIndLeft)
|
||
sIndent += L" w:firstLine=\"0\"";
|
||
|
||
if( !sIndent.empty() )
|
||
{
|
||
sResult += L"<w:ind " + sIndent + L"/>";
|
||
}
|
||
|
||
RENDER_OOX_BOOL( m_bIndRightAuto, sResult, L"w:adjustRightInd" );
|
||
RENDER_OOX_BOOL( m_bIndMirror, sResult, L"w:mirrorIndents" );
|
||
|
||
std::wstring sSpacing;
|
||
|
||
if (m_bKeepNext == 1)//nabidnik.rtf
|
||
{
|
||
if( PROP_DEF == m_nSpaceAfter ) m_nSpaceAfter = 0;
|
||
if( PROP_DEF == m_nSpaceBefore ) m_nSpaceBefore = 0;
|
||
}
|
||
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nSpaceBefore, sSpacing, L"w:before" );
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nSpaceAfter, sSpacing, L"w:after" );
|
||
|
||
if (m_nSpaceBeforeAuto == 1)
|
||
{
|
||
sSpacing += L" w:beforeAutospacing=\"on\"";
|
||
}
|
||
if (m_nSpaceAfterAuto == 1)
|
||
{
|
||
sSpacing += L" w:afterAutospacing=\"on\"";
|
||
}
|
||
//RENDER_OOX_INT_ATTRIBUTE( m_nSpaceBeforeAuto, sSpacing, L"w:beforeAutospacing" );
|
||
//RENDER_OOX_INT_ATTRIBUTE( m_nSpaceAfterAuto, sSpacing, L"w:afterAutospacing" );
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nSpaceBeforeLine, sSpacing, L"w:beforeLines" );
|
||
RENDER_OOX_INT_ATTRIBUTE( m_nSpaceAfterLine, sSpacing, L"w:afterLines" );
|
||
|
||
if( PROP_DEF != m_nSpaceBetween && 0 != m_nSpaceBetween )
|
||
{
|
||
if( m_nSpaceBetween > 0 )
|
||
sSpacing += L" w:line=\"" + std::to_wstring(m_nSpaceBetween) + L"\"";
|
||
else
|
||
sSpacing += L" w:line=\"" + std::to_wstring(-m_nSpaceBetween) + L"\"";
|
||
if( 0 == m_nSpaceMultiLine )
|
||
{
|
||
if( m_nSpaceBetween > 0 ) sSpacing += L" w:lineRule=\"atLeast\"";
|
||
else sSpacing += L" w:lineRule=\"exact\"";
|
||
}
|
||
else sSpacing += L" w:lineRule=\"auto\"";
|
||
}
|
||
//else
|
||
// sSpacing += L" w:line=\"240\""); //по умолчанию - единичный
|
||
if( !sSpacing.empty() )
|
||
{
|
||
sResult += L"<w:spacing " + sSpacing + L"/>";
|
||
}
|
||
|
||
RENDER_OOX_BOOL( m_bSnapToGrid, sResult, L"w:snapToGrid" );
|
||
RENDER_OOX_BOOL( m_bContextualSpacing, sResult, L"w:contextualSpacing" );
|
||
RENDER_OOX_BOOL( m_bRtl, sResult, L"w:bidi" );
|
||
|
||
if( 0 == m_bNoWordWrap ) sResult += L"<w:wordWrap w:val=\"false\"/>";
|
||
else if( PROP_DEF != m_bNoWordWrap ) sResult += L"<w:wordWrap w:val=\"true\"/>";
|
||
|
||
switch ( m_eTextBoxWrap )
|
||
{
|
||
case tbw_txbxtwno: sResult += L"<w:textboxTightWrap w:val=\"none\"/>"; break;
|
||
case tbw_txbxtwalways: sResult += L"<w:textboxTightWrap w:val=\"allLines\"/>"; break;
|
||
case tbw_txbxtwfirstlast: sResult += L"<w:textboxTightWrap w:val=\"firstAndLastLine\"/>"; break;
|
||
case tbw_txbxtwfirst: sResult += L"<w:textboxTightWrap w:val=\"firstLineOnly\"/>"; break;
|
||
case tbw_txbxtwlast: sResult += L"<w:textboxTightWrap w:val=\"lastLineOnly\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( PROP_DEF != m_nListId && PROP_DEF != m_nListLevel )
|
||
{
|
||
sResult += L"<w:numPr><w:ilvl w:val=\"" + std::to_wstring(m_nListLevel) + L"\"/><w:numId w:val=\"" + std::to_wstring(m_nListId) + L"\"/></w:numPr>";
|
||
}
|
||
|
||
if( true == m_oShading.IsValid() )
|
||
sResult += m_oShading.RenderToOOX(oRenderParameter);
|
||
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_BORDER_ATTRIBUTE;
|
||
std::wstring sBorder;
|
||
if( true == m_oBorderBox.IsValid() )
|
||
{
|
||
std::wstring sBorderContent = m_oBorderBox.RenderToOOX(oNewParam);
|
||
sBorder += L"<w:left "; sBorder += sBorderContent; sBorder += L" />";
|
||
sBorder += L"<w:top "; sBorder += sBorderContent; sBorder += L" />";
|
||
sBorder += L"<w:right "; sBorder += sBorderContent; sBorder += L" />";
|
||
sBorder += L"<w:bottom "; sBorder += sBorderContent; sBorder += L" />";
|
||
}
|
||
else
|
||
{
|
||
if( true == m_oBorderTop.IsValid() )
|
||
{
|
||
sBorder += L"<w:top " + m_oBorderTop.RenderToOOX(oNewParam) + L"/>";
|
||
}
|
||
if( true == m_oBorderLeft.IsValid() )
|
||
{
|
||
sBorder += L"<w:left " + m_oBorderLeft.RenderToOOX(oNewParam) + L"/>";
|
||
}
|
||
if( true == m_oBorderBottom.IsValid() )
|
||
{
|
||
sBorder += L"<w:bottom " + m_oBorderBottom.RenderToOOX(oNewParam) + L"/>";
|
||
}
|
||
if( true == m_oBorderRight.IsValid() )
|
||
{
|
||
sBorder += L"<w:right " + m_oBorderRight.RenderToOOX(oNewParam) + L"/>";
|
||
}
|
||
}
|
||
|
||
if( true == m_oBorderBar.IsValid() )
|
||
{
|
||
sBorder += L"<w:between ";
|
||
sBorder += m_oBorderBar.RenderToOOX(oNewParam);
|
||
sBorder += L"/>";
|
||
}
|
||
if( false == sBorder.empty() )
|
||
{
|
||
sResult += L"<w:pBdr>";
|
||
sResult += sBorder;
|
||
sResult += L"</w:pBdr>";
|
||
}
|
||
|
||
if( true == m_oFrame.IsValid() )
|
||
sResult += m_oFrame.RenderToOOX( oRenderParameter );
|
||
|
||
RENDER_OOX_BOOL( m_bOverlap, sResult, L"w:suppressOverlap" );
|
||
|
||
switch ( m_eTextFollow )
|
||
{
|
||
case tf_frmtxlrtb: sResult += L"<w:textFlow w:val=\"lrtb\"/>"; break;
|
||
case tf_frmtxtbrl: sResult += L"<w:textFlow w:val=\"tbrl\"/>"; break;
|
||
case tf_frmtxbtlr: sResult += L"<w:textFlow w:val=\"btlr\"/>"; break;
|
||
case tf_frmtxlrtbv: sResult += L"<w:textFlow w:val=\"lrtbV\"/>";break;
|
||
case tf_frmtxtbrlv: sResult += L"<w:textFlow w:val=\"tbrlV\"/>";break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (styleTabs.m_aTabs.size() != m_oTabs.m_aTabs.size() && m_oTabs.m_aTabs.size() > 0)
|
||
{//зачистка от стилевых табов (позиции по возрастанию)
|
||
for (int i = (int)styleTabs.m_aTabs.size() - 1; i >= 0; i--)
|
||
{
|
||
bool bPreset = false;
|
||
for (size_t j = 0; j < m_oTabs.m_aTabs.size(); j++)
|
||
{
|
||
if (m_oTabs.m_aTabs[j].m_nTab == styleTabs.m_aTabs[i].m_nTab)
|
||
{
|
||
bPreset = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!bPreset)
|
||
{
|
||
RtfTab tab_new = styleTabs.m_aTabs[i];
|
||
|
||
tab_new.m_eKind = RtfTab::tk_tqclear;
|
||
|
||
m_oTabs.m_aTabs.insert(m_oTabs.m_aTabs.begin(), tab_new);
|
||
}
|
||
}
|
||
}
|
||
|
||
sResult += m_oTabs.RenderToOOX( oRenderParameter );
|
||
|
||
std::wstring sCharProp = m_oCharProperty.RenderToOOX( oRenderParameter );
|
||
|
||
if( !sCharProp.empty() )
|
||
{
|
||
sResult += L"<w:rPr>";
|
||
sResult += sCharProp;
|
||
sResult += L"</w:rPr>";
|
||
}
|
||
if (m_pOldParagraphProp)
|
||
{
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_nPrAuth);
|
||
std::wstring sDate(RtfUtility::convertDateTime(m_nPrDate).c_str());
|
||
|
||
RenderParameter oRenderParameterNew = oRenderParameter;
|
||
oRenderParameterNew.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
|
||
sResult += L"<w:pPrChange w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
||
sResult += L"<w:pPr>";
|
||
sResult += m_pOldParagraphProp->RenderToOOX(oRenderParameterNew);
|
||
sResult += L"</w:pPr>";
|
||
sResult += L"</w:pPrChange>";
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfCellProperty::RtfCellProperty()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfCellProperty::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfCellProperty::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
m_nSpan = 1;
|
||
}
|
||
void RtfCellProperty::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY( m_bMergeFirst )
|
||
DEFAULT_PROPERTY( m_bMerge )
|
||
DEFAULT_PROPERTY( m_bMergeFirstVertical )
|
||
DEFAULT_PROPERTY( m_bMergeVertical )
|
||
DEFAULT_PROPERTY( m_bFitText )
|
||
DEFAULT_PROPERTY( m_bNoWrap )
|
||
|
||
DEFAULT_PROPERTY( m_nPaddingLeft )
|
||
DEFAULT_PROPERTY( m_ePaddingLeftUnit )
|
||
DEFAULT_PROPERTY( m_nPaddingRight )
|
||
DEFAULT_PROPERTY( m_ePaddingRightUnit )
|
||
DEFAULT_PROPERTY( m_nPaddingTop )
|
||
DEFAULT_PROPERTY( m_ePaddingTopUnit )
|
||
DEFAULT_PROPERTY( m_nPaddingBottom )
|
||
DEFAULT_PROPERTY( m_ePaddingBottomUnit )
|
||
|
||
DEFAULT_PROPERTY( m_nSpacingLeft )
|
||
DEFAULT_PROPERTY( m_eSpacingLeftUnit )
|
||
DEFAULT_PROPERTY( m_nSpacingRight )
|
||
DEFAULT_PROPERTY( m_eSpacingRightUnit )
|
||
DEFAULT_PROPERTY( m_nSpacingTop )
|
||
DEFAULT_PROPERTY( m_eSpacingTopUnit )
|
||
DEFAULT_PROPERTY( m_nSpacingBottom )
|
||
DEFAULT_PROPERTY( m_eSpacingBottomUnit )
|
||
|
||
m_eWidthUnit = mu_none;
|
||
DEFAULT_PROPERTY( m_nWidth )
|
||
DEFAULT_PROPERTY( m_bHideMark )
|
||
|
||
m_oBorderDiagonalLR.SetDefault();
|
||
m_oBorderDiagonalRL.SetDefault();
|
||
m_oBorderLeft.SetDefault();
|
||
m_oBorderTop.SetDefault();
|
||
m_oBorderRight.SetDefault();
|
||
m_oBorderBottom.SetDefault();
|
||
m_oBorderInsideH.SetDefault();
|
||
m_oBorderInsideV.SetDefault();
|
||
|
||
m_oShading.SetDefault();
|
||
DEFAULT_PROPERTY( m_nShadingPctFrom )
|
||
DEFAULT_PROPERTY( m_eAlign )
|
||
|
||
m_oCellFlow = cf_none;
|
||
|
||
DEFAULT_PROPERTY( m_nCellx )
|
||
DEFAULT_PROPERTY( m_nSpan )
|
||
|
||
DEFAULT_PROPERTY( m_bStyleFirstRow )
|
||
DEFAULT_PROPERTY( m_bStyleLastRow )
|
||
DEFAULT_PROPERTY( m_bStyleFirstCol )
|
||
DEFAULT_PROPERTY( m_bStyleLastCol )
|
||
DEFAULT_PROPERTY( m_bStyleOddRowBand )
|
||
DEFAULT_PROPERTY( m_bStyleEvenRowBand )
|
||
DEFAULT_PROPERTY( m_bStyleOddColBand )
|
||
DEFAULT_PROPERTY( m_bStyleEvenColBand )
|
||
DEFAULT_PROPERTY( m_bStyleNWCell )
|
||
DEFAULT_PROPERTY( m_bStyleNECell )
|
||
DEFAULT_PROPERTY( m_bStyleSWCell )
|
||
DEFAULT_PROPERTY( m_bStyleSECell )
|
||
}
|
||
bool RtfCellProperty::IsValid()
|
||
{
|
||
return PROP_DEF != m_nCellx;
|
||
}
|
||
void RtfCellProperty::Merge( RtfCellProperty& oCellPr )
|
||
{
|
||
MERGE_PROPERTY( m_bMergeFirst, oCellPr )
|
||
MERGE_PROPERTY( m_bMerge, oCellPr )
|
||
MERGE_PROPERTY( m_bMergeFirstVertical, oCellPr )
|
||
MERGE_PROPERTY( m_bMergeVertical, oCellPr )
|
||
|
||
MERGE_PROPERTY( m_bFitText, oCellPr )
|
||
MERGE_PROPERTY( m_bNoWrap, oCellPr )
|
||
|
||
MERGE_PROPERTY( m_nPaddingLeft, oCellPr )
|
||
MERGE_PROPERTY( m_ePaddingLeftUnit, oCellPr )
|
||
MERGE_PROPERTY( m_nPaddingRight, oCellPr )
|
||
MERGE_PROPERTY( m_ePaddingRightUnit, oCellPr )
|
||
MERGE_PROPERTY( m_nPaddingTop, oCellPr )
|
||
MERGE_PROPERTY( m_ePaddingTopUnit, oCellPr )
|
||
MERGE_PROPERTY( m_nPaddingBottom, oCellPr )
|
||
MERGE_PROPERTY( m_ePaddingBottomUnit, oCellPr )
|
||
|
||
MERGE_PROPERTY( m_nSpacingLeft, oCellPr )
|
||
MERGE_PROPERTY( m_eSpacingLeftUnit, oCellPr )
|
||
MERGE_PROPERTY( m_nSpacingRight, oCellPr )
|
||
MERGE_PROPERTY( m_eSpacingRightUnit, oCellPr )
|
||
MERGE_PROPERTY( m_nSpacingTop, oCellPr )
|
||
MERGE_PROPERTY( m_eSpacingTopUnit, oCellPr )
|
||
MERGE_PROPERTY( m_nSpacingBottom, oCellPr )
|
||
MERGE_PROPERTY( m_eSpacingBottomUnit, oCellPr )
|
||
|
||
MERGE_PROPERTY( m_eWidthUnit, oCellPr )
|
||
MERGE_PROPERTY( m_nWidth, oCellPr )
|
||
MERGE_PROPERTY( m_bHideMark, oCellPr )
|
||
|
||
m_oBorderDiagonalLR.Merge( oCellPr.m_oBorderDiagonalLR );
|
||
m_oBorderDiagonalRL.Merge( oCellPr.m_oBorderDiagonalRL );
|
||
m_oBorderLeft.Merge( oCellPr.m_oBorderLeft );
|
||
m_oBorderTop.Merge( oCellPr.m_oBorderTop );
|
||
m_oBorderRight.Merge( oCellPr.m_oBorderRight );
|
||
m_oBorderBottom.Merge( oCellPr.m_oBorderBottom );
|
||
m_oBorderInsideH.Merge( oCellPr.m_oBorderInsideH );
|
||
m_oBorderInsideV.Merge( oCellPr.m_oBorderInsideV );
|
||
|
||
m_oShading.Merge( oCellPr.m_oShading );
|
||
MERGE_PROPERTY ( m_nShadingPctFrom, oCellPr)
|
||
|
||
MERGE_PROPERTY( m_eAlign, oCellPr )
|
||
MERGE_PROPERTY( m_oCellFlow, oCellPr )
|
||
|
||
MERGE_PROPERTY( m_nCellx, oCellPr )
|
||
MERGE_PROPERTY( m_nSpan, oCellPr )
|
||
|
||
MERGE_PROPERTY( m_bStyleFirstRow, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleLastRow, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleFirstCol, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleLastCol, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleOddRowBand, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleEvenRowBand, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleOddColBand, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleEvenColBand, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleNWCell, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleNECell, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleSWCell, oCellPr )
|
||
MERGE_PROPERTY( m_bStyleSECell, oCellPr )
|
||
}
|
||
bool RtfCellProperty::GetAlignFromStringRtf( std::wstring & oAlign, CellAlign& oOutput )
|
||
{
|
||
if ( L"clvertalt" == oAlign ) { oOutput = ca_Top; return true;}
|
||
else if ( L"clvertalc" == oAlign ){ oOutput = ca_Center; return true;}
|
||
else if ( L"clvertalb" == oAlign ){ oOutput = ca_Bottom; return true;}
|
||
return false;
|
||
}
|
||
bool RtfCellProperty::GetAlignFromStringOOX( std::wstring & oAlign, CellAlign& oOutput )
|
||
{
|
||
if ( L"top" == oAlign ) { oOutput = ca_Top; return true;}
|
||
else if ( L"center" == oAlign ){ oOutput = ca_Center; return true;}
|
||
else if ( L"bottom" == oAlign ){ oOutput = ca_Bottom; return true;}
|
||
return false;
|
||
}
|
||
std::wstring RtfCellProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
RENDER_RTF_BOOL( m_bMergeFirst, sResult, L"clmgf" )
|
||
RENDER_RTF_BOOL( m_bMerge, sResult, L"clmrg" )
|
||
RENDER_RTF_BOOL( m_bMergeFirstVertical, sResult, L"clvmgf" )
|
||
RENDER_RTF_BOOL( m_bMergeVertical, sResult, L"clvmrg" )
|
||
|
||
RENDER_RTF_BOOL( m_bFitText, sResult, L"clFitText" )
|
||
RENDER_RTF_BOOL( m_bNoWrap, sResult, L"clNoWrap" )
|
||
|
||
//https://www.office-forums.com/threads/rtf-file-weirdness-clpadt-vs-clpadl.2163500/
|
||
RENDER_RTF_INT( m_nPaddingLeft, sResult, L"clpadt" ) //перепутаны top & left
|
||
RENDER_RTF_INT( m_ePaddingLeftUnit, sResult, L"clpadft" ) //перепутаны top & left
|
||
RENDER_RTF_INT( m_nPaddingRight, sResult, L"clpadr" )
|
||
RENDER_RTF_INT( m_ePaddingRightUnit, sResult, L"clpadfr" )
|
||
RENDER_RTF_INT( m_nPaddingTop, sResult, L"clpadl" ) //перепутаны top & left
|
||
RENDER_RTF_INT( m_ePaddingTopUnit, sResult, L"clpadfl" ) //перепутаны top & left
|
||
RENDER_RTF_INT( m_nPaddingBottom, sResult, L"clpadb" )
|
||
RENDER_RTF_INT( m_ePaddingBottomUnit, sResult, L"clpadfb" )
|
||
|
||
RENDER_RTF_INT( m_eSpacingLeftUnit, sResult, L"clspfl" )
|
||
RENDER_RTF_INT( m_nSpacingLeft, sResult, L"clspl" )
|
||
RENDER_RTF_INT( m_eSpacingRightUnit, sResult, L"clspl" )
|
||
RENDER_RTF_INT( m_nSpacingRight, sResult, L"clspr" )
|
||
|
||
RENDER_RTF_INT( m_eSpacingTopUnit, sResult, L"clspft" )
|
||
RENDER_RTF_INT( m_nSpacingTop, sResult, L"clspt" )
|
||
RENDER_RTF_INT( m_eSpacingBottomUnit, sResult, L"clspfb" )
|
||
RENDER_RTF_INT( m_nSpacingBottom, sResult, L"clspb" )
|
||
|
||
RENDER_RTF_BOOL( m_bHideMark, sResult, L"clhidemark" )
|
||
|
||
if( true == m_oBorderDiagonalLR.IsValid() )
|
||
{
|
||
sResult += L"\\cldglu";
|
||
sResult += m_oBorderDiagonalLR.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( true == m_oBorderDiagonalRL.IsValid() )
|
||
{
|
||
sResult += L"\\cldgll";
|
||
sResult += m_oBorderDiagonalRL.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( true == m_oBorderLeft.IsValid() )
|
||
{
|
||
sResult += L"\\clbrdrl";
|
||
sResult += m_oBorderLeft.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( true == m_oBorderTop.IsValid() )
|
||
{
|
||
sResult += L"\\clbrdrt";
|
||
sResult += m_oBorderTop.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( true == m_oBorderRight.IsValid() )
|
||
{
|
||
sResult += L"\\clbrdrr";
|
||
sResult += m_oBorderRight.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( true == m_oBorderBottom.IsValid() )
|
||
{
|
||
sResult += L"\\clbrdrb";
|
||
sResult += m_oBorderBottom.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( true == m_oShading.IsValid() )
|
||
sResult += m_oShading.RenderToRtf( oRenderParameter );
|
||
|
||
switch( m_eAlign )
|
||
{
|
||
case ca_Top: sResult += L"\\clvertalt"; break;
|
||
case ca_Center: sResult += L"\\clvertalc"; break;
|
||
case ca_Bottom: sResult += L"\\clvertalb"; break;
|
||
default:
|
||
break;
|
||
}
|
||
switch( m_oCellFlow )
|
||
{
|
||
case cf_lrtb: sResult += L"\\cltxlrtb"; break;
|
||
case cf_tbrl: sResult += L"\\cltxtbrl"; break;
|
||
case cf_btlr: sResult += L"\\cltxbtlr"; break;
|
||
case cf_lrtbv: sResult += L"\\cltxlrtbv"; break;
|
||
case cf_tbrlv: sResult += L"\\cltxtbrlv"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nWidth, sResult, L"clwWidth" )
|
||
switch( m_eWidthUnit )
|
||
{
|
||
case mu_none: sResult += L"\\clftsWidth0"; break;
|
||
case mu_Auto: sResult += L"\\clftsWidth1"; break;
|
||
case mu_Percent: sResult += L"\\clftsWidth2"; break;
|
||
case mu_Twips: sResult += L"\\clftsWidth3"; break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
sResult += L"\\cellx" + std::to_wstring(m_nCellx);
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfCellProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( 1 == m_bMergeFirst ) sResult += L"<w:hMerge w:val=\"restart\"/>";
|
||
if( 1 == m_bMerge ) sResult += L"<w:hMerge w:val=\"continue\"/>";
|
||
if( 1 == m_bMergeFirstVertical ) sResult += L"<w:vMerge w:val=\"restart\"/>";
|
||
if( 1 == m_bMergeVertical) sResult += L"<w:vMerge w:val=\"continue\"/>";
|
||
|
||
RENDER_OOX_BOOL( m_bFitText, sResult, L"w:tcFitText" )
|
||
RENDER_OOX_BOOL( m_bNoWrap, sResult, L"w:noWrap" )
|
||
|
||
std::wstring sMargin;
|
||
if( 3 == m_ePaddingLeftUnit && PROP_DEF != m_nPaddingLeft)
|
||
sMargin += L"<w:left w:w=\"" + std::to_wstring(m_nPaddingLeft) + L"\" w:type=\"dxa\"/>";
|
||
if( 3 == m_ePaddingRightUnit && PROP_DEF != m_nPaddingRight)
|
||
sMargin += L"<w:right w:w=\"" + std::to_wstring(m_nPaddingRight) + L"\" w:type=\"dxa\"/>";
|
||
if( 3 == m_ePaddingTopUnit && PROP_DEF != m_nPaddingTop)
|
||
sMargin += L"<w:top w:w=\"" + std::to_wstring(m_nPaddingTop) + L"\" w:type=\"dxa\"/>";
|
||
if( 3 == m_ePaddingBottomUnit && PROP_DEF != m_nPaddingBottom)
|
||
sMargin += L"<w:bottom w:w=\"" + std::to_wstring(m_nPaddingBottom) + L"\" w:type=\"dxa\"/>";
|
||
|
||
if( !sMargin.empty() )
|
||
{
|
||
sResult += L"<w:tcMar>";
|
||
sResult += sMargin;
|
||
sResult += L"</w:tcMar>";
|
||
}
|
||
|
||
//if( true == m_bIsSpacingLeft )
|
||
// sResult += L"trspdl3");
|
||
//else
|
||
// sResult += L"trspdl0");
|
||
//if( PROP_DEF != m_nSpacingLeft )
|
||
// sResult += L"trspdfl" + std::to_wstring(m_nSpacingLeft) + L"",);
|
||
//if( true == m_bIsSpacingRight )
|
||
// sResult += L"trspdr3");
|
||
//else
|
||
// sResult += L"trspdr0");
|
||
//if( PROP_DEF != m_nSpacingRight )
|
||
// sResult += L"trspdfr" + std::to_wstring(m_nSpacingRight) + L"",);
|
||
//if( true == m_bIsSpacingTop )
|
||
// sResult += L"trspdt3");
|
||
//else
|
||
// sResult += L"trspdt0");
|
||
//if( PROP_DEF != m_nSpacingTop )
|
||
// sResult += L"trspdft" + std::to_wstring(m_nSpacingTop) + L"",);
|
||
//if( true == m_bIsSpacingBottom )
|
||
// sResult += L"trspdb3");
|
||
//else
|
||
// sResult += L"trspdb0");
|
||
//if( PROP_DEF != m_nSpacingBottom )
|
||
// sResult += L"trspdfb" + std::to_wstring(m_nSpacingBottom) + L"",);
|
||
|
||
if( PROP_DEF != m_nWidth )
|
||
{
|
||
if( mu_Percent == m_eWidthUnit )
|
||
sResult += L"<w:tcW w:w=\"" + std::to_wstring(m_nWidth) + L"%\" w:type=\"pct\"/>";
|
||
else if( mu_Twips == m_eWidthUnit )
|
||
sResult += L"<w:tcW w:w=\"" + std::to_wstring(m_nWidth) + L"\" w:type=\"dxa\"/>";
|
||
}
|
||
RENDER_OOX_INT(m_nSpan, sResult, L"w:gridSpan");
|
||
RENDER_OOX_BOOL( m_bHideMark, sResult, L"w:hideMark" )
|
||
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_BORDER_TAG;
|
||
|
||
std::wstring sBorder;
|
||
if( true == m_oBorderDiagonalLR.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:tl2br";
|
||
sBorder += m_oBorderDiagonalLR.RenderToOOX(oNewParam);
|
||
}
|
||
if( true == m_oBorderDiagonalRL.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:tr2bl";
|
||
sBorder += m_oBorderDiagonalRL.RenderToOOX(oNewParam);
|
||
}
|
||
if( true == m_oBorderTop.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:top";
|
||
sBorder += m_oBorderTop.RenderToOOX(oNewParam);
|
||
}
|
||
if( true == m_oBorderLeft.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:left";
|
||
sBorder += m_oBorderLeft.RenderToOOX(oNewParam);
|
||
}
|
||
if( true == m_oBorderBottom.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:bottom";
|
||
sBorder += m_oBorderBottom.RenderToOOX(oNewParam);
|
||
}
|
||
if( true == m_oBorderRight.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:right";
|
||
sBorder += m_oBorderRight.RenderToOOX(oNewParam);
|
||
}
|
||
if( true == m_oBorderInsideH.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:insideH";
|
||
sResult += m_oBorderInsideH.RenderToOOX(oNewParam);
|
||
}
|
||
if( true == m_oBorderInsideV.IsValid() )
|
||
{
|
||
oNewParam.sValue = L"w:insideV";
|
||
sResult += m_oBorderInsideV.RenderToOOX(oNewParam);
|
||
}
|
||
if( false == sBorder.empty() )
|
||
{
|
||
sResult += L"<w:tcBorders>";
|
||
sResult += sBorder;
|
||
sResult += L"</w:tcBorders>";
|
||
}
|
||
|
||
if( true == m_oShading.IsValid() )
|
||
{
|
||
if (PROP_DEF != m_nShadingPctFrom && PROP_DEF != m_oShading.m_nValue && m_oShading.m_nValue != 0)
|
||
{
|
||
// todooo тут цвет подложки подкладывается от ячейки, таблицы или еще какой хрени
|
||
// пока берем второй цвет паттерна Romanization_Armenian.rtf
|
||
m_oShading.m_nBackColor = (int)(m_oShading.m_nForeColor * (m_oShading.m_nValue / 10000.));
|
||
}
|
||
sResult += m_oShading.RenderToOOX(oRenderParameter);
|
||
}
|
||
|
||
switch( m_eAlign )
|
||
{
|
||
case ca_Top: sResult += L"<w:vAlign w:val=\"top\"/>"; break;
|
||
case ca_Center: sResult += L"<w:vAlign w:val=\"center\"/>"; break;
|
||
case ca_Bottom: sResult += L"<w:vAlign w:val=\"bottom\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
switch( m_oCellFlow )
|
||
{
|
||
case cf_lrtb: sResult += L"<w:textDirection w:val=\"lrTb\"/>"; break;
|
||
case cf_tbrl: sResult += L"<w:textDirection w:val=\"tbRl\"/>"; break;
|
||
case cf_btlr: sResult += L"<w:textDirection w:val=\"btLr\"/>"; break;
|
||
case cf_lrtbv: sResult += L"<w:textDirection w:val=\"lrTbV\"/>"; break;
|
||
case cf_tbrlv: sResult += L"<w:textDirection w:val=\"tbRlV\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
//std::wstring scnfStyle;
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleFirstRow, scnfStyle, L"w:firstRow" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleLastRow, scnfStyle, L"w:lastRow" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleFirstCol, scnfStyle, L"w:firstColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleLastCol, scnfStyle, L"w:lastColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleOddRowBand, scnfStyle, L"w:oddHBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleEvenRowBand, scnfStyle, L"w:evenHBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleOddColBand, scnfStyle, L"w:oddVBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleEvenColBand, scnfStyle, L"w:evenvBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleNWCell, scnfStyle, L"w:firstRowFirstColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleNECell, scnfStyle, L"w:firstRowLastColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleSWCell, scnfStyle, L"w:lastRowFirstColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleSECell, scnfStyle, L"w:lastRowLastColumn" )
|
||
//if( !scnfStyle.empty() )
|
||
// sResult += L"<w:cnfStyle " + scnfStyle + T("(/>";
|
||
|
||
//cellx
|
||
|
||
return sResult;
|
||
}
|
||
|
||
RtfTableProperty::RtfTableProperty()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTableProperty::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTableProperty::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTableProperty::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY( m_bBidi )
|
||
DEFAULT_PROPERTY( m_nAutoFit )
|
||
DEFAULT_PROPERTY( m_nGraph )
|
||
|
||
DEFAULT_PROPERTY( nTableIndent )
|
||
DEFAULT_PROPERTY( eTableIndentUnit )
|
||
|
||
m_eJust = rj_none;
|
||
|
||
DEFAULT_PROPERTY( m_nWrapLeft )
|
||
DEFAULT_PROPERTY( m_nWrapRight )
|
||
DEFAULT_PROPERTY( m_nWrapTop )
|
||
DEFAULT_PROPERTY( m_nWrapBottom )
|
||
DEFAULT_PROPERTY( m_bOverlap )
|
||
|
||
DEFAULT_PROPERTY_DEF( m_eHRef, hr_none )
|
||
DEFAULT_PROPERTY_DEF( m_eVRef, vr_none )
|
||
DEFAULT_PROPERTY_DEF( m_eHPos, hp_none )
|
||
DEFAULT_PROPERTY_DEF( m_eVPos, vp_none )
|
||
DEFAULT_PROPERTY( m_nHPos )
|
||
DEFAULT_PROPERTY( m_nVPos )
|
||
|
||
DEFAULT_PROPERTY( m_nLeft )
|
||
DEFAULT_PROPERTY( m_nWidth )
|
||
|
||
m_eWidthUnit = mu_none;
|
||
|
||
//m_nDefCellMarBottom = 0;
|
||
//m_nDefCellMarRight = 108;
|
||
//m_nDefCellMarLeft = 108;
|
||
//m_nDefCellMarTop = 0;
|
||
DEFAULT_PROPERTY( m_nDefCellMarBottom )
|
||
DEFAULT_PROPERTY( m_nDefCellMarRight )
|
||
DEFAULT_PROPERTY( m_nDefCellMarLeft )
|
||
DEFAULT_PROPERTY( m_nDefCellMarTop )
|
||
|
||
//m_eDefCellMarBottomUnit = 3;
|
||
//m_eDefCellMarRightUnit = 3;
|
||
//m_eDefCellMarLeftUnit = 3;
|
||
//m_eDefCellMarTopUnit = 3;
|
||
DEFAULT_PROPERTY( m_eDefCellMarBottomUnit )
|
||
DEFAULT_PROPERTY( m_eDefCellMarRightUnit )
|
||
DEFAULT_PROPERTY( m_eDefCellMarLeftUnit )
|
||
DEFAULT_PROPERTY( m_eDefCellMarTopUnit )
|
||
|
||
DEFAULT_PROPERTY( m_nDefCellSpBottom )
|
||
DEFAULT_PROPERTY( m_nDefCellSpLeft )
|
||
DEFAULT_PROPERTY( m_nDefCellSpRight )
|
||
DEFAULT_PROPERTY( m_nDefCellSpTop )
|
||
|
||
DEFAULT_PROPERTY( m_eDefCellSpBottomUnit )
|
||
DEFAULT_PROPERTY( m_eDefCellSpLeftUnit )
|
||
DEFAULT_PROPERTY( m_eDefCellSpRightUnit )
|
||
DEFAULT_PROPERTY( m_eDefCellSpTopUnit )
|
||
|
||
m_oBorderLeft.SetEmpty();
|
||
m_oBorderRight.SetEmpty();
|
||
m_oBorderTop.SetEmpty();
|
||
m_oBorderBottom.SetEmpty();
|
||
m_oBorderVert.SetEmpty();
|
||
m_oBorderHor.SetEmpty();
|
||
|
||
m_oShading.SetDefault();
|
||
|
||
DEFAULT_PROPERTY( m_nStyle )
|
||
|
||
DEFAULT_PROPERTY( m_bAutoFirstRow )
|
||
DEFAULT_PROPERTY( m_bAutoLastRow )
|
||
DEFAULT_PROPERTY( m_bAutoFirstCol )
|
||
DEFAULT_PROPERTY( m_bAutoLastCol )
|
||
DEFAULT_PROPERTY( m_bAutoNoRowBand )
|
||
DEFAULT_PROPERTY( m_bAutoNoColBand )
|
||
|
||
DEFAULT_PROPERTY( m_nRowBandSize )
|
||
DEFAULT_PROPERTY( m_nColBandSize )
|
||
}
|
||
bool RtfTableProperty::IsValid()
|
||
{
|
||
return true;
|
||
}
|
||
void RtfTableProperty::Merge( RtfTableProperty& oTablePr )
|
||
{
|
||
MERGE_PROPERTY( m_bBidi, oTablePr )
|
||
MERGE_PROPERTY( m_nAutoFit, oTablePr )
|
||
MERGE_PROPERTY( m_nGraph, oTablePr )
|
||
MERGE_PROPERTY( nTableIndent, oTablePr )
|
||
MERGE_PROPERTY( eTableIndentUnit, oTablePr )
|
||
|
||
MERGE_PROPERTY_DEF( m_eJust, oTablePr, rj_none )
|
||
|
||
MERGE_PROPERTY( m_nWrapLeft, oTablePr )
|
||
MERGE_PROPERTY( m_nWrapRight, oTablePr )
|
||
MERGE_PROPERTY( m_nWrapTop, oTablePr )
|
||
MERGE_PROPERTY( m_nWrapBottom, oTablePr )
|
||
MERGE_PROPERTY( m_bOverlap, oTablePr )
|
||
|
||
MERGE_PROPERTY_DEF( m_eHRef, oTablePr, hr_none )
|
||
MERGE_PROPERTY_DEF( m_eVRef, oTablePr, vr_none )
|
||
MERGE_PROPERTY_DEF( m_eHPos, oTablePr, hp_none )
|
||
MERGE_PROPERTY_DEF( m_eVPos, oTablePr, vp_none )
|
||
MERGE_PROPERTY( m_nHPos, oTablePr )
|
||
MERGE_PROPERTY( m_nVPos, oTablePr )
|
||
|
||
MERGE_PROPERTY( m_nLeft, oTablePr )
|
||
MERGE_PROPERTY( m_nWidth, oTablePr )
|
||
|
||
MERGE_PROPERTY_DEF( m_eWidthUnit, oTablePr, mu_none )
|
||
|
||
MERGE_PROPERTY( m_nDefCellMarBottom, oTablePr )
|
||
MERGE_PROPERTY( m_nDefCellMarRight, oTablePr )
|
||
MERGE_PROPERTY( m_nDefCellMarLeft, oTablePr )
|
||
MERGE_PROPERTY( m_nDefCellMarTop, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellMarBottomUnit, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellMarRightUnit, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellMarLeftUnit, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellMarTopUnit, oTablePr )
|
||
|
||
MERGE_PROPERTY( m_nDefCellSpBottom, oTablePr )
|
||
MERGE_PROPERTY( m_nDefCellSpLeft, oTablePr )
|
||
MERGE_PROPERTY( m_nDefCellSpRight, oTablePr )
|
||
MERGE_PROPERTY( m_nDefCellSpTop, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellSpBottomUnit, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellSpLeftUnit, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellSpRightUnit, oTablePr )
|
||
MERGE_PROPERTY( m_eDefCellSpTopUnit, oTablePr )
|
||
|
||
m_oBorderLeft.Merge ( oTablePr.m_oBorderLeft );
|
||
m_oBorderRight.Merge( oTablePr.m_oBorderRight );
|
||
m_oBorderTop.Merge ( oTablePr.m_oBorderTop );
|
||
m_oBorderBottom.Merge( oTablePr.m_oBorderBottom );
|
||
m_oBorderVert.Merge ( oTablePr.m_oBorderVert );
|
||
m_oBorderHor.Merge ( oTablePr.m_oBorderHor );
|
||
m_oShading.Merge ( oTablePr.m_oShading );
|
||
|
||
MERGE_PROPERTY( m_nStyle, oTablePr )
|
||
|
||
MERGE_PROPERTY( m_bAutoFirstRow, oTablePr )
|
||
MERGE_PROPERTY( m_bAutoLastRow, oTablePr )
|
||
MERGE_PROPERTY( m_bAutoFirstCol, oTablePr )
|
||
MERGE_PROPERTY( m_bAutoLastCol, oTablePr )
|
||
MERGE_PROPERTY( m_bAutoNoRowBand, oTablePr )
|
||
MERGE_PROPERTY( m_bAutoNoColBand, oTablePr )
|
||
|
||
MERGE_PROPERTY( m_nRowBandSize, oTablePr )
|
||
MERGE_PROPERTY( m_nColBandSize, oTablePr )
|
||
}
|
||
std::wstring RtfTableProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
RENDER_RTF_BOOL( m_bBidi, sResult, L"taprtl" )
|
||
|
||
if( PROP_DEF == m_nAutoFit || 1 == m_nAutoFit )
|
||
sResult += L"\\trautofit1";
|
||
else if( 0 == m_nAutoFit )
|
||
sResult += L"\\trautofit0";
|
||
|
||
RENDER_RTF_INT( m_nAutoFit, sResult, L"trautofit" )
|
||
RENDER_RTF_INT( m_nGraph, sResult, L"trgaph" )
|
||
RENDER_RTF_INT( nTableIndent, sResult, L"tblind" )
|
||
RENDER_RTF_INT( eTableIndentUnit, sResult, L"tblindtype" )
|
||
|
||
RENDER_RTF_INT( m_nWrapLeft, sResult, L"tdfrmtxtLeft" )
|
||
RENDER_RTF_INT( m_nWrapRight, sResult, L"tdfrmtxtRight" )
|
||
RENDER_RTF_INT( m_nWrapTop, sResult, L"tdfrmtxtTop" )
|
||
RENDER_RTF_INT( m_nWrapBottom, sResult, L"tdfrmtxtBottom" )
|
||
RENDER_RTF_BOOL( m_bOverlap, sResult, L"tabsnoovrlp" )
|
||
|
||
switch ( m_eHRef )
|
||
{
|
||
case hr_phmrg: sResult += L"\\tphmrg"; break;
|
||
case hr_phpg: sResult += L"\\tphpg"; break;
|
||
case hr_phcol: sResult += L"\\tphcol"; break;
|
||
}
|
||
if( PROP_DEF != m_nHPos )
|
||
{
|
||
if( m_nHPos > 0 )
|
||
sResult += L"\\tposx" + std::to_wstring(m_nHPos);
|
||
else
|
||
sResult += L"\\tposnegx" + std::to_wstring(m_nHPos);
|
||
}
|
||
switch ( m_eHPos )
|
||
{
|
||
case hp_posxc: sResult += L"\\tposxc"; break;
|
||
case hp_posxi: sResult += L"\\tposxi"; break;
|
||
case hp_posxo: sResult += L"\\tposxo"; break;
|
||
case hp_posxl: sResult += L"\\tposxl"; break;
|
||
case hp_posxr: sResult += L"\\tposxr"; break;
|
||
}
|
||
|
||
switch ( m_eVRef )
|
||
{
|
||
case vr_pvmrg: sResult += L"\\tpvmrg"; break;
|
||
case vr_pvpg: sResult += L"\\tpvpg"; break;
|
||
case vr_pvpara: sResult += L"\\tpvpara"; break;
|
||
}
|
||
if( PROP_DEF != m_nVPos )
|
||
{
|
||
if( m_nVPos > 0 )
|
||
sResult += L"\\tposy" + std::to_wstring(m_nVPos);
|
||
else
|
||
sResult += L"\\tposnegy" + std::to_wstring(m_nVPos);
|
||
}
|
||
switch ( m_eVPos )
|
||
{
|
||
case vp_posyt: sResult += L"\\tposyt"; break;
|
||
case vp_posyil: sResult += L"\\tposyil"; break;
|
||
case vp_posyb: sResult += L"\\tposyb"; break;
|
||
case vp_posyc: sResult += L"\\tposyc"; break;
|
||
case vp_posyin: sResult += L"\\tposyin"; break;
|
||
case vp_posyout: sResult += L"\\tposyout"; break;
|
||
}
|
||
RENDER_RTF_INT( m_nLeft, sResult, L"trleft" )
|
||
|
||
RENDER_RTF_INT( m_nDefCellMarLeft, sResult, L"trpaddl" );
|
||
RENDER_RTF_INT( m_nDefCellMarRight, sResult, L"trpaddr" );
|
||
RENDER_RTF_INT( m_nDefCellMarTop, sResult, L"trpaddt" );
|
||
RENDER_RTF_INT( m_nDefCellMarBottom, sResult, L"trpaddb" );
|
||
RENDER_RTF_INT( m_eDefCellMarLeftUnit, sResult, L"trpaddfl" );
|
||
RENDER_RTF_INT( m_eDefCellMarRightUnit, sResult, L"trpaddfr" );
|
||
RENDER_RTF_INT( m_eDefCellMarTopUnit, sResult, L"trpaddft" );
|
||
RENDER_RTF_INT( m_eDefCellMarBottomUnit, sResult, L"trpaddfb" );
|
||
|
||
RENDER_RTF_INT( m_nDefCellSpBottom, sResult, L"trspdb" );
|
||
RENDER_RTF_INT( m_nDefCellSpLeft, sResult, L"trspdl" );
|
||
RENDER_RTF_INT( m_nDefCellSpRight, sResult, L"trspdr" );
|
||
RENDER_RTF_INT( m_nDefCellSpTop, sResult, L"trspdt" );
|
||
RENDER_RTF_INT( m_eDefCellSpBottomUnit, sResult, L"trspdfb" );
|
||
RENDER_RTF_INT( m_eDefCellSpLeftUnit, sResult, L"trspdfl" );
|
||
RENDER_RTF_INT( m_eDefCellSpRightUnit, sResult, L"trspdfr" );
|
||
RENDER_RTF_INT( m_eDefCellSpTopUnit, sResult, L"trspdft" );
|
||
|
||
if( m_oBorderTop.IsValid() == true )
|
||
{
|
||
sResult += L"\\trbrdrt";
|
||
sResult += m_oBorderTop.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( m_oBorderLeft.IsValid() == true )
|
||
{
|
||
sResult += L"\\trbrdrl";
|
||
sResult += m_oBorderLeft.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( m_oBorderBottom.IsValid() == true )
|
||
{
|
||
sResult += L"\\trbrdrb";
|
||
sResult += m_oBorderBottom.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( m_oBorderRight.IsValid() == true )
|
||
{
|
||
sResult += L"\\trbrdrr";
|
||
sResult += m_oBorderRight.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( m_oBorderHor.IsValid() == true/* && m_bAutoNoRowBand != 1*/)
|
||
{
|
||
sResult += L"\\trbrdrh";
|
||
sResult += m_oBorderHor.RenderToRtf( oRenderParameter );
|
||
}
|
||
if( m_oBorderVert.IsValid() == true/* && m_bAutoNoColBand != 1*/)
|
||
{
|
||
sResult += L"\\trbrdrv";
|
||
sResult += m_oBorderVert.RenderToRtf( oRenderParameter );
|
||
}
|
||
|
||
if( m_oShading.IsValid() == true )
|
||
sResult += m_oShading.RenderToRtf( oRenderParameter );
|
||
|
||
//RENDER_RTF_INT( m_nStyle, sResult, L"ts" )
|
||
|
||
RENDER_RTF_BOOL( m_bAutoFirstRow, sResult, L"tbllkhdrrows" )
|
||
RENDER_RTF_BOOL( m_bAutoLastRow, sResult, L"tbllklastrow" )
|
||
RENDER_RTF_BOOL( m_bAutoFirstCol, sResult, L"tbllkhdrcols" )
|
||
RENDER_RTF_BOOL( m_bAutoLastCol, sResult, L"tbllklastcol" )
|
||
RENDER_RTF_BOOL( m_bAutoNoRowBand, sResult, L"tbllknorowband" )
|
||
RENDER_RTF_BOOL( m_bAutoNoColBand, sResult, L"tbllknocolband" )
|
||
|
||
RENDER_RTF_INT( m_nRowBandSize, sResult, L"tscbandsh" )
|
||
RENDER_RTF_INT( m_nColBandSize, sResult, L"tscbandsv" )
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfTableProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( PROP_DEF != m_nStyle )
|
||
{
|
||
RtfDocument* poDocument = static_cast<RtfDocument*>( oRenderParameter.poDocument );
|
||
RtfStylePtr oCurStyle;
|
||
if( true == poDocument->m_oStyleTable.GetStyle( m_nStyle, oCurStyle) )
|
||
{
|
||
sResult += L"<w:tblStyle w:val=\"";
|
||
sResult += L"Style_" + std::to_wstring(m_nStyle); //oCurStyle->m_sName;
|
||
sResult += L"\"/>";
|
||
}
|
||
}
|
||
RENDER_OOX_BOOL( m_bBidi, sResult, L"w:bidiVisual" );
|
||
|
||
if( PROP_DEF == m_nAutoFit || 0 == m_nAutoFit )
|
||
sResult += L"<w:tblLayout w:type=\"fixed\"/>";
|
||
else if( 1 == m_nAutoFit )
|
||
sResult += L"<w:tblLayout w:type=\"autofit\"/>";
|
||
|
||
//сделаем не по документации, а как все остальные юниты !!!
|
||
if( PROP_DEF != nTableIndent && 3 == eTableIndentUnit )
|
||
{
|
||
sResult += L"<w:tblInd w:w=\"" + std::to_wstring(nTableIndent) + L"\" w:type=\"dxa\"/>";
|
||
}
|
||
|
||
if( 1 == m_bOverlap )
|
||
sResult += L"<w:tblOverlap w:val=\"overlap\"/>";
|
||
|
||
switch( m_eJust )
|
||
{
|
||
case rj_trql : sResult += L"<w:jc w:val=\"left\"/>"; break;
|
||
case rj_trqr : sResult += L"<w:jc w:val=\"right\"/>"; break;
|
||
case rj_trqc : sResult += L"<w:jc w:val=\"center\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
std::wstring sFloatingPosition;
|
||
if( PROP_DEF != m_nWrapLeft )
|
||
sFloatingPosition += L" w:leftFromText=\"" + std::to_wstring(m_nWrapLeft) + L"\"";
|
||
if( PROP_DEF != m_nWrapRight )
|
||
sFloatingPosition += L" w:rightFromText=\"" + std::to_wstring(m_nWrapRight) + L"\"";
|
||
if( PROP_DEF != m_nWrapTop )
|
||
sFloatingPosition += L" w:topFromText=\"" + std::to_wstring(m_nWrapTop) + L"\"";
|
||
if( PROP_DEF != m_nWrapBottom )
|
||
sFloatingPosition += L" w:bottomFromText=\"" + std::to_wstring(m_nWrapBottom) + L"\"";
|
||
|
||
switch ( m_eHRef )
|
||
{
|
||
case hr_phmrg: sFloatingPosition += L" w:horzAnchor=\"margin\""; break;
|
||
case hr_phpg: sFloatingPosition += L" w:horzAnchor=\"page\""; break;
|
||
case hr_phcol: sFloatingPosition += L" w:horzAnchor=\"text\""; break;
|
||
}
|
||
if( PROP_DEF != m_nHPos )
|
||
sFloatingPosition += L" w:tblpX=\"" + std::to_wstring(m_nHPos) + L"\"";
|
||
//else
|
||
switch ( m_eHPos )
|
||
{
|
||
case hp_posxc: sFloatingPosition += L" w:tblpXSpec=\"center\""; break;
|
||
case hp_posxi: sFloatingPosition += L" w:tblpXSpec=\"inside\""; break;
|
||
case hp_posxo: sFloatingPosition += L" w:tblpXSpec=\"outside\""; break;
|
||
case hp_posxl: sFloatingPosition += L" w:tblpXSpec=\"left\""; break;
|
||
case hp_posxr: sFloatingPosition += L" w:tblpXSpec=\"right\""; break;
|
||
}
|
||
|
||
switch ( m_eVRef )
|
||
{
|
||
case vr_pvmrg: sFloatingPosition += L" w:vertAnchor=\"margin\""; break;
|
||
case vr_pvpg: sFloatingPosition += L" w:vertAnchor=\"page\""; break;
|
||
case vr_pvpara: sFloatingPosition += L" w:vertAnchor=\"text\""; break;
|
||
}
|
||
|
||
if( PROP_DEF != m_nVPos )
|
||
sFloatingPosition += L" w:tblpY=\"" + std::to_wstring(m_nVPos) + L"\"";
|
||
//else
|
||
switch ( m_eVPos )
|
||
{
|
||
case vp_posyt: sFloatingPosition += L" w:tblpYSpec=\"top\""; break;
|
||
case vp_posyil: sFloatingPosition += L" w:tblpYSpec=\"inline\""; break;
|
||
case vp_posyb: sFloatingPosition += L" w:tblpYSpec=\"bottom\""; break;
|
||
case vp_posyc: sFloatingPosition += L" w:tblpYSpec=\"center\""; break;
|
||
case vp_posyin: sFloatingPosition += L" w:tblpYSpec=\"inside\""; break;
|
||
case vp_posyout: sFloatingPosition += L" w:tblpYSpec=\"outside\""; break;
|
||
}
|
||
if( false == sFloatingPosition.empty() )
|
||
{
|
||
sResult += L"<w:tblpPr ";
|
||
sResult += sFloatingPosition;
|
||
sResult += L"/>";
|
||
}
|
||
|
||
if( PROP_DEF != m_nWidth && ( 2 == m_eWidthUnit || 3 == m_eWidthUnit ))
|
||
{
|
||
if( 2 == m_eWidthUnit )
|
||
sResult += L"<w:tblW w:w=\"" + std::to_wstring(m_nWidth) + L"\" w:type=\"pct\"/>";
|
||
else
|
||
sResult += L"<w:tblW w:w=\"" + std::to_wstring(m_nWidth) + L"\" w:type=\"dxa\"/>";
|
||
}
|
||
else
|
||
sResult += L"<w:tblW w:w=\"0\" w:type=\"auto\"/>";
|
||
|
||
std::wstring sDefCellMargins;
|
||
if( PROP_DEF != m_nDefCellMarBottom && 3 == m_eDefCellMarBottomUnit )
|
||
sDefCellMargins += L"<w:bottom w:w=\"" + std::to_wstring(m_nDefCellMarBottom) + L"\" w:type=\"dxa\"/>";
|
||
if( PROP_DEF != m_nDefCellMarLeft && 3 == m_eDefCellMarLeftUnit )
|
||
sDefCellMargins += L"<w:left w:w=\"" + std::to_wstring(m_nDefCellMarLeft) + L"\" w:type=\"dxa\"/>";
|
||
else
|
||
sDefCellMargins += L"<w:left w:w=\"0\" w:type=\"dxa\"/>";
|
||
|
||
if( PROP_DEF != m_nDefCellMarRight && 3 == m_eDefCellMarRightUnit )
|
||
sDefCellMargins += L"<w:right w:w=\"" + std::to_wstring(m_nDefCellMarRight) + L"\" w:type=\"dxa\"/>";
|
||
else
|
||
sDefCellMargins += L"<w:right w:w=\"0\" w:type=\"dxa\"/>";
|
||
|
||
if( PROP_DEF != m_nDefCellMarTop && 3 == m_eDefCellMarTopUnit )
|
||
sDefCellMargins += L"<w:top w:w=\"" + std::to_wstring(m_nDefCellMarTop) + L"\" w:type=\"dxa\"/>";
|
||
|
||
if( !sDefCellMargins.empty() )
|
||
sResult += L"<w:tblCellMar>" + sDefCellMargins + L"</w:tblCellMar>";
|
||
|
||
if( PROP_DEF != m_nDefCellSpBottom && 3 == m_eDefCellSpBottomUnit )
|
||
sResult += L"<w:tblCellSpacing w:w=\"" + std::to_wstring(m_nDefCellSpBottom) + L"\" w:type=\"dxa\"/>";
|
||
|
||
//if( PROP_DEF != m_nLeft )
|
||
// sResult += L"<w:tblInd w:w=\"" + std::to_wstring(m_nLeft) + L"\" w:type=\"dxa\"/>";
|
||
|
||
RenderParameter oNewParam = oRenderParameter;
|
||
oNewParam.nType = RENDER_TO_OOX_PARAM_BORDER_ATTRIBUTE;
|
||
std::wstring sBorders;
|
||
if( m_oBorderLeft.IsValid() ) sBorders += L"<w:left " + m_oBorderLeft.RenderToOOX(oNewParam) + L"/>";
|
||
if( m_oBorderRight.IsValid() ) sBorders += L"<w:right " + m_oBorderRight.RenderToOOX(oNewParam) + L"/>";
|
||
if( m_oBorderTop.IsValid() ) sBorders += L"<w:top " + m_oBorderTop.RenderToOOX(oNewParam) + L"/>";
|
||
if( m_oBorderBottom.IsValid() ) sBorders += L"<w:bottom " + m_oBorderBottom.RenderToOOX(oNewParam) + L"/>";
|
||
if( m_oBorderVert.IsValid() ) sBorders += L"<w:insideV " + m_oBorderVert.RenderToOOX(oNewParam) + L"/>";
|
||
if( m_oBorderHor.IsValid() ) sBorders += L"<w:insideH " + m_oBorderHor.RenderToOOX(oNewParam) + L"/>";
|
||
|
||
if( !sBorders.empty() )
|
||
sResult += L"<w:tblBorders>" + sBorders+ L"</w:tblBorders>";
|
||
|
||
if( m_oShading.IsValid() == true )
|
||
sResult += m_oShading.RenderToOOX(oRenderParameter);
|
||
|
||
|
||
//if( RENDER_TO_OOX_PARAM_STYLES == oRenderParameter.nType )
|
||
//{
|
||
// RENDER_OOX_INT( m_nRowBandSize, sResult, L"w:tblStyleRowBandSize" )
|
||
// RENDER_OOX_INT( m_nColBandSize, sResult, L"w:tblStyleColBandSize " )
|
||
//}
|
||
//else
|
||
//{
|
||
// std::wstring sTableLook;
|
||
// RENDER_OOX_BOOL_ATTRIBUTE( m_bAutoFirstRow, sTableLook, L"w:firstRow" )
|
||
// RENDER_OOX_BOOL_ATTRIBUTE( m_bAutoLastRow, sTableLook, L"w:lastRow" )
|
||
// RENDER_OOX_BOOL_ATTRIBUTE( m_bAutoFirstCol, sTableLook, L"w:firstColumn" )
|
||
// RENDER_OOX_BOOL_ATTRIBUTE( m_bAutoLastCol, sTableLook, L"w:lastColumn" )
|
||
// RENDER_OOX_BOOL_ATTRIBUTE( m_bAutoNoRowBand, sTableLook, L"w:noHBand" )
|
||
// RENDER_OOX_BOOL_ATTRIBUTE( m_bAutoNoColBand, sTableLook, L"w:noVBand" )
|
||
|
||
// if( false == sTableLook.empty() )
|
||
// sResult += L"<w:tblLook " + sTableLook + L"/>");
|
||
//}
|
||
|
||
if( !sResult.empty() )
|
||
sResult = L"<w:tblPr>" + sResult + L"</w:tblPr>";
|
||
return sResult;
|
||
}
|
||
|
||
RtfRowProperty::RtfRowProperty()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfRowProperty::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfRowProperty::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
//не SetEmpty() !!!
|
||
m_oBorderLeft.SetDefault();
|
||
m_oBorderRight.SetDefault();
|
||
m_oBorderTop.SetDefault();
|
||
m_oBorderBottom.SetDefault();
|
||
m_oBorderVert.SetDefault();
|
||
m_oBorderHor.SetDefault();
|
||
}
|
||
void RtfRowProperty::SetDefault()
|
||
{
|
||
RtfTableProperty::SetDefault();
|
||
DEFAULT_PROPERTY( m_nIndex )
|
||
DEFAULT_PROPERTY( m_nBandIndex )
|
||
DEFAULT_PROPERTY( m_bLastRow )
|
||
DEFAULT_PROPERTY( m_nAutoFit )
|
||
DEFAULT_PROPERTY( m_bIsHeader )
|
||
DEFAULT_PROPERTY( m_bKeep )
|
||
DEFAULT_PROPERTY( m_nRightToLeft )
|
||
|
||
DEFAULT_PROPERTY( m_nHeight )
|
||
|
||
DEFAULT_PROPERTY( m_nWidthStartInvCell )
|
||
DEFAULT_PROPERTY( m_nWidthEndInvCell )
|
||
|
||
m_eWidthStartInvCellUnit = mu_none;
|
||
m_eWidthEndInvCellUnit = mu_none;
|
||
|
||
DEFAULT_PROPERTY( m_nGridBefore )
|
||
DEFAULT_PROPERTY( m_nGridAfter )
|
||
m_aArray.clear();
|
||
|
||
DEFAULT_PROPERTY( m_bStyleFirstRow )
|
||
DEFAULT_PROPERTY( m_bStyleLastRow )
|
||
DEFAULT_PROPERTY( m_bStyleFirstCol )
|
||
DEFAULT_PROPERTY( m_bStyleLastCol )
|
||
DEFAULT_PROPERTY( m_bStyleOddRowBand )
|
||
DEFAULT_PROPERTY( m_bStyleEvenRowBand )
|
||
DEFAULT_PROPERTY( m_bStyleOddColBand )
|
||
DEFAULT_PROPERTY( m_bStyleEvenColBand )
|
||
DEFAULT_PROPERTY( m_bStyleNWCell )
|
||
DEFAULT_PROPERTY( m_bStyleNECell )
|
||
DEFAULT_PROPERTY( m_bStyleSWCell )
|
||
DEFAULT_PROPERTY( m_bStyleSECell )
|
||
|
||
DEFAULT_PROPERTY( m_nTrAuth)
|
||
DEFAULT_PROPERTY( m_nTrDate)
|
||
|
||
m_pOldRowProperty = RtfRowPropertyPtr();
|
||
}
|
||
bool RtfRowProperty::IsValid()
|
||
{
|
||
return true;
|
||
}
|
||
void RtfRowProperty::Merge( RtfRowProperty& oRowPr )
|
||
{
|
||
RtfTableProperty::Merge( oRowPr );
|
||
|
||
MERGE_PROPERTY( m_nIndex, oRowPr )
|
||
MERGE_PROPERTY( m_nBandIndex, oRowPr )
|
||
MERGE_PROPERTY( m_bLastRow, oRowPr )
|
||
MERGE_PROPERTY( m_nRightToLeft, oRowPr )
|
||
|
||
MERGE_PROPERTY( m_nAutoFit, oRowPr )
|
||
MERGE_PROPERTY( m_bIsHeader, oRowPr )
|
||
MERGE_PROPERTY( m_bKeep, oRowPr )
|
||
|
||
MERGE_PROPERTY( m_nHeight, oRowPr )
|
||
|
||
MERGE_PROPERTY ( m_nWidthStartInvCell, oRowPr )
|
||
MERGE_PROPERTY_DEF ( m_eWidthStartInvCellUnit, oRowPr, mu_none )
|
||
MERGE_PROPERTY ( m_nWidthEndInvCell, oRowPr )
|
||
MERGE_PROPERTY_DEF ( m_eWidthEndInvCellUnit, oRowPr, mu_none )
|
||
|
||
MERGE_PROPERTY_DEF ( m_nGridBefore, oRowPr, mu_none )
|
||
MERGE_PROPERTY_DEF ( m_nGridAfter, oRowPr, mu_none )
|
||
|
||
MERGE_PROPERTY( m_bStyleFirstRow, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleLastRow, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleFirstCol, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleLastCol, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleOddRowBand, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleEvenRowBand, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleOddColBand, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleEvenColBand, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleNWCell, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleNECell, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleSWCell, oRowPr )
|
||
MERGE_PROPERTY( m_bStyleSECell, oRowPr )
|
||
|
||
MERGE_PROPERTY( m_nTrAuth, oRowPr )
|
||
MERGE_PROPERTY( m_nTrDate, oRowPr )
|
||
}
|
||
std::wstring RtfRowProperty::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if( RENDER_TO_RTF_PARAM_NO_WROWD != oRenderParameter.nType )
|
||
sResult += L"\\trowd";
|
||
|
||
RENDER_RTF_INT ( m_nIndex, sResult, L"irow" );
|
||
RENDER_RTF_INT ( m_nBandIndex, sResult, L"irowband" );
|
||
RENDER_RTF_BOOL ( m_bLastRow, sResult, L"lastrow" );
|
||
RENDER_RTF_INT ( m_nAutoFit, sResult, L"trautofit" );
|
||
RENDER_RTF_BOOL ( m_bIsHeader, sResult, L"trhdr" );
|
||
RENDER_RTF_BOOL ( m_bKeep, sResult, L"trkeep" );
|
||
|
||
if (m_nRightToLeft == 1) sResult += L"\\rtlrow";
|
||
if (m_nRightToLeft == 0) sResult += L"\\ltrrow";
|
||
|
||
switch( m_eJust )
|
||
{
|
||
case rj_trql : sResult += L"\\trql"; break;
|
||
case rj_trqr : sResult += L"\\trqr"; break;
|
||
case rj_trqc : sResult += L"\\trqc"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nHeight, sResult, L"trrh" );
|
||
|
||
switch( m_eWidthUnit )
|
||
{
|
||
case mu_Auto: sResult += L"\\trftsWidth1"; break;
|
||
case mu_Percent: sResult += L"\\trftsWidth2"; break;
|
||
case mu_Twips: sResult += L"\\trftsWidth3"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nWidth, sResult, L"trwWidth" );
|
||
switch( m_eWidthStartInvCellUnit )
|
||
{
|
||
case mu_Auto: sResult += L"\\trftsWidthB1"; break;
|
||
case mu_Percent: sResult += L"\\trftsWidthB2"; break;
|
||
case mu_Twips: sResult += L"\\trftsWidthB3"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nWidthStartInvCell, sResult, L"trwWidthB" );
|
||
switch( m_eWidthEndInvCellUnit )
|
||
{
|
||
case mu_Auto: sResult += L"\\trftsWidthA1"; break;
|
||
case mu_Percent: sResult += L"\\trftsWidthA2"; break;
|
||
case mu_Twips: sResult += L"\\trftsWidthA3"; break;
|
||
default:
|
||
break;
|
||
}
|
||
RENDER_RTF_INT( m_nWidthEndInvCell, sResult, L"trwWidthA" );
|
||
sResult += RtfTableProperty::RenderToRtf( oRenderParameter );
|
||
|
||
for (size_t i = 0; i < m_aArray.size(); i++ )
|
||
sResult += m_aArray[i].RenderToRtf( oRenderParameter );
|
||
|
||
if (m_pOldRowProperty)
|
||
{
|
||
sResult += L"{\\*\\oldtprops";
|
||
sResult += m_pOldRowProperty->RenderToRtf(oRenderParameter);
|
||
sResult += L"}";
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
std::wstring RtfRowProperty::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
RtfDocument * poRtfDocument = static_cast<RtfDocument*> (oRenderParameter.poDocument);
|
||
OOXWriter * poOOXWriter = static_cast<OOXWriter*> (oRenderParameter.poWriter);
|
||
|
||
RENDER_OOX_BOOL( m_bIsHeader, sResult, L"w:tblHeader" )
|
||
RENDER_OOX_BOOL( m_bKeep, sResult, L"w:cantSplit" )
|
||
|
||
switch( m_eJust )
|
||
{
|
||
case rj_trql : sResult += L"<w:jc w:val=\"left\"/>"; break;
|
||
case rj_trqr : sResult += L"<w:jc w:val=\"right\"/>"; break;
|
||
case rj_trqc : sResult += L"<w:jc w:val=\"center\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
if( PROP_DEF != m_nHeight )
|
||
{
|
||
if( m_nHeight > 0 )
|
||
sResult += L"<w:trHeight w:val=\"" + std::to_wstring(m_nHeight) +L"\" w:hRule=\"atLeast\"/>";
|
||
else if( m_nHeight < 0 )
|
||
sResult += L"<w:trHeight w:val=\"" + std::to_wstring(-m_nHeight) +L"\" w:hRule=\"exact\"/>";
|
||
}
|
||
|
||
if( PROP_DEF != m_nWidthStartInvCell )
|
||
{
|
||
switch( m_eWidthStartInvCellUnit )
|
||
{
|
||
case mu_Percent: sResult += L"<w:wBefore w:type=\"pct\" w:w=\"" + std::to_wstring(m_nWidthStartInvCell) + L"%\"/>"; break;
|
||
case mu_Twips: sResult += L"<w:wBefore w:type=\"dxa\" w:w=\"" + std::to_wstring(m_nWidthStartInvCell) + L"\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
if( PROP_DEF != m_nWidthEndInvCell )
|
||
{
|
||
switch( m_eWidthEndInvCellUnit )
|
||
{
|
||
case mu_Percent: sResult += L"<w:wAfter w:type=\"pct\" w:w=\"" + std::to_wstring(m_nWidthEndInvCell) + L"\"/>"; break;
|
||
case mu_Twips: sResult += L"<w:wAfter w:type=\"dxa\" w:w=\"" + std::to_wstring(m_nWidthEndInvCell) + L"\"/>"; break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
RENDER_OOX_INT( m_nGridBefore, sResult, L"w:gridBefore" )
|
||
RENDER_OOX_INT( m_nGridAfter, sResult, L"w:gridAfter" )
|
||
|
||
//std::wstring scnfStyle;
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleFirstRow, scnfStyle, L"w:firstRow" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleLastRow, scnfStyle, L"w:lastRow" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleFirstCol, scnfStyle, L"w:firstColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleLastCol, scnfStyle, L"w:lastColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleOddRowBand, scnfStyle, L"w:oddHBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleEvenRowBand, scnfStyle, L"w:evenHBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleOddColBand, scnfStyle, L"w:oddVBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleEvenColBand, scnfStyle, L"w:evenvBand" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleNWCell, scnfStyle, L"w:firstRowFirstColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleNECell, scnfStyle, L"w:firstRowLastColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleSWCell, scnfStyle, L"w:lastRowFirstColumn" )
|
||
//RENDER_OOX_BOOL_ATTRIBUTE( m_bStyleSECell, scnfStyle, L"w:lastRowLastColumn" )
|
||
//if(!scnfStyle.empty() )
|
||
// sResult += L"<w:cnfStyle " + scnfStyle + L"/>" );
|
||
|
||
// _bstr_t hk;
|
||
|
||
if (m_pOldRowProperty)
|
||
{
|
||
m_pOldRowProperty;
|
||
//if ( PROP_DEF != oReader.m_oState->m_oCharProp.m_nDeleted )
|
||
//{
|
||
// std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(oReader.m_oState->m_oCharProp.m_nRevauthDel);
|
||
// std::wstring sDate(RtfUtility::convertDateTime(oReader.m_oState->m_oCharProp.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"\"/>";
|
||
//}
|
||
//if ( PROP_DEF != oReader.m_oState->m_oCharProp.m_nRevised )
|
||
//{
|
||
// std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(oReader.m_oState->m_oCharProp.m_nRevauth);
|
||
// std::wstring sDate(RtfUtility::convertDateTime(oReader.m_oState->m_oCharProp.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"\"/>";
|
||
//}
|
||
std::wstring sAuthor = poRtfDocument->m_oRevisionTable.GetAuthor(m_nTrAuth);
|
||
std::wstring sDate(RtfUtility::convertDateTime(m_nTrDate).c_str());
|
||
|
||
RenderParameter oRenderParameterNew = oRenderParameter;
|
||
oRenderParameterNew.nType = RENDER_TO_OOX_PARAM_UNKNOWN;
|
||
std::wstring rowChangeProps = m_pOldRowProperty->RenderToOOX(oRenderParameterNew);
|
||
|
||
if (rowChangeProps.empty())
|
||
{
|
||
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"\"/>";
|
||
}
|
||
else
|
||
{
|
||
sResult += L"<w:trPrChange w:date=\"" + sDate + L"\" w:author=\"" + XmlUtils::EncodeXmlString(sAuthor) + L"\" w:id=\"" + std::to_wstring(poOOXWriter->m_nCurTrackChangesId++).c_str() + L"\">";
|
||
sResult += L"<w:trPr>";
|
||
sResult += rowChangeProps;
|
||
sResult += L"</w:trPr>";
|
||
sResult += L"</w:trPrChange>";
|
||
}
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfInformation::RtfInformation()
|
||
{
|
||
SetDefault();
|
||
}
|
||
bool RtfInformation::IsValid()
|
||
{
|
||
return true;
|
||
}
|
||
void RtfInformation::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfInformation::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfInformation::SetDefault()
|
||
{
|
||
m_sTitle = L"";
|
||
m_sSubject = L"";
|
||
m_sAuthor = L"";
|
||
m_sManager = L"";
|
||
m_sCompany = L"";
|
||
m_sOperator = L"";
|
||
m_sCategory = L"";
|
||
m_sKeywords = L"";
|
||
m_sComment = L"";
|
||
m_sDocCom = L"";
|
||
m_sLinkBase = L"";
|
||
m_oCreateTime.SetDefault();
|
||
m_oRevTime.SetDefault();
|
||
m_oPrintTime.SetDefault();
|
||
m_oBackupTime.SetDefault();
|
||
|
||
DEFAULT_PROPERTY( m_nVersion )
|
||
DEFAULT_PROPERTY( m_nInternalVersion )
|
||
DEFAULT_PROPERTY( m_nEndingTime )
|
||
|
||
DEFAULT_PROPERTY( m_nNumberOfPages )
|
||
DEFAULT_PROPERTY( m_nNumberOfWords )
|
||
DEFAULT_PROPERTY( m_nNumberOfCharactersWithSpace )
|
||
DEFAULT_PROPERTY( m_nNumberOfCharactersWithoutSpace )
|
||
DEFAULT_PROPERTY( m_nInternalId )
|
||
}
|
||
std::wstring RtfInformation::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if( !m_sTitle.empty() )
|
||
{
|
||
sResult += L"{\\title "; sResult += RtfChar::renderRtfText( m_sTitle, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sSubject.empty() )
|
||
{
|
||
sResult += L"{\\subject "; sResult += RtfChar::renderRtfText( m_sSubject, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sAuthor.empty() )
|
||
{
|
||
sResult += L"{\\author "; sResult += RtfChar::renderRtfText( m_sAuthor, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sManager.empty() )
|
||
{
|
||
sResult += L"{\\manager "; sResult += RtfChar::renderRtfText( m_sManager, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sCompany.empty() )
|
||
{
|
||
sResult += L"{\\company "; sResult += RtfChar::renderRtfText( m_sCompany, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sOperator.empty() )
|
||
{
|
||
sResult += L"{\\operator "; sResult += RtfChar::renderRtfText( m_sOperator, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sCategory.empty() )
|
||
{
|
||
sResult += L"{\\category "; sResult += RtfChar::renderRtfText( m_sCategory, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sKeywords.empty() )
|
||
{
|
||
sResult += L"{\\keywords "; sResult += RtfChar::renderRtfText( m_sKeywords, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sComment.empty() )
|
||
{
|
||
sResult += L"{\\comment "; sResult += RtfChar::renderRtfText( m_sComment, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sDocCom.empty() )
|
||
{
|
||
sResult += L"{\\doccomm "; sResult += RtfChar::renderRtfText( m_sDocCom, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( !m_sDocCom.empty() )
|
||
{
|
||
sResult += L"{\\doccomm "; sResult += RtfChar::renderRtfText( m_sDocCom, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
if( PROP_DEF != m_nInternalVersion )
|
||
{
|
||
sResult += L"{\\vern" + std::to_wstring(m_nInternalVersion) + L"}";
|
||
}
|
||
if( !m_sLinkBase.empty() )
|
||
{
|
||
sResult += L"{\\hlinkbase "; sResult += RtfChar::renderRtfText( m_sLinkBase, oRenderParameter.poDocument ); sResult += L"}";
|
||
}
|
||
|
||
std::wstring sCreateTime = m_oCreateTime.RenderToRtf( oRenderParameter );
|
||
if( !sCreateTime.empty() )
|
||
{
|
||
sResult += L"{\\creatim"; sResult += sCreateTime; sResult += L"}";
|
||
}
|
||
std::wstring sRevTime = m_oRevTime.RenderToRtf( oRenderParameter );
|
||
if( !sRevTime.empty() )
|
||
{
|
||
sResult += L"{\\revtim"; sResult += sRevTime; sResult += L"}";
|
||
}
|
||
std::wstring sPrintTime = m_oPrintTime.RenderToRtf( oRenderParameter );
|
||
if( !sPrintTime.empty() )
|
||
{
|
||
sResult += L"{\\printim"; sResult += sPrintTime; sResult += L"}";
|
||
}
|
||
std::wstring sBackupTime = m_oBackupTime.RenderToRtf( oRenderParameter );
|
||
if( !sBackupTime.empty() )
|
||
{
|
||
sResult += L"{\\buptim"; sResult += sBackupTime; sResult += L"}";
|
||
}
|
||
if( PROP_DEF != m_nEndingTime )
|
||
{
|
||
sResult += L"{\\edmins" + std::to_wstring(m_nEndingTime) + L"}";
|
||
}
|
||
if( PROP_DEF != m_nNumberOfPages )
|
||
{
|
||
sResult += L"{\\nofpages" + std::to_wstring(m_nNumberOfPages) + L"}";
|
||
}
|
||
if( PROP_DEF != m_nNumberOfWords )
|
||
{
|
||
sResult += L"{\\nofwords" + std::to_wstring(m_nNumberOfWords) + L"}";
|
||
}
|
||
if( PROP_DEF != m_nNumberOfCharactersWithSpace )
|
||
{
|
||
sResult += L"{\\nofchars" + std::to_wstring(m_nNumberOfCharactersWithSpace) + L"}";
|
||
}
|
||
if( PROP_DEF != m_nNumberOfCharactersWithoutSpace )
|
||
{
|
||
sResult += L"{\\nofcharsws" + std::to_wstring(m_nNumberOfCharactersWithoutSpace) + L"}";
|
||
}
|
||
|
||
if( PROP_DEF != m_nInternalId )
|
||
sResult += L"{\\id" + std::to_wstring(m_nInternalId) + L"}";
|
||
|
||
std::wstring m_sApplication = NSSystemUtils::GetEnvVariable(NSSystemUtils::gc_EnvApplicationName);
|
||
if (m_sApplication.empty())
|
||
m_sApplication = NSSystemUtils::gc_EnvApplicationNameDefault;
|
||
|
||
#if defined(INTVER)
|
||
std::string s = VALUE2STR(INTVER);
|
||
m_sApplication += L"/" + std::wstring(s.begin(), s.end());
|
||
#endif
|
||
if( !m_sApplication.empty() )
|
||
{
|
||
sResult += L"{\\*\\userprops ";
|
||
sResult += L"{\\propname Application}";
|
||
sResult += L"\\proptype30";
|
||
sResult += L"{\\staticval " + RtfChar::renderRtfText( m_sApplication, oRenderParameter.poDocument ) + L"}";
|
||
sResult += L"}";
|
||
}
|
||
|
||
if( !sResult.empty() )
|
||
sResult = L"{\\info" + sResult + L"}";
|
||
return sResult;
|
||
}
|
||
std::wstring RtfInformation::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
if( RENDER_TO_OOX_PARAM_CORE == oRenderParameter.nType )
|
||
{
|
||
OOX::CCore *pCore = static_cast<OOX::CCore*>( oRenderParameter.poWriter );
|
||
|
||
if( !m_sTitle.empty() ) pCore->m_sTitle = XmlUtils::EncodeXmlString(m_sTitle);
|
||
if( !m_sSubject.empty() ) pCore->m_sSubject = XmlUtils::EncodeXmlString(m_sSubject);
|
||
if( !m_sAuthor.empty() ) pCore->m_sCreator = m_sAuthor;
|
||
if( !m_sKeywords.empty() ) pCore->m_sKeywords = m_sKeywords;
|
||
if( !m_sComment.empty() ) pCore->m_sDescription = XmlUtils::EncodeXmlString(m_sComment);
|
||
|
||
//std::wstring sCreateTime = m_oCreateTime.RenderToOOX( oRenderParameter );
|
||
//if( false == sCreateTime.empty() ) pCore->m_sCreated = sCreateTime;
|
||
//
|
||
//std::wstring sRevTime = m_oRevTime.RenderToOOX( oRenderParameter );
|
||
//if( false == sRevTime.empty() ) pCore->m_sModified = sRevTime;
|
||
|
||
//std::wstring sPrintTime = m_oPrintTime.RenderToOOX( oRenderParameter );
|
||
//if( L"" != sPrintTime )
|
||
// sResult += L"<dcterms:created xsi:type=\"dcterms:W3CDTF\">" + sCreateTime + L"</dcterms:created>";
|
||
//std::wstring sBackupTime = m_oBackupTime.RenderToOOX( oRenderParameter );
|
||
//if( L"" != sBackupTime )
|
||
// sResult += L"<dcterms:created xsi:type=\"dcterms:W3CDTF\">" + sCreateTime + L"</dcterms:created>";
|
||
}
|
||
else if( RENDER_TO_OOX_PARAM_APP == oRenderParameter.nType )
|
||
{
|
||
OOX::CApp *pApp = static_cast<OOX::CApp*>( oRenderParameter.poWriter );
|
||
|
||
if( PROP_DEF != m_nEndingTime) pApp->m_nTotalTime = m_nEndingTime;
|
||
if( PROP_DEF != m_nNumberOfPages ) pApp->m_nPages = m_nNumberOfPages;
|
||
if( PROP_DEF != m_nNumberOfWords ) pApp->m_nWords = m_nNumberOfWords;
|
||
if( PROP_DEF != m_nNumberOfCharactersWithSpace ) pApp->m_nCharactersWithSpaces = m_nNumberOfCharactersWithSpace;
|
||
|
||
//if( PROP_DEF != m_nNumberOfCharactersWithoutSpace )
|
||
// sResult += L"<CharactersWithSpaces>" + std::to_wstring() + L"</CharactersWithSpaces>",m_nNumberOfCharactersWithoutSpace );
|
||
}
|
||
return L"";
|
||
}
|
||
|
||
RtfTime::RtfTime()
|
||
{
|
||
SetDefault();
|
||
}
|
||
bool RtfTime::IsValid()
|
||
{
|
||
return true;
|
||
}
|
||
void RtfTime::SetDefaultRtf()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTime::SetDefaultOOX()
|
||
{
|
||
SetDefault();
|
||
}
|
||
void RtfTime::SetDefault()
|
||
{
|
||
DEFAULT_PROPERTY( m_nYear )
|
||
DEFAULT_PROPERTY( m_nMonth )
|
||
DEFAULT_PROPERTY( m_nDay )
|
||
DEFAULT_PROPERTY( m_nHour )
|
||
DEFAULT_PROPERTY( m_nMin )
|
||
DEFAULT_PROPERTY( m_nSecond )
|
||
}
|
||
std::wstring RtfTime::RenderToRtf(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( PROP_DEF != m_nYear ) sResult += L"\\yr" + std::to_wstring(m_nYear);
|
||
if( PROP_DEF != m_nMonth ) sResult += L"\\mo" + std::to_wstring(m_nMonth);
|
||
if( PROP_DEF != m_nDay ) sResult += L"\\dy" + std::to_wstring(m_nDay);
|
||
if( PROP_DEF != m_nHour ) sResult += L"\\hr" + std::to_wstring(m_nHour);
|
||
if( PROP_DEF != m_nMin ) sResult += L"\\min" + std::to_wstring(m_nMin);
|
||
if( PROP_DEF != m_nSecond ) sResult += L"\\sec" + std::to_wstring(m_nSecond);
|
||
return sResult;
|
||
}
|
||
std::wstring RtfTime::RenderToOOX(RenderParameter oRenderParameter)
|
||
{
|
||
std::wstring sResult;
|
||
if( PROP_DEF != m_nYear || PROP_DEF != m_nMonth || PROP_DEF != m_nDay )
|
||
{
|
||
int nYear = 0;
|
||
if( PROP_DEF != m_nYear ) nYear = m_nYear;
|
||
int nMonth = 0;
|
||
if( PROP_DEF != m_nMonth ) nMonth = m_nMonth;
|
||
int nDay = 0;
|
||
if( PROP_DEF != m_nDay ) nDay = m_nDay;
|
||
|
||
sResult = std::to_wstring(nYear) + L"-" + std::to_wstring(nMonth) + L"-" + std::to_wstring(nDay) + L"T";
|
||
}
|
||
if( PROP_DEF != m_nHour || PROP_DEF != m_nMin || PROP_DEF != m_nSecond )
|
||
{
|
||
int nHour = 0;
|
||
if( PROP_DEF != m_nHour ) nHour = m_nHour;
|
||
int nMin = 0;
|
||
if( PROP_DEF != m_nMin ) nMin = m_nMin;
|
||
int nSecond = 0;
|
||
if( PROP_DEF != m_nSecond ) nSecond = m_nSecond;
|
||
|
||
sResult = std::to_wstring(nHour) + L":" + std::to_wstring(nMin) + L":" + std::to_wstring(nSecond) + L"Z";
|
||
}
|
||
return sResult;
|
||
}
|
||
|
||
RtfCharStyle::RtfCharStyle()
|
||
{
|
||
SetDefault();
|
||
m_eType = stCharacter;
|
||
}
|
||
int RtfCharStyle::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_STYLE_CHAR;
|
||
}
|
||
void RtfCharStyle::Merge( RtfStylePtr oStyle )
|
||
{
|
||
RtfStyle::Merge( oStyle );
|
||
if( TYPE_RTF_PROPERTY_STYLE_CHAR == oStyle->GetType() )
|
||
{
|
||
RtfCharStylePtr oCharStyle = boost::static_pointer_cast<RtfCharStyle, RtfStyle>( oStyle );
|
||
m_oCharProp.Merge( oCharStyle->m_oCharProp );
|
||
}
|
||
else if( TYPE_RTF_PROPERTY_STYLE_PARAGRAPH == oStyle->GetType() )
|
||
{
|
||
RtfParagraphStylePtr oParagraphStyle = boost::static_pointer_cast<RtfParagraphStyle, RtfStyle>( oStyle );
|
||
m_oCharProp.Merge( oParagraphStyle->m_oCharProp );
|
||
}
|
||
else if( TYPE_RTF_PROPERTY_STYLE_TABLE == oStyle->GetType() )
|
||
{
|
||
RtfTableStylePtr oTableStyle = boost::static_pointer_cast<RtfTableStyle, RtfStyle>( oStyle );
|
||
m_oCharProp.Merge( oTableStyle->m_oCharProp );
|
||
}
|
||
}
|
||
|
||
RtfParagraphStyle::RtfParagraphStyle()
|
||
{
|
||
SetDefault();
|
||
m_eType = stParagraph;
|
||
}
|
||
int RtfParagraphStyle::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_STYLE_PARAGRAPH;
|
||
}
|
||
void RtfParagraphStyle::Merge( RtfStylePtr oStyle )
|
||
{
|
||
RtfStyle::Merge( oStyle );
|
||
if( TYPE_RTF_PROPERTY_STYLE_CHAR == oStyle->GetType() )
|
||
{
|
||
RtfCharStylePtr oCharStyle = boost::static_pointer_cast<RtfCharStyle, RtfStyle>( oStyle );
|
||
m_oCharProp.Merge( oCharStyle->m_oCharProp );
|
||
}
|
||
else if( TYPE_RTF_PROPERTY_STYLE_PARAGRAPH == oStyle->GetType() )
|
||
{
|
||
RtfParagraphStylePtr oParagraphStyle = boost::static_pointer_cast<RtfParagraphStyle, RtfStyle>( oStyle );
|
||
m_oParProp.Merge( oParagraphStyle->m_oParProp );
|
||
m_oCharProp.Merge( oParagraphStyle->m_oCharProp );
|
||
}
|
||
else if( TYPE_RTF_PROPERTY_STYLE_TABLE == oStyle->GetType() )
|
||
{
|
||
RtfTableStylePtr oTableStyle = boost::static_pointer_cast<RtfTableStyle, RtfStyle>( oStyle );
|
||
m_oParProp.Merge( oTableStyle->m_oParProp );
|
||
m_oCharProp.Merge( oTableStyle->m_oCharProp );
|
||
}
|
||
}
|
||
|
||
RtfTableStyle::RtfTableStyle()
|
||
{
|
||
SetDefault();
|
||
m_eType = stTable;
|
||
}
|
||
void RtfTableStyle::SetDefault()
|
||
{
|
||
RtfStyle::SetDefault();
|
||
m_oFirstRow = RtfTableStylePtr();
|
||
m_oLastRow = RtfTableStylePtr();
|
||
m_oFirstCol = RtfTableStylePtr();
|
||
m_oLastCol = RtfTableStylePtr();
|
||
m_oBandHorEven = RtfTableStylePtr();
|
||
m_oBandVerEven = RtfTableStylePtr();
|
||
m_oBandHorOdd = RtfTableStylePtr();
|
||
m_oBandVerOdd = RtfTableStylePtr();
|
||
m_oNWCell = RtfTableStylePtr();
|
||
m_oNECell = RtfTableStylePtr();
|
||
m_oSWCell = RtfTableStylePtr();
|
||
m_oSECell = RtfTableStylePtr();
|
||
}
|
||
int RtfTableStyle::GetType()
|
||
{
|
||
return TYPE_RTF_PROPERTY_STYLE_TABLE;
|
||
}
|
||
void RtfTableStyle::Merge( RtfStylePtr oStyle )
|
||
{
|
||
RtfStyle::Merge( oStyle );
|
||
if( TYPE_RTF_PROPERTY_STYLE_CHAR == oStyle->GetType() )
|
||
{
|
||
RtfCharStylePtr oCharStyle = boost::static_pointer_cast<RtfCharStyle, RtfStyle>( oStyle );
|
||
|
||
m_oCharProp.Merge( oCharStyle->m_oCharProp );
|
||
}
|
||
else if( TYPE_RTF_PROPERTY_STYLE_PARAGRAPH == oStyle->GetType() )
|
||
{
|
||
RtfParagraphStylePtr oParagraphStyle = boost::static_pointer_cast<RtfParagraphStyle, RtfStyle>( oStyle );
|
||
|
||
m_oParProp.Merge( oParagraphStyle->m_oParProp );
|
||
m_oCharProp.Merge( oParagraphStyle->m_oCharProp );
|
||
}
|
||
if( TYPE_RTF_PROPERTY_STYLE_TABLE == oStyle->GetType() )
|
||
{
|
||
RtfTableStylePtr oTableStyle = boost::static_pointer_cast<RtfTableStyle, RtfStyle>( oStyle );
|
||
|
||
m_oTableProp.Merge ( oTableStyle->m_oTableProp );
|
||
m_oRowProp.Merge ( oTableStyle->m_oRowProp );
|
||
m_oCellProp.Merge ( oTableStyle->m_oCellProp );
|
||
m_oParProp.Merge ( oTableStyle->m_oParProp );
|
||
m_oCharProp.Merge ( oTableStyle->m_oCharProp );
|
||
|
||
if( NULL != oTableStyle->m_oFirstRow )
|
||
{
|
||
m_oFirstRow = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oFirstRow->Merge( oTableStyle->m_oFirstRow );
|
||
}
|
||
if( NULL != oTableStyle->m_oLastRow )
|
||
{
|
||
m_oLastRow = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oLastRow->Merge( oTableStyle->m_oLastRow );
|
||
}
|
||
if( NULL != oTableStyle->m_oFirstCol )
|
||
{
|
||
m_oFirstCol = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oFirstCol->Merge( oTableStyle->m_oFirstCol );
|
||
}
|
||
if( NULL != oTableStyle->m_oLastCol )
|
||
{
|
||
m_oLastCol = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oLastCol->Merge( oTableStyle->m_oLastCol );
|
||
}
|
||
if( NULL != oTableStyle->m_oBandHorEven )
|
||
{
|
||
m_oBandHorEven = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oBandHorEven->Merge( oTableStyle->m_oBandHorEven );
|
||
}
|
||
if( NULL != oTableStyle->m_oBandVerEven )
|
||
{
|
||
m_oBandVerEven = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oBandVerEven->Merge( oTableStyle->m_oBandVerEven );
|
||
}
|
||
if( NULL != oTableStyle->m_oBandHorOdd )
|
||
{
|
||
m_oBandHorOdd = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oBandHorOdd->Merge( oTableStyle->m_oBandHorOdd );
|
||
}
|
||
if( NULL != oTableStyle->m_oBandVerOdd )
|
||
{
|
||
m_oBandVerOdd = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oBandVerOdd->Merge( oTableStyle->m_oBandVerOdd );
|
||
}
|
||
if( NULL != oTableStyle->m_oNWCell )
|
||
{
|
||
m_oNWCell = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oNWCell->Merge( oTableStyle->m_oNWCell );
|
||
}
|
||
if( NULL != oTableStyle->m_oNECell )
|
||
{
|
||
m_oNECell = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oNECell->Merge( oTableStyle->m_oNECell );
|
||
}
|
||
if( NULL != oTableStyle->m_oSWCell )
|
||
{
|
||
m_oSWCell = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oSWCell->Merge( oTableStyle->m_oSWCell );
|
||
}
|
||
if( NULL != oTableStyle->m_oSECell )
|
||
{
|
||
m_oSECell = RtfTableStylePtr( new RtfTableStyle() );
|
||
m_oSECell->Merge( oTableStyle->m_oSECell );
|
||
}
|
||
}
|
||
}
|