mirror of
https://github.com/unidoc/unioffice.git
synced 2025-04-29 13:49:10 +08:00
1121 lines
41 KiB
Go
1121 lines
41 KiB
Go
// Copyright 2017 Baliance. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by the terms of the Affero GNU General
|
|
// Public License version 3.0 as published by the Free Software Foundation and
|
|
// appearing in the file LICENSE included in the packaging of this file. A
|
|
// commercial license can be purchased by contacting sales@baliance.com.
|
|
|
|
package wordprocessingml
|
|
|
|
import (
|
|
"encoding/xml"
|
|
"fmt"
|
|
"log"
|
|
)
|
|
|
|
type CT_Compat struct {
|
|
// Use Simplified Rules For Table Border Conflicts
|
|
UseSingleBorderforContiguousCells *CT_OnOff
|
|
// Fit To Expanded Width When Performing Full Justification
|
|
WpJustification *CT_OnOff
|
|
// Do Not Create Custom Tab Stop for Hanging Indent
|
|
NoTabHangInd *CT_OnOff
|
|
// Do Not Add Leading Between Lines of Text
|
|
NoLeading *CT_OnOff
|
|
// Add Additional Space Below Baseline For Underlined East Asian Text
|
|
SpaceForUL *CT_OnOff
|
|
// Do Not Balance Text Columns within a Section
|
|
NoColumnBalance *CT_OnOff
|
|
// Balance Single Byte and Double Byte Characters
|
|
BalanceSingleByteDoubleByteWidth *CT_OnOff
|
|
// Do Not Center Content on Lines With Exact Line Height
|
|
NoExtraLineSpacing *CT_OnOff
|
|
// Display Backslash As Yen Sign
|
|
DoNotLeaveBackslashAlone *CT_OnOff
|
|
// Underline All Trailing Spaces
|
|
UlTrailSpace *CT_OnOff
|
|
// Don't Justify Lines Ending in Soft Line Break
|
|
DoNotExpandShiftReturn *CT_OnOff
|
|
// Only Expand/Condense Text By Whole Points
|
|
SpacingInWholePoints *CT_OnOff
|
|
// Ignore Compression of Full-Width Punctuation Ending a Line
|
|
LineWrapLikeWord6 *CT_OnOff
|
|
// Print Body Text before Header/Footer Contents
|
|
PrintBodyTextBeforeHeader *CT_OnOff
|
|
// Print Colors as Black And White without Dithering
|
|
PrintColBlack *CT_OnOff
|
|
// Use Specific Space Width
|
|
WpSpaceWidth *CT_OnOff
|
|
// Display Page/Column Breaks Present in Frames
|
|
ShowBreaksInFrames *CT_OnOff
|
|
// Require Exact Size During Font Substitution
|
|
SubFontBySize *CT_OnOff
|
|
// Ignore Exact Line Height for Last Line on Page
|
|
SuppressBottomSpacing *CT_OnOff
|
|
// Ignore Minimum and Exact Line Height for First Line on Page
|
|
SuppressTopSpacing *CT_OnOff
|
|
// Ignore Minimum Line Height for First Line on Page
|
|
SuppressSpacingAtTopOfPage *CT_OnOff
|
|
// Use Static Text Leading
|
|
SuppressTopSpacingWP *CT_OnOff
|
|
// Do Not Use Space Before On First Line After a Page Break
|
|
SuppressSpBfAfterPgBrk *CT_OnOff
|
|
// Swap Paragraph Borders on Odd Numbered Pages
|
|
SwapBordersFacingPages *CT_OnOff
|
|
// Treat Backslash Quotation Delimiter as Two Quotation Marks
|
|
ConvMailMergeEsc *CT_OnOff
|
|
// Use Truncated Integer Division For Font Calculation
|
|
TruncateFontHeightsLikeWP6 *CT_OnOff
|
|
// Use Specific Small Caps Algorithm
|
|
MwSmallCaps *CT_OnOff
|
|
// Use Printer Metrics To Display Documents
|
|
UsePrinterMetrics *CT_OnOff
|
|
// Do Not Suppress Paragraph Borders Next To Frames
|
|
DoNotSuppressParagraphBorders *CT_OnOff
|
|
// Line Wrap Trailing Spaces
|
|
WrapTrailSpaces *CT_OnOff
|
|
// Ignore Page Break from Continuous Section Break
|
|
FootnoteLayoutLikeWW8 *CT_OnOff
|
|
// Ignore Text Wrapping around Objects at Bottom of Page
|
|
ShapeLayoutLikeWW8 *CT_OnOff
|
|
// Align Table Rows Independently
|
|
AlignTablesRowByRow *CT_OnOff
|
|
// Ignore Width of Last Tab Stop When Aligning Paragraph If It Is Not Left Aligned
|
|
ForgetLastTabAlignment *CT_OnOff
|
|
// Add Document Grid Line Pitch To Lines in Table Cells
|
|
AdjustLineHeightInTable *CT_OnOff
|
|
// Incorrectly Adjust Text Spacing for Specific Unicode Ranges
|
|
AutoSpaceLikeWord95 *CT_OnOff
|
|
// Do Not Increase Line Height for Raised/Lowered Text
|
|
NoSpaceRaiseLower *CT_OnOff
|
|
// Use Fixed Paragraph Spacing for HTML Auto Setting
|
|
DoNotUseHTMLParagraphAutoSpacing *CT_OnOff
|
|
// Ignore Space Before Table When Deciding If Table Should Wrap Floating Object
|
|
LayoutRawTableWidth *CT_OnOff
|
|
// Allow Table Rows to Wrap Inline Objects Independently
|
|
LayoutTableRowsApart *CT_OnOff
|
|
// Use Incorrect Inter-Character Spacing Rules
|
|
UseWord97LineBreakRules *CT_OnOff
|
|
// Do Not Allow Floating Tables To Break Across Pages
|
|
DoNotBreakWrappedTables *CT_OnOff
|
|
// Do Not Snap to Document Grid in Table Cells with Objects
|
|
DoNotSnapToGridInCell *CT_OnOff
|
|
// Select Field When First or Last Character Is Selected
|
|
SelectFldWithFirstOrLastChar *CT_OnOff
|
|
// Use Legacy Ethiopic and Amharic Line Breaking Rules
|
|
ApplyBreakingRules *CT_OnOff
|
|
// Do Not Allow Hanging Punctuation With Character Grid
|
|
DoNotWrapTextWithPunct *CT_OnOff
|
|
// Do Not Compress Compressible Characters When Using Document Grid
|
|
DoNotUseEastAsianBreakRules *CT_OnOff
|
|
// Incorrectly Display Top Border of Conditional Columns
|
|
UseWord2002TableStyleRules *CT_OnOff
|
|
// Allow Tables to AutoFit Into Page Margins
|
|
GrowAutofit *CT_OnOff
|
|
// Do Not Bypass East Asian/Complex Script Layout Code
|
|
UseFELayout *CT_OnOff
|
|
// Do Not Automatically Apply List Paragraph Style To Bulleted/Numbered Text
|
|
UseNormalStyleForList *CT_OnOff
|
|
// Ignore Hanging Indent When Creating Tab Stop After Numbering
|
|
DoNotUseIndentAsNumberingTabStop *CT_OnOff
|
|
// Use Alternate Set of East Asian Line Breaking Rules
|
|
UseAltKinsokuLineBreakRules *CT_OnOff
|
|
// Allow Contextual Spacing of Paragraphs in Tables
|
|
AllowSpaceOfSameStyleInTable *CT_OnOff
|
|
// Do Not Ignore Floating Objects When Calculating Paragraph Indentation
|
|
DoNotSuppressIndentation *CT_OnOff
|
|
// Do Not AutoFit Tables To Fit Next To Wrapped Objects
|
|
DoNotAutofitConstrainedTables *CT_OnOff
|
|
// Allow Table Columns To Exceed Preferred Widths of Constituent Cells
|
|
AutofitToFirstFixedWidthCell *CT_OnOff
|
|
// Underline Following Character Following Numbering
|
|
UnderlineTabInNumList *CT_OnOff
|
|
// Always Use Fixed Width for Hangul Characters
|
|
DisplayHangulFixedWidth *CT_OnOff
|
|
// Always Move Paragraph Mark to Page after a Page Break
|
|
SplitPgBreakAndParaMark *CT_OnOff
|
|
// Don't Vertically Align Cells Containing Floating Objects
|
|
DoNotVertAlignCellWithSp *CT_OnOff
|
|
// Don't Break Table Rows Around Floating Tables
|
|
DoNotBreakConstrainedForcedTable *CT_OnOff
|
|
// Ignore Vertical Alignment in Textboxes
|
|
DoNotVertAlignInTxbx *CT_OnOff
|
|
// Use ANSI Kerning Pairs from Fonts
|
|
UseAnsiKerningPairs *CT_OnOff
|
|
// Use Cached Paragraph Information for Column Balancing
|
|
CachedColBalance *CT_OnOff
|
|
// Custom Compatibility Setting
|
|
CompatSetting []*CT_CompatSetting
|
|
}
|
|
|
|
func NewCT_Compat() *CT_Compat {
|
|
ret := &CT_Compat{}
|
|
return ret
|
|
}
|
|
|
|
func (m *CT_Compat) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
|
e.EncodeToken(start)
|
|
if m.UseSingleBorderforContiguousCells != nil {
|
|
seuseSingleBorderforContiguousCells := xml.StartElement{Name: xml.Name{Local: "w:useSingleBorderforContiguousCells"}}
|
|
e.EncodeElement(m.UseSingleBorderforContiguousCells, seuseSingleBorderforContiguousCells)
|
|
}
|
|
if m.WpJustification != nil {
|
|
sewpJustification := xml.StartElement{Name: xml.Name{Local: "w:wpJustification"}}
|
|
e.EncodeElement(m.WpJustification, sewpJustification)
|
|
}
|
|
if m.NoTabHangInd != nil {
|
|
senoTabHangInd := xml.StartElement{Name: xml.Name{Local: "w:noTabHangInd"}}
|
|
e.EncodeElement(m.NoTabHangInd, senoTabHangInd)
|
|
}
|
|
if m.NoLeading != nil {
|
|
senoLeading := xml.StartElement{Name: xml.Name{Local: "w:noLeading"}}
|
|
e.EncodeElement(m.NoLeading, senoLeading)
|
|
}
|
|
if m.SpaceForUL != nil {
|
|
sespaceForUL := xml.StartElement{Name: xml.Name{Local: "w:spaceForUL"}}
|
|
e.EncodeElement(m.SpaceForUL, sespaceForUL)
|
|
}
|
|
if m.NoColumnBalance != nil {
|
|
senoColumnBalance := xml.StartElement{Name: xml.Name{Local: "w:noColumnBalance"}}
|
|
e.EncodeElement(m.NoColumnBalance, senoColumnBalance)
|
|
}
|
|
if m.BalanceSingleByteDoubleByteWidth != nil {
|
|
sebalanceSingleByteDoubleByteWidth := xml.StartElement{Name: xml.Name{Local: "w:balanceSingleByteDoubleByteWidth"}}
|
|
e.EncodeElement(m.BalanceSingleByteDoubleByteWidth, sebalanceSingleByteDoubleByteWidth)
|
|
}
|
|
if m.NoExtraLineSpacing != nil {
|
|
senoExtraLineSpacing := xml.StartElement{Name: xml.Name{Local: "w:noExtraLineSpacing"}}
|
|
e.EncodeElement(m.NoExtraLineSpacing, senoExtraLineSpacing)
|
|
}
|
|
if m.DoNotLeaveBackslashAlone != nil {
|
|
sedoNotLeaveBackslashAlone := xml.StartElement{Name: xml.Name{Local: "w:doNotLeaveBackslashAlone"}}
|
|
e.EncodeElement(m.DoNotLeaveBackslashAlone, sedoNotLeaveBackslashAlone)
|
|
}
|
|
if m.UlTrailSpace != nil {
|
|
seulTrailSpace := xml.StartElement{Name: xml.Name{Local: "w:ulTrailSpace"}}
|
|
e.EncodeElement(m.UlTrailSpace, seulTrailSpace)
|
|
}
|
|
if m.DoNotExpandShiftReturn != nil {
|
|
sedoNotExpandShiftReturn := xml.StartElement{Name: xml.Name{Local: "w:doNotExpandShiftReturn"}}
|
|
e.EncodeElement(m.DoNotExpandShiftReturn, sedoNotExpandShiftReturn)
|
|
}
|
|
if m.SpacingInWholePoints != nil {
|
|
sespacingInWholePoints := xml.StartElement{Name: xml.Name{Local: "w:spacingInWholePoints"}}
|
|
e.EncodeElement(m.SpacingInWholePoints, sespacingInWholePoints)
|
|
}
|
|
if m.LineWrapLikeWord6 != nil {
|
|
selineWrapLikeWord6 := xml.StartElement{Name: xml.Name{Local: "w:lineWrapLikeWord6"}}
|
|
e.EncodeElement(m.LineWrapLikeWord6, selineWrapLikeWord6)
|
|
}
|
|
if m.PrintBodyTextBeforeHeader != nil {
|
|
seprintBodyTextBeforeHeader := xml.StartElement{Name: xml.Name{Local: "w:printBodyTextBeforeHeader"}}
|
|
e.EncodeElement(m.PrintBodyTextBeforeHeader, seprintBodyTextBeforeHeader)
|
|
}
|
|
if m.PrintColBlack != nil {
|
|
seprintColBlack := xml.StartElement{Name: xml.Name{Local: "w:printColBlack"}}
|
|
e.EncodeElement(m.PrintColBlack, seprintColBlack)
|
|
}
|
|
if m.WpSpaceWidth != nil {
|
|
sewpSpaceWidth := xml.StartElement{Name: xml.Name{Local: "w:wpSpaceWidth"}}
|
|
e.EncodeElement(m.WpSpaceWidth, sewpSpaceWidth)
|
|
}
|
|
if m.ShowBreaksInFrames != nil {
|
|
seshowBreaksInFrames := xml.StartElement{Name: xml.Name{Local: "w:showBreaksInFrames"}}
|
|
e.EncodeElement(m.ShowBreaksInFrames, seshowBreaksInFrames)
|
|
}
|
|
if m.SubFontBySize != nil {
|
|
sesubFontBySize := xml.StartElement{Name: xml.Name{Local: "w:subFontBySize"}}
|
|
e.EncodeElement(m.SubFontBySize, sesubFontBySize)
|
|
}
|
|
if m.SuppressBottomSpacing != nil {
|
|
sesuppressBottomSpacing := xml.StartElement{Name: xml.Name{Local: "w:suppressBottomSpacing"}}
|
|
e.EncodeElement(m.SuppressBottomSpacing, sesuppressBottomSpacing)
|
|
}
|
|
if m.SuppressTopSpacing != nil {
|
|
sesuppressTopSpacing := xml.StartElement{Name: xml.Name{Local: "w:suppressTopSpacing"}}
|
|
e.EncodeElement(m.SuppressTopSpacing, sesuppressTopSpacing)
|
|
}
|
|
if m.SuppressSpacingAtTopOfPage != nil {
|
|
sesuppressSpacingAtTopOfPage := xml.StartElement{Name: xml.Name{Local: "w:suppressSpacingAtTopOfPage"}}
|
|
e.EncodeElement(m.SuppressSpacingAtTopOfPage, sesuppressSpacingAtTopOfPage)
|
|
}
|
|
if m.SuppressTopSpacingWP != nil {
|
|
sesuppressTopSpacingWP := xml.StartElement{Name: xml.Name{Local: "w:suppressTopSpacingWP"}}
|
|
e.EncodeElement(m.SuppressTopSpacingWP, sesuppressTopSpacingWP)
|
|
}
|
|
if m.SuppressSpBfAfterPgBrk != nil {
|
|
sesuppressSpBfAfterPgBrk := xml.StartElement{Name: xml.Name{Local: "w:suppressSpBfAfterPgBrk"}}
|
|
e.EncodeElement(m.SuppressSpBfAfterPgBrk, sesuppressSpBfAfterPgBrk)
|
|
}
|
|
if m.SwapBordersFacingPages != nil {
|
|
seswapBordersFacingPages := xml.StartElement{Name: xml.Name{Local: "w:swapBordersFacingPages"}}
|
|
e.EncodeElement(m.SwapBordersFacingPages, seswapBordersFacingPages)
|
|
}
|
|
if m.ConvMailMergeEsc != nil {
|
|
seconvMailMergeEsc := xml.StartElement{Name: xml.Name{Local: "w:convMailMergeEsc"}}
|
|
e.EncodeElement(m.ConvMailMergeEsc, seconvMailMergeEsc)
|
|
}
|
|
if m.TruncateFontHeightsLikeWP6 != nil {
|
|
setruncateFontHeightsLikeWP6 := xml.StartElement{Name: xml.Name{Local: "w:truncateFontHeightsLikeWP6"}}
|
|
e.EncodeElement(m.TruncateFontHeightsLikeWP6, setruncateFontHeightsLikeWP6)
|
|
}
|
|
if m.MwSmallCaps != nil {
|
|
semwSmallCaps := xml.StartElement{Name: xml.Name{Local: "w:mwSmallCaps"}}
|
|
e.EncodeElement(m.MwSmallCaps, semwSmallCaps)
|
|
}
|
|
if m.UsePrinterMetrics != nil {
|
|
seusePrinterMetrics := xml.StartElement{Name: xml.Name{Local: "w:usePrinterMetrics"}}
|
|
e.EncodeElement(m.UsePrinterMetrics, seusePrinterMetrics)
|
|
}
|
|
if m.DoNotSuppressParagraphBorders != nil {
|
|
sedoNotSuppressParagraphBorders := xml.StartElement{Name: xml.Name{Local: "w:doNotSuppressParagraphBorders"}}
|
|
e.EncodeElement(m.DoNotSuppressParagraphBorders, sedoNotSuppressParagraphBorders)
|
|
}
|
|
if m.WrapTrailSpaces != nil {
|
|
sewrapTrailSpaces := xml.StartElement{Name: xml.Name{Local: "w:wrapTrailSpaces"}}
|
|
e.EncodeElement(m.WrapTrailSpaces, sewrapTrailSpaces)
|
|
}
|
|
if m.FootnoteLayoutLikeWW8 != nil {
|
|
sefootnoteLayoutLikeWW8 := xml.StartElement{Name: xml.Name{Local: "w:footnoteLayoutLikeWW8"}}
|
|
e.EncodeElement(m.FootnoteLayoutLikeWW8, sefootnoteLayoutLikeWW8)
|
|
}
|
|
if m.ShapeLayoutLikeWW8 != nil {
|
|
seshapeLayoutLikeWW8 := xml.StartElement{Name: xml.Name{Local: "w:shapeLayoutLikeWW8"}}
|
|
e.EncodeElement(m.ShapeLayoutLikeWW8, seshapeLayoutLikeWW8)
|
|
}
|
|
if m.AlignTablesRowByRow != nil {
|
|
sealignTablesRowByRow := xml.StartElement{Name: xml.Name{Local: "w:alignTablesRowByRow"}}
|
|
e.EncodeElement(m.AlignTablesRowByRow, sealignTablesRowByRow)
|
|
}
|
|
if m.ForgetLastTabAlignment != nil {
|
|
seforgetLastTabAlignment := xml.StartElement{Name: xml.Name{Local: "w:forgetLastTabAlignment"}}
|
|
e.EncodeElement(m.ForgetLastTabAlignment, seforgetLastTabAlignment)
|
|
}
|
|
if m.AdjustLineHeightInTable != nil {
|
|
seadjustLineHeightInTable := xml.StartElement{Name: xml.Name{Local: "w:adjustLineHeightInTable"}}
|
|
e.EncodeElement(m.AdjustLineHeightInTable, seadjustLineHeightInTable)
|
|
}
|
|
if m.AutoSpaceLikeWord95 != nil {
|
|
seautoSpaceLikeWord95 := xml.StartElement{Name: xml.Name{Local: "w:autoSpaceLikeWord95"}}
|
|
e.EncodeElement(m.AutoSpaceLikeWord95, seautoSpaceLikeWord95)
|
|
}
|
|
if m.NoSpaceRaiseLower != nil {
|
|
senoSpaceRaiseLower := xml.StartElement{Name: xml.Name{Local: "w:noSpaceRaiseLower"}}
|
|
e.EncodeElement(m.NoSpaceRaiseLower, senoSpaceRaiseLower)
|
|
}
|
|
if m.DoNotUseHTMLParagraphAutoSpacing != nil {
|
|
sedoNotUseHTMLParagraphAutoSpacing := xml.StartElement{Name: xml.Name{Local: "w:doNotUseHTMLParagraphAutoSpacing"}}
|
|
e.EncodeElement(m.DoNotUseHTMLParagraphAutoSpacing, sedoNotUseHTMLParagraphAutoSpacing)
|
|
}
|
|
if m.LayoutRawTableWidth != nil {
|
|
selayoutRawTableWidth := xml.StartElement{Name: xml.Name{Local: "w:layoutRawTableWidth"}}
|
|
e.EncodeElement(m.LayoutRawTableWidth, selayoutRawTableWidth)
|
|
}
|
|
if m.LayoutTableRowsApart != nil {
|
|
selayoutTableRowsApart := xml.StartElement{Name: xml.Name{Local: "w:layoutTableRowsApart"}}
|
|
e.EncodeElement(m.LayoutTableRowsApart, selayoutTableRowsApart)
|
|
}
|
|
if m.UseWord97LineBreakRules != nil {
|
|
seuseWord97LineBreakRules := xml.StartElement{Name: xml.Name{Local: "w:useWord97LineBreakRules"}}
|
|
e.EncodeElement(m.UseWord97LineBreakRules, seuseWord97LineBreakRules)
|
|
}
|
|
if m.DoNotBreakWrappedTables != nil {
|
|
sedoNotBreakWrappedTables := xml.StartElement{Name: xml.Name{Local: "w:doNotBreakWrappedTables"}}
|
|
e.EncodeElement(m.DoNotBreakWrappedTables, sedoNotBreakWrappedTables)
|
|
}
|
|
if m.DoNotSnapToGridInCell != nil {
|
|
sedoNotSnapToGridInCell := xml.StartElement{Name: xml.Name{Local: "w:doNotSnapToGridInCell"}}
|
|
e.EncodeElement(m.DoNotSnapToGridInCell, sedoNotSnapToGridInCell)
|
|
}
|
|
if m.SelectFldWithFirstOrLastChar != nil {
|
|
seselectFldWithFirstOrLastChar := xml.StartElement{Name: xml.Name{Local: "w:selectFldWithFirstOrLastChar"}}
|
|
e.EncodeElement(m.SelectFldWithFirstOrLastChar, seselectFldWithFirstOrLastChar)
|
|
}
|
|
if m.ApplyBreakingRules != nil {
|
|
seapplyBreakingRules := xml.StartElement{Name: xml.Name{Local: "w:applyBreakingRules"}}
|
|
e.EncodeElement(m.ApplyBreakingRules, seapplyBreakingRules)
|
|
}
|
|
if m.DoNotWrapTextWithPunct != nil {
|
|
sedoNotWrapTextWithPunct := xml.StartElement{Name: xml.Name{Local: "w:doNotWrapTextWithPunct"}}
|
|
e.EncodeElement(m.DoNotWrapTextWithPunct, sedoNotWrapTextWithPunct)
|
|
}
|
|
if m.DoNotUseEastAsianBreakRules != nil {
|
|
sedoNotUseEastAsianBreakRules := xml.StartElement{Name: xml.Name{Local: "w:doNotUseEastAsianBreakRules"}}
|
|
e.EncodeElement(m.DoNotUseEastAsianBreakRules, sedoNotUseEastAsianBreakRules)
|
|
}
|
|
if m.UseWord2002TableStyleRules != nil {
|
|
seuseWord2002TableStyleRules := xml.StartElement{Name: xml.Name{Local: "w:useWord2002TableStyleRules"}}
|
|
e.EncodeElement(m.UseWord2002TableStyleRules, seuseWord2002TableStyleRules)
|
|
}
|
|
if m.GrowAutofit != nil {
|
|
segrowAutofit := xml.StartElement{Name: xml.Name{Local: "w:growAutofit"}}
|
|
e.EncodeElement(m.GrowAutofit, segrowAutofit)
|
|
}
|
|
if m.UseFELayout != nil {
|
|
seuseFELayout := xml.StartElement{Name: xml.Name{Local: "w:useFELayout"}}
|
|
e.EncodeElement(m.UseFELayout, seuseFELayout)
|
|
}
|
|
if m.UseNormalStyleForList != nil {
|
|
seuseNormalStyleForList := xml.StartElement{Name: xml.Name{Local: "w:useNormalStyleForList"}}
|
|
e.EncodeElement(m.UseNormalStyleForList, seuseNormalStyleForList)
|
|
}
|
|
if m.DoNotUseIndentAsNumberingTabStop != nil {
|
|
sedoNotUseIndentAsNumberingTabStop := xml.StartElement{Name: xml.Name{Local: "w:doNotUseIndentAsNumberingTabStop"}}
|
|
e.EncodeElement(m.DoNotUseIndentAsNumberingTabStop, sedoNotUseIndentAsNumberingTabStop)
|
|
}
|
|
if m.UseAltKinsokuLineBreakRules != nil {
|
|
seuseAltKinsokuLineBreakRules := xml.StartElement{Name: xml.Name{Local: "w:useAltKinsokuLineBreakRules"}}
|
|
e.EncodeElement(m.UseAltKinsokuLineBreakRules, seuseAltKinsokuLineBreakRules)
|
|
}
|
|
if m.AllowSpaceOfSameStyleInTable != nil {
|
|
seallowSpaceOfSameStyleInTable := xml.StartElement{Name: xml.Name{Local: "w:allowSpaceOfSameStyleInTable"}}
|
|
e.EncodeElement(m.AllowSpaceOfSameStyleInTable, seallowSpaceOfSameStyleInTable)
|
|
}
|
|
if m.DoNotSuppressIndentation != nil {
|
|
sedoNotSuppressIndentation := xml.StartElement{Name: xml.Name{Local: "w:doNotSuppressIndentation"}}
|
|
e.EncodeElement(m.DoNotSuppressIndentation, sedoNotSuppressIndentation)
|
|
}
|
|
if m.DoNotAutofitConstrainedTables != nil {
|
|
sedoNotAutofitConstrainedTables := xml.StartElement{Name: xml.Name{Local: "w:doNotAutofitConstrainedTables"}}
|
|
e.EncodeElement(m.DoNotAutofitConstrainedTables, sedoNotAutofitConstrainedTables)
|
|
}
|
|
if m.AutofitToFirstFixedWidthCell != nil {
|
|
seautofitToFirstFixedWidthCell := xml.StartElement{Name: xml.Name{Local: "w:autofitToFirstFixedWidthCell"}}
|
|
e.EncodeElement(m.AutofitToFirstFixedWidthCell, seautofitToFirstFixedWidthCell)
|
|
}
|
|
if m.UnderlineTabInNumList != nil {
|
|
seunderlineTabInNumList := xml.StartElement{Name: xml.Name{Local: "w:underlineTabInNumList"}}
|
|
e.EncodeElement(m.UnderlineTabInNumList, seunderlineTabInNumList)
|
|
}
|
|
if m.DisplayHangulFixedWidth != nil {
|
|
sedisplayHangulFixedWidth := xml.StartElement{Name: xml.Name{Local: "w:displayHangulFixedWidth"}}
|
|
e.EncodeElement(m.DisplayHangulFixedWidth, sedisplayHangulFixedWidth)
|
|
}
|
|
if m.SplitPgBreakAndParaMark != nil {
|
|
sesplitPgBreakAndParaMark := xml.StartElement{Name: xml.Name{Local: "w:splitPgBreakAndParaMark"}}
|
|
e.EncodeElement(m.SplitPgBreakAndParaMark, sesplitPgBreakAndParaMark)
|
|
}
|
|
if m.DoNotVertAlignCellWithSp != nil {
|
|
sedoNotVertAlignCellWithSp := xml.StartElement{Name: xml.Name{Local: "w:doNotVertAlignCellWithSp"}}
|
|
e.EncodeElement(m.DoNotVertAlignCellWithSp, sedoNotVertAlignCellWithSp)
|
|
}
|
|
if m.DoNotBreakConstrainedForcedTable != nil {
|
|
sedoNotBreakConstrainedForcedTable := xml.StartElement{Name: xml.Name{Local: "w:doNotBreakConstrainedForcedTable"}}
|
|
e.EncodeElement(m.DoNotBreakConstrainedForcedTable, sedoNotBreakConstrainedForcedTable)
|
|
}
|
|
if m.DoNotVertAlignInTxbx != nil {
|
|
sedoNotVertAlignInTxbx := xml.StartElement{Name: xml.Name{Local: "w:doNotVertAlignInTxbx"}}
|
|
e.EncodeElement(m.DoNotVertAlignInTxbx, sedoNotVertAlignInTxbx)
|
|
}
|
|
if m.UseAnsiKerningPairs != nil {
|
|
seuseAnsiKerningPairs := xml.StartElement{Name: xml.Name{Local: "w:useAnsiKerningPairs"}}
|
|
e.EncodeElement(m.UseAnsiKerningPairs, seuseAnsiKerningPairs)
|
|
}
|
|
if m.CachedColBalance != nil {
|
|
secachedColBalance := xml.StartElement{Name: xml.Name{Local: "w:cachedColBalance"}}
|
|
e.EncodeElement(m.CachedColBalance, secachedColBalance)
|
|
}
|
|
if m.CompatSetting != nil {
|
|
secompatSetting := xml.StartElement{Name: xml.Name{Local: "w:compatSetting"}}
|
|
e.EncodeElement(m.CompatSetting, secompatSetting)
|
|
}
|
|
e.EncodeToken(xml.EndElement{Name: start.Name})
|
|
return nil
|
|
}
|
|
|
|
func (m *CT_Compat) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
|
// initialize to default
|
|
lCT_Compat:
|
|
for {
|
|
tok, err := d.Token()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch el := tok.(type) {
|
|
case xml.StartElement:
|
|
switch el.Name.Local {
|
|
case "useSingleBorderforContiguousCells":
|
|
m.UseSingleBorderforContiguousCells = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UseSingleBorderforContiguousCells, &el); err != nil {
|
|
return err
|
|
}
|
|
case "wpJustification":
|
|
m.WpJustification = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.WpJustification, &el); err != nil {
|
|
return err
|
|
}
|
|
case "noTabHangInd":
|
|
m.NoTabHangInd = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.NoTabHangInd, &el); err != nil {
|
|
return err
|
|
}
|
|
case "noLeading":
|
|
m.NoLeading = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.NoLeading, &el); err != nil {
|
|
return err
|
|
}
|
|
case "spaceForUL":
|
|
m.SpaceForUL = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SpaceForUL, &el); err != nil {
|
|
return err
|
|
}
|
|
case "noColumnBalance":
|
|
m.NoColumnBalance = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.NoColumnBalance, &el); err != nil {
|
|
return err
|
|
}
|
|
case "balanceSingleByteDoubleByteWidth":
|
|
m.BalanceSingleByteDoubleByteWidth = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.BalanceSingleByteDoubleByteWidth, &el); err != nil {
|
|
return err
|
|
}
|
|
case "noExtraLineSpacing":
|
|
m.NoExtraLineSpacing = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.NoExtraLineSpacing, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotLeaveBackslashAlone":
|
|
m.DoNotLeaveBackslashAlone = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotLeaveBackslashAlone, &el); err != nil {
|
|
return err
|
|
}
|
|
case "ulTrailSpace":
|
|
m.UlTrailSpace = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UlTrailSpace, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotExpandShiftReturn":
|
|
m.DoNotExpandShiftReturn = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotExpandShiftReturn, &el); err != nil {
|
|
return err
|
|
}
|
|
case "spacingInWholePoints":
|
|
m.SpacingInWholePoints = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SpacingInWholePoints, &el); err != nil {
|
|
return err
|
|
}
|
|
case "lineWrapLikeWord6":
|
|
m.LineWrapLikeWord6 = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.LineWrapLikeWord6, &el); err != nil {
|
|
return err
|
|
}
|
|
case "printBodyTextBeforeHeader":
|
|
m.PrintBodyTextBeforeHeader = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.PrintBodyTextBeforeHeader, &el); err != nil {
|
|
return err
|
|
}
|
|
case "printColBlack":
|
|
m.PrintColBlack = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.PrintColBlack, &el); err != nil {
|
|
return err
|
|
}
|
|
case "wpSpaceWidth":
|
|
m.WpSpaceWidth = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.WpSpaceWidth, &el); err != nil {
|
|
return err
|
|
}
|
|
case "showBreaksInFrames":
|
|
m.ShowBreaksInFrames = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.ShowBreaksInFrames, &el); err != nil {
|
|
return err
|
|
}
|
|
case "subFontBySize":
|
|
m.SubFontBySize = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SubFontBySize, &el); err != nil {
|
|
return err
|
|
}
|
|
case "suppressBottomSpacing":
|
|
m.SuppressBottomSpacing = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SuppressBottomSpacing, &el); err != nil {
|
|
return err
|
|
}
|
|
case "suppressTopSpacing":
|
|
m.SuppressTopSpacing = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SuppressTopSpacing, &el); err != nil {
|
|
return err
|
|
}
|
|
case "suppressSpacingAtTopOfPage":
|
|
m.SuppressSpacingAtTopOfPage = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SuppressSpacingAtTopOfPage, &el); err != nil {
|
|
return err
|
|
}
|
|
case "suppressTopSpacingWP":
|
|
m.SuppressTopSpacingWP = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SuppressTopSpacingWP, &el); err != nil {
|
|
return err
|
|
}
|
|
case "suppressSpBfAfterPgBrk":
|
|
m.SuppressSpBfAfterPgBrk = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SuppressSpBfAfterPgBrk, &el); err != nil {
|
|
return err
|
|
}
|
|
case "swapBordersFacingPages":
|
|
m.SwapBordersFacingPages = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SwapBordersFacingPages, &el); err != nil {
|
|
return err
|
|
}
|
|
case "convMailMergeEsc":
|
|
m.ConvMailMergeEsc = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.ConvMailMergeEsc, &el); err != nil {
|
|
return err
|
|
}
|
|
case "truncateFontHeightsLikeWP6":
|
|
m.TruncateFontHeightsLikeWP6 = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.TruncateFontHeightsLikeWP6, &el); err != nil {
|
|
return err
|
|
}
|
|
case "mwSmallCaps":
|
|
m.MwSmallCaps = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.MwSmallCaps, &el); err != nil {
|
|
return err
|
|
}
|
|
case "usePrinterMetrics":
|
|
m.UsePrinterMetrics = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UsePrinterMetrics, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotSuppressParagraphBorders":
|
|
m.DoNotSuppressParagraphBorders = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotSuppressParagraphBorders, &el); err != nil {
|
|
return err
|
|
}
|
|
case "wrapTrailSpaces":
|
|
m.WrapTrailSpaces = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.WrapTrailSpaces, &el); err != nil {
|
|
return err
|
|
}
|
|
case "footnoteLayoutLikeWW8":
|
|
m.FootnoteLayoutLikeWW8 = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.FootnoteLayoutLikeWW8, &el); err != nil {
|
|
return err
|
|
}
|
|
case "shapeLayoutLikeWW8":
|
|
m.ShapeLayoutLikeWW8 = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.ShapeLayoutLikeWW8, &el); err != nil {
|
|
return err
|
|
}
|
|
case "alignTablesRowByRow":
|
|
m.AlignTablesRowByRow = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.AlignTablesRowByRow, &el); err != nil {
|
|
return err
|
|
}
|
|
case "forgetLastTabAlignment":
|
|
m.ForgetLastTabAlignment = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.ForgetLastTabAlignment, &el); err != nil {
|
|
return err
|
|
}
|
|
case "adjustLineHeightInTable":
|
|
m.AdjustLineHeightInTable = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.AdjustLineHeightInTable, &el); err != nil {
|
|
return err
|
|
}
|
|
case "autoSpaceLikeWord95":
|
|
m.AutoSpaceLikeWord95 = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.AutoSpaceLikeWord95, &el); err != nil {
|
|
return err
|
|
}
|
|
case "noSpaceRaiseLower":
|
|
m.NoSpaceRaiseLower = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.NoSpaceRaiseLower, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotUseHTMLParagraphAutoSpacing":
|
|
m.DoNotUseHTMLParagraphAutoSpacing = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotUseHTMLParagraphAutoSpacing, &el); err != nil {
|
|
return err
|
|
}
|
|
case "layoutRawTableWidth":
|
|
m.LayoutRawTableWidth = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.LayoutRawTableWidth, &el); err != nil {
|
|
return err
|
|
}
|
|
case "layoutTableRowsApart":
|
|
m.LayoutTableRowsApart = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.LayoutTableRowsApart, &el); err != nil {
|
|
return err
|
|
}
|
|
case "useWord97LineBreakRules":
|
|
m.UseWord97LineBreakRules = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UseWord97LineBreakRules, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotBreakWrappedTables":
|
|
m.DoNotBreakWrappedTables = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotBreakWrappedTables, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotSnapToGridInCell":
|
|
m.DoNotSnapToGridInCell = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotSnapToGridInCell, &el); err != nil {
|
|
return err
|
|
}
|
|
case "selectFldWithFirstOrLastChar":
|
|
m.SelectFldWithFirstOrLastChar = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SelectFldWithFirstOrLastChar, &el); err != nil {
|
|
return err
|
|
}
|
|
case "applyBreakingRules":
|
|
m.ApplyBreakingRules = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.ApplyBreakingRules, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotWrapTextWithPunct":
|
|
m.DoNotWrapTextWithPunct = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotWrapTextWithPunct, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotUseEastAsianBreakRules":
|
|
m.DoNotUseEastAsianBreakRules = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotUseEastAsianBreakRules, &el); err != nil {
|
|
return err
|
|
}
|
|
case "useWord2002TableStyleRules":
|
|
m.UseWord2002TableStyleRules = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UseWord2002TableStyleRules, &el); err != nil {
|
|
return err
|
|
}
|
|
case "growAutofit":
|
|
m.GrowAutofit = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.GrowAutofit, &el); err != nil {
|
|
return err
|
|
}
|
|
case "useFELayout":
|
|
m.UseFELayout = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UseFELayout, &el); err != nil {
|
|
return err
|
|
}
|
|
case "useNormalStyleForList":
|
|
m.UseNormalStyleForList = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UseNormalStyleForList, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotUseIndentAsNumberingTabStop":
|
|
m.DoNotUseIndentAsNumberingTabStop = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotUseIndentAsNumberingTabStop, &el); err != nil {
|
|
return err
|
|
}
|
|
case "useAltKinsokuLineBreakRules":
|
|
m.UseAltKinsokuLineBreakRules = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UseAltKinsokuLineBreakRules, &el); err != nil {
|
|
return err
|
|
}
|
|
case "allowSpaceOfSameStyleInTable":
|
|
m.AllowSpaceOfSameStyleInTable = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.AllowSpaceOfSameStyleInTable, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotSuppressIndentation":
|
|
m.DoNotSuppressIndentation = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotSuppressIndentation, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotAutofitConstrainedTables":
|
|
m.DoNotAutofitConstrainedTables = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotAutofitConstrainedTables, &el); err != nil {
|
|
return err
|
|
}
|
|
case "autofitToFirstFixedWidthCell":
|
|
m.AutofitToFirstFixedWidthCell = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.AutofitToFirstFixedWidthCell, &el); err != nil {
|
|
return err
|
|
}
|
|
case "underlineTabInNumList":
|
|
m.UnderlineTabInNumList = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UnderlineTabInNumList, &el); err != nil {
|
|
return err
|
|
}
|
|
case "displayHangulFixedWidth":
|
|
m.DisplayHangulFixedWidth = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DisplayHangulFixedWidth, &el); err != nil {
|
|
return err
|
|
}
|
|
case "splitPgBreakAndParaMark":
|
|
m.SplitPgBreakAndParaMark = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.SplitPgBreakAndParaMark, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotVertAlignCellWithSp":
|
|
m.DoNotVertAlignCellWithSp = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotVertAlignCellWithSp, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotBreakConstrainedForcedTable":
|
|
m.DoNotBreakConstrainedForcedTable = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotBreakConstrainedForcedTable, &el); err != nil {
|
|
return err
|
|
}
|
|
case "doNotVertAlignInTxbx":
|
|
m.DoNotVertAlignInTxbx = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.DoNotVertAlignInTxbx, &el); err != nil {
|
|
return err
|
|
}
|
|
case "useAnsiKerningPairs":
|
|
m.UseAnsiKerningPairs = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.UseAnsiKerningPairs, &el); err != nil {
|
|
return err
|
|
}
|
|
case "cachedColBalance":
|
|
m.CachedColBalance = NewCT_OnOff()
|
|
if err := d.DecodeElement(m.CachedColBalance, &el); err != nil {
|
|
return err
|
|
}
|
|
case "compatSetting":
|
|
tmp := NewCT_CompatSetting()
|
|
if err := d.DecodeElement(tmp, &el); err != nil {
|
|
return err
|
|
}
|
|
m.CompatSetting = append(m.CompatSetting, tmp)
|
|
default:
|
|
log.Printf("skipping unsupported element on CT_Compat %v", el.Name)
|
|
if err := d.Skip(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
case xml.EndElement:
|
|
break lCT_Compat
|
|
case xml.CharData:
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Validate validates the CT_Compat and its children
|
|
func (m *CT_Compat) Validate() error {
|
|
return m.ValidateWithPath("CT_Compat")
|
|
}
|
|
|
|
// ValidateWithPath validates the CT_Compat and its children, prefixing error messages with path
|
|
func (m *CT_Compat) ValidateWithPath(path string) error {
|
|
if m.UseSingleBorderforContiguousCells != nil {
|
|
if err := m.UseSingleBorderforContiguousCells.ValidateWithPath(path + "/UseSingleBorderforContiguousCells"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.WpJustification != nil {
|
|
if err := m.WpJustification.ValidateWithPath(path + "/WpJustification"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.NoTabHangInd != nil {
|
|
if err := m.NoTabHangInd.ValidateWithPath(path + "/NoTabHangInd"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.NoLeading != nil {
|
|
if err := m.NoLeading.ValidateWithPath(path + "/NoLeading"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SpaceForUL != nil {
|
|
if err := m.SpaceForUL.ValidateWithPath(path + "/SpaceForUL"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.NoColumnBalance != nil {
|
|
if err := m.NoColumnBalance.ValidateWithPath(path + "/NoColumnBalance"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.BalanceSingleByteDoubleByteWidth != nil {
|
|
if err := m.BalanceSingleByteDoubleByteWidth.ValidateWithPath(path + "/BalanceSingleByteDoubleByteWidth"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.NoExtraLineSpacing != nil {
|
|
if err := m.NoExtraLineSpacing.ValidateWithPath(path + "/NoExtraLineSpacing"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotLeaveBackslashAlone != nil {
|
|
if err := m.DoNotLeaveBackslashAlone.ValidateWithPath(path + "/DoNotLeaveBackslashAlone"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UlTrailSpace != nil {
|
|
if err := m.UlTrailSpace.ValidateWithPath(path + "/UlTrailSpace"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotExpandShiftReturn != nil {
|
|
if err := m.DoNotExpandShiftReturn.ValidateWithPath(path + "/DoNotExpandShiftReturn"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SpacingInWholePoints != nil {
|
|
if err := m.SpacingInWholePoints.ValidateWithPath(path + "/SpacingInWholePoints"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.LineWrapLikeWord6 != nil {
|
|
if err := m.LineWrapLikeWord6.ValidateWithPath(path + "/LineWrapLikeWord6"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.PrintBodyTextBeforeHeader != nil {
|
|
if err := m.PrintBodyTextBeforeHeader.ValidateWithPath(path + "/PrintBodyTextBeforeHeader"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.PrintColBlack != nil {
|
|
if err := m.PrintColBlack.ValidateWithPath(path + "/PrintColBlack"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.WpSpaceWidth != nil {
|
|
if err := m.WpSpaceWidth.ValidateWithPath(path + "/WpSpaceWidth"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.ShowBreaksInFrames != nil {
|
|
if err := m.ShowBreaksInFrames.ValidateWithPath(path + "/ShowBreaksInFrames"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SubFontBySize != nil {
|
|
if err := m.SubFontBySize.ValidateWithPath(path + "/SubFontBySize"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SuppressBottomSpacing != nil {
|
|
if err := m.SuppressBottomSpacing.ValidateWithPath(path + "/SuppressBottomSpacing"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SuppressTopSpacing != nil {
|
|
if err := m.SuppressTopSpacing.ValidateWithPath(path + "/SuppressTopSpacing"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SuppressSpacingAtTopOfPage != nil {
|
|
if err := m.SuppressSpacingAtTopOfPage.ValidateWithPath(path + "/SuppressSpacingAtTopOfPage"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SuppressTopSpacingWP != nil {
|
|
if err := m.SuppressTopSpacingWP.ValidateWithPath(path + "/SuppressTopSpacingWP"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SuppressSpBfAfterPgBrk != nil {
|
|
if err := m.SuppressSpBfAfterPgBrk.ValidateWithPath(path + "/SuppressSpBfAfterPgBrk"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SwapBordersFacingPages != nil {
|
|
if err := m.SwapBordersFacingPages.ValidateWithPath(path + "/SwapBordersFacingPages"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.ConvMailMergeEsc != nil {
|
|
if err := m.ConvMailMergeEsc.ValidateWithPath(path + "/ConvMailMergeEsc"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.TruncateFontHeightsLikeWP6 != nil {
|
|
if err := m.TruncateFontHeightsLikeWP6.ValidateWithPath(path + "/TruncateFontHeightsLikeWP6"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.MwSmallCaps != nil {
|
|
if err := m.MwSmallCaps.ValidateWithPath(path + "/MwSmallCaps"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UsePrinterMetrics != nil {
|
|
if err := m.UsePrinterMetrics.ValidateWithPath(path + "/UsePrinterMetrics"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotSuppressParagraphBorders != nil {
|
|
if err := m.DoNotSuppressParagraphBorders.ValidateWithPath(path + "/DoNotSuppressParagraphBorders"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.WrapTrailSpaces != nil {
|
|
if err := m.WrapTrailSpaces.ValidateWithPath(path + "/WrapTrailSpaces"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.FootnoteLayoutLikeWW8 != nil {
|
|
if err := m.FootnoteLayoutLikeWW8.ValidateWithPath(path + "/FootnoteLayoutLikeWW8"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.ShapeLayoutLikeWW8 != nil {
|
|
if err := m.ShapeLayoutLikeWW8.ValidateWithPath(path + "/ShapeLayoutLikeWW8"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.AlignTablesRowByRow != nil {
|
|
if err := m.AlignTablesRowByRow.ValidateWithPath(path + "/AlignTablesRowByRow"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.ForgetLastTabAlignment != nil {
|
|
if err := m.ForgetLastTabAlignment.ValidateWithPath(path + "/ForgetLastTabAlignment"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.AdjustLineHeightInTable != nil {
|
|
if err := m.AdjustLineHeightInTable.ValidateWithPath(path + "/AdjustLineHeightInTable"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.AutoSpaceLikeWord95 != nil {
|
|
if err := m.AutoSpaceLikeWord95.ValidateWithPath(path + "/AutoSpaceLikeWord95"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.NoSpaceRaiseLower != nil {
|
|
if err := m.NoSpaceRaiseLower.ValidateWithPath(path + "/NoSpaceRaiseLower"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotUseHTMLParagraphAutoSpacing != nil {
|
|
if err := m.DoNotUseHTMLParagraphAutoSpacing.ValidateWithPath(path + "/DoNotUseHTMLParagraphAutoSpacing"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.LayoutRawTableWidth != nil {
|
|
if err := m.LayoutRawTableWidth.ValidateWithPath(path + "/LayoutRawTableWidth"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.LayoutTableRowsApart != nil {
|
|
if err := m.LayoutTableRowsApart.ValidateWithPath(path + "/LayoutTableRowsApart"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UseWord97LineBreakRules != nil {
|
|
if err := m.UseWord97LineBreakRules.ValidateWithPath(path + "/UseWord97LineBreakRules"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotBreakWrappedTables != nil {
|
|
if err := m.DoNotBreakWrappedTables.ValidateWithPath(path + "/DoNotBreakWrappedTables"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotSnapToGridInCell != nil {
|
|
if err := m.DoNotSnapToGridInCell.ValidateWithPath(path + "/DoNotSnapToGridInCell"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SelectFldWithFirstOrLastChar != nil {
|
|
if err := m.SelectFldWithFirstOrLastChar.ValidateWithPath(path + "/SelectFldWithFirstOrLastChar"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.ApplyBreakingRules != nil {
|
|
if err := m.ApplyBreakingRules.ValidateWithPath(path + "/ApplyBreakingRules"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotWrapTextWithPunct != nil {
|
|
if err := m.DoNotWrapTextWithPunct.ValidateWithPath(path + "/DoNotWrapTextWithPunct"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotUseEastAsianBreakRules != nil {
|
|
if err := m.DoNotUseEastAsianBreakRules.ValidateWithPath(path + "/DoNotUseEastAsianBreakRules"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UseWord2002TableStyleRules != nil {
|
|
if err := m.UseWord2002TableStyleRules.ValidateWithPath(path + "/UseWord2002TableStyleRules"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.GrowAutofit != nil {
|
|
if err := m.GrowAutofit.ValidateWithPath(path + "/GrowAutofit"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UseFELayout != nil {
|
|
if err := m.UseFELayout.ValidateWithPath(path + "/UseFELayout"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UseNormalStyleForList != nil {
|
|
if err := m.UseNormalStyleForList.ValidateWithPath(path + "/UseNormalStyleForList"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotUseIndentAsNumberingTabStop != nil {
|
|
if err := m.DoNotUseIndentAsNumberingTabStop.ValidateWithPath(path + "/DoNotUseIndentAsNumberingTabStop"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UseAltKinsokuLineBreakRules != nil {
|
|
if err := m.UseAltKinsokuLineBreakRules.ValidateWithPath(path + "/UseAltKinsokuLineBreakRules"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.AllowSpaceOfSameStyleInTable != nil {
|
|
if err := m.AllowSpaceOfSameStyleInTable.ValidateWithPath(path + "/AllowSpaceOfSameStyleInTable"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotSuppressIndentation != nil {
|
|
if err := m.DoNotSuppressIndentation.ValidateWithPath(path + "/DoNotSuppressIndentation"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotAutofitConstrainedTables != nil {
|
|
if err := m.DoNotAutofitConstrainedTables.ValidateWithPath(path + "/DoNotAutofitConstrainedTables"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.AutofitToFirstFixedWidthCell != nil {
|
|
if err := m.AutofitToFirstFixedWidthCell.ValidateWithPath(path + "/AutofitToFirstFixedWidthCell"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UnderlineTabInNumList != nil {
|
|
if err := m.UnderlineTabInNumList.ValidateWithPath(path + "/UnderlineTabInNumList"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DisplayHangulFixedWidth != nil {
|
|
if err := m.DisplayHangulFixedWidth.ValidateWithPath(path + "/DisplayHangulFixedWidth"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.SplitPgBreakAndParaMark != nil {
|
|
if err := m.SplitPgBreakAndParaMark.ValidateWithPath(path + "/SplitPgBreakAndParaMark"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotVertAlignCellWithSp != nil {
|
|
if err := m.DoNotVertAlignCellWithSp.ValidateWithPath(path + "/DoNotVertAlignCellWithSp"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotBreakConstrainedForcedTable != nil {
|
|
if err := m.DoNotBreakConstrainedForcedTable.ValidateWithPath(path + "/DoNotBreakConstrainedForcedTable"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.DoNotVertAlignInTxbx != nil {
|
|
if err := m.DoNotVertAlignInTxbx.ValidateWithPath(path + "/DoNotVertAlignInTxbx"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.UseAnsiKerningPairs != nil {
|
|
if err := m.UseAnsiKerningPairs.ValidateWithPath(path + "/UseAnsiKerningPairs"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if m.CachedColBalance != nil {
|
|
if err := m.CachedColBalance.ValidateWithPath(path + "/CachedColBalance"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i, v := range m.CompatSetting {
|
|
if err := v.ValidateWithPath(fmt.Sprintf("%s/CompatSetting[%d]", path, i)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|