Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
DocumentServer-v-9.2.0/core/OOXML/DocxFormat/Settings/Settings.cpp
Yajbir Singh f1b860b25c
Some checks failed
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

3100 lines
99 KiB
C++
Raw Permalink Blame History

/*
* (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 "../DocxFlat.h"
#include "Settings.h"
#include "../Endnote.h"
#include "../Footnote.h"
#include "../Math/oMathContent.h"
#include "../Logic/Vml.h"
#include "../Logic/VmlOfficeDrawing.h"
namespace OOX
{
namespace Settings
{
//--------------------------------------------------------------------------------
// CWritingStyle 17.15.1.2 (Part 1)
//--------------------------------------------------------------------------------
CWritingStyle::CWritingStyle()
{
}
CWritingStyle::~CWritingStyle()
{
}
EElementType CWritingStyle::getType() const
{
return OOX::et_w_activeWritingStyle;
}
void CWritingStyle::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CWritingStyle::fromXML(XmlUtils::CXmlNode& oNode)
}
void CWritingStyle::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CWritingStyle::toXML() const
{
std::wstring sResult = L"<w:activeWritingStyle ";
sResult += m_oLang.ToAttribute( L"w:lang");
sResult += m_sVendorID.ToAttribute( L"w:vendorID");
sResult += m_sDllVersion.ToAttribute( L"w:dllVersion");
sResult += m_oNlCheck.ToAttribute( L"w:nlCheck" );
sResult += m_oCheckSyle.ToAttribute( L"w:checkStyle");
sResult += m_sAppName.ToAttribute( L"w:appName" );
sResult += L"/>";
return sResult;
}
void CWritingStyle::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'a':
if ( L"w:appName" == wsName ) m_sAppName = oReader.GetText();
break;
case 'c':
if ( L"w:checkStyle" == wsName ) m_oCheckSyle = oReader.GetText();
break;
case 'd':
if ( L"w:dllVersion" == wsName ) m_sDllVersion = oReader.GetText();
break;
case 'l':
if ( L"w:lang" == wsName ) m_oLang = oReader.GetText();
break;
case 'n':
if ( L"w:nlCheck" == wsName ) m_oNlCheck = oReader.GetText();
break;
case 'v':
if ( L"w:vendorID" == wsName ) m_sVendorID = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CAutoCaption 17.15.1.7 (Part 1)
//--------------------------------------------------------------------------------
CAutoCaption::CAutoCaption()
{
}
CAutoCaption::~CAutoCaption()
{
}
EElementType CAutoCaption::getType() const
{
return OOX::et_w_autoCaption;
}
void CAutoCaption::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CAutoCaption::fromXML(XmlUtils::CXmlNode& oNode)
}
void CAutoCaption::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CAutoCaption::toXML() const
{
std::wstring sResult = L"<w:autoCaption ";
sResult += m_sName.ToAttribute( L"w:name");
sResult += m_sCaption.ToAttribute( L"w:caption");
sResult += L"/>";
return sResult;
}
void CAutoCaption::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
// Читаем атрибуты
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'c':
if ( L"w:caption" == wsName ) m_sCaption = oReader.GetText();
break;
case 'n':
if ( L"w:name" == wsName ) m_sName = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CAutoCaptions 17.15.1.8 (Part 1)
//--------------------------------------------------------------------------------
CAutoCaptions::CAutoCaptions()
{
}
CAutoCaptions::~CAutoCaptions()
{
for ( unsigned int nIndex = 0; nIndex < m_arrAutoCaption.size(); nIndex++ )
{
if (m_arrAutoCaption[nIndex] ) delete m_arrAutoCaption[nIndex];
m_arrAutoCaption[nIndex] = NULL;
}
m_arrAutoCaption.clear();
}
EElementType CAutoCaptions::getType() const
{
return OOX::et_w_autoCaptions;
}
void CAutoCaptions::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CAutoCaptions::fromXML(XmlUtils::CXmlNode& oNode)
}
void CAutoCaptions::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"w:autoCaption" == sName )
{
OOX::Settings::CAutoCaption *oAC = new OOX::Settings::CAutoCaption();
*oAC = oReader;
if (oAC) m_arrAutoCaption.push_back( oAC );
}
}
}
std::wstring CAutoCaptions::toXML() const
{
std::wstring sResult = L"<w:autoCaptions>";
for ( unsigned int nIndex = 0; nIndex < m_arrAutoCaption.size(); nIndex++ )
{
if (m_arrAutoCaption[nIndex])
sResult += m_arrAutoCaption[nIndex]->toXML();
}
sResult += L"</w:autoCaptions>";
return sResult;
}
//--------------------------------------------------------------------------------
// CCaption 17.15.1.16 (Part 1)
//--------------------------------------------------------------------------------
CCaption::CCaption()
{
}
CCaption::~CCaption()
{
}
EElementType CCaption::getType() const
{
return OOX::et_w_caption;
}
void CCaption::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CCaption::fromXML(XmlUtils::CXmlNode& oNode)
}
void CCaption::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CCaption::toXML() const
{
std::wstring sResult = L"<w:caption w:name=\"" + m_sName + L"\" ";
ComplexTypes_WriteAttribute( L"w:pos=\"", m_oPos );
sResult += m_oChapNum.ToAttribute( L"w:chapNum");
ComplexTypes_WriteAttribute( L"w:heading=\"", m_oHeading );
sResult += m_oNoLabel.ToAttribute( L"w:noLabel");
ComplexTypes_WriteAttribute( L"w:numFmt=\"", m_oNumFmt );
ComplexTypes_WriteAttribute( L"w:sep=\"", m_oSep );
sResult += L"/>";
return sResult;
}
void CCaption::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
// Читаем атрибуты
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'c':
if ( L"w:chapNum" == wsName ) m_oChapNum = oReader.GetText();
break;
case 'h':
if ( L"w:heading" == wsName ) m_oHeading = oReader.GetText();
break;
case 'n':
if ( L"w:name" == wsName ) m_sName = oReader.GetText();
else if ( L"w:noLabel" == wsName ) m_oNoLabel = oReader.GetText();
else if ( L"w:numFmt" == wsName ) m_oNumFmt = oReader.GetText();
break;
case 'p':
if ( L"w:pos" == wsName ) m_oPos = oReader.GetText();
break;
case 's':
if ( L"w:sep" == wsName ) m_oSep = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CCaptions 17.15.1.17 (Part 1)
//--------------------------------------------------------------------------------
CCaptions::CCaptions()
{
}
CCaptions::~CCaptions()
{
for ( unsigned int nIndex = 0; nIndex < m_arrCaption.size(); nIndex++ )
{
if ( m_arrCaption[nIndex] ) delete m_arrCaption[nIndex];
m_arrCaption[nIndex] = NULL;
}
m_arrCaption.clear();
}
EElementType CCaptions::getType() const
{
return OOX::et_w_captions;
}
void CCaptions::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CCaptions::fromXML(XmlUtils::CXmlNode& oNode)
}
void CCaptions::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"w:caption" == sName )
{
OOX::Settings::CCaption *oC = new OOX::Settings::CCaption();
*oC = oReader;
if (oC) m_arrCaption.push_back( oC );
}
else if ( L"w:autoCaptions" == sName )
m_oAutoCaptions = oReader;
}
}
std::wstring CCaptions::toXML() const
{
std::wstring sResult = L"<w:captions>";
for ( unsigned int nIndex = 0; nIndex < m_arrCaption.size(); nIndex++ )
{
if (m_arrCaption[nIndex])
sResult += m_arrCaption[nIndex]->toXML();
}
if ( m_oAutoCaptions.IsInit() )
sResult += m_oAutoCaptions->toXML();
sResult += L"</w:captions>";
return sResult;
}
//--------------------------------------------------------------------------------
// CCharacterSpacing 17.15.1.18 (Part 1)
//--------------------------------------------------------------------------------
CCharacterSpacing::CCharacterSpacing()
{
}
CCharacterSpacing::~CCharacterSpacing()
{
}
EElementType CCharacterSpacing::getType() const
{
return OOX::et_w_characterSpacingControl;
}
void CCharacterSpacing::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CCharacterSpacing::fromXML(XmlUtils::CXmlNode& oNode)
}
void CCharacterSpacing::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CCharacterSpacing::toXML() const
{
std::wstring sResult = L"<w:characterSpacingControl w:val=\"" + m_oVal.ToString() + L"\"/>";
return sResult;
}
void CCharacterSpacing::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'v':
if ( L"w:val" == wsName ) m_oVal = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CCompatSetting 17.15.3.4 (Part 1)
//--------------------------------------------------------------------------------
CCompatSetting::CCompatSetting()
{
}
CCompatSetting::~CCompatSetting()
{
}
EElementType CCompatSetting::getType() const
{
return OOX::et_w_compatSetting;
}
void CCompatSetting::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CCompatSetting::fromXML(XmlUtils::CXmlNode& oNode)
}
void CCompatSetting::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CCompatSetting::toXML() const
{
std::wstring sResult = L"<w:compatSetting ";
sResult += m_sName.ToAttribute( L"w:name");
sResult += m_sUri.ToAttribute( L"w:uri");
sResult += m_sVal.ToAttribute( L"w:val" );
sResult += L"/>";
return sResult;
}
void CCompatSetting::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'n':
if ( L"w:name" == wsName ) m_sName = oReader.GetText();
break;
case 'u':
if ( L"w:uri" == wsName ) m_sUri = oReader.GetText();
break;
case 'v':
if ( L"w:val" == wsName ) m_sVal = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
if (m_sName.IsInit() && (*m_sName == L"compatibilityMode") && m_sVal.IsInit())
{
CDocxFlat* flat_docx = dynamic_cast<CDocxFlat*>(m_pMainDocument);
if (flat_docx)
{
flat_docx->m_sCompatibilityMode = *m_sVal;
}
}
}
//--------------------------------------------------------------------------------
// CCompat 17.15.1.21 (Part 1)
//--------------------------------------------------------------------------------
CCompat::CCompat()
{
}
CCompat::~CCompat()
{
for ( unsigned int nIndex = 0; nIndex < m_arrCompatSettings.size(); nIndex++ )
{
if ( m_arrCompatSettings[nIndex] ) delete m_arrCompatSettings[nIndex];
m_arrCompatSettings[nIndex] = NULL;
}
m_arrCompatSettings.clear();
}
EElementType CCompat::getType() const
{
return OOX::et_w_compat;
}
void CCompat::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CCompat::fromXML(XmlUtils::CXmlNode& oNode)
}
void CCompat::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"w:useSingleBorderforContiguousCells" == sName )
m_oUseSingleBorderforContiguousCells = oReader;
else if ( L"w:wpJustification" == sName )
m_oWpJustification = oReader;
else if ( L"w:noTabHangInd" == sName )
m_oNoTabHangInd = oReader;
else if ( L"w:noLeading" == sName )
m_oNoLeading = oReader;
else if ( L"w:spaceForUL" == sName )
m_oSpaceForUL = oReader;
else if ( L"w:noColumnBalance" == sName )
m_oNoColumnBalance = oReader;
else if ( L"w:balanceSingleByteDoubleByteWidth" == sName )
m_oBalanceSingleByteDoubleByteWidth = oReader;
else if ( L"w:noExtraLineSpacing" == sName )
m_oNoExtraLineSpacing = oReader;
else if ( L"w:doNotLeaveBackslashAlone" == sName )
m_oDoNotLeaveBackslashAlone = oReader;
else if ( L"w:ulTrailSpace" == sName )
m_oUlTrailSpace = oReader;
else if ( L"w:doNotExpandShiftReturn" == sName )
m_oDoNotExpandShiftReturn = oReader;
else if ( L"w:spacingInWholePoints" == sName )
m_oSpacingInWholePoints = oReader;
else if ( L"w:lineWrapLikeWord6" == sName )
m_oLineWrapLikeWord6 = oReader;
else if ( L"w:printBodyTextBeforeHeader" == sName )
m_oPrintBodyTextBeforeHeader = oReader;
else if ( L"w:printColBlack" == sName )
m_oPrintColBlack = oReader;
else if ( L"w:wpSpaceWidth" == sName )
m_oWpSpaceWidth = oReader;
else if ( L"w:showBreaksInFrames" == sName )
m_oShowBreaksInFrames = oReader;
else if ( L"w:subFontBySize" == sName )
m_oSubFontBySize = oReader;
else if ( L"w:suppressBottomSpacing" == sName )
m_oSuppressBottomSpacing = oReader;
else if ( L"w:suppressTopSpacing" == sName )
m_oSuppressTopSpacing = oReader;
else if ( L"w:suppressSpacingAtTopOfPage" == sName )
m_oSuppressSpacingAtTopOfPage = oReader;
else if ( L"w:suppressTopSpacingWP" == sName )
m_oSuppressTopSpacingWP = oReader;
else if ( L"w:suppressSpBfAfterPgBrk" == sName )
m_oSuppressSpBfAfterPgBrk = oReader;
else if ( L"w:swapBordersFacingPages" == sName )
m_oSwapBordersFacingPages = oReader;
else if ( L"w:convMailMergeEsc" == sName )
m_oConvMailMergeEsc = oReader;
else if ( L"w:truncateFontHeightsLikeWP6" == sName )
m_oTruncateFontHeightsLikeWP6 = oReader;
else if ( L"w:mwSmallCaps" == sName )
m_oMwSmallCaps = oReader;
else if ( L"w:usePrinterMetrics" == sName )
m_oUsePrinterMetrics = oReader;
else if ( L"w:doNotSuppressParagraphBorders" == sName )
m_oDoNotSuppressParagraphBorders = oReader;
else if ( L"w:wrapTrailSpaces" == sName )
m_oWrapTrailSpaces = oReader;
else if ( L"w:footnoteLayoutLikeWW8" == sName )
m_oFootnoteLayoutLikeWW8 = oReader;
else if ( L"w:shapeLayoutLikeWW8" == sName )
m_oShapeLayoutLikeWW8 = oReader;
else if ( L"w:alignTablesRowByRow" == sName )
m_oAlignTablesRowByRow = oReader;
else if ( L"w:forgetLastTabAlignment" == sName )
m_oForgetLastTabAlignment = oReader;
else if ( L"w:adjustLineHeightInTable" == sName )
m_oAdjustLineHeightInTable = oReader;
else if ( L"w:autoSpaceLikeWord95" == sName )
m_oAutoSpaceLikeWord95 = oReader;
else if ( L"w:noSpaceRaiseLower" == sName )
m_oNoSpaceRaiseLower = oReader;
else if ( L"w:doNotUseHTMLParagraphAutoSpacing" == sName )
m_oDoNotUseHTMLParagraphAutoSpacing = oReader;
else if ( L"w:layoutRawTableWidth" == sName )
m_oLayoutRawTableWidth = oReader;
else if ( L"w:layoutTableRowsApart" == sName )
m_oLayoutTableRowsApart = oReader;
else if ( L"w:useWord97LineBreakRules" == sName )
m_oUseWord97LineBreakRules = oReader;
else if (L"w:breakWrappedTables" == sName)
{
m_oDoNotBreakWrappedTables = oReader;
m_oDoNotBreakWrappedTables->m_oVal.FromBool(!m_oDoNotBreakWrappedTables->m_oVal.ToBool());
}
else if ( L"w:doNotBreakWrappedTables" == sName )
m_oDoNotBreakWrappedTables = oReader;
else if (L"w:snapToGridInCell" == sName)
{
m_oDoNotSnapToGridInCell = oReader;
m_oDoNotSnapToGridInCell->m_oVal.FromBool(!m_oDoNotSnapToGridInCell->m_oVal.ToBool());
}
else if ( L"w:doNotSnapToGridInCell" == sName )
m_oDoNotSnapToGridInCell = oReader;
else if ( L"w:selectFldWithFirstOrLastChar" == sName )
m_oSelectFldWithFirstOrLastChar = oReader;
else if ( L"w:applyBreakingRules" == sName )
m_oApplyBreakingRules = oReader;
else if (L"w:wrapTextWithPunct" == sName)
{
m_oDoNotWrapTextWithPunct = oReader;
m_oDoNotWrapTextWithPunct->m_oVal.FromBool(!m_oDoNotWrapTextWithPunct->m_oVal.ToBool());
}
else if ( L"w:doNotWrapTextWithPunct" == sName )
m_oDoNotWrapTextWithPunct = oReader;
else if (L"w:useAsianBreakRules" == sName)
{
m_oDoNotUseEastAsianBreakRules = oReader;
m_oDoNotUseEastAsianBreakRules->m_oVal.FromBool(!m_oDoNotUseEastAsianBreakRules->m_oVal.ToBool());
}
else if ( L"w:doNotUseEastAsianBreakRules" == sName )
m_oDoNotUseEastAsianBreakRules = oReader;
else if ( L"w:useWord2002TableStyleRules" == sName )
m_oUseWord2002TableStyleRules = oReader;
else if ( L"w:growAutofit" == sName )
m_oGrowAutofit = oReader;
else if (L"w:dontGrowAutofit" == sName)
{
m_oGrowAutofit = oReader;
m_oGrowAutofit->m_oVal.FromBool(!m_oGrowAutofit->m_oVal.ToBool());
}
else if ( L"w:useFELayout" == sName )
m_oUseFELayout = oReader;
else if ( L"w:useNormalStyleForList" == sName )
m_oUseNormalStyleForList = oReader;
else if ( L"w:doNotUseIndentAsNumberingTabStop" == sName )
m_oDoNotUseIndentAsNumberingTabStop = oReader;
else if ( L"w:useAltKinsokuLineBreakRules" == sName )
m_oUseAltKinsokuLineBreakRules = oReader;
else if ( L"w:allowSpaceOfSameStyleInTable" == sName )
m_oAllowSpaceOfSameStyleInTable = oReader;
else if ( L"w:doNotSuppressIndentation" == sName )
m_oDoNotSuppressIndentation = oReader;
else if ( L"w:doNotAutofitConstrainedTables" == sName )
m_oDoNotAutofitConstrainedTables = oReader;
else if ( L"w:autofitToFirstFixedWidthCell" == sName )
m_oAutofitToFirstFixedWidthCell = oReader;
else if ( L"w:underlineTabInNumList" == sName )
m_oUnderlineTabInNumList = oReader;
else if ( L"w:displayHangulFixedWidth" == sName )
m_oDisplayHangulFixedWidth = oReader;
else if ( L"w:splitPgBreakAndParaMark" == sName )
m_oSplitPgBreakAndParaMark = oReader;
else if ( L"w:doNotVertAlignCellWithSp" == sName )
m_oDoNotVertAlignCellWithSp = oReader;
else if ( L"w:doNotBreakConstrainedForcedTable" == sName )
m_oDoNotBreakConstrainedForcedTable = oReader;
else if ( L"w:doNotVertAlignInTxbx" == sName )
m_oDoNotVertAlignInTxbx = oReader;
else if ( L"w:useAnsiKerningPairs" == sName )
m_oUseAnsiKerningPairs = oReader;
else if ( L"w:cachedColBalance" == sName )
m_oCachedColBalance = oReader;
else if ( L"w:compatSetting" == sName )
{
OOX::Settings::CCompatSetting *oCS = new OOX::Settings::CCompatSetting();
*oCS = oReader;
if (oCS) m_arrCompatSettings.push_back( oCS );
}
}
}
std::wstring CCompat::toXML() const
{
std::wstring sResult = L"<w:compat>";
WritingElement_WriteNode_1( L"<w:useSingleBorderforContiguousCells ", m_oUseSingleBorderforContiguousCells );
WritingElement_WriteNode_1( L"<w:wpJustification ", m_oWpJustification );
WritingElement_WriteNode_1( L"<w:noTabHangInd ", m_oNoTabHangInd );
WritingElement_WriteNode_1( L"<w:noLeading ", m_oNoLeading );
WritingElement_WriteNode_1( L"<w:spaceForUL ", m_oSpaceForUL );
WritingElement_WriteNode_1( L"<w:noColumnBalance ", m_oNoColumnBalance );
WritingElement_WriteNode_1( L"<w:balanceSingleByteDoubleByteWidth ", m_oBalanceSingleByteDoubleByteWidth );
WritingElement_WriteNode_1( L"<w:noExtraLineSpacing ", m_oNoExtraLineSpacing );
WritingElement_WriteNode_1( L"<w:doNotLeaveBackslashAlone ", m_oDoNotLeaveBackslashAlone );
WritingElement_WriteNode_1( L"<w:ulTrailSpace ", m_oUlTrailSpace );
WritingElement_WriteNode_1( L"<w:doNotExpandShiftReturn ", m_oDoNotExpandShiftReturn );
WritingElement_WriteNode_1( L"<w:spacingInWholePoints ", m_oSpacingInWholePoints );
WritingElement_WriteNode_1( L"<w:lineWrapLikeWord6 ", m_oLineWrapLikeWord6 );
WritingElement_WriteNode_1( L"<w:printBodyTextBeforeHeader ", m_oPrintBodyTextBeforeHeader );
WritingElement_WriteNode_1( L"<w:printColBlack ", m_oPrintColBlack );
WritingElement_WriteNode_1( L"<w:wpSpaceWidth ", m_oWpSpaceWidth );
WritingElement_WriteNode_1( L"<w:showBreaksInFrames ", m_oShowBreaksInFrames );
WritingElement_WriteNode_1( L"<w:subFontBySize ", m_oSubFontBySize );
WritingElement_WriteNode_1( L"<w:suppressBottomSpacing ", m_oSuppressBottomSpacing );
WritingElement_WriteNode_1( L"<w:suppressTopSpacing ", m_oSuppressTopSpacing );
WritingElement_WriteNode_1( L"<w:suppressSpacingAtTopOfPage ", m_oSuppressSpacingAtTopOfPage );
WritingElement_WriteNode_1( L"<w:suppressTopSpacingWP ", m_oSuppressTopSpacingWP );
WritingElement_WriteNode_1( L"<w:suppressSpBfAfterPgBrk ", m_oSuppressSpBfAfterPgBrk );
WritingElement_WriteNode_1( L"<w:swapBordersFacingPages ", m_oSwapBordersFacingPages );
WritingElement_WriteNode_1( L"<w:convMailMergeEsc ", m_oConvMailMergeEsc );
WritingElement_WriteNode_1( L"<w:truncateFontHeightsLikeWP6 ", m_oTruncateFontHeightsLikeWP6 );
WritingElement_WriteNode_1( L"<w:mwSmallCaps ", m_oMwSmallCaps );
WritingElement_WriteNode_1( L"<w:usePrinterMetrics ", m_oUsePrinterMetrics );
WritingElement_WriteNode_1( L"<w:doNotSuppressParagraphBorders ", m_oDoNotSuppressParagraphBorders );
WritingElement_WriteNode_1( L"<w:wrapTrailSpaces ", m_oWrapTrailSpaces );
WritingElement_WriteNode_1( L"<w:footnoteLayoutLikeWW8 ", m_oFootnoteLayoutLikeWW8 );
WritingElement_WriteNode_1( L"<w:shapeLayoutLikeWW8 ", m_oShapeLayoutLikeWW8 );
WritingElement_WriteNode_1( L"<w:alignTablesRowByRow ", m_oAlignTablesRowByRow );
WritingElement_WriteNode_1( L"<w:forgetLastTabAlignment ", m_oForgetLastTabAlignment );
WritingElement_WriteNode_1( L"<w:adjustLineHeightInTable ", m_oAdjustLineHeightInTable );
WritingElement_WriteNode_1( L"<w:autoSpaceLikeWord95 ", m_oAutoSpaceLikeWord95 );
WritingElement_WriteNode_1( L"<w:noSpaceRaiseLower ", m_oNoSpaceRaiseLower );
WritingElement_WriteNode_1( L"<w:doNotUseHTMLParagraphAutoSpacing ", m_oDoNotUseHTMLParagraphAutoSpacing );
WritingElement_WriteNode_1( L"<w:layoutRawTableWidth ", m_oLayoutRawTableWidth );
WritingElement_WriteNode_1( L"<w:layoutTableRowsApart ", m_oLayoutTableRowsApart );
WritingElement_WriteNode_1( L"<w:useWord97LineBreakRules ", m_oUseWord97LineBreakRules );
WritingElement_WriteNode_1( L"<w:doNotBreakWrappedTables ", m_oDoNotBreakWrappedTables );
WritingElement_WriteNode_1( L"<w:doNotSnapToGridInCell ", m_oDoNotSnapToGridInCell );
WritingElement_WriteNode_1( L"<w:selectFldWithFirstOrLastChar ", m_oSelectFldWithFirstOrLastChar );
WritingElement_WriteNode_1( L"<w:applyBreakingRules ", m_oApplyBreakingRules );
WritingElement_WriteNode_1( L"<w:doNotWrapTextWithPunct ", m_oDoNotWrapTextWithPunct );
WritingElement_WriteNode_1( L"<w:doNotUseEastAsianBreakRules ", m_oDoNotUseEastAsianBreakRules );
WritingElement_WriteNode_1( L"<w:useWord2002TableStyleRules ", m_oUseWord2002TableStyleRules );
WritingElement_WriteNode_1( L"<w:growAutofit ", m_oGrowAutofit );
WritingElement_WriteNode_1( L"<w:useFELayout ", m_oUseFELayout );
WritingElement_WriteNode_1( L"<w:useNormalStyleForList ", m_oUseNormalStyleForList );
WritingElement_WriteNode_1( L"<w:doNotUseIndentAsNumberingTabStop ", m_oDoNotUseIndentAsNumberingTabStop );
WritingElement_WriteNode_1( L"<w:useAltKinsokuLineBreakRules ", m_oUseAltKinsokuLineBreakRules );
WritingElement_WriteNode_1( L"<w:allowSpaceOfSameStyleInTable ", m_oAllowSpaceOfSameStyleInTable );
WritingElement_WriteNode_1( L"<w:doNotSuppressIndentation ", m_oDoNotSuppressIndentation );
WritingElement_WriteNode_1( L"<w:doNotAutofitConstrainedTables ", m_oDoNotAutofitConstrainedTables );
WritingElement_WriteNode_1( L"<w:autofitToFirstFixedWidthCell ", m_oAutofitToFirstFixedWidthCell );
WritingElement_WriteNode_1( L"<w:underlineTabInNumList ", m_oUnderlineTabInNumList );
WritingElement_WriteNode_1( L"<w:displayHangulFixedWidth ", m_oDisplayHangulFixedWidth );
WritingElement_WriteNode_1( L"<w:splitPgBreakAndParaMark ", m_oSplitPgBreakAndParaMark );
WritingElement_WriteNode_1( L"<w:doNotVertAlignCellWithSp ", m_oDoNotVertAlignCellWithSp );
WritingElement_WriteNode_1( L"<w:doNotBreakConstrainedForcedTable ", m_oDoNotBreakConstrainedForcedTable );
WritingElement_WriteNode_1( L"<w:doNotVertAlignInTxbx ", m_oDoNotVertAlignInTxbx );
WritingElement_WriteNode_1( L"<w:useAnsiKerningPairs ", m_oUseAnsiKerningPairs );
WritingElement_WriteNode_1( L"<w:cachedColBalance ", m_oCachedColBalance );
for ( unsigned int nIndex = 0; nIndex < m_arrCompatSettings.size(); nIndex++ )
{
if (m_arrCompatSettings[nIndex])
sResult += m_arrCompatSettings[nIndex]->toXML();
}
sResult += L"</w:compat>";
return sResult;
}
//--------------------------------------------------------------------------------
// CDocProtect 17.15.1.29 (Part 1)
//--------------------------------------------------------------------------------
CDocProtect::CDocProtect()
{
}
CDocProtect::~CDocProtect()
{
}
EElementType CDocProtect::getType() const
{
return OOX::et_w_documentProtection;
}
void CDocProtect::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CDocProtect::fromXML(XmlUtils::CXmlNode& oNode)
}
void CDocProtect::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CDocProtect::toXML() const
{
std::wstring sResult = L"<w:documentProtection ";
ComplexTypes_WriteAttribute ( L"w:edit=\"", m_oEdit );
sResult += m_oFormatting.ToAttribute( L"w:formatting");
sResult += m_oEnforcment.ToAttribute( L"w:enforcement");
if (m_oCryptProviderType.IsInit() || m_oCryptAlgorithmSid.IsInit())
{
ComplexTypes_WriteAttribute(L"w:cryptProviderType=\"", m_oCryptProviderType);
sResult += m_oAlgIdExt.ToAttribute(L"w:algIdEx");
sResult += m_oAlgIdExtSource.ToAttribute(L"w:algIdExtSource");
ComplexTypes_WriteAttribute(L"w:cryptAlgorithmClass=\"", m_oCryptAlgorithmClass);
ComplexTypes_WriteAttribute(L"w:cryptAlgorithmType=\"", m_oCryptAlgorithmType);
sResult += m_oCryptAlgorithmSid.ToAttribute(L"w:cryptAlgorithmSid");
sResult += m_oCryptProvider.ToAttribute(L"w:cryptProvider");
sResult += m_oCryptProviderTypeExt.ToAttribute(L"w:cryptProviderTypeExt");
sResult += m_oCryptProviderTypeExtSource.ToAttribute(L"w:cryptProviderTypeExtSource");
sResult += m_oSpinCount.ToAttribute(L"w:cryptSpinCount");
sResult += m_sHashValue.ToAttribute(L"w:hash");
sResult += m_sSaltValue.ToAttribute(L"w:salt");
}
else
{
ComplexTypes_WriteAttribute(L"w:algorithmName=\"", m_oAlgorithmName);
sResult += m_sHashValue.ToAttribute(L"w:hashValue");
sResult += m_sSaltValue.ToAttribute(L"w:saltValue");
sResult += m_oSpinCount.ToAttribute(L"w:spinCount");
}
sResult += L"/>";
return sResult;
}
void CDocProtect::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'a':
if ( L"w:algorithmName" == wsName ) m_oAlgorithmName = oReader.GetText();
else if (L"w:algIdExt" == wsName) m_oAlgIdExt = oReader.GetText();
else if (L"w:algIdExtSource" == wsName) m_oAlgIdExtSource = oReader.GetText();
break;
case 'c':
if (L"w:cryptProviderType" == wsName) m_oCryptProviderType = oReader.GetText();
else if (L"w:cryptProvider" == wsName) m_oCryptProvider = oReader.GetText();
else if (L"w:cryptProviderTypeExt" == wsName) m_oCryptProviderTypeExt = oReader.GetText();
else if (L"w:cryptProviderTypeExtSource" == wsName) m_oCryptProviderTypeExtSource = oReader.GetText();
else if (L"w:cryptAlgorithmSid" == wsName) m_oCryptAlgorithmSid = oReader.GetText();
else if (L"w:cryptAlgorithmType" == wsName) m_oCryptAlgorithmType = oReader.GetText();
else if (L"w:cryptAlgorithmClass" == wsName) m_oCryptAlgorithmClass = oReader.GetText();
else if (L"w:cryptSpinCount" == wsName) m_oSpinCount = oReader.GetText();
break;
case 'e':
if ( L"w:edit" == wsName ) m_oEdit = oReader.GetText();
else if ( L"w:enforcement" == wsName ) m_oEnforcment = oReader.GetText();
break;
case 'f':
if ( L"w:formatting" == wsName ) m_oFormatting = oReader.GetText();
break;
case 'h':
if ( L"w:hashValue" == wsName ) m_sHashValue = oReader.GetText();
else if (L"w:hash" == wsName) m_sHashValue = oReader.GetText();
break;
case 's':
if ( L"w:saltValue" == wsName ) m_sSaltValue = oReader.GetText();
else if (L"w:salt" == wsName) m_sSaltValue = oReader.GetText();
else if ( L"w:spinCount" == wsName ) m_oSpinCount = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CDocType 17.15.1.30 (Part 1)
//--------------------------------------------------------------------------------
CDocType::CDocType()
{
}
CDocType::~CDocType()
{
}
void CDocType::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CDocType::fromXML(XmlUtils::CXmlNode& oNode)
}
void CDocType::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CDocType::toXML() const
{
std::wstring sResult = L"<w:documentType w:val=\"" + m_oVal.ToString() + L"\"/>";
return sResult;
}
EElementType CDocType::getType() const
{
return OOX::et_w_documentType;
}
void CDocType::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'v':
if ( L"w:val" == wsName ) m_oVal = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CDocVar 17.15.1.31 (Part 1)
//--------------------------------------------------------------------------------
CDocVar::CDocVar()
{
}
CDocVar::~CDocVar()
{
}
void CDocVar::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CDocVar::fromXML(XmlUtils::CXmlNode& oNode)
}
void CDocVar::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CDocVar::toXML() const
{
std::wstring sResult = L"<w:docVar w:name=\"" + m_sName + L"\" w:val=\"" + m_sVal + L"\"/>";
return sResult;
}
EElementType CDocVar::getType() const
{
return OOX::et_w_docVar;
}
void CDocVar::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'n':
if ( L"w:name" == wsName ) m_sName = oReader.GetText();
break;
case 'v':
if ( L"w:val" == wsName ) m_sVal = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CDocVars 17.15.1.32 (Part 1)
//--------------------------------------------------------------------------------
CDocVars::CDocVars()
{
}
CDocVars::~CDocVars()
{
for ( unsigned int nIndex = 0; nIndex < m_arrDocVar.size(); nIndex++ )
{
if ( m_arrDocVar[nIndex] ) delete m_arrDocVar[nIndex];
m_arrDocVar[nIndex] = NULL;
}
m_arrDocVar.clear();
}
void CDocVars::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CDocVars::fromXML(XmlUtils::CXmlNode& oNode)
}
void CDocVars::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"w:docVar" == sName )
{
OOX::Settings::CDocVar *oDV = new OOX::Settings::CDocVar();
*oDV = oReader;
if (oDV) m_arrDocVar.push_back( oDV );
}
}
}
std::wstring CDocVars::toXML() const
{
std::wstring sResult = L"<w:docVars>";
for (unsigned int nIndex = 0; nIndex < m_arrDocVar.size(); nIndex++ )
{
if (m_arrDocVar[nIndex])
sResult += m_arrDocVar[nIndex]->toXML();
}
sResult += L"</w:docVars>";
return sResult;
}
EElementType CDocVars::getType() const
{
return OOX::et_w_docVars;
}
//--------------------------------------------------------------------------------
// CKinsoku 17.15.1.58 (Part 1)
//--------------------------------------------------------------------------------
CKinsoku::CKinsoku()
{
}
CKinsoku::~CKinsoku()
{
}
void CKinsoku::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CKinsoku::fromXML(XmlUtils::CXmlNode& oNode)
}
void CKinsoku::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
m_eType = et_Unknown;
std::wstring sName = oReader.GetName();
if ( L"w:noLineBreaksAfter" == sName )
m_eType = et_w_noLineBreaksAfter;
else if ( L"w:noLineBreaksBefore" == sName )
m_eType = et_w_noLineBreaksBefore;
else
return;
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CKinsoku::toXML() const
{
std::wstring sResult;
if ( et_w_noLineBreaksAfter == m_eType )
sResult = L"<w:noLineBreaksAfter w:lang=\"" + m_sLang + L"\" w:val=\"" + m_sVal + L"\"/>";
else if ( et_w_noLineBreaksBefore == m_eType )
sResult = L"<w:noLineBreaksBefore w:lang=\"" + m_sLang + L"\" w:val=\"" + m_sVal + L"\"/>";
return sResult;
}
EElementType CKinsoku::getType() const
{
return m_eType;
}
void CKinsoku::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'l':
if ( L"w:lang" == wsName ) m_sLang = oReader.GetText();
break;
case 'v':
if ( L"w:val" == wsName ) m_sVal = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CProof 17.15.1.65 (Part 1)
//--------------------------------------------------------------------------------
CProof::CProof()
{
}
CProof::~CProof()
{
}
void CProof::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CProof::fromXML(XmlUtils::CXmlNode& oNode)
}
void CProof::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CProof::toXML() const
{
std::wstring sResult = L"<w:proofState ";
ComplexTypes_WriteAttribute ( L"w:spelling=\"", m_oSpelling );
ComplexTypes_WriteAttribute ( L"w:grammar=\"", m_oGrammar );
sResult += L"/>";
return sResult;
}
EElementType CProof::getType() const
{
return OOX::et_w_proofState;
}
void CProof::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'g':
if ( L"w:grammar" == wsName ) m_oGrammar = oReader.GetText();
break;
case 's':
if ( L"w:spelling" == wsName ) m_oSpelling = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CReadingModeInkLockDown 17.15.1.66 (Part 1)
//--------------------------------------------------------------------------------
CReadingModeInkLockDown::CReadingModeInkLockDown()
{
}
CReadingModeInkLockDown::~CReadingModeInkLockDown()
{
}
void CReadingModeInkLockDown::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CReadingModeInkLockDown::fromXML(XmlUtils::CXmlNode& oNode)
}
void CReadingModeInkLockDown::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
EElementType CReadingModeInkLockDown::getType() const
{
return OOX::et_w_readModeInkLockDown;
}
std::wstring CReadingModeInkLockDown::toXML() const
{
std::wstring sResult = L"<w:readModeInkLockDown ";
sResult += L"w:w=\"" + m_oW.ToString()
+ L"\" w:h=\"" + m_oH.ToString()
+ L"\" w:fontSz=\"" + m_oFontSz.ToString()
+ L"\" w:actualPg=\"" + m_oActualPg.ToString() + L"\"/>";
return sResult;
}
void CReadingModeInkLockDown::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'a':
if ( L"w:actualPg" == wsName ) m_oActualPg = oReader.GetText();
break;
case 'f':
if ( L"w:fontSz" == wsName ) m_oFontSz = oReader.GetText();
break;
case 'h':
if ( L"w:h" == wsName ) m_oH = oReader.GetText();
break;
case 'w':
if ( L"w:w" == wsName ) m_oW = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CTrackChangesView 17.15.1.69 (Part 1)
//--------------------------------------------------------------------------------
CTrackChangesView::CTrackChangesView()
{
}
CTrackChangesView::~CTrackChangesView()
{
}
void CTrackChangesView::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CTrackChangesView::fromXML(XmlUtils::CXmlNode& oNode)
}
void CTrackChangesView::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
EElementType CTrackChangesView::getType() const
{
return OOX::et_w_revisionView;
}
std::wstring CTrackChangesView::toXML() const
{
std::wstring sResult = L"<w:revisionView ";
sResult += m_oMarkup.ToAttribute( L"w:markup");
sResult += m_oComments.ToAttribute( L"w:comments");
sResult += m_oInsDel.ToAttribute( L"w:insDel");
sResult += m_oFormatting.ToAttribute( L"w:formatting");
sResult += m_oInkAnnotataions.ToAttribute( L"w:inkAnnotations");
sResult += L"/>";
return sResult;
}
void CTrackChangesView::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'c':
if ( L"w:comments" == wsName ) m_oComments = oReader.GetText();
break;
case 'f':
if ( L"w:formatting" == wsName ) m_oFormatting = oReader.GetText();
break;
case 'i':
if ( L"w:inkAnnotations" == wsName ) m_oInkAnnotataions = oReader.GetText();
else if ( L"w:insDel" == wsName ) m_oInsDel = oReader.GetText();
break;
case 'm':
if ( L"w:markup" == wsName ) m_oMarkup = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CDocRsids 17.15.1.72 (Part 1)
//--------------------------------------------------------------------------------
CDocRsids::CDocRsids()
{
}
CDocRsids::~CDocRsids()
{
for ( unsigned int nIndex = 0; nIndex < m_arrRsid.size(); nIndex++ )
{
if ( m_arrRsid[nIndex] ) delete m_arrRsid[nIndex];
m_arrRsid[nIndex] = NULL;
}
m_arrRsid.clear();
}
void CDocRsids::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CDocRsids::fromXML(XmlUtils::CXmlNode& oNode)
}
void CDocRsids::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"w:rsid" == sName )
{
ComplexTypes::Word::CLongHexNumber *oRsid = new ComplexTypes::Word::CLongHexNumber();
*oRsid = oReader;
if (oRsid) m_arrRsid.push_back( oRsid );
}
else if ( L"w:rsidRoot" == sName )
m_oRsidRoot = oReader;
}
}
std::wstring CDocRsids::toXML() const
{
std::wstring sResult = L"<w:rsids>";
if ( m_oRsidRoot.IsInit() )
{
sResult += L"<w:rsidRoot ";
sResult += m_oRsidRoot->ToString();
sResult += L"/>";
}
for ( unsigned int nIndex = 0; nIndex < m_arrRsid.size(); nIndex++ )
{
sResult += L"<w:rsid ";
if (m_arrRsid[nIndex])
sResult += m_arrRsid[nIndex]->ToString();
sResult += L"/>";
}
sResult += L"</w:rsids>";
return sResult;
}
EElementType CDocRsids::getType() const
{
return OOX::et_w_rsids;
}
//--------------------------------------------------------------------------------
// CSaveThroughXslt 17.15.1.76 (Part 1)
//--------------------------------------------------------------------------------
CSaveThroughXslt::CSaveThroughXslt()
{
}
CSaveThroughXslt::~CSaveThroughXslt()
{
}
void CSaveThroughXslt::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CTrackChangesView::fromXML(XmlUtils::CXmlNode& oNode)
}
void CSaveThroughXslt::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CSaveThroughXslt::toXML() const
{
std::wstring sResult = L"<w:saveThroughXslt ";
ComplexTypes_WriteAttribute ( L"r:id=\"", m_rId );
sResult += m_sSolutionID.ToAttribute(L"w:solutionID");
sResult += L"/>";
return sResult;
}
EElementType CSaveThroughXslt::getType() const
{
return OOX::et_w_saveThroughXslt;
}
void CSaveThroughXslt::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
WritingElement_ReadAttributes_Start(oReader)
WritingElement_ReadAttributes_Read_if (oReader, L"w:solutionID", m_sSolutionID)
WritingElement_ReadAttributes_Read_else_if (oReader, L"r:id", m_rId)
WritingElement_ReadAttributes_Read_else_if (oReader, L"relationships:id", m_rId)
WritingElement_ReadAttributes_End(oReader)
}
//--------------------------------------------------------------------------------
// CSmartTagType 17.15.1.81 (Part 1)
//--------------------------------------------------------------------------------
CSmartTagType::CSmartTagType()
{
}
CSmartTagType::~CSmartTagType()
{
}
void CSmartTagType::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CSmartTagType::fromXML(XmlUtils::CXmlNode& oNode)
}
void CSmartTagType::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CSmartTagType::toXML() const
{
std::wstring sResult = L"<w:smartTagType ";
sResult += m_sNameSpaceUri.ToAttribute( L"w:namespaceuri");
sResult += m_sName.ToAttribute( L"w:name");
sResult += m_sUrl.ToAttribute( L"w:url");
sResult += L"/>";
return sResult;
}
EElementType CSmartTagType::getType() const
{
return OOX::et_w_smartTagType;
}
void CSmartTagType::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
if ( L"w:name" == wsName ) m_sName = oReader.GetText();
else if ( L"w:namespaceuri" == wsName ) m_sNameSpaceUri = oReader.GetText();
else if ( L"w:url" == wsName ) m_sUrl = oReader.GetText();
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CStylePaneFilter 17.15.1.85 (Part 1)
//--------------------------------------------------------------------------------
CStylePaneFilter::CStylePaneFilter()
{
}
CStylePaneFilter::~CStylePaneFilter()
{
}
void CStylePaneFilter::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CStylePaneFilter::fromXML(XmlUtils::CXmlNode& oNode)
}
void CStylePaneFilter::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
EElementType CStylePaneFilter::getType() const
{
return OOX::et_w_stylePaneFormatFilter;
}
std::wstring CStylePaneFilter::toXML() const
{
std::wstring sResult = L"<w:stylePaneFormatFilter ";
sResult += m_oAllStyles.ToAttribute( L"w:allStyles");
sResult += m_oAlternateStyleNames.ToAttribute( L"w:alternateStyleNames");
sResult += m_oClearFormatting.ToAttribute( L"w:clearFormatting");
sResult += m_oCustomStyles.ToAttribute( L"w:customStyles");
sResult += m_oDirectFormattingOnNumbering.ToAttribute( L"w:directFormattingOnNumbering");
sResult += m_oDirectFormattingOnParagraphs.ToAttribute( L"w:directFormattingOnParagraphs");
sResult += m_oDirectFormattingOnRuns.ToAttribute( L"w:directFormattingOnRuns");
sResult += m_oDirectFormattingOnTables.ToAttribute( L"w:directFormattingOnTables");
sResult += m_oHeadingStyles.ToAttribute( L"w:headingStyles");
sResult += m_oLatentStyles.ToAttribute( L"w:latentStyles");
sResult += m_oNumberingStyles.ToAttribute( L"w:numberingStyles");
sResult += m_oStylesInUse.ToAttribute( L"w:stylesInUse");
sResult += m_oTableStyles.ToAttribute( L"w:tableStyles");
sResult += m_oTop3HeadingStyles.ToAttribute( L"w:top3HeadingStyles");
sResult += m_oVisibleStyles.ToAttribute( L"w:visibleStyles");
sResult += L"/>";
return sResult;
}
void CStylePaneFilter::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'a':
if ( L"w:allStyles" == wsName ) m_oAllStyles = oReader.GetText();
else if ( L"w:alternateStyleNames" == wsName ) m_oAlternateStyleNames = oReader.GetText();
break;
case 'c':
if ( L"w:clearFormatting" == wsName ) m_oClearFormatting = oReader.GetText();
else if ( L"w:customStyles" == wsName ) m_oCustomStyles = oReader.GetText();
break;
case 'd':
if ( L"w:directFormattingOnNumbering" == wsName ) m_oDirectFormattingOnNumbering = oReader.GetText();
else if ( L"w:directFormattingOnParagraphs" == wsName ) m_oDirectFormattingOnParagraphs = oReader.GetText();
else if ( L"w:directFormattingOnRuns" == wsName ) m_oDirectFormattingOnRuns = oReader.GetText();
else if ( L"w:directFormattingOnTables" == wsName ) m_oDirectFormattingOnTables = oReader.GetText();
break;
case 'h':
if ( L"w:headingStyles" == wsName ) m_oHeadingStyles = oReader.GetText();
break;
case 'l':
if ( L"w:latentStyles" == wsName ) m_oLatentStyles = oReader.GetText();
break;
case 'n':
if ( L"w:numberingStyles" == wsName ) m_oNumberingStyles = oReader.GetText();
break;
case 's':
if ( L"w:stylesInUse" == wsName ) m_oStylesInUse = oReader.GetText();
break;
case 't':
if ( L"w:tableStyles" == wsName ) m_oTableStyles = oReader.GetText();
else if ( L"w:top3HeadingStyles" == wsName ) m_oTop3HeadingStyles = oReader.GetText();
break;
case 'v':
if ( L"w:visibleStyles" == wsName ) m_oVisibleStyles = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CWriteProtection 17.15.1.93 (Part 1)
//--------------------------------------------------------------------------------
CWriteProtection::CWriteProtection()
{
}
CWriteProtection::~CWriteProtection()
{
}
void CWriteProtection::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CWriteProtection::fromXML(XmlUtils::CXmlNode& oNode)
}
void CWriteProtection::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
EElementType CWriteProtection::getType() const
{
return OOX::et_w_writeProtection;
}
std::wstring CWriteProtection::toXML() const
{
std::wstring sResult = L"<w:writeProtection ";
sResult += m_oRecommended.ToAttribute( L"w:recommended");
if (m_oCryptProviderType.IsInit() || m_oCryptAlgorithmSid.IsInit())
{
ComplexTypes_WriteAttribute(L"w:cryptProviderType=\"", m_oCryptProviderType);
sResult += m_oAlgIdExt.ToAttribute(L"w:algIdEx");
sResult += m_oAlgIdExtSource.ToAttribute(L"w:algIdExtSource");
ComplexTypes_WriteAttribute(L"w:cryptAlgorithmClass=\"", m_oCryptAlgorithmClass);
ComplexTypes_WriteAttribute(L"w:cryptAlgorithmType=\"", m_oCryptAlgorithmType);
sResult += m_oCryptAlgorithmSid.ToAttribute(L"w:cryptAlgorithmSid");
sResult += m_oCryptProvider.ToAttribute(L"w:cryptProvider");
sResult += m_oCryptProviderTypeExt.ToAttribute(L"w:cryptProviderTypeExt");
sResult += m_oCryptProviderTypeExtSource.ToAttribute(L"w:cryptProviderTypeExtSource");
sResult += m_oSpinCount.ToAttribute(L"w:cryptSpinCount");
sResult += m_sHashValue.ToAttribute(L"w:hash");
sResult += m_sSaltValue.ToAttribute(L"w:salt");
}
else
{
ComplexTypes_WriteAttribute(L"w:algorithmName=\"", m_oAlgorithmName);
sResult += m_sHashValue.ToAttribute(L"w:hashValue");
sResult += m_sSaltValue.ToAttribute(L"w:saltValue");
sResult += m_oSpinCount.ToAttribute(L"w:spinCount");
}
sResult += L"/>";
return sResult;
}
void CWriteProtection::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'a':
if ( L"w:algorithmName" == wsName ) m_oAlgorithmName = oReader.GetText();
else if (L"w:algIdExt" == wsName) m_oAlgIdExt = oReader.GetText();
else if (L"w:algIdExtSource" == wsName) m_oAlgIdExtSource = oReader.GetText();
break;
case 'c':
if ( L"w:cryptProviderType" == wsName ) m_oCryptProviderType = oReader.GetText();
else if (L"w:cryptProvider" == wsName) m_oCryptProvider = oReader.GetText();
else if (L"w:cryptProviderTypeExt" == wsName) m_oCryptProviderTypeExt = oReader.GetText();
else if (L"w:cryptProviderTypeExtSource" == wsName) m_oCryptProviderTypeExtSource = oReader.GetText();
else if ( L"w:cryptAlgorithmSid" == wsName ) m_oCryptAlgorithmSid = oReader.GetText();
else if ( L"w:cryptAlgorithmType" == wsName ) m_oCryptAlgorithmType = oReader.GetText();
else if ( L"w:cryptAlgorithmClass" == wsName ) m_oCryptAlgorithmClass = oReader.GetText();
else if ( L"w:cryptSpinCount" == wsName ) m_oSpinCount = oReader.GetText();
break;
case 'h':
if ( L"w:hashValue" == wsName ) m_sHashValue = oReader.GetText();
else if ( L"w:hash" == wsName ) m_sHashValue = oReader.GetText();
break;
case 'r':
if ( L"w:recommended" == wsName ) m_oRecommended = oReader.GetText();
break;
case 's':
if ( L"w:saltValue" == wsName ) m_sSaltValue = oReader.GetText();
else if ( L"w:salt" == wsName ) m_sSaltValue = oReader.GetText();
else if ( L"w:spinCount" == wsName ) m_oSpinCount = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CZoom 17.15.1.94 (Part 1)
//--------------------------------------------------------------------------------
CZoom::CZoom()
{
}
CZoom::~CZoom()
{
}
void CZoom::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CZoom::fromXML(XmlUtils::CXmlNode& oNode)
}
void CZoom::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
std::wstring CZoom::toXML() const
{
std::wstring sResult = L"<w:zoom ";
ComplexTypes_WriteAttribute ( L"w:val=\"", m_oVal );
sResult += L"w:percent=\"" + m_oPercent.ToString() + L"\"/>";
return sResult;
}
EElementType CZoom::getType() const
{
return OOX::et_w_zoom;
}
void CZoom::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
wchar_t wsChar0 = wsName[0];
wchar_t wsChar2 = wsName[2]; // w:_
if ( 'w' == wsChar0 )
{
switch ( wsChar2 )
{
case 'p':
if ( L"w:percent" == wsName ) m_oPercent = oReader.GetText();
break;
case 'v':
if ( L"w:val" == wsName ) m_oVal = oReader.GetText();
break;
}
}
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CEdnDocProps 17.11.4 (Part 1)
//--------------------------------------------------------------------------------
CEdnDocProps::CEdnDocProps(OOX::Document *pMain) : OOX::WritingElement(pMain)
{
}
CEdnDocProps::~CEdnDocProps()
{
for ( unsigned int nIndex = 0; nIndex < m_arrEndnote.size(); nIndex++ )
{
if ( m_arrEndnote[nIndex] ) delete m_arrEndnote[nIndex];
m_arrEndnote[nIndex] = NULL;
}
m_arrEndnote.clear();
}
void CEdnDocProps::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CEdnDocProps::fromXML(XmlUtils::CXmlNode& oNode)
}
EElementType CEdnDocProps::getType() const
{
return et_w_endnotePr;
}
void CEdnDocProps::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nParentDepth = oReader.GetDepth();
while( oReader.ReadNextSiblingNode( nParentDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"w:numFmt" == sName )
m_oNumFmt = oReader;
else if ( L"w:numRestart" == sName )
m_oNumRestart = oReader;
else if ( L"w:numStart" == sName )
m_oNumStart = oReader;
else if ( L"w:pos" == sName )
m_oPos = oReader;
else if ( L"w:endnote" == sName )
{
CDocxFlat* docx_flat = dynamic_cast<CDocxFlat*>(WritingElement::m_pMainDocument);
if (docx_flat)
{
CFtnEdn *pEndnote = new CFtnEdn(WritingElement::m_pMainDocument);
pEndnote->fromXML(oReader);
pEndnote->m_oId.Init();
pEndnote->m_oId->SetValue((int)docx_flat->m_pEndnotes->m_arrEndnote.size() - 1);
docx_flat->m_pSettings->m_oEndnotePr->m_arrEndnote.push_back(new CFtnEdnSepRef());
docx_flat->m_pSettings->m_oEndnotePr->m_arrEndnote.back()->m_oId = pEndnote->m_oId;
docx_flat->m_pSettings->m_oEndnotePr->m_arrEndnote.back()->m_eType = OOX::et_w_endnote;
docx_flat->m_pEndnotes->m_arrEndnote.push_back(pEndnote);
docx_flat->m_pEndnotes->m_mapEndnote.insert(std::make_pair(pEndnote->m_oId->GetValue(), pEndnote));
}
else
{
OOX::CFtnEdnSepRef *oFE = new OOX::CFtnEdnSepRef(oReader);
if (oFE) m_arrEndnote.push_back(oFE);
}
}
}
}
std::wstring CEdnDocProps::toXML() const
{
std::wstring sResult = L"<w:endnotePr>";
if (m_oPos.IsInit())
{
sResult += L"<w:pos ";
sResult += m_oPos->ToString();
sResult += L"/>";
}
if ( m_oNumFmt.IsInit() )
{
sResult += L"<w:numFmt ";
sResult += m_oNumFmt->ToString();
sResult += L"/>";
}
if ( m_oNumStart.IsInit() )
{
sResult += L"<w:numStart ";
sResult += m_oNumStart->ToString();
sResult += L"/>";
}
if ( m_oNumRestart.IsInit() )
{
sResult += L"<w:numRestart ";
sResult += m_oNumRestart->ToString();
sResult += L"/>";
}
for (unsigned int nIndex = 0; nIndex < m_arrEndnote.size(); nIndex++)
{
if (m_arrEndnote[nIndex])
sResult += m_arrEndnote[nIndex]->toXML();
}
sResult += L"</w:endnotePr>";
return sResult;
}
//--------------------------------------------------------------------------------
// CFtnDocProps 17.11.12 (Part 1)
//--------------------------------------------------------------------------------
CFtnDocProps::CFtnDocProps(OOX::Document *pMain) : OOX::WritingElement(pMain)
{
}
CFtnDocProps::~CFtnDocProps()
{
for ( unsigned int nIndex = 0; nIndex < m_arrFootnote.size(); nIndex++ )
{
if ( m_arrFootnote[nIndex] ) delete m_arrFootnote[nIndex];
m_arrFootnote[nIndex] = NULL;
}
m_arrFootnote.clear();
}
void CFtnDocProps::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CFtnDocProps::fromXML(XmlUtils::CXmlNode& oNode)
}
EElementType CFtnDocProps::getType() const
{
return et_w_footnotePr;
}
void CFtnDocProps::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nParentDepth = oReader.GetDepth();
while( oReader.ReadNextSiblingNode( nParentDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"w:numFmt" == sName )
m_oNumFmt = oReader;
else if ( L"w:numRestart" == sName )
m_oNumRestart = oReader;
else if ( L"w:numStart" == sName )
m_oNumStart = oReader;
else if ( L"w:pos" == sName )
m_oPos = oReader;
else if ( L"w:footnote" == sName )
{
CDocxFlat* docx_flat = dynamic_cast<CDocxFlat*>(WritingElement::m_pMainDocument);
if (docx_flat)
{
CFtnEdn *pFootnote = new CFtnEdn(WritingElement::m_pMainDocument);
pFootnote->fromXML(oReader);
pFootnote->m_oId.Init();
pFootnote->m_oId->SetValue((int)docx_flat->m_pFootnotes->m_arrFootnote.size() - 1);
docx_flat->m_pSettings->m_oFootnotePr->m_arrFootnote.push_back(new CFtnEdnSepRef());
docx_flat->m_pSettings->m_oFootnotePr->m_arrFootnote.back()->m_oId = pFootnote->m_oId;
docx_flat->m_pSettings->m_oFootnotePr->m_arrFootnote.back()->m_eType = OOX::et_w_footnote;
docx_flat->m_pFootnotes->m_arrFootnote.push_back(pFootnote);
docx_flat->m_pFootnotes->m_mapFootnote.insert(std::make_pair(pFootnote->m_oId->GetValue(), pFootnote));
}
else
{
OOX::CFtnEdnSepRef *oFE = new OOX::CFtnEdnSepRef(oReader);
if (oFE) m_arrFootnote.push_back(oFE);
}
}
}
}
std::wstring CFtnDocProps::toXML() const
{
std::wstring sResult = L"<w:footnotePr>";
if (m_oPos.IsInit())
{
sResult += L"<w:pos ";
sResult += m_oPos->ToString();
sResult += L"/>";
}
if ( m_oNumFmt.IsInit() )
{
sResult += L"<w:numFmt ";
sResult += m_oNumFmt->ToString();
sResult += L"/>";
}
if (m_oNumStart.IsInit())
{
sResult += L"<w:numStart ";
sResult += m_oNumStart->ToString();
sResult += L"/>";
}
if ( m_oNumRestart.IsInit() )
{
sResult += L"<w:numRestart ";
sResult += m_oNumRestart->ToString();
sResult += L"/>";
}
for (unsigned int nIndex = 0; nIndex < m_arrFootnote.size(); nIndex++)
{
if (m_arrFootnote[nIndex])
sResult += m_arrFootnote[nIndex]->toXML();
}
sResult += L"</w:footnotePr>";
return sResult;
}
//--------------------------------------------------------------------------------
// CSchema 23.2.1 (Part 1)
//--------------------------------------------------------------------------------
CSchema::CSchema()
{
}
CSchema::~CSchema()
{
}
void CSchema::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CSchema::fromXML(XmlUtils::CXmlNode& oNode)
}
void CSchema::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( !oReader.IsEmptyNode() )
oReader.ReadTillEnd();
}
EElementType CSchema::getType() const
{
return OOX::et_sl_schema;
}
std::wstring CSchema::toXML() const
{
std::wstring sResult = L"<sl:schema sl:uri=\"" + m_sUri
+ L"\" sl:manifestLocation=\"" + m_sManifestLocation
+ L"\" sl:schemaLocation=\"" + m_sShemaLocation
+ L"\" sl:schemaLanguage=\"" + m_sShemaLanguage + L"\"/>";
return sResult;
}
void CSchema::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.GetAttributesCount() <= 0 )
return;
if ( !oReader.MoveToFirstAttribute() )
return;
std::wstring wsName = oReader.GetName();
while( !wsName.empty() )
{
if ( L"sl:uri" == wsName )
m_sUri = oReader.GetText();
else if ( L"sl:schemaLocation" == wsName )
m_sShemaLocation = oReader.GetText();
else if ( L"sl:schemaLanguage" == wsName )
m_sShemaLanguage = oReader.GetText();
else if ( L"sl:manifestLocation" == wsName )
m_sManifestLocation = oReader.GetText();
if ( !oReader.MoveToNextAttribute() )
break;
wsName = oReader.GetName();
}
oReader.MoveToElement();
}
//--------------------------------------------------------------------------------
// CSchemaLibrary 23.2.2 (Part 1)
//--------------------------------------------------------------------------------
CSchemaLibrary::CSchemaLibrary()
{
}
CSchemaLibrary::~CSchemaLibrary()
{
for ( unsigned int nIndex = 0; nIndex < m_arrSchema.size(); nIndex++ )
{
if ( m_arrSchema[nIndex] ) delete m_arrSchema[nIndex];
m_arrSchema[nIndex] = NULL;
}
m_arrSchema.clear();
}
void CSchemaLibrary::fromXML(XmlUtils::CXmlNode& oNode)
{
// TO DO: Реализовать CSchemaLibrary::fromXML(XmlUtils::CXmlNode& oNode)
}
void CSchemaLibrary::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = oReader.GetName();
if ( L"sl:schema" == sName )
{
OOX::Settings::CSchema *oSchema = new OOX::Settings::CSchema();
*oSchema = oReader;
if (oSchema) m_arrSchema.push_back( oSchema );
}
}
}
std::wstring CSchemaLibrary::toXML() const
{
std::wstring sResult = L"<sl:schemaLibrary>";
for ( unsigned int nIndex = 0; nIndex < m_arrSchema.size(); nIndex++ )
{
if (m_arrSchema[nIndex])
sResult += m_arrSchema[nIndex]->toXML();
}
sResult += L"</sl:schemaLibrary>";
return sResult;
}
EElementType CSchemaLibrary::getType() const
{
return OOX::et_sl_schemaLibrary;
}
//--------------------------------------------------------------------------------
// CShapeDefaults 9.7.2.1;9.7.2.2 (Part 4)
//--------------------------------------------------------------------------------
CShapeDefaults::CShapeDefaults()
{
}
CShapeDefaults::CShapeDefaults(EElementType type)
{
m_eType = type;
}
CShapeDefaults::~CShapeDefaults()
{
}
void CShapeDefaults::fromXML(XmlUtils::CXmlNode& oNode)
{
m_eType = et_Unknown;
// TO DO: Реализовать CShapeDefaults::fromXML(XmlUtils::CXmlNode& oNode)
}
void CShapeDefaults::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
m_eType = et_Unknown;
std::wstring sName = oReader.GetName();
if ( L"w:hdrShapeDefaults" == sName )
m_eType = et_w_hdrShapeDefaults;
else if ( L"w:shapeDefaults" == sName )
m_eType = et_w_shapeDefaults;
else
return;
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nCurDepth ) )
{
sName = oReader.GetName();
WritingElement* pItem = NULL;
wchar_t wChar0 = sName[0];
if ( 'o' == wChar0 )
{
wchar_t wChar2 = sName[2]; // o:_
switch ( wChar2 )
{
case 'b':
if ( L"o:bottom" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CStrokeChild, oReader)
break;
case 'c':
if ( L"o:callout" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CCallout, oReader)
else if ( L"o:clippath" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CClipPath, oReader)
else if ( L"o:column" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CStrokeChild, oReader)
else if ( L"o:complex" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CComplex, oReader)
break;
case 'd':
if ( L"o:diagram" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CDiagram, oReader)
break;
case 'e':
if ( L"o:equationxml" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CEquationXml, oReader)
else if ( L"o:extrusion" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CExtrusion, oReader)
break;
case 'f':
if ( L"o:fill" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CFill, oReader)
break;
case 'i':
if ( L"o:ink" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CInk, oReader)
break;
case 'l':
if ( L"o:left" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CStrokeChild, oReader)
else if ( L"o:lock" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CLock, oReader)
break;
case 'O':
if ( L"o:OLEObject" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::COLEObject, oReader)
break;
case 'r':
if ( L"o:right" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CStrokeChild, oReader)
break;
case 's':
if ( L"o:shapedefaults" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CShapeDefaults, oReader)
else if ( L"o:shapelayout" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CShapeLayout, oReader)
else if ( L"o:signatureline" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CSignatureLine, oReader)
else if ( L"o:skew" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CSkew, oReader)
break;
case 't':
if ( L"o:top" == sName )
AssignPtrXmlContent(pItem, OOX::VmlOffice::CStrokeChild, oReader)
break;
}
}
if ( pItem )
m_arrItems.push_back( pItem );
}
}
std::wstring CShapeDefaults::toXML() const
{
std::wstring sResult;
if ( et_w_hdrShapeDefaults == m_eType )
sResult = L"<w:hdrShapeDefaults>";
else if ( et_w_shapeDefaults == m_eType )
sResult = L"<w:shapeDefaults>";
else
return L"";
for ( size_t i = 0; i < m_arrItems.size(); ++i)
{
if ( m_arrItems[i] )
{
sResult += m_arrItems[i]->toXML();
}
}
if ( et_w_hdrShapeDefaults == m_eType )
sResult += L"</w:hdrShapeDefaults>";
else if ( et_w_shapeDefaults == m_eType )
sResult += L"</w:shapeDefaults>";
return sResult;
}
EElementType CShapeDefaults::getType() const
{
return m_eType;
}
} // namespace Settings
//--------------------------------------------------------------------------------
// CSettings 17.11.15.1.78
//--------------------------------------------------------------------------------
CSettings::CSettings(OOX::Document *pMain) : OOX::File(pMain), OOX::WritingElement(pMain)
{
CDocx* docx = dynamic_cast<CDocx*>(File::m_pMainDocument);
if (docx)
{
if (docx->m_bGlossaryRead) docx->m_oGlossary.settings = this;
else docx->m_oMain.settings = this;
}
}
CSettings::CSettings(OOX::Document *pMain, const CPath& oPath) : OOX::File(pMain), OOX::WritingElement(pMain)
{
CDocx* docx = dynamic_cast<CDocx*>(File::m_pMainDocument);
if (docx)
{
if (docx->m_bGlossaryRead) docx->m_oGlossary.settings = this;
else docx->m_oMain.settings = this;
}
read( oPath );
}
CSettings::CSettings(XmlUtils::CXmlNode& oNode) : File(NULL), WritingElement(NULL)
{
fromXML( oNode );
}
CSettings::CSettings(XmlUtils::CXmlLiteReader& oReader) : File(NULL), WritingElement(NULL)
{
fromXML( oReader );
}
CSettings::~CSettings()
{
for ( unsigned int nIndex = 0; nIndex < m_arrSmartTagType.size(); nIndex++ )
{
if ( m_arrSmartTagType[nIndex] )delete m_arrSmartTagType[nIndex];
m_arrSmartTagType[nIndex] = NULL;
}
m_arrSmartTagType.clear();
m_oMathPr.reset();
}
void CSettings::read(const CPath& oFilePath)
{
XmlUtils::CXmlLiteReader oReader;
if ( !oReader.FromFile( oFilePath.GetPath() ) )
return;
if ( !oReader.ReadNextNode() )
return;
fromXML(oReader);
}
void CSettings::fromXML(XmlUtils::CXmlNode& oNode)
{
}
const OOX::FileType CSettings::type() const
{
return FileTypes::Setting;
}
const CPath CSettings::DefaultDirectory() const
{
return type().DefaultDirectory();
}
const CPath CSettings::DefaultFileName() const
{
return type().DefaultFileName();
}
void CSettings::SetDefaults()
{
m_oDefaultTabStop.Init();
m_oDefaultTabStop->m_oVal.Init();
m_oDefaultTabStop->m_oVal->FromTwips(708);
m_oZoom.Init();
m_oZoom->m_oPercent.SetValue(100);
m_oCharacterSpacingControl.Init();
m_oCharacterSpacingControl->m_oVal.SetValue(SimpleTypes::charspacingDoNotCompress);
m_oThemeFontLang.Init();
m_oThemeFontLang->m_oEastAsia = L"zh-CN";
m_oThemeFontLang->m_oVal = L"en-US";
m_oShapeDefaults = new Settings::CShapeDefaults(et_w_shapeDefaults);
OOX::VmlOffice::CShapeDefaults *vDefault = new OOX::VmlOffice::CShapeDefaults();
vDefault->m_oExt.Init(); vDefault->m_oExt->SetValue(SimpleTypes::extEdit);
vDefault->m_oSpIdMax.SetValue(1026);
m_oShapeDefaults->m_arrItems.push_back(vDefault);
OOX::VmlOffice::CShapeLayout *vLayout = new OOX::VmlOffice::CShapeLayout();
vLayout->m_oExt.Init(); vLayout->m_oExt->SetValue(SimpleTypes::extEdit);
vLayout->m_oIdMap.Init(); vLayout->m_oIdMap->m_sData = L"1";
vLayout->m_oIdMap->m_oExt.Init(); vLayout->m_oIdMap->m_oExt->SetValue(SimpleTypes::extEdit);
m_oShapeDefaults->m_arrItems.push_back(vLayout);
}
void CSettings::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
if (oReader.IsEmptyNode()) return;
std::wstring sName = oReader.GetName();
if ( L"w:settings" != sName && L"w:docPr" != sName) return;
int nStylesDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nStylesDepth ) )
{
sName = oReader.GetName();
wchar_t wChar0 = sName[0];
wchar_t wChar2 = sName[2];
if ( 'w' == wChar0 )
{
switch ( wChar2 )
{
case 'a':
if ( L"w:activeWritingStyle" == sName ) m_oActiveWritingStyle = oReader;
else if ( L"w:alignBordersAndEdges" == sName ) m_oAlignBordersAndEdges = oReader;
else if ( L"w:alwaysMergeEmptyNamespace" == sName ) m_oAlwaysMergeEmptyNamespace = oReader;
else if ( L"w:alwaysShowPlaceholderText" == sName ) m_oAlwaysShowPlaceholderText = oReader;
else if ( L"w:attachedSchema" == sName ) m_oAttachedSchema = oReader;
else if ( L"w:attachedTemplate" == sName ) m_oAttachedTemplate = oReader;
else if ( L"w:autoFormatOverride" == sName ) m_oAutoFormatOverride = oReader;
else if ( L"w:autoHyphenation" == sName ) m_oAutoHyphenation = oReader;
break;
case 'b':
if ( L"w:bookFoldPrinting" == sName ) m_oBookFoldPrinting = oReader;
else if ( L"w:bookFoldPrintingSheets" == sName ) m_oBookFoldPrintingSheets = oReader;
else if ( L"w:bookFoldRevPrinting" == sName ) m_oBookFoldRevPrinting = oReader;
else if ( L"w:bordersDoNotSurroundFooter" == sName ) m_oBordersDoNotSurroundFooter = oReader;
else if ( L"w:bordersDoNotSurroundHeader" == sName ) m_oBordersDoNotSurroundHeader = oReader;
break;
case 'c':
if ( L"w:captions" == sName ) m_oCaptions = oReader;
else if ( L"w:characterSpacingControl" == sName ) m_oCharacterSpacingControl = oReader;
else if ( L"w:clickAndTypeStyle" == sName ) m_oClickAndTypeStyle = oReader;
else if ( L"w:clrSchemeMapping" == sName ) m_oClrSchemeMapping = oReader;
else if ( L"w:compat" == sName ) m_oCompat = oReader;
else if ( L"w:consecutiveHyphenLimit" == sName ) m_oConsecutiveHyphenLimit = oReader;
break;
case 'd':
if ( L"w:decimalSymbol" == sName ) m_oDecimalSymbol = oReader;
else if ( L"w:defaultTableStyle" == sName ) m_oDefaultTableStyle = oReader;
else if ( L"w:defaultTabStop" == sName ) m_oDefaultTabStop = oReader;
else if ( L"w:displayBackgroundShape" == sName ) m_oDisplayBackgroundShape = oReader;
else if ( L"w:displayHorizontalDrawingGridEvery" == sName ) m_oDisplayHorizontalDrawingGridEvery = oReader;
else if ( L"w:displayVerticalDrawingGridEvery" == sName ) m_oDisplayVerticalDrawingGridEvery = oReader;
else if ( L"w:documentProtection" == sName ) m_oDocumentProtection = oReader;
else if ( L"w:documentType" == sName ) m_oDocumentType = oReader;
else if ( L"w:docVars" == sName ) m_oDocVars = oReader;
else if ( L"w:doNotAutoCompressPictures" == sName ) m_oDoNotAutoCompressPictures = oReader;
else if ( L"w:doNotDemarcateInvalidXml" == sName ) m_oDoNotDemarcateInvalidXml = oReader;
else if ( L"w:doNotDisplayPageBoundaries" == sName ) m_oDoNotDisplayPageBoundaries = oReader;
else if ( L"w:doNotEmbedSmartTags" == sName ) m_oDoNotEmbedSmartTags = oReader;
else if ( L"w:doNotHyphenateCaps" == sName ) m_oDoNotHyphenateCaps = oReader;
else if ( L"w:doNotIncludeSubdocsInStats" == sName ) m_oDoNotIncludeSubdocsInStats = oReader;
else if ( L"w:doNotShadeFormData" == sName ) m_oDoNotShadeFormData = oReader;
else if ( L"w:doNotTrackFormatting" == sName ) m_oDoNotTrackFormatting = oReader;
else if ( L"w:doNotTrackMoves" == sName ) m_oDoNotTrackMoves = oReader;
else if ( L"w:doNotUseMarginsForDrawingGridOrigin" == sName ) m_oDoNotUseMarginsForDrawingGridOrigin = oReader;
else if ( L"w:doNotValidateAgainstSchema" == sName ) m_oDoNotValidateAgainstSchema = oReader;
else if ( L"w:drawingGridHorizontalOrigin" == sName ) m_oDrawingGridHorizontalOrigin = oReader;
else if ( L"w:drawingGridHorizontalSpacing" == sName ) m_oDrawingGridHorizontalSpacing = oReader;
else if ( L"w:drawingGridVerticalOrigin" == sName ) m_oDrawingGridVerticalOrigin = oReader;
else if ( L"w:drawingGridVerticalSpacing" == sName ) m_oDrawingGridVerticalSpacing = oReader;
break;
case 'e':
if ( L"w:embedSystemFonts" == sName ) m_oEmbedSystemFonts = oReader;
else if ( L"w:embedTrueTypeFonts" == sName ) m_oEmbedTrueTypeFonts = oReader;
else if (L"w:endnotePr" == sName)
{
m_oEndnotePr = new Settings::CEdnDocProps(WritingElement::m_pMainDocument);
m_oEndnotePr->fromXML(oReader);
}
else if ( L"w:evenAndOddHeaders" == sName ) m_oEvenAndOddHeaders = oReader;
break;
case 'f':
if (L"w:footnotePr" == sName)
{
m_oFootnotePr = new Settings::CFtnDocProps(WritingElement::m_pMainDocument);
m_oFootnotePr->fromXML(oReader);
}
else if ( L"w:forceUpgrade" == sName ) m_oForceUpgrade = oReader;
else if ( L"w:formsDesign" == sName ) m_oFormsDesign = oReader;
break;
case 'g':
if ( L"w:gutterAtTop" == sName ) m_oGutterAtTop = oReader;
break;
case 'h':
if ( L"w:hdrShapeDefaults" == sName ) m_oHdrShapeDefaults = oReader;
else if ( L"w:hideGrammaticalErrors" == sName ) m_oHideGrammaticalErrors = oReader;
else if ( L"w:hideSpellingErrors" == sName ) m_oHideSpellingErrors = oReader;
else if ( L"w:hyphenationZone" == sName ) m_oHyphenationZone = oReader;
break;
case 'i':
if ( L"w:ignoreMixedContent" == sName ) m_oIgnoreMixedContent = oReader;
break;
case 'l':
if ( L"w:linkStyles" == sName ) m_oLinkStyles = oReader;
else if ( L"w:listSeparator" == sName ) m_oListSeparator = oReader;
break;
case 'm':
if ( L"w:mirrorMargins" == sName ) m_oMirrorMargins = oReader;
break;
case 'n':
if ( L"w:noLineBreaksAfter" == sName ) m_oNoLineBreaksAfter = oReader;
else if ( L"w:noLineBreaksBefore" == sName ) m_oNoLineBreaksBefore = oReader;
else if ( L"w:noPunctuationKerning" == sName ) m_oNoPunctuationKerning = oReader;
break;
case 'p':
if ( L"w:printFormsData" == sName ) m_oPrintFormsData = oReader;
else if ( L"w:printFractionalCharacterWidth" == sName ) m_oPrintFractionalCharacterWidth = oReader;
else if ( L"w:printPostScriptOverText" == sName ) m_oPrintPostScriptOverText = oReader;
else if ( L"w:printTwoOnOne" == sName ) m_oPrintTwoOnOne = oReader;
else if ( L"w:proofState" == sName ) m_oProofState = oReader;
break;
case 'r':
if ( L"w:readModeInkLockDown" == sName ) m_oReadModeInkLockDown = oReader;
else if ( L"w:removeDateAndTime" == sName ) m_oRemoveDateAndTime = oReader;
else if ( L"w:removePersonalInformation" == sName ) m_oRemovePersonalInformation = oReader;
else if ( L"w:revisionView" == sName ) m_oRevisionView = oReader;
else if ( L"w:rsids" == sName ) m_oRsids = oReader;
break;
case 's':
if ( L"w:saveFormsData" == sName ) m_oSaveFormsData = oReader;
else if ( L"w:saveInvalidXml" == sName ) m_oSaveInvalidXml = oReader;
else if ( L"w:savePreviewPicture" == sName ) m_oSavePreviewPicture = oReader;
else if ( L"w:saveSubsetFonts" == sName ) m_oSaveSubsetFonts = oReader;
else if ( L"w:saveThroughXslt" == sName ) m_oSaveThroughtXslt = oReader;
else if ( L"w:saveXmlDataOnly" == sName ) m_oSaveXmlDataOnly = oReader;
else if ( L"w:shapeDefaults" == sName ) m_oShapeDefaults = oReader;
else if ( L"w:showEnvelope" == sName ) m_oShowEnvelope = oReader;
else if ( L"w:showXMLTags" == sName ) m_oShowXMLTags = oReader;
else if ( L"w:smartTagType" == sName )
{
OOX::Settings::CSmartTagType *oSTT = new OOX::Settings::CSmartTagType();
*oSTT = oReader;
if (oSTT) m_arrSmartTagType.push_back( oSTT );
}
else if ( L"w:strictFirstAndLastChars" == sName ) m_oStrictFirstAndLastChars = oReader;
else if ( L"w:styleLockQFSet" == sName ) m_oStyleLockQFSet = oReader;
else if ( L"w:styleLockTheme" == sName ) m_oStyleLockTheme = oReader;
else if ( L"w:stylePaneFormatFilter" == sName ) m_oStylePaneFormatFilter = oReader;
else if ( L"w:stylePaneSortMethod" == sName ) m_oStylePaneSortMethod = oReader;
else if ( L"w:summaryLength" == sName ) m_oSummaryLength = oReader;
break;
case 't':
if ( L"w:themeFontLang" == sName ) m_oThemeFontLang = oReader;
else if ( L"w:trackRevisions" == sName ) m_oTrackRevisions = oReader;
break;
case 'u':
if ( L"w:updateFields" == sName ) m_oUpdateFields = oReader;
else if ( L"w:useXSLTWhenSaving" == sName ) m_oUseXSLTWhenSaving = oReader;
break;
case 'v':
if ( L"w:view" == sName ) m_oView = oReader;
break;
case 'w':
if ( L"w:writeProtection" == sName ) m_oWriteProtection = oReader;
break;
case 'z':
if ( L"w:zoom" == sName ) m_oZoom = oReader;
break;
}
}
else if ( 's' == wChar0 )
{
if ( L"sl:schemaLibrary" == sName )
m_oSchemaLibrary = oReader;
}
else if ( 'm' == wChar0 )
{
if ( L"m:mathPr" == sName )
m_oMathPr = oReader;
}
}
}
void CSettings::write(const CPath& oFilePath, const CPath& oDirectory, CContentTypes& oContent) const
{
std::wstring sXml = L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
sXml += toXML();
CDirectory::SaveToFile( oFilePath.GetPath(), sXml );
oContent.Registration( type().OverrideType(), oDirectory, oFilePath.GetFilename() );
}
std::wstring CSettings::toXML() const
{
std::wstring sXml = L"<w:settings xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:sl=\"http://schemas.openxmlformats.org/schemaLibrary/2006/main\" mc:Ignorable=\"w14 w15\">";
if ( m_oWriteProtection.IsInit() )
sXml += m_oWriteProtection->toXML();
if ( m_oView.IsInit() )
sXml += m_oView->toXML();
if ( m_oZoom.IsInit() )
sXml += m_oZoom->toXML();
if ( m_oRemovePersonalInformation.IsInit() )
sXml += L"<w:removePersonalInformation " + m_oRemovePersonalInformation->ToString() + L"/>";
if ( m_oRemoveDateAndTime.IsInit() )
sXml += L"<w:removeDateAndTime " + m_oRemoveDateAndTime->ToString() + L"/>";
if ( m_oDoNotDisplayPageBoundaries.IsInit() )
sXml += L"<w:doNotDisplayPageBoundaries " + m_oDoNotDisplayPageBoundaries->ToString() + L"/>";
if ( m_oDisplayBackgroundShape.IsInit() )
sXml += L"<w:displayBackgroundShape " + m_oDisplayBackgroundShape->ToString() + L"/>";
if ( m_oPrintPostScriptOverText.IsInit() )
sXml += L"<w:printPostScriptOverText " + m_oPrintPostScriptOverText->ToString() + L"/>";
if ( m_oPrintFractionalCharacterWidth.IsInit() )
sXml += L"<w:printFractionalCharacterWidth " + m_oPrintFractionalCharacterWidth->ToString() + L"/>";
if ( m_oPrintFormsData.IsInit() )
sXml += L"<w:printFormsData " + m_oPrintFormsData->ToString() + L"/>";
if ( m_oEmbedTrueTypeFonts.IsInit() )
sXml += L"<w:embedTrueTypeFonts " + m_oEmbedTrueTypeFonts->ToString() + L"/>";
if ( m_oEmbedSystemFonts.IsInit() )
sXml += L"<w:embedSystemFonts " + m_oEmbedSystemFonts->ToString() + L"/>";
if ( m_oSaveSubsetFonts.IsInit() )
sXml += L"<w:saveSubsetFonts " + m_oSaveSubsetFonts->ToString() + L"/>";
if ( m_oSaveFormsData.IsInit() )
sXml += L"<w:saveFormsData " + m_oSaveFormsData->ToString() + L"/>";
if ( m_oMirrorMargins.IsInit() )
sXml += L"<w:mirrorMargins " + m_oMirrorMargins->ToString() + L"/>";
if ( m_oAlignBordersAndEdges.IsInit() )
sXml += L"<w:alignBordersAndEdges " + m_oAlignBordersAndEdges->ToString() + L"/>";
if ( m_oBordersDoNotSurroundHeader.IsInit() )
sXml += L"<w:bordersDoNotSurroundHeader " + m_oBordersDoNotSurroundHeader->ToString() + L"/>";
if (m_oBordersDoNotSurroundFooter.IsInit())
sXml += L"<w:bordersDoNotSurroundFooter " + m_oBordersDoNotSurroundFooter->ToString() + L"/>";
if ( m_oGutterAtTop.IsInit() )
sXml += L"<w:gutterAtTop " + m_oGutterAtTop->ToString() + L"/>";
if ( m_oHideSpellingErrors.IsInit() )
sXml += L"<w:hideSpellingErrors " + m_oHideSpellingErrors->ToString() + L"/>";
if ( m_oHideGrammaticalErrors.IsInit() )
sXml += L"<w:hideGrammaticalErrors " + m_oHideGrammaticalErrors->ToString() + L"/>";
if ( m_oActiveWritingStyle.IsInit() )
sXml += m_oActiveWritingStyle->toXML();
if ( m_oProofState.IsInit() )
sXml += m_oProofState->toXML();
if ( m_oFormsDesign.IsInit() )
sXml += L"<w:formsDesign " + m_oFormsDesign->ToString() + L"/>";
if ( m_oAttachedTemplate.IsInit() )
sXml += L"<w:attachedTemplate " + m_oAttachedTemplate->ToString() + L"/>";
if ( m_oLinkStyles.IsInit() )
sXml += L"<w:linkStyles " + m_oLinkStyles->ToString() + L"/>";
if ( m_oStylePaneFormatFilter.IsInit() )
sXml += m_oStylePaneFormatFilter->toXML();
if ( m_oStylePaneSortMethod.IsInit() )
sXml += m_oStylePaneSortMethod->toXML();
if ( m_oDocumentType.IsInit() )
sXml += m_oDocumentType->toXML();
// TO DO: Здесь вставить запись w:mailMerge
if ( m_oRevisionView.IsInit() )
sXml += m_oRevisionView->toXML();
if ( m_oTrackRevisions.IsInit() )
sXml += L"<w:trackRevisions " + m_oTrackRevisions->ToString() + L"/>";
if ( m_oDoNotTrackMoves.IsInit() )
sXml += L"<w:doNotTrackMoves " + m_oDoNotTrackMoves->ToString() + L"/>";
if ( m_oDoNotTrackFormatting.IsInit() )
sXml += L"<w:doNotTrackFormatting " + m_oDoNotTrackFormatting->ToString() + L"/>";
if ( m_oDocumentProtection.IsInit() )
sXml += m_oDocumentProtection->toXML();
if ( m_oAutoFormatOverride.IsInit() )
sXml += L"<w:autoFormatOverride " + m_oAutoFormatOverride->ToString() + L"/>";
if ( m_oStyleLockTheme.IsInit() )
sXml += L"<w:styleLockTheme " + m_oStyleLockTheme->ToString() + L"/>";
if ( m_oStyleLockQFSet.IsInit() )
sXml += L"<w:styleLockQFSet " + m_oStyleLockQFSet->ToString() + L"/>";
if ( m_oDefaultTabStop.IsInit() )
sXml += L"<w:defaultTabStop " + m_oDefaultTabStop->ToString() + L"/>";
if ( m_oAutoHyphenation.IsInit() )
sXml += L"<w:autoHyphenation " + m_oAutoHyphenation->ToString() + L"/>";
if ( m_oConsecutiveHyphenLimit.IsInit() )
sXml += L"<w:consecutiveHyphenLimit " + m_oConsecutiveHyphenLimit->ToString() + L"/>";
if ( m_oHyphenationZone.IsInit() )
sXml += L"<w:hyphenationZone " + m_oHyphenationZone->ToString() + L"/>";
if ( m_oDoNotHyphenateCaps.IsInit() )
sXml += L"<w:doNotHyphenateCaps " + m_oDoNotHyphenateCaps->ToString() + L"/>";
if ( m_oShowEnvelope.IsInit() )
sXml += L"<w:showEnvelope " + m_oShowEnvelope->ToString() + L"/>";
if ( m_oSummaryLength.IsInit() )
sXml += L"<w:summaryLength " + m_oSummaryLength->ToString() + L"/>";
if ( m_oClickAndTypeStyle.IsInit() )
sXml += L"<w:clickAndTypeStyle " + m_oClickAndTypeStyle->ToString() + L"/>";
if ( m_oDefaultTableStyle.IsInit() )
sXml += L"<w:defaultTableStyle " + m_oDefaultTableStyle->ToString() + L"/>";
if ( m_oEvenAndOddHeaders.IsInit() )
sXml += L"<w:evenAndOddHeaders " + m_oEvenAndOddHeaders->ToString() + L"/>";
if ( m_oBookFoldRevPrinting.IsInit() )
sXml += L"<w:bookFoldRevPrinting " + m_oBookFoldRevPrinting->ToString() + L"/>";
if ( m_oBookFoldPrinting.IsInit() )
sXml += L"<w:bookFoldPrinting " + m_oBookFoldPrinting->ToString() + L"/>";
if ( m_oBookFoldPrintingSheets.IsInit() )
sXml += L"<w:bookFoldPrintingSheets " + m_oBookFoldPrintingSheets->ToString() + L"/>";
if ( m_oDrawingGridHorizontalSpacing.IsInit() )
sXml += L"<w:drawingGridHorizontalSpacing " + m_oDrawingGridHorizontalSpacing->ToString() + L"/>";
if ( m_oDrawingGridVerticalSpacing.IsInit() )
sXml += L"<w:drawingGridVerticalSpacing " + m_oDrawingGridVerticalSpacing->ToString() + L"/>";
if ( m_oDisplayHorizontalDrawingGridEvery.IsInit() )
sXml += L"<w:displayHorizontalDrawingGridEvery " + m_oDisplayHorizontalDrawingGridEvery->ToString() + L"/>";
if ( m_oDisplayVerticalDrawingGridEvery.IsInit() )
sXml += L"<w:displayVerticalDrawingGridEvery " + m_oDisplayVerticalDrawingGridEvery->ToString() + L"/>";
if ( m_oDoNotUseMarginsForDrawingGridOrigin.IsInit() )
sXml += L"<w:doNotUseMarginsForDrawingGridOrigin " + m_oDoNotUseMarginsForDrawingGridOrigin->ToString() + L"/>";
if ( m_oDrawingGridHorizontalOrigin.IsInit() )
sXml += L"<w:drawingGridHorizontalOrigin " + m_oDrawingGridHorizontalOrigin->ToString() + L"/>";
if ( m_oDrawingGridVerticalOrigin.IsInit() )
sXml += L"<w:drawingGridVerticalOrigin " + m_oDrawingGridVerticalOrigin->ToString() + L"/>";
if ( m_oDoNotShadeFormData.IsInit() )
sXml += L"<w:doNotShadeFormData " + m_oDoNotShadeFormData->ToString() + L"/>";
if ( m_oNoPunctuationKerning.IsInit() )
sXml += L"<w:noPunctuationKerning " + m_oNoPunctuationKerning->ToString() + L"/>";
if ( m_oCharacterSpacingControl.IsInit() )
sXml += m_oCharacterSpacingControl->toXML();
if ( m_oPrintTwoOnOne.IsInit() )
sXml += L"<w:printTwoOnOne " + m_oPrintTwoOnOne->ToString() + L"/>";
if ( m_oStrictFirstAndLastChars.IsInit() )
sXml += L"<w:strictFirstAndLastChars " + m_oStrictFirstAndLastChars->ToString() + L"/>";
if ( m_oNoLineBreaksAfter.IsInit() )
sXml += m_oNoLineBreaksAfter->toXML();
if ( m_oNoLineBreaksBefore.IsInit() )
sXml += m_oNoLineBreaksBefore->toXML();
if ( m_oSavePreviewPicture.IsInit() )
sXml += L"<w:savePreviewPicture " + m_oSavePreviewPicture->ToString() + L"/>";
if ( m_oDoNotValidateAgainstSchema.IsInit() )
sXml += L"<w:doNotValidateAgainstSchema " + m_oDoNotValidateAgainstSchema->ToString() + L"/>";
if ( m_oSaveInvalidXml.IsInit() )
sXml += L"<w:saveInvalidXml " + m_oSaveInvalidXml->ToString() + L"/>";
if ( m_oIgnoreMixedContent.IsInit() )
sXml += L"<w:ignoreMixedContent " + m_oIgnoreMixedContent->ToString() + L"/>";
if ( m_oAlwaysShowPlaceholderText.IsInit() )
sXml += L"<w:alwaysShowPlaceholderText " + m_oAlwaysShowPlaceholderText->ToString() + L"/>";
if ( m_oDoNotDemarcateInvalidXml.IsInit() )
sXml += L"<w:doNotDemarcateInvalidXml " + m_oDoNotDemarcateInvalidXml->ToString() + L"/>";
if ( m_oSaveXmlDataOnly.IsInit() )
sXml += L"<w:saveXmlDataOnly " + m_oSaveXmlDataOnly->ToString() + L"/>";
if ( m_oUseXSLTWhenSaving.IsInit() )
sXml += L"<w:useXSLTWhenSaving " + m_oUseXSLTWhenSaving->ToString() + L"/>";
if ( m_oSaveThroughtXslt.IsInit() )
sXml += m_oSaveThroughtXslt->toXML();
if ( m_oShowXMLTags.IsInit() )
sXml += L"<w:showXMLTags " + m_oShowXMLTags->ToString() + L"/>";
if ( m_oAlwaysMergeEmptyNamespace.IsInit() )
sXml += L"<w:alwaysMergeEmptyNamespace " + m_oAlwaysMergeEmptyNamespace->ToString() + L"/>";
if ( m_oUpdateFields.IsInit() )
sXml += L"<w:updateFields " + m_oUpdateFields->ToString() + L"/>";
if ( m_oHdrShapeDefaults.IsInit() )
sXml += m_oHdrShapeDefaults->toXML();
if ( m_oFootnotePr.IsInit() )
sXml += m_oFootnotePr->toXML();
if ( m_oEndnotePr.IsInit() )
sXml += m_oEndnotePr->toXML();
if ( m_oCompat.IsInit() )
sXml += m_oCompat->toXML();
if ( m_oDocVars.IsInit() )
sXml += m_oDocVars->toXML();
if ( m_oRsids.IsInit() )
sXml += m_oRsids->toXML();
if ( m_oMathPr.IsInit() )
sXml += m_oMathPr->toXML();
if ( m_oAttachedSchema.IsInit() )
sXml += L"<w:attachedSchema " + m_oAttachedSchema->ToString() + L"/>";
if ( m_oThemeFontLang.IsInit() )
sXml += L"<w:themeFontLang " + m_oThemeFontLang->ToString() + L"/>";
if ( m_oClrSchemeMapping.IsInit() )
sXml += m_oClrSchemeMapping->toXML();
if ( m_oDoNotIncludeSubdocsInStats.IsInit() )
sXml += L"<w:doNotIncludeSubdocsInStats " + m_oDoNotIncludeSubdocsInStats->ToString() + L"/>";
if ( m_oDoNotAutoCompressPictures.IsInit() )
sXml += L"<w:doNotAutoCompressPictures " + m_oDoNotAutoCompressPictures->ToString() + L"/>";
if ( m_oForceUpgrade.IsInit() )
sXml += L"<<w:forceUpgrade/>";
if ( m_oCaptions.IsInit() )
sXml += m_oCaptions->toXML();
if ( m_oReadModeInkLockDown.IsInit() )
sXml += m_oReadModeInkLockDown->toXML();
for ( unsigned int nIndex = 0; nIndex < m_arrSmartTagType.size(); nIndex++ )
{
if (m_arrSmartTagType[nIndex])
sXml += m_arrSmartTagType[nIndex]->toXML();
}
if ( m_oSchemaLibrary.IsInit() )
sXml += m_oSchemaLibrary->toXML();
if ( m_oShapeDefaults.IsInit() )
sXml += m_oShapeDefaults->toXML();
if ( m_oDoNotEmbedSmartTags.IsInit() )
sXml += L"<w:doNotEmbedSmartTags " + m_oDoNotEmbedSmartTags->ToString() + L"/>";
if ( m_oDecimalSymbol.IsInit() )
sXml += L"<w:decimalSymbol " + m_oDecimalSymbol->ToString() + L"/>";
if ( m_oListSeparator.IsInit() )
sXml += L"<w:listSeparator " + m_oListSeparator->ToString() + L"/>";
sXml += L"</w:settings>";
return sXml;
}
EElementType CSettings::getType() const
{
return et_w_settings;
}
//--------------------------------------------------------------------------------
// CSettingsCustom
//--------------------------------------------------------------------------------
void CSettingsCustom::fromXML(const std::wstring& sXml)
{
XmlUtils::CXmlLiteReader oReader;
if ( !oReader.FromString(sXml) )
return;
if ( !oReader.ReadNextNode() )
return;
std::wstring sName = oReader.GetName();
if ( L"w:settings" == sName && !oReader.IsEmptyNode() )
{
int nStylesDepth = oReader.GetDepth();
while ( oReader.ReadNextSiblingNode( nStylesDepth ) )
{
sName = oReader.GetName();
if ( L"w:SdtGlobalColor" == sName )
m_oSdtGlobalColor = oReader;
else if ( L"w:SdtGlobalShowHighlight" == sName )
m_oSdtGlobalShowHighlight = oReader;
else if ( L"w:SpecialFormsHighlight" == sName )
m_oSpecialFormsHighlight = oReader;
}
}
}
std::wstring CSettingsCustom::toXML()
{
std::wstring sXml;
sXml += L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><w:settings xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">";
if(m_oSdtGlobalColor.IsInit())
{
sXml += L"<w:SdtGlobalColor ";
sXml += m_oSdtGlobalColor->ToString();
sXml += L"/>";
}
if(m_oSdtGlobalShowHighlight.IsInit())
{
sXml += L"<w:SdtGlobalShowHighlight ";
sXml += m_oSdtGlobalShowHighlight->ToString();
sXml += L"/>";
}
if(m_oSpecialFormsHighlight.IsInit())
{
sXml += L"<w:SpecialFormsHighlight ";
sXml += m_oSpecialFormsHighlight->ToString();
sXml += L"/>";
}
sXml += L"</w:settings>";
return sXml;
}
std::wstring CSettingsCustom::GetSchemaUrl()
{
return L"http://schemas.onlyoffice.com/settingsCustom";
}
bool CSettingsCustom::IsEmpty()
{
return !(m_oSdtGlobalColor.IsInit() || m_oSdtGlobalShowHighlight.IsInit() || m_oSpecialFormsHighlight.IsInit());
}
} // namespace OOX
Reference in New Issue View Git Blame Copy Permalink