1962 lines
66 KiB
C++
1962 lines
66 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 "TableProperty.h"
|
||
|
||
namespace ComplexTypes
|
||
{
|
||
namespace Word
|
||
{
|
||
//--------------------------------------------------------------------------------
|
||
// CellMergeTrackChange
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CCellMergeTrackChange::CCellMergeTrackChange()
|
||
{
|
||
}
|
||
CCellMergeTrackChange::~CCellMergeTrackChange()
|
||
{
|
||
}
|
||
void CCellMergeTrackChange::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:author", m_sAuthor );
|
||
XmlMacroReadAttributeBase( oNode, L"w:date", m_oDate );
|
||
XmlMacroReadAttributeBase( oNode, L"w:id", m_oId );
|
||
XmlMacroReadAttributeBase( oNode, L"w:vMerge", m_oVMerge );
|
||
XmlMacroReadAttributeBase( oNode, L"w:vMergeOrig", m_oVMergeOrig );
|
||
XmlMacroReadAttributeBase( oNode, L"oouserid", m_sUserId );
|
||
}
|
||
void CCellMergeTrackChange::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
}
|
||
std::wstring CCellMergeTrackChange::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if ( m_sAuthor.IsInit() )
|
||
{
|
||
sResult += L"w:author=\"";
|
||
sResult += XmlUtils::EncodeXmlString(m_sAuthor.get2());
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
ComplexTypes_WriteAttribute( L"w:date=\"", m_oDate );
|
||
ComplexTypes_WriteAttribute( L"w:id=\"", m_oId );
|
||
ComplexTypes_WriteAttribute( L"w:vMerge=\"", m_oVMerge );
|
||
ComplexTypes_WriteAttribute( L"w:vMergeOrig=\"", m_oVMergeOrig );
|
||
|
||
if ( m_sUserId.IsInit() )
|
||
{
|
||
sResult += L"oouserid=\"";
|
||
sResult += m_sUserId.get2();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
void CCellMergeTrackChange::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, L"w:author", m_sAuthor )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:date", m_oDate )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:id", m_oId )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:vMerge", m_oVMerge )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:vMergeOrig", m_oVMergeOrig )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"oouserid", m_sUserId )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// HMerge
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CHMerge::CHMerge()
|
||
{
|
||
}
|
||
CHMerge::~CHMerge()
|
||
{
|
||
}
|
||
void CHMerge::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:val", m_oVal );
|
||
}
|
||
void CHMerge::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
}
|
||
std::wstring CHMerge::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
ComplexTypes_WriteAttribute( L"w:val=\"", m_oVal );
|
||
|
||
return sResult;
|
||
}
|
||
void CHMerge::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_ReadSingle( oReader, L"w:val", m_oVal )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// VMerge
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CVMerge::CVMerge()
|
||
{
|
||
}
|
||
CVMerge::~CVMerge()
|
||
{
|
||
}
|
||
void CVMerge::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:val", m_oVal );
|
||
}
|
||
void CVMerge::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
}
|
||
std::wstring CVMerge::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
ComplexTypes_WriteAttribute( L"w:val=\"", m_oVal );
|
||
|
||
return sResult;
|
||
}
|
||
void CVMerge::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_ReadSingle( oReader, L"w:val", m_oVal )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// Height
|
||
//--------------------------------------------------------------------------------
|
||
CHeight::CHeight()
|
||
{
|
||
}
|
||
CHeight::~CHeight()
|
||
{
|
||
}
|
||
void CHeight::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:hRule", m_oHRule );
|
||
XmlMacroReadAttributeBase( oNode, L"w:val", m_oVal );
|
||
XmlMacroReadAttributeBase(oNode, L"w:h-rule", m_oHRule);
|
||
}
|
||
void CHeight::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
}
|
||
std::wstring CHeight::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
ComplexTypes_WriteAttribute( L"w:hRule=\"", m_oHRule );
|
||
ComplexTypes_WriteAttribute( L"w:val=\"", m_oVal );
|
||
|
||
return sResult;
|
||
}
|
||
void CHeight::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, L"w:hRule", m_oHRule )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:val", m_oVal )
|
||
WritingElement_ReadAttributes_Read_else_if(oReader, L"w:h-rule", m_oHRule)
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// JcTable
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CJcTable::CJcTable()
|
||
{
|
||
}
|
||
CJcTable::~CJcTable()
|
||
{
|
||
}
|
||
void CJcTable::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:val", m_oVal );
|
||
}
|
||
void CJcTable::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
}
|
||
std::wstring CJcTable::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if ( m_oVal.IsInit() )
|
||
{
|
||
sResult += L"w:val=\"";
|
||
sResult += m_oVal->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
void CJcTable::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_ReadSingle( oReader, L"w:val", m_oVal )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TblLayoutType
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CTblLayoutType::CTblLayoutType()
|
||
{
|
||
}
|
||
CTblLayoutType::~CTblLayoutType()
|
||
{
|
||
}
|
||
void CTblLayoutType::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:type", m_oType );
|
||
}
|
||
void CTblLayoutType::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
}
|
||
std::wstring CTblLayoutType::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if ( m_oType.IsInit() )
|
||
{
|
||
sResult += L"w:type=\"";
|
||
sResult += m_oType->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
void CTblLayoutType::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_ReadSingle( oReader, L"w:type", m_oType )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TblLook
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CTblLook::CTblLook()
|
||
{
|
||
}
|
||
CTblLook::~CTblLook()
|
||
{
|
||
}
|
||
void CTblLook::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:firstColumn", m_oFirstColumn );
|
||
XmlMacroReadAttributeBase( oNode, L"w:firstRow", m_oFirstRow );
|
||
XmlMacroReadAttributeBase( oNode, L"w:lastColumn", m_oLastColumn );
|
||
XmlMacroReadAttributeBase( oNode, L"w:lastRow", m_oLastRow );
|
||
XmlMacroReadAttributeBase( oNode, L"w:noHBand", m_oNoHBand );
|
||
XmlMacroReadAttributeBase( oNode, L"w:noVBand", m_oNoVBand );
|
||
XmlMacroReadAttributeBase( oNode, L"w:val", m_oVal );
|
||
}
|
||
void CTblLook::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
}
|
||
std::wstring CTblLook::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if ( m_oFirstColumn.IsInit() )
|
||
{
|
||
sResult += L"w:firstColumn=\"";
|
||
sResult += m_oFirstColumn->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
if ( m_oFirstRow.IsInit() )
|
||
{
|
||
sResult += L"w:firstRow=\"";
|
||
sResult += m_oFirstRow->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
if ( m_oLastColumn.IsInit() )
|
||
{
|
||
sResult += L"w:lastColumn=\"";
|
||
sResult += m_oLastColumn->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
if ( m_oLastRow.IsInit() )
|
||
{
|
||
sResult += L"w:lastRow=\"";
|
||
sResult += m_oLastRow->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
if ( m_oNoHBand.IsInit() )
|
||
{
|
||
sResult += L"w:noHBand=\"";
|
||
sResult += m_oNoHBand->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
if ( m_oNoVBand.IsInit() )
|
||
{
|
||
sResult += L"w:noVBand=\"";
|
||
sResult += m_oNoVBand->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
ComplexTypes_WriteAttribute( L"w:val=\"", m_oVal );
|
||
|
||
return sResult;
|
||
}
|
||
const bool CTblLook::IsFirstRow() const
|
||
{
|
||
if ( m_oFirstRow.IsInit() )
|
||
return ( SimpleTypes::onoffTrue == m_oFirstRow->GetValue() );
|
||
|
||
if ( m_oVal.IsInit() )
|
||
return ( 0 != ( m_oVal->GetValue() & 0x0020 ) );
|
||
|
||
return false;
|
||
}
|
||
const bool CTblLook::IsLastRow() const
|
||
{
|
||
if ( m_oLastRow.IsInit() )
|
||
return ( SimpleTypes::onoffTrue == m_oLastRow->GetValue() );
|
||
|
||
if ( m_oVal.IsInit() )
|
||
return ( 0 != ( m_oVal->GetValue() & 0x0040 ) );
|
||
|
||
return false;
|
||
}
|
||
const bool CTblLook::IsFirstColumn() const
|
||
{
|
||
if ( m_oFirstColumn.IsInit() )
|
||
return ( SimpleTypes::onoffTrue == m_oFirstColumn->GetValue() );
|
||
|
||
if ( m_oVal.IsInit() )
|
||
return ( 0 != ( m_oVal->GetValue() & 0x0080 ) );
|
||
|
||
return false;
|
||
}
|
||
const bool CTblLook::IsLastColumn () const
|
||
{
|
||
if ( m_oLastColumn.IsInit() )
|
||
return ( SimpleTypes::onoffTrue == m_oLastColumn->GetValue() );
|
||
|
||
if ( m_oVal.IsInit() )
|
||
return ( 0 != ( m_oVal->GetValue() & 0x0100 ) );
|
||
|
||
return false;
|
||
}
|
||
const bool CTblLook::IsNoHBand () const
|
||
{
|
||
if ( m_oNoHBand.IsInit() )
|
||
return ( SimpleTypes::onoffTrue == m_oNoHBand->GetValue() );
|
||
|
||
if ( m_oVal.IsInit() )
|
||
return ( 0 != ( m_oVal->GetValue() & 0x0200 ) );
|
||
|
||
return false;
|
||
}
|
||
const bool CTblLook::IsNoVBand () const
|
||
{
|
||
if ( m_oNoVBand.IsInit() )
|
||
return ( SimpleTypes::onoffTrue == m_oNoVBand->GetValue() );
|
||
|
||
if ( m_oVal.IsInit() )
|
||
return ( 0 != ( m_oVal->GetValue() & 0x0400 ) );
|
||
|
||
return false;
|
||
}
|
||
const int CTblLook::GetValue() const
|
||
{
|
||
int nRes = 0;
|
||
if(m_oVal.IsInit())
|
||
nRes = m_oVal->GetValue();
|
||
else
|
||
{
|
||
if ( m_oNoVBand.IsInit() && SimpleTypes::onoffTrue == m_oNoVBand->GetValue())
|
||
nRes |= 0x0400;
|
||
if ( m_oNoHBand.IsInit() && SimpleTypes::onoffTrue == m_oNoHBand->GetValue())
|
||
nRes |= 0x0200;
|
||
if ( m_oLastColumn.IsInit() && SimpleTypes::onoffTrue == m_oLastColumn->GetValue())
|
||
nRes |= 0x0100;
|
||
if ( m_oFirstColumn.IsInit() && SimpleTypes::onoffTrue == m_oFirstColumn->GetValue())
|
||
nRes |= 0x0080;
|
||
if ( m_oLastRow.IsInit() && SimpleTypes::onoffTrue == m_oLastRow->GetValue())
|
||
nRes |= 0x0040;
|
||
if ( m_oFirstRow.IsInit() && SimpleTypes::onoffTrue == m_oFirstRow->GetValue())
|
||
nRes |= 0x0020;
|
||
}
|
||
return nRes;
|
||
}
|
||
void CTblLook::SetValue(int nVal)
|
||
{
|
||
m_oVal.Init();
|
||
m_oVal->SetValue(nVal);
|
||
if ( 0 != (nVal & 0x0400))
|
||
{
|
||
m_oNoVBand.Init();
|
||
m_oNoVBand->FromBool(true);
|
||
}
|
||
if ( 0 != (nVal & 0x0200))
|
||
{
|
||
m_oNoHBand.Init();
|
||
m_oNoHBand->FromBool(true);
|
||
}
|
||
if ( 0 != (nVal & 0x0100))
|
||
{
|
||
m_oLastColumn.Init();
|
||
m_oLastColumn->FromBool(true);
|
||
}
|
||
if ( 0 != (nVal & 0x0080))
|
||
{
|
||
m_oFirstColumn.Init();
|
||
m_oFirstColumn->FromBool(true);
|
||
}
|
||
if ( 0 != (nVal & 0x0040))
|
||
{
|
||
m_oLastRow.Init();
|
||
m_oLastRow->FromBool(true);
|
||
}
|
||
if ( 0 != (nVal & 0x0020))
|
||
{
|
||
m_oFirstRow.Init();
|
||
m_oFirstRow->FromBool(true);
|
||
}
|
||
}
|
||
void CTblLook::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, L"w:firstColumn", m_oFirstColumn )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:firstRow", m_oFirstRow )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:lastColumn", m_oLastColumn )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:lastRow", m_oLastRow )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:noHBand", m_oNoHBand )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:noVBand", m_oNoVBand )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:val", m_oVal )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TblOverlap
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CTblOverlap::CTblOverlap()
|
||
{
|
||
}
|
||
CTblOverlap::~CTblOverlap()
|
||
{
|
||
}
|
||
void CTblOverlap::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:val", m_oVal );
|
||
}
|
||
void CTblOverlap::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_ReadSingle( oReader, L"w:val", m_oVal )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
std::wstring CTblOverlap::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
if ( m_oVal.IsInit() )
|
||
{
|
||
sResult += L"w:val=\"";
|
||
sResult += m_oVal->ToString();
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
return sResult;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TblPPr
|
||
//--------------------------------------------------------------------------------
|
||
CTblPPr::CTblPPr()
|
||
{
|
||
}
|
||
CTblPPr::~CTblPPr()
|
||
{
|
||
}
|
||
void CTblPPr::PrepareAfterRead()
|
||
{
|
||
if(false == m_oHorzAnchor.IsInit())
|
||
{
|
||
m_oHorzAnchor.Init();
|
||
m_oHorzAnchor->SetValue(SimpleTypes::hanchorText);
|
||
}
|
||
if(false == m_oVertAnchor.IsInit())
|
||
{
|
||
m_oVertAnchor.Init();
|
||
m_oVertAnchor->SetValue(SimpleTypes::vanchorMargin);
|
||
}
|
||
if(false == m_oTblpXSpec.IsInit())
|
||
{
|
||
if(false == m_oTblpX.IsInit())
|
||
{
|
||
m_oTblpX.Init();
|
||
m_oTblpX->FromTwips(0);
|
||
}
|
||
//Several values of sprmTDxaAbs have special meanings as specified by
|
||
//[ECMA-376] Part 4, Section 2.18.114. These values are specified as
|
||
//follows.
|
||
switch(m_oTblpX->ToTwips())
|
||
{
|
||
case 0:
|
||
m_oTblpX.reset(NULL);
|
||
m_oTblpXSpec.Init();
|
||
m_oTblpXSpec->SetValue(SimpleTypes::xalignLeft);
|
||
break;
|
||
case -4:
|
||
m_oTblpX.reset(NULL);
|
||
m_oTblpXSpec.Init();
|
||
m_oTblpXSpec->SetValue(SimpleTypes::xalignCenter);
|
||
break;
|
||
case -8:
|
||
m_oTblpX.reset(NULL);
|
||
m_oTblpXSpec.Init();
|
||
m_oTblpXSpec->SetValue(SimpleTypes::xalignRight);
|
||
break;
|
||
case -12:
|
||
m_oTblpX.reset(NULL);
|
||
m_oTblpXSpec.Init();
|
||
m_oTblpXSpec->SetValue(SimpleTypes::xalignInside);
|
||
break;
|
||
case -16:
|
||
m_oTblpX.reset(NULL);
|
||
m_oTblpXSpec.Init();
|
||
m_oTblpXSpec->SetValue(SimpleTypes::xalignOutside);
|
||
break;
|
||
}
|
||
}
|
||
if(false == m_oTblpYSpec.IsInit())
|
||
{
|
||
if(false == m_oTblpY.IsInit())
|
||
{
|
||
m_oTblpY.Init();
|
||
m_oTblpY->FromTwips(0);
|
||
}
|
||
//The meanings that are provided correspond to
|
||
//values that are defined in [ECMA-376] Part 4, Section 2.18.115 ST_YAlign
|
||
//(Vertical Alignment Location).
|
||
switch(m_oTblpY->ToTwips())
|
||
{
|
||
case 0:
|
||
m_oVertAnchor.Init();
|
||
m_oVertAnchor->SetValue(SimpleTypes::vanchorText);
|
||
break;
|
||
case -4:
|
||
m_oTblpY.reset(NULL);
|
||
m_oTblpYSpec.Init();
|
||
m_oTblpYSpec->SetValue(SimpleTypes::yalignTop);
|
||
break;
|
||
case -8:
|
||
m_oTblpY.reset(NULL);
|
||
m_oTblpYSpec.Init();
|
||
m_oTblpYSpec->SetValue(SimpleTypes::yalignCenter);
|
||
break;
|
||
case -12:
|
||
m_oTblpY.reset(NULL);
|
||
m_oTblpYSpec.Init();
|
||
m_oTblpYSpec->SetValue(SimpleTypes::yalignBottom);
|
||
break;
|
||
case -16:
|
||
m_oTblpY.reset(NULL);
|
||
m_oTblpYSpec.Init();
|
||
m_oTblpYSpec->SetValue(SimpleTypes::yalignInside);
|
||
break;
|
||
case -20:
|
||
m_oTblpY.reset(NULL);
|
||
m_oTblpYSpec.Init();
|
||
m_oTblpYSpec->SetValue(SimpleTypes::yalignOutside);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
void CTblPPr::FromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
XmlMacroReadAttributeBase( oNode, L"w:bottomFromText", m_oBottomFromText );
|
||
XmlMacroReadAttributeBase( oNode, L"w:horzAnchor", m_oHorzAnchor );
|
||
XmlMacroReadAttributeBase( oNode, L"w:leftFromText", m_oLeftFromText );
|
||
XmlMacroReadAttributeBase( oNode, L"w:rightFromText", m_oRightFromText );
|
||
XmlMacroReadAttributeBase( oNode, L"w:tblpX", m_oTblpX );
|
||
XmlMacroReadAttributeBase( oNode, L"w:tblpXSpec", m_oTblpXSpec );
|
||
XmlMacroReadAttributeBase( oNode, L"w:tblpY", m_oTblpY );
|
||
XmlMacroReadAttributeBase( oNode, L"w:tblpYSpec", m_oTblpYSpec );
|
||
XmlMacroReadAttributeBase( oNode, L"w:topFromText", m_oTopFromText );
|
||
XmlMacroReadAttributeBase( oNode, L"w:vertAnchor", m_oVertAnchor );
|
||
PrepareAfterRead();
|
||
}
|
||
void CTblPPr::FromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes(oReader);
|
||
|
||
if ( !oReader.IsEmptyNode() )
|
||
oReader.ReadTillEnd();
|
||
PrepareAfterRead();
|
||
}
|
||
std::wstring CTblPPr::ToString() const
|
||
{
|
||
std::wstring sResult;
|
||
|
||
ComplexTypes_WriteAttribute( L"w:bottomFromText=\"", m_oBottomFromText );
|
||
ComplexTypes_WriteAttribute( L"w:horzAnchor=\"", m_oHorzAnchor );
|
||
ComplexTypes_WriteAttribute( L"w:leftFromText=\"", m_oLeftFromText );
|
||
ComplexTypes_WriteAttribute( L"w:rightFromText=\"", m_oRightFromText );
|
||
ComplexTypes_WriteAttribute( L"w:tblpX=\"", m_oTblpX );
|
||
ComplexTypes_WriteAttribute( L"w:tblpXSpec=\"", m_oTblpXSpec );
|
||
ComplexTypes_WriteAttribute( L"w:tblpY=\"", m_oTblpY );
|
||
ComplexTypes_WriteAttribute( L"w:tblpYSpec=\"", m_oTblpYSpec );
|
||
ComplexTypes_WriteAttribute( L"w:topFromText=\"", m_oTopFromText );
|
||
ComplexTypes_WriteAttribute( L"w:vertAnchor=\"", m_oVertAnchor );
|
||
|
||
return sResult;
|
||
}
|
||
void CTblPPr::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
// Читаем атрибуты
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, L"w:bottomFromText", m_oBottomFromText )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:horzAnchor", m_oHorzAnchor )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:leftFromText", m_oLeftFromText )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:rightFromText", m_oRightFromText )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:tblpX", m_oTblpX )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:tblpXSpec", m_oTblpXSpec )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:tblpY", m_oTblpY )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:tblpYSpec", m_oTblpYSpec )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:topFromText", m_oTopFromText )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, L"w:vertAnchor", m_oVertAnchor )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
} // Word
|
||
} // ComplexTypes
|
||
|
||
namespace OOX
|
||
{
|
||
namespace Logic
|
||
{
|
||
//--------------------------------------------------------------------------------
|
||
// TblBorders
|
||
//--------------------------------------------------------------------------------
|
||
CTblBorders::CTblBorders()
|
||
{
|
||
}
|
||
CTblBorders::~CTblBorders()
|
||
{
|
||
}
|
||
void CTblBorders::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:tblBorders" != oNode.GetName() )
|
||
return;
|
||
|
||
XmlUtils::CXmlNode oChild;
|
||
|
||
if ( oNode.GetNode( L"w:bottom", oChild ) )
|
||
m_oBottom = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:end", oChild ) )
|
||
m_oEnd = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:insideH", oChild ) )
|
||
m_oInsideH = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:insideV", oChild ) )
|
||
m_oInsideV = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:start", oChild ) )
|
||
m_oStart = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:top", oChild ) )
|
||
m_oTop = oChild;
|
||
|
||
if ( !m_oEnd.IsInit() && oNode.GetNode( L"w:right", oChild ) )
|
||
m_oEnd = oChild;
|
||
|
||
if ( !m_oStart.IsInit() && oNode.GetNode( L"w:left", oChild ) )
|
||
m_oStart = oChild;
|
||
}
|
||
void CTblBorders::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
if ( L"w:bottom" == sName )
|
||
m_oBottom = oReader;
|
||
else if ( L"w:end" == sName )
|
||
m_oEnd = oReader;
|
||
else if ( L"w:insideH" == sName )
|
||
m_oInsideH = oReader;
|
||
else if ( L"w:insideV" == sName )
|
||
m_oInsideV = oReader;
|
||
else if ( L"w:start" == sName )
|
||
m_oStart = oReader;
|
||
else if ( L"w:top" == sName )
|
||
m_oTop = oReader;
|
||
else if ( L"w:right" == sName )
|
||
m_oEnd = oReader;
|
||
else if ( L"w:left" == sName )
|
||
m_oStart = oReader;
|
||
}
|
||
}
|
||
std::wstring CTblBorders::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:tblBorders>";
|
||
|
||
if (m_oTop.IsInit())
|
||
{
|
||
sResult += L"<w:top ";
|
||
sResult += m_oTop->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
if (m_oStart.IsInit())
|
||
{
|
||
//sResult += L"<w:start ";
|
||
sResult += L"<w:left "; //Transitional Migration Features
|
||
sResult += m_oStart->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
if ( m_oBottom.IsInit() )
|
||
{
|
||
sResult += L"<w:bottom ";
|
||
sResult += m_oBottom->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
if ( m_oEnd.IsInit() )
|
||
{
|
||
//sResult += L"<w:end ";
|
||
sResult += L"<w:right "; //Transitional Migration Features
|
||
sResult += m_oEnd->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
if ( m_oInsideH.IsInit() )
|
||
{
|
||
sResult += L"<w:insideH ";
|
||
sResult += m_oInsideH->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
if ( m_oInsideV.IsInit() )
|
||
{
|
||
sResult += L"<w:insideV ";
|
||
sResult += m_oInsideV->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
sResult += L"</w:tblBorders>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTblBorders::getType() const
|
||
{
|
||
return et_w_tblBorders;
|
||
}
|
||
const CTblBorders CTblBorders::Merge(const CTblBorders& oPrev, const CTblBorders& oCurrent)
|
||
{
|
||
CTblBorders oProperties;
|
||
oProperties.m_oBottom = Merge( oPrev.m_oBottom, oCurrent.m_oBottom );
|
||
oProperties.m_oEnd = Merge( oPrev.m_oEnd, oCurrent.m_oEnd );
|
||
oProperties.m_oInsideH = Merge( oPrev.m_oInsideH, oCurrent.m_oInsideH );
|
||
oProperties.m_oInsideV = Merge( oPrev.m_oInsideV, oCurrent.m_oInsideV );
|
||
oProperties.m_oStart = Merge( oPrev.m_oStart, oCurrent.m_oStart );
|
||
oProperties.m_oTop = Merge( oPrev.m_oTop, oCurrent.m_oTop );
|
||
|
||
return oProperties;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TblCellMar
|
||
//--------------------------------------------------------------------------------
|
||
CTblCellMar::CTblCellMar()
|
||
{
|
||
}
|
||
CTblCellMar::~CTblCellMar()
|
||
{
|
||
}
|
||
void CTblCellMar::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:tblCellMar" != oNode.GetName() )
|
||
return;
|
||
|
||
XmlUtils::CXmlNode oChild;
|
||
|
||
if ( oNode.GetNode( L"w:bottom", oChild ) )
|
||
m_oBottom = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:end", oChild ) )
|
||
m_oEnd = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:start", oChild ) )
|
||
m_oStart = oChild;
|
||
|
||
if ( oNode.GetNode( L"w:top", oChild ) )
|
||
m_oTop = oChild;
|
||
|
||
if ( !m_oEnd.IsInit() && oNode.GetNode( L"w:right", oChild ) )
|
||
m_oEnd = oChild;
|
||
|
||
if ( !m_oStart.IsInit() && oNode.GetNode( L"w:left", oChild ) )
|
||
m_oStart = oChild;
|
||
}
|
||
void CTblCellMar::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
if ( L"w:bottom" == sName )
|
||
m_oBottom = oReader;
|
||
else if ( L"w:end" == sName )
|
||
m_oEnd = oReader;
|
||
else if ( L"w:start" == sName )
|
||
m_oStart = oReader;
|
||
else if ( L"w:top" == sName )
|
||
m_oTop = oReader;
|
||
else if ( L"w:right" == sName )
|
||
m_oEnd = oReader;
|
||
else if ( L"w:left" == sName )
|
||
m_oStart = oReader;
|
||
}
|
||
}
|
||
std::wstring CTblCellMar::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:tblCellMar>";
|
||
|
||
if ( m_oBottom.IsInit() )
|
||
{
|
||
sResult += L"<w:bottom ";
|
||
sResult += m_oBottom->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
|
||
if ( m_oEnd.IsInit() )
|
||
{
|
||
sResult += L"<w:end ";
|
||
sResult += m_oEnd->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
|
||
if ( m_oStart.IsInit() )
|
||
{
|
||
sResult += L"<w:start ";
|
||
sResult += m_oStart->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
|
||
if ( m_oTop.IsInit() )
|
||
{
|
||
sResult += L"<w:top ";
|
||
sResult += m_oTop->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
|
||
sResult += L"</w:tblCellMar>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTblCellMar::getType() const
|
||
{
|
||
return et_w_tblCellMar;
|
||
}
|
||
const CTblCellMar CTblCellMar::Merge(const CTblCellMar& oPrev, const CTblCellMar& oCurrent)
|
||
{
|
||
CTblCellMar oProperties;
|
||
oProperties.m_oBottom = Merge( oPrev.m_oBottom, oCurrent.m_oBottom );
|
||
oProperties.m_oEnd = Merge( oPrev.m_oEnd, oCurrent.m_oEnd );
|
||
oProperties.m_oStart = Merge( oPrev.m_oStart, oCurrent.m_oStart );
|
||
oProperties.m_oTop = Merge( oPrev.m_oTop, oCurrent.m_oTop );
|
||
|
||
return oProperties;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TblPrChange +
|
||
//--------------------------------------------------------------------------------
|
||
CTblPrChange::CTblPrChange(OOX::Document *pMain) : WritingElement(pMain)
|
||
{
|
||
m_pTblPr = new CTableProperty(pMain);
|
||
m_pTblPr->m_bTblPrChange = true;
|
||
}
|
||
CTblPrChange::~CTblPrChange()
|
||
{
|
||
}
|
||
const CTblPrChange& CTblPrChange::operator = (const XmlUtils::CXmlNode &oNode)
|
||
{
|
||
fromXML( (XmlUtils::CXmlNode &)oNode );
|
||
return *this;
|
||
}
|
||
const CTblPrChange& CTblPrChange::operator = (const XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
fromXML( (XmlUtils::CXmlLiteReader&)oReader );
|
||
return *this;
|
||
}
|
||
void CTblPrChange::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( _T("w:tblPrChange") != oNode.GetName() )
|
||
return;
|
||
|
||
XmlMacroReadAttributeBase( oNode, _T("w:author"), m_sAuthor );
|
||
XmlMacroReadAttributeBase( oNode, _T("w:date"), m_oDate );
|
||
XmlMacroReadAttributeBase( oNode, _T("w:id"), m_oId );
|
||
XmlMacroReadAttributeBase( oNode, _T("oouserid"), m_sUserId );
|
||
|
||
XmlUtils::CXmlNode oNode_tblPr;
|
||
|
||
if ( m_pTblPr.IsInit() && oNode.GetNode( _T("w:tblPr"), oNode_tblPr ) )
|
||
m_pTblPr->fromXML( oNode_tblPr );
|
||
|
||
}
|
||
void CTblPrChange::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes( oReader );
|
||
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
if ( m_pTblPr.IsInit() && _T("w:tblPr") == sName )
|
||
m_pTblPr->fromXML( oReader );
|
||
}
|
||
}
|
||
std::wstring CTblPrChange::toXML() const
|
||
{
|
||
std::wstring sResult = _T("<w:tblPrChange ");
|
||
|
||
if ( m_sAuthor.IsInit() )
|
||
{
|
||
sResult += _T("w:author=\"");
|
||
sResult += XmlUtils::EncodeXmlString(m_sAuthor.get2());
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
if ( m_oDate.IsInit() )
|
||
{
|
||
sResult += _T("w:date=\"");
|
||
sResult += m_oDate->ToString();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
if ( m_oId.IsInit() )
|
||
{
|
||
sResult += _T("w:id=\"");
|
||
sResult += m_oId->ToString();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
if ( m_sUserId.IsInit() )
|
||
{
|
||
sResult += _T("oouserid=\"");
|
||
sResult += m_sUserId.get2();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
sResult += _T(">");
|
||
|
||
if ( m_pTblPr.IsInit() )
|
||
sResult += m_pTblPr->toXML();
|
||
|
||
sResult += _T("</w:tblPrChange>");
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTblPrChange::getType() const
|
||
{
|
||
return et_w_tblPrChange;
|
||
}
|
||
void CTblPrChange::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, _T("w:author"), m_sAuthor )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:date"), m_oDate )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:id"), m_oId )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, _T("oouserid"), m_sUserId )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TableProperty
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CTableProperty::CTableProperty(OOX::Document *pMain)
|
||
{
|
||
m_bTblPrChange = false;
|
||
}
|
||
CTableProperty::~CTableProperty()
|
||
{
|
||
}
|
||
const CTableProperty& CTableProperty::operator=(const XmlUtils::CXmlNode &oNode)
|
||
{
|
||
fromXML( (XmlUtils::CXmlNode &)oNode );
|
||
return *this;
|
||
}
|
||
const CTableProperty& CTableProperty::operator=(const XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
fromXML( (XmlUtils::CXmlLiteReader&)oReader );
|
||
return *this;
|
||
}
|
||
void CTableProperty::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:tblPr" != oNode.GetName() )
|
||
return;
|
||
|
||
XmlUtils::CXmlNode oChild;
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:bidiVisual", m_oBidiVisual );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:jc", m_oJc );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:shd", m_oShade );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblBorders", m_oTblBorders );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblCaption", m_oTblCaption );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblCellMar", m_oTblCellMar );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblCellSpacing", m_oTblCellSpacing );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblDescription", m_oTblDescription );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblInd", m_oTblInd );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblLayout", m_oTblLayout );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblLook", m_oTblLook );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblOverlap", m_oTblOverlap );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblpPr", m_oTblpPr );
|
||
|
||
if ( !m_bTblPrChange )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblPrChange", m_oTblPrChange );
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblStyle", m_oTblStyle );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblStyleColBandSize", m_oTblStyleColBandSize );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblStyleRowBandSize", m_oTblStyleRowBandSize );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblW", m_oTblW );
|
||
}
|
||
void CTableProperty::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
|
||
if ( L"w:bidiVisual" == sName ) m_oBidiVisual = oReader;
|
||
else if ( L"w:jc" == sName ) m_oJc = oReader;
|
||
else if ( L"w:shd" == sName ) m_oShade = oReader;
|
||
else if ( L"w:tblBorders" == sName ) m_oTblBorders = oReader;
|
||
else if ( L"w:tblCaption" == sName ) m_oTblCaption = oReader;
|
||
else if ( L"w:tblCellMar" == sName ) m_oTblCellMar = oReader;
|
||
else if ( L"w:tblCellSpacing" == sName ) m_oTblCellSpacing = oReader;
|
||
else if ( L"w:tblDescription" == sName ) m_oTblDescription = oReader;
|
||
else if ( L"w:tblInd" == sName ) m_oTblInd = oReader;
|
||
else if ( L"w:tblLayout" == sName ) m_oTblLayout = oReader;
|
||
else if ( L"w:tblLook" == sName ) m_oTblLook = oReader;
|
||
else if ( L"w:tblOverlap" == sName ) m_oTblOverlap = oReader;
|
||
else if ( L"w:tblpPr" == sName ) m_oTblpPr = oReader;
|
||
else if ( !m_bTblPrChange && L"w:tblPrChange" == sName ) m_oTblPrChange = oReader;
|
||
else if ( L"w:tblStyle" == sName ) m_oTblStyle = oReader;
|
||
else if ( L"w:tblStyleColBandSize" == sName ) m_oTblStyleColBandSize = oReader;
|
||
else if ( L"w:tblStyleRowBandSize" == sName ) m_oTblStyleRowBandSize = oReader;
|
||
else if ( L"w:tblW" == sName ) m_oTblW = oReader;
|
||
else if ( L"w:tblPr" == sName)
|
||
{//387.docx
|
||
fromXML(oReader);
|
||
}
|
||
}
|
||
}
|
||
std::wstring CTableProperty::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:tblPr>";
|
||
|
||
WritingElement_WriteNode_1(L"<w:tblStyle ", m_oTblStyle);
|
||
WritingElement_WriteNode_1(L"<w:bidiVisual ", m_oBidiVisual);
|
||
WritingElement_WriteNode_1(L"<w:jc ", m_oJc);
|
||
WritingElement_WriteNode_1(L"<w:shd ", m_oShade);
|
||
WritingElement_WriteNode_2(m_oTblBorders);
|
||
WritingElement_WriteNode_1(L"<w:tblCaption ", m_oTblCaption);
|
||
WritingElement_WriteNode_2(m_oTblCellMar);
|
||
WritingElement_WriteNode_1(L"<w:tblCellSpacing ", m_oTblCellSpacing);
|
||
WritingElement_WriteNode_1(L"<w:tblDescription ", m_oTblDescription);
|
||
WritingElement_WriteNode_1(L"<w:tblInd ", m_oTblInd);
|
||
WritingElement_WriteNode_1(L"<w:tblLayout ", m_oTblLayout);
|
||
WritingElement_WriteNode_1(L"<w:tblLook ", m_oTblLook);
|
||
WritingElement_WriteNode_1(L"<w:tblOverlap ", m_oTblOverlap);
|
||
WritingElement_WriteNode_1(L"<w:tblpPr ", m_oTblpPr);
|
||
|
||
if ( !m_bTblPrChange )
|
||
WritingElement_WriteNode_2( m_oTblPrChange );
|
||
|
||
WritingElement_WriteNode_1(L"<w:tblStyleColBandSize ", m_oTblStyleColBandSize);
|
||
WritingElement_WriteNode_1(L"<w:tblStyleRowBandSize ", m_oTblStyleRowBandSize);
|
||
WritingElement_WriteNode_1(L"<w:tblW ", m_oTblW);
|
||
|
||
sResult += L"</w:tblPr>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTableProperty::getType() const
|
||
{
|
||
return et_w_tblPr;
|
||
}
|
||
const CTableProperty CTableProperty::Merge(const CTableProperty& oPrev, const CTableProperty& oCurrent)
|
||
{
|
||
CTableProperty oProperties;
|
||
oProperties.m_bTblPrChange = oPrev.m_bTblPrChange || oCurrent.m_bTblPrChange;
|
||
oProperties.m_oBidiVisual = Merge( oPrev.m_oBidiVisual, oCurrent.m_oBidiVisual );
|
||
oProperties.m_oJc = Merge( oPrev.m_oJc, oCurrent.m_oJc );
|
||
oProperties.m_oShade = Merge( oPrev.m_oShade, oCurrent.m_oShade );
|
||
|
||
if ( oCurrent.m_oTblBorders.IsInit() && oPrev.m_oTblBorders.IsInit() )
|
||
oProperties.m_oTblBorders = OOX::Logic::CTblBorders::Merge(oPrev.m_oTblBorders.get(), oCurrent.m_oTblBorders.get());
|
||
else
|
||
oProperties.m_oTblBorders = Merge( oPrev.m_oTblBorders, oCurrent.m_oTblBorders );
|
||
|
||
oProperties.m_oTblCaption = Merge( oPrev.m_oTblCaption, oCurrent.m_oTblCaption );
|
||
|
||
if ( oCurrent.m_oTblCellMar.IsInit() && oPrev.m_oTblCellMar.IsInit() )
|
||
oProperties.m_oTblCellMar = OOX::Logic::CTblCellMar::Merge(oPrev.m_oTblCellMar.get(), oCurrent.m_oTblCellMar.get());
|
||
else
|
||
oProperties.m_oTblCellMar = Merge( oPrev.m_oTblCellMar, oCurrent.m_oTblCellMar );
|
||
|
||
oProperties.m_oTblCellSpacing = Merge( oPrev.m_oTblCellSpacing, oCurrent.m_oTblCellSpacing );
|
||
oProperties.m_oTblDescription = Merge( oPrev.m_oTblDescription, oCurrent.m_oTblDescription );
|
||
oProperties.m_oTblInd = Merge( oPrev.m_oTblInd, oCurrent.m_oTblInd );
|
||
oProperties.m_oTblLayout = Merge( oPrev.m_oTblLayout, oCurrent.m_oTblLayout );
|
||
oProperties.m_oTblLook = Merge( oPrev.m_oTblLook, oCurrent.m_oTblLook );
|
||
oProperties.m_oTblOverlap = Merge( oPrev.m_oTblOverlap, oCurrent.m_oTblOverlap );
|
||
oProperties.m_oTblpPr = Merge( oPrev.m_oTblpPr, oCurrent.m_oTblpPr );
|
||
oProperties.m_oTblPrChange = Merge( oPrev.m_oTblPrChange, oCurrent.m_oTblPrChange );
|
||
oProperties.m_oTblStyle = Merge( oPrev.m_oTblStyle, oCurrent.m_oTblStyle );
|
||
oProperties.m_oTblStyleColBandSize = Merge( oPrev.m_oTblStyleColBandSize, oCurrent.m_oTblStyleColBandSize );
|
||
oProperties.m_oTblStyleRowBandSize = Merge( oPrev.m_oTblStyleRowBandSize, oCurrent.m_oTblStyleRowBandSize );
|
||
oProperties.m_oTblW = Merge( oPrev.m_oTblW, oCurrent.m_oTblW );
|
||
return oProperties;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TrPrChange +
|
||
//--------------------------------------------------------------------------------
|
||
CTrPrChange::CTrPrChange(OOX::Document *pMain) : WritingElement(pMain)
|
||
{
|
||
m_pTrPr.Init();
|
||
m_pTrPr->m_bTrPrChange = true;
|
||
}
|
||
CTrPrChange::~CTrPrChange()
|
||
{
|
||
}
|
||
const CTrPrChange& CTrPrChange::operator = (const XmlUtils::CXmlNode &oNode)
|
||
{
|
||
fromXML( (XmlUtils::CXmlNode &)oNode );
|
||
return *this;
|
||
}
|
||
const CTrPrChange& CTrPrChange::operator = (const XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
fromXML( (XmlUtils::CXmlLiteReader&)oReader );
|
||
return *this;
|
||
}
|
||
void CTrPrChange::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( _T("w:trPrChange") != oNode.GetName() )
|
||
return;
|
||
|
||
XmlMacroReadAttributeBase( oNode, _T("w:author"), m_sAuthor );
|
||
XmlMacroReadAttributeBase( oNode, _T("w:date"), m_oDate );
|
||
XmlMacroReadAttributeBase( oNode, _T("w:id"), m_oId );
|
||
XmlMacroReadAttributeBase( oNode, _T("oouserid"), m_sUserId );
|
||
|
||
XmlUtils::CXmlNode oNode_tblPr;
|
||
|
||
if ( m_pTrPr.IsInit() && oNode.GetNode( _T("w:trPr"), oNode_tblPr ) )
|
||
m_pTrPr->fromXML( oNode_tblPr );
|
||
|
||
}
|
||
void CTrPrChange::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes( oReader );
|
||
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
if ( m_pTrPr.IsInit() && _T("w:trPr") == sName )
|
||
m_pTrPr->fromXML( oReader );
|
||
}
|
||
}
|
||
std::wstring CTrPrChange::toXML() const
|
||
{
|
||
std::wstring sResult = _T("<w:trPrChange ");
|
||
|
||
if ( m_sAuthor.IsInit() )
|
||
{
|
||
sResult += L"w:author=\"";
|
||
sResult += XmlUtils::EncodeXmlString(m_sAuthor.get2());
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
if ( m_oDate.IsInit() )
|
||
{
|
||
sResult += _T("w:date=\"");
|
||
sResult += m_oDate->ToString();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
if ( m_oId.IsInit() )
|
||
{
|
||
sResult += _T("w:id=\"");
|
||
sResult += m_oId->ToString();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
if ( m_sUserId.IsInit() )
|
||
{
|
||
sResult += _T("oouserid=\"");
|
||
sResult += m_sUserId.get2();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
sResult += _T(">");
|
||
|
||
if ( m_pTrPr.IsInit() )
|
||
sResult += m_pTrPr->toXML();
|
||
|
||
sResult += _T("</w:trPrChange>");
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTrPrChange::getType() const
|
||
{
|
||
return et_w_trPrChange;
|
||
}
|
||
void CTrPrChange::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, _T("w:author"), m_sAuthor )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:date"), m_oDate )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:id"), m_oId )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("oouserid"), m_sUserId )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TableRowProperties +
|
||
//--------------------------------------------------------------------------------
|
||
CTableRowProperties::CTableRowProperties(OOX::Document *pMain) : WritingElement(pMain)
|
||
{
|
||
m_bTrPrChange = false;
|
||
}
|
||
CTableRowProperties::~CTableRowProperties()
|
||
{
|
||
}
|
||
const CTableRowProperties& CTableRowProperties::operator =(const XmlUtils::CXmlNode &oNode)
|
||
{
|
||
fromXML( (XmlUtils::CXmlNode &)oNode );
|
||
return *this;
|
||
}
|
||
const CTableRowProperties& CTableRowProperties::operator =(const XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
fromXML( (XmlUtils::CXmlLiteReader&)oReader );
|
||
return *this;
|
||
}
|
||
void CTableRowProperties::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:trPr" != oNode.GetName() )
|
||
return;
|
||
|
||
XmlUtils::CXmlNode oChild;
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:cantSplit", m_oCantSplit );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:cnfStyle", m_oCnfStyle );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:del", m_oDel );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:divId", m_oDivId );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:gridAfter", m_oGridAfter );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:gridBefore", m_oGridBefore );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:hidden", m_oHidden );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:ins", m_oIns );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:jc", m_oJc );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblCellSpacing", m_oTblCellSpacing );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tblHeader", m_oTblHeader );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:trHeight", m_oTblHeight );
|
||
|
||
if ( !m_bTrPrChange )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:trPrChange", m_oTrPrChange );
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:wAfter", m_oWAfter );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:wBefore", m_oWBefore );
|
||
}
|
||
void CTableRowProperties::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
|
||
if ( L"w:cantSplit" == sName ) m_oCantSplit = oReader;
|
||
else if ( L"w:cnfStyle" == sName ) m_oCnfStyle = oReader;
|
||
else if ( L"w:del" == sName ) m_oDel = oReader;
|
||
else if ( L"w:divId" == sName ) m_oDivId = oReader;
|
||
else if ( L"w:gridAfter" == sName ) m_oGridAfter = oReader;
|
||
else if ( L"w:gridBefore" == sName ) m_oGridBefore = oReader;
|
||
else if ( L"w:hidden" == sName ) m_oHidden = oReader;
|
||
else if ( L"w:ins" == sName ) m_oIns = oReader;
|
||
else if ( L"w:jc" == sName ) m_oJc = oReader;
|
||
else if ( L"w:tblCellSpacing" == sName ) m_oTblCellSpacing = oReader;
|
||
else if ( L"w:tblHeader" == sName ) m_oTblHeader = oReader;
|
||
else if ( L"w:trHeight" == sName ) m_oTblHeight = oReader;
|
||
else if ( !m_bTrPrChange && L"w:trPrChange" == sName ) m_oTrPrChange = oReader;
|
||
else if ( L"w:wAfter" == sName ) m_oWAfter = oReader;
|
||
else if ( L"w:wBefore" == sName ) m_oWBefore = oReader;
|
||
}
|
||
}
|
||
std::wstring CTableRowProperties::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:trPr>";
|
||
|
||
WritingElement_WriteNode_1( L"<w:cantSplit ", m_oCantSplit );
|
||
WritingElement_WriteNode_1( L"<w:cnfStyle ", m_oCnfStyle );
|
||
WritingElement_WriteNode_1( L"<w:del ", m_oDel );
|
||
WritingElement_WriteNode_1( L"<w:divId ", m_oDivId );
|
||
WritingElement_WriteNode_1( L"<w:gridAfter ", m_oGridAfter );
|
||
WritingElement_WriteNode_1( L"<w:gridBefore ", m_oGridBefore );
|
||
WritingElement_WriteNode_1( L"<w:hidden ", m_oHidden );
|
||
WritingElement_WriteNode_1( L"<w:ins ", m_oIns );
|
||
WritingElement_WriteNode_1( L"<w:jc ", m_oJc );
|
||
WritingElement_WriteNode_1( L"<w:tblCellSpacing ", m_oTblCellSpacing );
|
||
WritingElement_WriteNode_1( L"<w:tblHeader ", m_oTblHeader );
|
||
WritingElement_WriteNode_1( L"<w:trHeight ", m_oTblHeight );
|
||
|
||
if ( !m_bTrPrChange )
|
||
WritingElement_WriteNode_2( m_oTrPrChange );
|
||
|
||
WritingElement_WriteNode_1( L"<w:wAfter ", m_oWAfter );
|
||
WritingElement_WriteNode_1( L"<w:wBefore ", m_oWBefore );
|
||
|
||
sResult += L"</w:trPr>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTableRowProperties::getType() const
|
||
{
|
||
return et_w_trPr;
|
||
}
|
||
const CTableRowProperties CTableRowProperties::Merge(const CTableRowProperties& oPrev, const CTableRowProperties& oCurrent)
|
||
{
|
||
CTableRowProperties oProperties;
|
||
|
||
oProperties.m_bTrPrChange = oPrev.m_bTrPrChange || oCurrent.m_bTrPrChange;
|
||
oProperties.m_oCantSplit = Merge( oPrev.m_oCantSplit, oCurrent.m_oCantSplit );
|
||
oProperties.m_oCnfStyle = Merge( oPrev.m_oCnfStyle, oCurrent.m_oCnfStyle );
|
||
oProperties.m_oDel = Merge( oPrev.m_oDel, oCurrent.m_oDel );
|
||
oProperties.m_oDivId = Merge( oPrev.m_oDivId, oCurrent.m_oDivId );
|
||
oProperties.m_oGridAfter = Merge( oPrev.m_oGridAfter, oCurrent.m_oGridAfter );
|
||
oProperties.m_oGridBefore = Merge( oPrev.m_oGridBefore, oCurrent.m_oGridBefore );
|
||
oProperties.m_oHidden = Merge( oPrev.m_oHidden, oCurrent.m_oHidden );
|
||
oProperties.m_oIns = Merge( oPrev.m_oIns, oCurrent.m_oIns );
|
||
oProperties.m_oJc = Merge( oPrev.m_oJc, oCurrent.m_oJc );
|
||
oProperties.m_oTblCellSpacing = Merge( oPrev.m_oTblCellSpacing, oCurrent.m_oTblCellSpacing );
|
||
oProperties.m_oTblHeader = Merge( oPrev.m_oTblHeader, oCurrent.m_oTblHeader );
|
||
oProperties.m_oTblHeight = Merge( oPrev.m_oTblHeight, oCurrent.m_oTblHeight );
|
||
oProperties.m_oTrPrChange = Merge( oPrev.m_oTrPrChange, oCurrent.m_oTrPrChange );
|
||
oProperties.m_oWAfter = Merge( oPrev.m_oWAfter, oCurrent.m_oWAfter );
|
||
oProperties.m_oWBefore = Merge( oPrev.m_oWBefore, oCurrent.m_oWBefore );
|
||
|
||
return oProperties;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// Headers
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CHeaders::CHeaders(OOX::Document *pMain) : WritingElement(pMain)
|
||
{
|
||
}
|
||
CHeaders::~CHeaders()
|
||
{
|
||
for ( unsigned int nIndex = 0; nIndex < m_arrHeaders.size(); nIndex++ )
|
||
{
|
||
if ( m_arrHeaders[nIndex] ) delete m_arrHeaders[nIndex];
|
||
m_arrHeaders[nIndex] = NULL;
|
||
}
|
||
m_arrHeaders.clear();
|
||
}
|
||
void CHeaders::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:headers" != oNode.GetName() )
|
||
return;
|
||
|
||
std::vector<XmlUtils::CXmlNode> oHeaders;
|
||
|
||
if ( oNode.GetNodes( L"w:header", oHeaders ) )
|
||
{
|
||
for ( size_t nIndex = 0; nIndex < oHeaders.size(); nIndex++ )
|
||
{
|
||
XmlUtils::CXmlNode& oHeader = oHeaders[nIndex];
|
||
if ( oHeader.IsValid() )
|
||
{
|
||
ComplexTypes::Word::String *oHead = new ComplexTypes::Word::String();
|
||
*oHead = oHeader;
|
||
|
||
if (oHead) m_arrHeaders.push_back( oHead );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
void CHeaders::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
|
||
if ( L"w:header" == sName )
|
||
{
|
||
ComplexTypes::Word::String *oHead = new ComplexTypes::Word::String();
|
||
*oHead = oReader;
|
||
|
||
if (oHead) m_arrHeaders.push_back( oHead );
|
||
}
|
||
}
|
||
}
|
||
std::wstring CHeaders::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:headers>";
|
||
|
||
for (unsigned int nIndex = 0; nIndex < m_arrHeaders.size(); nIndex++ )
|
||
{
|
||
sResult += L"<w:header ";
|
||
if (m_arrHeaders[nIndex])
|
||
sResult += m_arrHeaders[nIndex]->ToString();
|
||
sResult += L"/>";
|
||
}
|
||
|
||
sResult += L"</w:headers>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CHeaders::getType() const
|
||
{
|
||
return et_w_headers;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TcBorders
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CTcBorders::CTcBorders()
|
||
{
|
||
}
|
||
CTcBorders::~CTcBorders()
|
||
{
|
||
}
|
||
void CTcBorders::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:tcBorders" != oNode.GetName() )
|
||
return;
|
||
|
||
XmlUtils::CXmlNode oChild;
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:bottom", m_oBottom );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:end", m_oEnd );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:insideH", m_oInsideH );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:insideV", m_oInsideV );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:start", m_oStart );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tl2br", m_oTL2BR );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:top", m_oTop );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tr2bl", m_oTR2BL );
|
||
|
||
if ( !m_oEnd.IsInit() )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:right", m_oEnd );
|
||
|
||
if ( !m_oStart.IsInit() )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:left", m_oStart );
|
||
}
|
||
void CTcBorders::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
|
||
if ( L"w:bottom" == sName ) m_oBottom = oReader;
|
||
else if ( L"w:end" == sName ) m_oEnd = oReader;
|
||
else if ( L"w:insideH" == sName ) m_oInsideH = oReader;
|
||
else if ( L"w:insideV" == sName ) m_oInsideV = oReader;
|
||
else if ( L"w:start" == sName ) m_oStart = oReader;
|
||
else if ( L"w:tl2br" == sName ) m_oTL2BR = oReader;
|
||
else if ( L"w:top" == sName ) m_oTop = oReader;
|
||
else if ( L"w:tr2bl" == sName ) m_oTR2BL = oReader;
|
||
else if ( !m_oEnd.IsInit() && L"w:right" == sName ) m_oEnd = oReader;
|
||
else if ( !m_oStart.IsInit() && L"w:left" == sName ) m_oStart = oReader;
|
||
}
|
||
}
|
||
std::wstring CTcBorders::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:tcBorders>";
|
||
|
||
WritingElement_WriteNode_1( L"<w:top ", m_oTop );
|
||
//WritingElement_WriteNode_1( L"<w:start ", m_oStart );
|
||
WritingElement_WriteNode_1( L"<w:left ", m_oStart); //Transitional Migration Features
|
||
WritingElement_WriteNode_1( L"<w:bottom ", m_oBottom );
|
||
//WritingElement_WriteNode_1( L"<w:end ", m_oEnd );
|
||
WritingElement_WriteNode_1( L"<w:right ", m_oEnd); //Transitional Migration Features
|
||
WritingElement_WriteNode_1( L"<w:insideH ", m_oInsideH );
|
||
WritingElement_WriteNode_1( L"<w:insideV ", m_oInsideV );
|
||
WritingElement_WriteNode_1( L"<w:tl2br ", m_oTL2BR );
|
||
WritingElement_WriteNode_1( L"<w:tr2bl ", m_oTR2BL );
|
||
|
||
sResult += L"</w:tcBorders>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTcBorders::getType() const
|
||
{
|
||
return et_w_tcBorders;
|
||
}
|
||
const CTcBorders CTcBorders::Merge(const CTcBorders& oPrev, const CTcBorders& oCurrent)
|
||
{
|
||
CTcBorders oProperties;
|
||
oProperties.m_oBottom = Merge( oPrev.m_oBottom, oCurrent.m_oBottom );
|
||
oProperties.m_oEnd = Merge( oPrev.m_oEnd, oCurrent.m_oEnd );
|
||
oProperties.m_oInsideH = Merge( oPrev.m_oInsideH, oCurrent.m_oInsideH );
|
||
oProperties.m_oInsideV = Merge( oPrev.m_oInsideV, oCurrent.m_oInsideV );
|
||
oProperties.m_oStart = Merge( oPrev.m_oStart, oCurrent.m_oStart );
|
||
oProperties.m_oTL2BR = Merge( oPrev.m_oTL2BR, oCurrent.m_oTL2BR );
|
||
oProperties.m_oTop = Merge( oPrev.m_oTop, oCurrent.m_oTop );
|
||
oProperties.m_oTR2BL = Merge( oPrev.m_oTR2BL, oCurrent.m_oTR2BL );
|
||
|
||
return oProperties;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TcMar
|
||
//--------------------------------------------------------------------------------
|
||
|
||
CTcMar::CTcMar()
|
||
{
|
||
}
|
||
CTcMar::~CTcMar()
|
||
{
|
||
}
|
||
void CTcMar::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:tcMar" != oNode.GetName() )
|
||
return;
|
||
|
||
XmlUtils::CXmlNode oChild;
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:bottom", m_oBottom );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:end", m_oEnd );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:start", m_oStart );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:top", m_oTop );
|
||
|
||
if ( !m_oEnd.IsInit() )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:right", m_oEnd );
|
||
|
||
if ( !m_oStart.IsInit() )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:left", m_oStart );
|
||
}
|
||
void CTcMar::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
|
||
if ( L"w:bottom" == sName ) m_oBottom = oReader;
|
||
else if ( L"w:end" == sName ) m_oEnd = oReader;
|
||
else if ( L"w:start" == sName ) m_oStart = oReader;
|
||
else if ( L"w:top" == sName ) m_oTop = oReader;
|
||
else if ( !m_oEnd.IsInit() && L"w:right" == sName ) m_oEnd = oReader;
|
||
else if ( !m_oStart.IsInit() && L"w:left" == sName ) m_oStart = oReader;
|
||
}
|
||
}
|
||
std::wstring CTcMar::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:tcMar>";
|
||
|
||
WritingElement_WriteNode_1( L"<w:bottom ", m_oBottom );
|
||
WritingElement_WriteNode_1( L"<w:end ", m_oEnd );
|
||
WritingElement_WriteNode_1( L"<w:start ", m_oStart );
|
||
WritingElement_WriteNode_1( L"<w:top ", m_oTop );
|
||
|
||
sResult += L"</w:tcMar>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTcMar::getType() const
|
||
{
|
||
return et_w_tcMar;
|
||
}
|
||
const CTcMar CTcMar::Merge(const CTcMar& oPrev, const CTcMar& oCurrent)
|
||
{
|
||
CTcMar oProperties;
|
||
oProperties.m_oBottom = Merge( oPrev.m_oBottom, oCurrent.m_oBottom );
|
||
oProperties.m_oEnd = Merge( oPrev.m_oEnd, oCurrent.m_oEnd );
|
||
oProperties.m_oStart = Merge( oPrev.m_oStart, oCurrent.m_oStart );
|
||
oProperties.m_oTop = Merge( oPrev.m_oTop, oCurrent.m_oTop );
|
||
|
||
return oProperties;
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TcPrChange +
|
||
//--------------------------------------------------------------------------------
|
||
CTcPrChange::CTcPrChange(OOX::Document *pMain) : WritingElement(pMain)
|
||
{
|
||
m_pTcPr.Init();
|
||
m_pTcPr->m_bTcPrChange = true;
|
||
}
|
||
CTcPrChange::~CTcPrChange()
|
||
{
|
||
}
|
||
const CTcPrChange& CTcPrChange::operator = (const XmlUtils::CXmlNode &oNode)
|
||
{
|
||
fromXML( (XmlUtils::CXmlNode &)oNode );
|
||
return *this;
|
||
}
|
||
const CTcPrChange& CTcPrChange::operator = (const XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
fromXML( (XmlUtils::CXmlLiteReader&)oReader );
|
||
return *this;
|
||
}
|
||
void CTcPrChange::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( _T("w:tcPrChange") != oNode.GetName() )
|
||
return;
|
||
|
||
XmlMacroReadAttributeBase( oNode, _T("w:author"), m_sAuthor );
|
||
XmlMacroReadAttributeBase( oNode, _T("w:date"), m_oDate );
|
||
XmlMacroReadAttributeBase( oNode, _T("w:id"), m_oId );
|
||
XmlMacroReadAttributeBase( oNode, _T("oouserid"), m_sUserId );
|
||
|
||
XmlUtils::CXmlNode oNode_tcPr;
|
||
|
||
if ( m_pTcPr.IsInit() && oNode.GetNode( _T("w:tcPr"), oNode_tcPr ) )
|
||
m_pTcPr->fromXML( oNode_tcPr );
|
||
|
||
}
|
||
void CTcPrChange::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
ReadAttributes( oReader );
|
||
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
if ( m_pTcPr.IsInit() && _T("w:tcPr") == sName )
|
||
m_pTcPr->fromXML( oReader );
|
||
}
|
||
}
|
||
std::wstring CTcPrChange::toXML() const
|
||
{
|
||
std::wstring sResult = _T("<w:tcPrChange ");
|
||
|
||
if ( m_sAuthor.IsInit() )
|
||
{
|
||
sResult += L"w:author=\"";
|
||
sResult += XmlUtils::EncodeXmlString(m_sAuthor.get2());
|
||
sResult += L"\" ";
|
||
}
|
||
|
||
if ( m_oDate.IsInit() )
|
||
{
|
||
sResult += _T("w:date=\"");
|
||
sResult += m_oDate->ToString();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
if ( m_oId.IsInit() )
|
||
{
|
||
sResult += _T("w:id=\"");
|
||
sResult += m_oId->ToString();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
if ( m_sUserId.IsInit() )
|
||
{
|
||
sResult += _T("oouserid=\"");
|
||
sResult += m_sUserId.get2();
|
||
sResult += _T("\" ");
|
||
}
|
||
|
||
sResult += _T(">");
|
||
|
||
if ( m_pTcPr.IsInit() )
|
||
sResult += m_pTcPr->toXML();
|
||
|
||
sResult += _T("</w:tcPrChange>");
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTcPrChange::getType() const
|
||
{
|
||
return et_w_tcPrChange;
|
||
}
|
||
void CTcPrChange::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
WritingElement_ReadAttributes_Start( oReader )
|
||
WritingElement_ReadAttributes_Read_if ( oReader, _T("w:author"), m_sAuthor )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:date"), m_oDate )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:id"), m_oId )
|
||
WritingElement_ReadAttributes_Read_else_if( oReader, _T("oouserid"), m_sUserId )
|
||
WritingElement_ReadAttributes_End( oReader )
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// TableCellProperties
|
||
//--------------------------------------------------------------------------------
|
||
CTableCellProperties::CTableCellProperties(OOX::Document *pMain) : WritingElement(pMain)
|
||
{
|
||
m_bTcPrChange = false;
|
||
}
|
||
CTableCellProperties::~CTableCellProperties()
|
||
{
|
||
}
|
||
const CTableCellProperties& CTableCellProperties::operator =(const XmlUtils::CXmlNode &oNode)
|
||
{
|
||
fromXML( (XmlUtils::CXmlNode &)oNode );
|
||
return *this;
|
||
}
|
||
const CTableCellProperties& CTableCellProperties::operator =(const XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
fromXML( (XmlUtils::CXmlLiteReader&)oReader );
|
||
return *this;
|
||
}
|
||
void CTableCellProperties::fromXML(XmlUtils::CXmlNode& oNode)
|
||
{
|
||
if ( L"w:tcPr" != oNode.GetName() )
|
||
return;
|
||
|
||
XmlUtils::CXmlNode oChild;
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:cellDel", m_oCellDel );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:cellIns", m_oCellIns );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:cellMerge", m_oCellMerge );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:cnfStyle", m_oCnfStyle );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:gridSpan", m_oGridSpan );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:headers", m_oHeaders );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:hideMark", m_oHideMark );
|
||
|
||
// В списке аттрибутов написано "hMerge", а в примере "hmerge"
|
||
WritingElement_ReadNode( oNode, oChild, L"w:hmerge", m_oHMerge );
|
||
if ( !m_oHMerge.IsInit() )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:hMerge", m_oHMerge );
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:noWrap", m_oNoWrap );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:shd", m_oShd );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tcBorders", m_oTcBorders );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tcFitText", m_oTcFitText );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tcMar", m_oTcMar );
|
||
|
||
if ( !m_bTcPrChange )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tcPrChange", m_oTcPrChange );
|
||
|
||
WritingElement_ReadNode( oNode, oChild, L"w:tcW", m_oTcW );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:textDirection", m_oTextDirection );
|
||
WritingElement_ReadNode( oNode, oChild, L"w:vAlign", m_oVAlign );
|
||
|
||
// В списке аттрибутов написано "vMerge", а в примере "vmerge"
|
||
WritingElement_ReadNode( oNode, oChild, L"w:vmerge", m_oVMerge );
|
||
if ( !m_oVMerge.IsInit() )
|
||
WritingElement_ReadNode( oNode, oChild, L"w:vMerge", m_oVMerge );
|
||
}
|
||
void CTableCellProperties::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
||
{
|
||
if ( oReader.IsEmptyNode() )
|
||
return;
|
||
|
||
int nParentDepth = oReader.GetDepth();
|
||
while( oReader.ReadNextSiblingNode( nParentDepth ) )
|
||
{
|
||
std::wstring sName = oReader.GetName();
|
||
|
||
if ( L"w:cellDel" == sName ) m_oCellDel = oReader;
|
||
else if ( L"w:cellIns" == sName ) m_oCellIns = oReader;
|
||
else if ( L"w:cellMerge" == sName ) m_oCellMerge = oReader;
|
||
else if ( L"w:cnfStyle" == sName ) m_oCnfStyle = oReader;
|
||
else if ( L"w:gridSpan" == sName ) m_oGridSpan = oReader;
|
||
else if ( L"w:headers" == sName ) m_oHeaders = oReader;
|
||
else if ( L"w:hideMark" == sName ) m_oHideMark = oReader;
|
||
else if ( L"w:noWrap" == sName ) m_oNoWrap = oReader;
|
||
else if ( L"w:shd" == sName ) m_oShd = oReader;
|
||
else if ( L"w:tcBorders" == sName ) m_oTcBorders = oReader;
|
||
else if ( L"w:tcFitText" == sName ) m_oTcFitText = oReader;
|
||
else if ( L"w:tcMar" == sName ) m_oTcMar = oReader;
|
||
else if ( !m_bTcPrChange && L"w:tcPrChange" == sName ) m_oTcPrChange = oReader;
|
||
else if ( L"w:tcW" == sName ) m_oTcW = oReader;
|
||
else if ( L"w:vAlign" == sName ) m_oVAlign = oReader;
|
||
|
||
else if ( L"w:textDirection" == sName || L"w:textFlow" == sName) m_oTextDirection = oReader;
|
||
else if ( L"w:hMerge" == sName || L"w:hmerge" == sName) m_oHMerge = oReader;
|
||
else if ( L"w:vMerge" == sName || L"w:vmerge" == sName) m_oVMerge = oReader;
|
||
}
|
||
}
|
||
std::wstring CTableCellProperties::toXML() const
|
||
{
|
||
std::wstring sResult = L"<w:tcPr>";
|
||
|
||
WritingElement_WriteNode_1(L"<w:cnfStyle ", m_oCnfStyle );
|
||
WritingElement_WriteNode_1(L"<w:tcW ", m_oTcW);
|
||
WritingElement_WriteNode_1(L"<w:gridSpan ", m_oGridSpan);
|
||
WritingElement_WriteNode_1(L"<w:hMerge ", m_oHMerge);
|
||
WritingElement_WriteNode_1(L"<w:vMerge ", m_oVMerge);
|
||
|
||
WritingElement_WriteNode_2(m_oTcBorders);
|
||
|
||
WritingElement_WriteNode_1(L"<w:shd ", m_oShd);
|
||
WritingElement_WriteNode_1(L"<w:noWrap ", m_oNoWrap);
|
||
|
||
WritingElement_WriteNode_2(m_oTcMar);
|
||
|
||
WritingElement_WriteNode_1(L"<w:textDirection ", m_oTextDirection);
|
||
WritingElement_WriteNode_1(L"<w:tcFitText ", m_oTcFitText);
|
||
|
||
WritingElement_WriteNode_1(L"<w:vAlign ", m_oVAlign);
|
||
WritingElement_WriteNode_1(L"<w:hideMark ", m_oHideMark);
|
||
|
||
WritingElement_WriteNode_2(m_oHeaders);
|
||
|
||
WritingElement_WriteNode_1(L"<w:cellIns ", m_oCellIns );
|
||
WritingElement_WriteNode_1(L"<w:cellDel ", m_oCellDel );
|
||
WritingElement_WriteNode_1(L"<w:cellMerge ", m_oCellMerge);
|
||
|
||
if ( !m_bTcPrChange )
|
||
WritingElement_WriteNode_2( m_oTcPrChange );
|
||
|
||
sResult += L"</w:tcPr>";
|
||
|
||
return sResult;
|
||
}
|
||
EElementType CTableCellProperties::getType() const
|
||
{
|
||
return et_w_tcPr;
|
||
}
|
||
const CTableCellProperties CTableCellProperties::Merge(const CTableCellProperties& oPrev, const CTableCellProperties& oCurrent)
|
||
{
|
||
CTableCellProperties oProperties;
|
||
oProperties.m_bTcPrChange = oPrev.m_bTcPrChange || oCurrent.m_bTcPrChange;
|
||
oProperties.m_oCellDel = Merge( oPrev.m_oCellDel, oCurrent.m_oCellDel );
|
||
oProperties.m_oCellIns = Merge( oPrev.m_oCellIns, oCurrent.m_oCellIns );
|
||
oProperties.m_oCellMerge = Merge( oPrev.m_oCellMerge, oCurrent.m_oCellMerge );
|
||
oProperties.m_oCnfStyle = Merge( oPrev.m_oCnfStyle, oCurrent.m_oCnfStyle );
|
||
oProperties.m_oGridSpan = Merge( oPrev.m_oGridSpan, oCurrent.m_oGridSpan );
|
||
oProperties.m_oHeaders = Merge( oPrev.m_oHeaders, oCurrent.m_oHeaders );
|
||
oProperties.m_oHideMark = Merge( oPrev.m_oHideMark, oCurrent.m_oHideMark );
|
||
oProperties.m_oHMerge = Merge( oPrev.m_oHMerge, oCurrent.m_oHMerge );
|
||
oProperties.m_oNoWrap = Merge( oPrev.m_oNoWrap, oCurrent.m_oNoWrap );
|
||
oProperties.m_oShd = Merge( oPrev.m_oShd, oCurrent.m_oShd );
|
||
|
||
if ( oCurrent.m_oTcBorders.IsInit() && oPrev.m_oTcBorders.IsInit() )
|
||
oProperties.m_oTcBorders = OOX::Logic::CTcBorders::Merge(oPrev.m_oTcBorders.get(), oCurrent.m_oTcBorders.get());
|
||
else
|
||
oProperties.m_oTcBorders = Merge( oPrev.m_oTcBorders, oCurrent.m_oTcBorders );
|
||
|
||
oProperties.m_oTcFitText = Merge( oPrev.m_oTcFitText, oCurrent.m_oTcFitText );
|
||
|
||
if ( oCurrent.m_oTcMar.IsInit() && oPrev.m_oTcMar.IsInit() )
|
||
oProperties.m_oTcMar = OOX::Logic::CTcMar::Merge(oPrev.m_oTcMar.get(), oCurrent.m_oTcMar.get());
|
||
else
|
||
oProperties.m_oTcMar = Merge( oPrev.m_oTcMar, oCurrent.m_oTcMar );
|
||
|
||
oProperties.m_oTcPrChange = Merge( oPrev.m_oTcPrChange, oCurrent.m_oTcPrChange );
|
||
oProperties.m_oTcW = Merge( oPrev.m_oTcW, oCurrent.m_oTcW );
|
||
oProperties.m_oTextDirection = Merge( oPrev.m_oTextDirection, oCurrent.m_oTextDirection );
|
||
oProperties.m_oVAlign = Merge( oPrev.m_oVAlign, oCurrent.m_oVAlign );
|
||
oProperties.m_oVMerge = Merge( oPrev.m_oVMerge, oCurrent.m_oVMerge );
|
||
|
||
return oProperties;
|
||
}
|
||
|
||
|
||
} // namespace Logic
|
||
} // namespace OOX
|