wml

package
v0.7.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 25, 2018 License: AGPL-3.0 Imports: 11 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

View Source 
const ST_CnfPattern = `[01]*`
View Source 
const ST_TextScalePercentPattern = `0*(600|([0-5]?[0-9]?[0-9]))%`

Variables ¶

View Source 
var ST_CnfPatternRe = regexp.MustCompile(ST_CnfPattern)
View Source 
var ST_TextScalePercentPatternRe = regexp.MustCompile(ST_TextScalePercentPattern)

Functions ¶

func ParseStdlibTime ¶ 

func ParseStdlibTime(s string) (time.Time, error)

func ParseUnionST_Coordinate ¶ 

func ParseUnionST_Coordinate(s string) (dml.ST_Coordinate, error)

func ParseUnionST_OnOff ¶ 

func ParseUnionST_OnOff(s string) (sharedTypes.ST_OnOff, error)

func ParseUnionST_TwipsMeasure ¶ 

func ParseUnionST_TwipsMeasure(s string) (sharedTypes.ST_TwipsMeasure, error)

Types ¶

type AG_Password ¶ 

type AG_Password struct {
	AlgorithmNameAttr *string
	HashValueAttr     *string
	SaltValueAttr     *string
	SpinCountAttr     *int64
}

func NewAG_Password ¶ 

func NewAG_Password() *AG_Password

func (*AG_Password) MarshalXML ¶ 

func (m *AG_Password) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*AG_Password) UnmarshalXML ¶ 

func (m *AG_Password) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*AG_Password) Validate ¶ 

func (m *AG_Password) Validate() error

Validate validates the AG_Password and its children

func (*AG_Password) ValidateWithPath ¶ 

func (m *AG_Password) ValidateWithPath(path string) error

ValidateWithPath validates the AG_Password and its children, prefixing error messages with path

type AG_SectPrAttributes ¶ 

type AG_SectPrAttributes struct {
	RsidRPrAttr  *string
	RsidDelAttr  *string
	RsidRAttr    *string
	RsidSectAttr *string
}

func NewAG_SectPrAttributes ¶ 

func NewAG_SectPrAttributes() *AG_SectPrAttributes

func (*AG_SectPrAttributes) MarshalXML ¶ 

func (m *AG_SectPrAttributes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*AG_SectPrAttributes) UnmarshalXML ¶ 

func (m *AG_SectPrAttributes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*AG_SectPrAttributes) Validate ¶ 

func (m *AG_SectPrAttributes) Validate() error

Validate validates the AG_SectPrAttributes and its children

func (*AG_SectPrAttributes) ValidateWithPath ¶ 

func (m *AG_SectPrAttributes) ValidateWithPath(path string) error

ValidateWithPath validates the AG_SectPrAttributes and its children, prefixing error messages with path

type AG_TransitionalPassword ¶ 

type AG_TransitionalPassword struct {
	CryptProviderTypeAttr          sharedTypes.ST_CryptProv
	CryptAlgorithmClassAttr        sharedTypes.ST_AlgClass
	CryptAlgorithmTypeAttr         sharedTypes.ST_AlgType
	CryptAlgorithmSidAttr          *int64
	CryptSpinCountAttr             *int64
	CryptProviderAttr              *string
	AlgIdExtAttr                   *string
	AlgIdExtSourceAttr             *string
	CryptProviderTypeExtAttr       *string
	CryptProviderTypeExtSourceAttr *string
	HashAttr                       *string
	SaltAttr                       *string
}

func NewAG_TransitionalPassword ¶ 

func NewAG_TransitionalPassword() *AG_TransitionalPassword

func (*AG_TransitionalPassword) MarshalXML ¶ 

func (m *AG_TransitionalPassword) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*AG_TransitionalPassword) UnmarshalXML ¶ 

func (m *AG_TransitionalPassword) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*AG_TransitionalPassword) Validate ¶ 

func (m *AG_TransitionalPassword) Validate() error

Validate validates the AG_TransitionalPassword and its children

func (*AG_TransitionalPassword) ValidateWithPath ¶ 

func (m *AG_TransitionalPassword) ValidateWithPath(path string) error

ValidateWithPath validates the AG_TransitionalPassword and its children, prefixing error messages with path

type CT_AbstractNum ¶ 

type CT_AbstractNum struct {
	// Abstract Numbering Definition ID
	AbstractNumIdAttr int64
	// Abstract Numbering Definition Identifier
	Nsid *CT_LongHexNumber
	// Abstract Numbering Definition Type
	MultiLevelType *CT_MultiLevelType
	// Numbering Template Code
	Tmpl *CT_LongHexNumber
	// Abstract Numbering Definition Name
	Name *CT_String
	// Numbering Style Definition
	StyleLink *CT_String
	// Numbering Style Reference
	NumStyleLink *CT_String
	// Numbering Level Definition
	Lvl []*CT_Lvl
}

func NewCT_AbstractNum ¶ 

func NewCT_AbstractNum() *CT_AbstractNum

func (*CT_AbstractNum) MarshalXML ¶ 

func (m *CT_AbstractNum) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_AbstractNum) UnmarshalXML ¶ 

func (m *CT_AbstractNum) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_AbstractNum) Validate ¶ 

func (m *CT_AbstractNum) Validate() error

Validate validates the CT_AbstractNum and its children

func (*CT_AbstractNum) ValidateWithPath ¶ 

func (m *CT_AbstractNum) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AbstractNum and its children, prefixing error messages with path

type CT_AltChunk ¶ 

type CT_AltChunk struct {
	IdAttr *string
	// External Content Import Properties
	AltChunkPr *CT_AltChunkPr
}

func NewCT_AltChunk ¶ 

func NewCT_AltChunk() *CT_AltChunk

func (*CT_AltChunk) MarshalXML ¶ 

func (m *CT_AltChunk) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_AltChunk) UnmarshalXML ¶ 

func (m *CT_AltChunk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_AltChunk) Validate ¶ 

func (m *CT_AltChunk) Validate() error

Validate validates the CT_AltChunk and its children

func (*CT_AltChunk) ValidateWithPath ¶ 

func (m *CT_AltChunk) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AltChunk and its children, prefixing error messages with path

type CT_AltChunkPr ¶ 

type CT_AltChunkPr struct {
	// Keep Source Formatting on Import
	MatchSrc *CT_OnOff
}

func NewCT_AltChunkPr ¶ 

func NewCT_AltChunkPr() *CT_AltChunkPr

func (*CT_AltChunkPr) MarshalXML ¶ 

func (m *CT_AltChunkPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_AltChunkPr) UnmarshalXML ¶ 

func (m *CT_AltChunkPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_AltChunkPr) Validate ¶ 

func (m *CT_AltChunkPr) Validate() error

Validate validates the CT_AltChunkPr and its children

func (*CT_AltChunkPr) ValidateWithPath ¶ 

func (m *CT_AltChunkPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AltChunkPr and its children, prefixing error messages with path

type CT_Attr ¶ 

type CT_Attr struct {
	// Namespace
	UriAttr *string
	// Name
	NameAttr string
	// Value
	ValAttr string
}

func NewCT_Attr ¶ 

func NewCT_Attr() *CT_Attr

func (*CT_Attr) MarshalXML ¶ 

func (m *CT_Attr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Attr) UnmarshalXML ¶ 

func (m *CT_Attr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Attr) Validate ¶ 

func (m *CT_Attr) Validate() error

Validate validates the CT_Attr and its children

func (*CT_Attr) ValidateWithPath ¶ 

func (m *CT_Attr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Attr and its children, prefixing error messages with path

type CT_AutoCaption ¶ 

type CT_AutoCaption struct {
	// Identifier of Object to be Automatically Captioned
	NameAttr string
	// Caption Used for Automatic Captioning
	CaptionAttr string
}

func NewCT_AutoCaption ¶ 

func NewCT_AutoCaption() *CT_AutoCaption

func (*CT_AutoCaption) MarshalXML ¶ 

func (m *CT_AutoCaption) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_AutoCaption) UnmarshalXML ¶ 

func (m *CT_AutoCaption) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_AutoCaption) Validate ¶ 

func (m *CT_AutoCaption) Validate() error

Validate validates the CT_AutoCaption and its children

func (*CT_AutoCaption) ValidateWithPath ¶ 

func (m *CT_AutoCaption) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AutoCaption and its children, prefixing error messages with path

type CT_AutoCaptions ¶ 

type CT_AutoCaptions struct {
	// Single Automatic Captioning Setting
	AutoCaption []*CT_AutoCaption
}

func NewCT_AutoCaptions ¶ 

func NewCT_AutoCaptions() *CT_AutoCaptions

func (*CT_AutoCaptions) MarshalXML ¶ 

func (m *CT_AutoCaptions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_AutoCaptions) UnmarshalXML ¶ 

func (m *CT_AutoCaptions) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_AutoCaptions) Validate ¶ 

func (m *CT_AutoCaptions) Validate() error

Validate validates the CT_AutoCaptions and its children

func (*CT_AutoCaptions) ValidateWithPath ¶ 

func (m *CT_AutoCaptions) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AutoCaptions and its children, prefixing error messages with path

type CT_Background ¶ 

type CT_Background struct {
	// Background Color
	ColorAttr *ST_HexColor
	// Background Theme Color
	ThemeColorAttr ST_ThemeColor
	// Background Theme Color Tint
	ThemeTintAttr *string
	// Background Theme Color Shade
	ThemeShadeAttr *string
	Drawing        *CT_Drawing
}

func NewCT_Background ¶ 

func NewCT_Background() *CT_Background

func (*CT_Background) MarshalXML ¶ 

func (m *CT_Background) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Background) UnmarshalXML ¶ 

func (m *CT_Background) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Background) Validate ¶ 

func (m *CT_Background) Validate() error

Validate validates the CT_Background and its children

func (*CT_Background) ValidateWithPath ¶ 

func (m *CT_Background) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Background and its children, prefixing error messages with path

type CT_Base64Binary ¶ 

type CT_Base64Binary struct {
	ValAttr string
}

func NewCT_Base64Binary ¶ 

func NewCT_Base64Binary() *CT_Base64Binary

func (*CT_Base64Binary) MarshalXML ¶ 

func (m *CT_Base64Binary) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Base64Binary) UnmarshalXML ¶ 

func (m *CT_Base64Binary) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Base64Binary) Validate ¶ 

func (m *CT_Base64Binary) Validate() error

Validate validates the CT_Base64Binary and its children

func (*CT_Base64Binary) ValidateWithPath ¶ 

func (m *CT_Base64Binary) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Base64Binary and its children, prefixing error messages with path

type CT_BdoContentRun ¶ 

type CT_BdoContentRun struct {
	// Direction of Override
	ValAttr ST_Direction
	// Simple Field
	FldSimple []*CT_SimpleField
	// Hyperlink
	Hyperlink *CT_Hyperlink
	// Anchor for Subdocument Location
	SubDoc               *CT_Rel
	EG_ContentRunContent []*EG_ContentRunContent
}

func NewCT_BdoContentRun ¶ 

func NewCT_BdoContentRun() *CT_BdoContentRun

func (*CT_BdoContentRun) MarshalXML ¶ 

func (m *CT_BdoContentRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_BdoContentRun) UnmarshalXML ¶ 

func (m *CT_BdoContentRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_BdoContentRun) Validate ¶ 

func (m *CT_BdoContentRun) Validate() error

Validate validates the CT_BdoContentRun and its children

func (*CT_BdoContentRun) ValidateWithPath ¶ 

func (m *CT_BdoContentRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BdoContentRun and its children, prefixing error messages with path

type CT_Body ¶ 

type CT_Body struct {
	EG_BlockLevelElts []*EG_BlockLevelElts
	// Document Final Section Properties
	SectPr *CT_SectPr
}

func NewCT_Body ¶ 

func NewCT_Body() *CT_Body

func (*CT_Body) MarshalXML ¶ 

func (m *CT_Body) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Body) UnmarshalXML ¶ 

func (m *CT_Body) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Body) Validate ¶ 

func (m *CT_Body) Validate() error

Validate validates the CT_Body and its children

func (*CT_Body) ValidateWithPath ¶ 

func (m *CT_Body) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Body and its children, prefixing error messages with path

type CT_Bookmark ¶ 

type CT_Bookmark struct {
	NameAttr                 string
	ColFirstAttr             *int64
	ColLastAttr              *int64
	DisplacedByCustomXmlAttr ST_DisplacedByCustomXml
	// Annotation Identifier
	IdAttr int64
}

func NewCT_Bookmark ¶ 

func NewCT_Bookmark() *CT_Bookmark

func (*CT_Bookmark) MarshalXML ¶ 

func (m *CT_Bookmark) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Bookmark) UnmarshalXML ¶ 

func (m *CT_Bookmark) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Bookmark) Validate ¶ 

func (m *CT_Bookmark) Validate() error

Validate validates the CT_Bookmark and its children

func (*CT_Bookmark) ValidateWithPath ¶ 

func (m *CT_Bookmark) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Bookmark and its children, prefixing error messages with path

type CT_BookmarkRange ¶ 

type CT_BookmarkRange struct {
	ColFirstAttr             *int64
	ColLastAttr              *int64
	DisplacedByCustomXmlAttr ST_DisplacedByCustomXml
	// Annotation Identifier
	IdAttr int64
}

func NewCT_BookmarkRange ¶ 

func NewCT_BookmarkRange() *CT_BookmarkRange

func (*CT_BookmarkRange) MarshalXML ¶ 

func (m *CT_BookmarkRange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_BookmarkRange) UnmarshalXML ¶ 

func (m *CT_BookmarkRange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_BookmarkRange) Validate ¶ 

func (m *CT_BookmarkRange) Validate() error

Validate validates the CT_BookmarkRange and its children

func (*CT_BookmarkRange) ValidateWithPath ¶ 

func (m *CT_BookmarkRange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BookmarkRange and its children, prefixing error messages with path

type CT_Border ¶ 

type CT_Border struct {
	// Border Style
	ValAttr ST_Border
	// Border Color
	ColorAttr *ST_HexColor
	// Border Theme Color
	ThemeColorAttr ST_ThemeColor
	// Border Theme Color Tint
	ThemeTintAttr *string
	// Border Theme Color Shade
	ThemeShadeAttr *string
	// Border Width
	SzAttr *uint64
	// Border Spacing Measurement
	SpaceAttr *uint64
	// Border Shadow
	ShadowAttr *sharedTypes.ST_OnOff
	// Create Frame Effect
	FrameAttr *sharedTypes.ST_OnOff
}

func NewCT_Border ¶ 

func NewCT_Border() *CT_Border

func (*CT_Border) MarshalXML ¶ 

func (m *CT_Border) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Border) UnmarshalXML ¶ 

func (m *CT_Border) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Border) Validate ¶ 

func (m *CT_Border) Validate() error

Validate validates the CT_Border and its children

func (*CT_Border) ValidateWithPath ¶ 

func (m *CT_Border) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Border and its children, prefixing error messages with path

type CT_BottomPageBorder ¶ 

type CT_BottomPageBorder struct {
	BottomLeftAttr  *string
	BottomRightAttr *string
	IdAttr          *string
	// Border Style
	ValAttr ST_Border
	// Border Color
	ColorAttr *ST_HexColor
	// Border Theme Color
	ThemeColorAttr ST_ThemeColor
	// Border Theme Color Tint
	ThemeTintAttr *string
	// Border Theme Color Shade
	ThemeShadeAttr *string
	// Border Width
	SzAttr *uint64
	// Border Spacing Measurement
	SpaceAttr *uint64
	// Border Shadow
	ShadowAttr *sharedTypes.ST_OnOff
	// Create Frame Effect
	FrameAttr *sharedTypes.ST_OnOff
}

func NewCT_BottomPageBorder ¶ 

func NewCT_BottomPageBorder() *CT_BottomPageBorder

func (*CT_BottomPageBorder) MarshalXML ¶ 

func (m *CT_BottomPageBorder) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_BottomPageBorder) UnmarshalXML ¶ 

func (m *CT_BottomPageBorder) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_BottomPageBorder) Validate ¶ 

func (m *CT_BottomPageBorder) Validate() error

Validate validates the CT_BottomPageBorder and its children

func (*CT_BottomPageBorder) ValidateWithPath ¶ 

func (m *CT_BottomPageBorder) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BottomPageBorder and its children, prefixing error messages with path

type CT_Br ¶ 

type CT_Br struct {
	// Break Type
	TypeAttr ST_BrType
	// Restart Location For Text Wrapping Break
	ClearAttr ST_BrClear
}

func NewCT_Br ¶ 

func NewCT_Br() *CT_Br

func (*CT_Br) MarshalXML ¶ 

func (m *CT_Br) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Br) UnmarshalXML ¶ 

func (m *CT_Br) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Br) Validate ¶ 

func (m *CT_Br) Validate() error

Validate validates the CT_Br and its children

func (*CT_Br) ValidateWithPath ¶ 

func (m *CT_Br) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Br and its children, prefixing error messages with path

type CT_CalendarType ¶ 

type CT_CalendarType struct {
	// Calendar Type Value
	ValAttr sharedTypes.ST_CalendarType
}

func NewCT_CalendarType ¶ 

func NewCT_CalendarType() *CT_CalendarType

func (*CT_CalendarType) MarshalXML ¶ 

func (m *CT_CalendarType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CalendarType) UnmarshalXML ¶ 

func (m *CT_CalendarType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CalendarType) Validate ¶ 

func (m *CT_CalendarType) Validate() error

Validate validates the CT_CalendarType and its children

func (*CT_CalendarType) ValidateWithPath ¶ 

func (m *CT_CalendarType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CalendarType and its children, prefixing error messages with path

type CT_Caption ¶ 

type CT_Caption struct {
	// Caption Type Name
	NameAttr string
	// Automatic Caption Placement
	PosAttr ST_CaptionPos
	// Include Chapter Number in Field for Caption
	ChapNumAttr *sharedTypes.ST_OnOff
	// Style for Chapter Headings
	HeadingAttr *int64
	// Do Not Include Name In Caption
	NoLabelAttr *sharedTypes.ST_OnOff
	// Caption Numbering Format
	NumFmtAttr ST_NumberFormat
	// Chapter Number/Item Index Separator
	SepAttr ST_ChapterSep
}

func NewCT_Caption ¶ 

func NewCT_Caption() *CT_Caption

func (*CT_Caption) MarshalXML ¶ 

func (m *CT_Caption) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Caption) UnmarshalXML ¶ 

func (m *CT_Caption) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Caption) Validate ¶ 

func (m *CT_Caption) Validate() error

Validate validates the CT_Caption and its children

func (*CT_Caption) ValidateWithPath ¶ 

func (m *CT_Caption) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Caption and its children, prefixing error messages with path

type CT_Captions ¶ 

type CT_Captions struct {
	// Single Caption Type Definition
	Caption []*CT_Caption
	// Automatic Captioning Settings
	AutoCaptions *CT_AutoCaptions
}

func NewCT_Captions ¶ 

func NewCT_Captions() *CT_Captions

func (*CT_Captions) MarshalXML ¶ 

func (m *CT_Captions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Captions) UnmarshalXML ¶ 

func (m *CT_Captions) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Captions) Validate ¶ 

func (m *CT_Captions) Validate() error

Validate validates the CT_Captions and its children

func (*CT_Captions) ValidateWithPath ¶ 

func (m *CT_Captions) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Captions and its children, prefixing error messages with path

type CT_CellMergeTrackChange ¶ 

type CT_CellMergeTrackChange struct {
	VMergeAttr     ST_AnnotationVMerge
	VMergeOrigAttr ST_AnnotationVMerge
	AuthorAttr     string
	DateAttr       *time.Time
	// Annotation Identifier
	IdAttr int64
}

func NewCT_CellMergeTrackChange ¶ 

func NewCT_CellMergeTrackChange() *CT_CellMergeTrackChange

func (*CT_CellMergeTrackChange) MarshalXML ¶ 

func (m *CT_CellMergeTrackChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CellMergeTrackChange) UnmarshalXML ¶ 

func (m *CT_CellMergeTrackChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CellMergeTrackChange) Validate ¶ 

func (m *CT_CellMergeTrackChange) Validate() error

Validate validates the CT_CellMergeTrackChange and its children

func (*CT_CellMergeTrackChange) ValidateWithPath ¶ 

func (m *CT_CellMergeTrackChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CellMergeTrackChange and its children, prefixing error messages with path

type CT_CharacterSpacing ¶ 

type CT_CharacterSpacing struct {
	// Value
	ValAttr ST_CharacterSpacing
}

func NewCT_CharacterSpacing ¶ 

func NewCT_CharacterSpacing() *CT_CharacterSpacing

func (*CT_CharacterSpacing) MarshalXML ¶ 

func (m *CT_CharacterSpacing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CharacterSpacing) UnmarshalXML ¶ 

func (m *CT_CharacterSpacing) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CharacterSpacing) Validate ¶ 

func (m *CT_CharacterSpacing) Validate() error

Validate validates the CT_CharacterSpacing and its children

func (*CT_CharacterSpacing) ValidateWithPath ¶ 

func (m *CT_CharacterSpacing) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CharacterSpacing and its children, prefixing error messages with path

type CT_Charset ¶ 

type CT_Charset struct {
	// Value
	ValAttr *string
	// IANA Name of Character Set
	CharacterSetAttr *string
}

func NewCT_Charset ¶ 

func NewCT_Charset() *CT_Charset

func (*CT_Charset) MarshalXML ¶ 

func (m *CT_Charset) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Charset) UnmarshalXML ¶ 

func (m *CT_Charset) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Charset) Validate ¶ 

func (m *CT_Charset) Validate() error

Validate validates the CT_Charset and its children

func (*CT_Charset) ValidateWithPath ¶ 

func (m *CT_Charset) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Charset and its children, prefixing error messages with path

type CT_Cnf ¶ 

type CT_Cnf struct {
	// Conditional Formatting Bit Mask
	ValAttr *string
	// First Row
	FirstRowAttr *sharedTypes.ST_OnOff
	// Last Row
	LastRowAttr *sharedTypes.ST_OnOff
	// First Column
	FirstColumnAttr *sharedTypes.ST_OnOff
	// Last Column
	LastColumnAttr *sharedTypes.ST_OnOff
	// Odd Numbered Vertical Band
	OddVBandAttr *sharedTypes.ST_OnOff
	// Even Numbered Vertical Band
	EvenVBandAttr *sharedTypes.ST_OnOff
	// Odd Numbered Horizontal Band
	OddHBandAttr *sharedTypes.ST_OnOff
	// Even Numbered Horizontal Band
	EvenHBandAttr *sharedTypes.ST_OnOff
	// First Row and First Column
	FirstRowFirstColumnAttr *sharedTypes.ST_OnOff
	// First Row and Last Column
	FirstRowLastColumnAttr *sharedTypes.ST_OnOff
	// Last Row and First Column
	LastRowFirstColumnAttr *sharedTypes.ST_OnOff
	// Last Row and Last Column
	LastRowLastColumnAttr *sharedTypes.ST_OnOff
}

func NewCT_Cnf ¶ 

func NewCT_Cnf() *CT_Cnf

func (*CT_Cnf) MarshalXML ¶ 

func (m *CT_Cnf) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Cnf) UnmarshalXML ¶ 

func (m *CT_Cnf) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Cnf) Validate ¶ 

func (m *CT_Cnf) Validate() error

Validate validates the CT_Cnf and its children

func (*CT_Cnf) ValidateWithPath ¶ 

func (m *CT_Cnf) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Cnf and its children, prefixing error messages with path

type CT_Color ¶ 

type CT_Color struct {
	// Run Content Color
	ValAttr ST_HexColor
	// Run Content Theme Color
	ThemeColorAttr ST_ThemeColor
	// Run Content Theme Color Tint
	ThemeTintAttr *string
	// Run Content Theme Color Shade
	ThemeShadeAttr *string
}

func NewCT_Color ¶ 

func NewCT_Color() *CT_Color

func (*CT_Color) MarshalXML ¶ 

func (m *CT_Color) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Color) UnmarshalXML ¶ 

func (m *CT_Color) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Color) Validate ¶ 

func (m *CT_Color) Validate() error

Validate validates the CT_Color and its children

func (*CT_Color) ValidateWithPath ¶ 

func (m *CT_Color) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Color and its children, prefixing error messages with path

type CT_ColorSchemeMapping ¶ 

type CT_ColorSchemeMapping struct {
	// Background 1 Theme Color Mapping
	Bg1Attr ST_WmlColorSchemeIndex
	// Text 1 Theme Color Mapping
	T1Attr ST_WmlColorSchemeIndex
	// Background 2 Theme Color Mapping
	Bg2Attr ST_WmlColorSchemeIndex
	// Text 2 Theme Color Mapping
	T2Attr ST_WmlColorSchemeIndex
	// Accent 1 Theme Color Mapping
	Accent1Attr ST_WmlColorSchemeIndex
	// Accent 2 Theme Color Mapping
	Accent2Attr ST_WmlColorSchemeIndex
	// Accent3 Theme Color Mapping
	Accent3Attr ST_WmlColorSchemeIndex
	// Accent4 Theme Color Mapping
	Accent4Attr ST_WmlColorSchemeIndex
	// Accent5 Theme Color Mapping
	Accent5Attr ST_WmlColorSchemeIndex
	// Accent6 Theme Color Mapping
	Accent6Attr ST_WmlColorSchemeIndex
	// Hyperlink Theme Color Mapping
	HyperlinkAttr ST_WmlColorSchemeIndex
	// Followed Hyperlink Theme Color Mapping
	FollowedHyperlinkAttr ST_WmlColorSchemeIndex
}

func NewCT_ColorSchemeMapping ¶ 

func NewCT_ColorSchemeMapping() *CT_ColorSchemeMapping

func (*CT_ColorSchemeMapping) MarshalXML ¶ 

func (m *CT_ColorSchemeMapping) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ColorSchemeMapping) UnmarshalXML ¶ 

func (m *CT_ColorSchemeMapping) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ColorSchemeMapping) Validate ¶ 

func (m *CT_ColorSchemeMapping) Validate() error

Validate validates the CT_ColorSchemeMapping and its children

func (*CT_ColorSchemeMapping) ValidateWithPath ¶ 

func (m *CT_ColorSchemeMapping) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ColorSchemeMapping and its children, prefixing error messages with path

type CT_Column ¶ 

type CT_Column struct {
	// Column Width
	WAttr *sharedTypes.ST_TwipsMeasure
	// Space Before Following Column
	SpaceAttr *sharedTypes.ST_TwipsMeasure
}

func NewCT_Column ¶ 

func NewCT_Column() *CT_Column

func (*CT_Column) MarshalXML ¶ 

func (m *CT_Column) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Column) UnmarshalXML ¶ 

func (m *CT_Column) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Column) Validate ¶ 

func (m *CT_Column) Validate() error

Validate validates the CT_Column and its children

func (*CT_Column) ValidateWithPath ¶ 

func (m *CT_Column) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Column and its children, prefixing error messages with path

type CT_Columns ¶ 

type CT_Columns struct {
	// Equal Column Widths
	EqualWidthAttr *sharedTypes.ST_OnOff
	// Spacing Between Equal Width Columns
	SpaceAttr *sharedTypes.ST_TwipsMeasure
	// Number of Equal Width Columns
	NumAttr *int64
	// Draw Line Between Columns
	SepAttr *sharedTypes.ST_OnOff
	// Single Column Definition
	Col []*CT_Column
}

func NewCT_Columns ¶ 

func NewCT_Columns() *CT_Columns

func (*CT_Columns) MarshalXML ¶ 

func (m *CT_Columns) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Columns) UnmarshalXML ¶ 

func (m *CT_Columns) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Columns) Validate ¶ 

func (m *CT_Columns) Validate() error

Validate validates the CT_Columns and its children

func (*CT_Columns) ValidateWithPath ¶ 

func (m *CT_Columns) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Columns and its children, prefixing error messages with path

type CT_Comment ¶ 

type CT_Comment struct {
	InitialsAttr *string
	AuthorAttr   string
	DateAttr     *time.Time
	// Annotation Identifier
	IdAttr            int64
	EG_BlockLevelElts []*EG_BlockLevelElts
}

func NewCT_Comment ¶ 

func NewCT_Comment() *CT_Comment

func (*CT_Comment) MarshalXML ¶ 

func (m *CT_Comment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Comment) UnmarshalXML ¶ 

func (m *CT_Comment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Comment) Validate ¶ 

func (m *CT_Comment) Validate() error

Validate validates the CT_Comment and its children

func (*CT_Comment) ValidateWithPath ¶ 

func (m *CT_Comment) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Comment and its children, prefixing error messages with path

type CT_Comments ¶ 

type CT_Comments struct {
	// Comment Content
	Comment []*CT_Comment
}

func NewCT_Comments ¶ 

func NewCT_Comments() *CT_Comments

func (*CT_Comments) MarshalXML ¶ 

func (m *CT_Comments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Comments) UnmarshalXML ¶ 

func (m *CT_Comments) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Comments) Validate ¶ 

func (m *CT_Comments) Validate() error

Validate validates the CT_Comments and its children

func (*CT_Comments) ValidateWithPath ¶ 

func (m *CT_Comments) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Comments and its children, prefixing error messages with path

type CT_Compat ¶ 

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 ¶ 

func NewCT_Compat() *CT_Compat

func (*CT_Compat) MarshalXML ¶ 

func (m *CT_Compat) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Compat) UnmarshalXML ¶ 

func (m *CT_Compat) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Compat) Validate ¶ 

func (m *CT_Compat) Validate() error

Validate validates the CT_Compat and its children

func (*CT_Compat) ValidateWithPath ¶ 

func (m *CT_Compat) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Compat and its children, prefixing error messages with path

type CT_CompatSetting ¶ 

type CT_CompatSetting struct {
	// Name of Setting
	NameAttr *string
	// Namespace of Setting
	UriAttr *string
	// Value of Setting
	ValAttr *string
}

func NewCT_CompatSetting ¶ 

func NewCT_CompatSetting() *CT_CompatSetting

func (*CT_CompatSetting) MarshalXML ¶ 

func (m *CT_CompatSetting) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CompatSetting) UnmarshalXML ¶ 

func (m *CT_CompatSetting) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CompatSetting) Validate ¶ 

func (m *CT_CompatSetting) Validate() error

Validate validates the CT_CompatSetting and its children

func (*CT_CompatSetting) ValidateWithPath ¶ 

func (m *CT_CompatSetting) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CompatSetting and its children, prefixing error messages with path

type CT_Control ¶ 

type CT_Control struct {
	// Unique Name for Embedded Control
	NameAttr *string
	// Shape Reference
	ShapeidAttr *string
	IdAttr      *string
}

func NewCT_Control ¶ 

func NewCT_Control() *CT_Control

func (*CT_Control) MarshalXML ¶ 

func (m *CT_Control) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Control) UnmarshalXML ¶ 

func (m *CT_Control) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Control) Validate ¶ 

func (m *CT_Control) Validate() error

Validate validates the CT_Control and its children

func (*CT_Control) ValidateWithPath ¶ 

func (m *CT_Control) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Control and its children, prefixing error messages with path

type CT_CustomXmlBlock ¶ 

type CT_CustomXmlBlock struct {
	// Custom XML Element Namespace
	UriAttr *string
	// Custom XML Element Name
	ElementAttr string
	// Custom XML Element Properties
	CustomXmlPr            *CT_CustomXmlPr
	EG_ContentBlockContent []*EG_ContentBlockContent
}

func NewCT_CustomXmlBlock ¶ 

func NewCT_CustomXmlBlock() *CT_CustomXmlBlock

func (*CT_CustomXmlBlock) MarshalXML ¶ 

func (m *CT_CustomXmlBlock) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CustomXmlBlock) UnmarshalXML ¶ 

func (m *CT_CustomXmlBlock) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CustomXmlBlock) Validate ¶ 

func (m *CT_CustomXmlBlock) Validate() error

Validate validates the CT_CustomXmlBlock and its children

func (*CT_CustomXmlBlock) ValidateWithPath ¶ 

func (m *CT_CustomXmlBlock) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CustomXmlBlock and its children, prefixing error messages with path

type CT_CustomXmlCell ¶ 

type CT_CustomXmlCell struct {
	// Custom XML Element Namespace
	UriAttr *string
	// Custom XML Element Name
	ElementAttr string
	// Custom XML Element Properties
	CustomXmlPr           *CT_CustomXmlPr
	EG_ContentCellContent []*EG_ContentCellContent
}

func NewCT_CustomXmlCell ¶ 

func NewCT_CustomXmlCell() *CT_CustomXmlCell

func (*CT_CustomXmlCell) MarshalXML ¶ 

func (m *CT_CustomXmlCell) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CustomXmlCell) UnmarshalXML ¶ 

func (m *CT_CustomXmlCell) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CustomXmlCell) Validate ¶ 

func (m *CT_CustomXmlCell) Validate() error

Validate validates the CT_CustomXmlCell and its children

func (*CT_CustomXmlCell) ValidateWithPath ¶ 

func (m *CT_CustomXmlCell) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CustomXmlCell and its children, prefixing error messages with path

type CT_CustomXmlPr ¶ 

type CT_CustomXmlPr struct {
	// Custom XML Element Placeholder Text
	Placeholder *CT_String
	// Custom XML Attribute
	Attr []*CT_Attr
}

func NewCT_CustomXmlPr ¶ 

func NewCT_CustomXmlPr() *CT_CustomXmlPr

func (*CT_CustomXmlPr) MarshalXML ¶ 

func (m *CT_CustomXmlPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CustomXmlPr) UnmarshalXML ¶ 

func (m *CT_CustomXmlPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CustomXmlPr) Validate ¶ 

func (m *CT_CustomXmlPr) Validate() error

Validate validates the CT_CustomXmlPr and its children

func (*CT_CustomXmlPr) ValidateWithPath ¶ 

func (m *CT_CustomXmlPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CustomXmlPr and its children, prefixing error messages with path

type CT_CustomXmlRow ¶ 

type CT_CustomXmlRow struct {
	// Custom XML Element Namespace
	UriAttr *string
	// Custom XML Element Name
	ElementAttr string
	// Custom XML Element Properties
	CustomXmlPr          *CT_CustomXmlPr
	EG_ContentRowContent []*EG_ContentRowContent
}

func NewCT_CustomXmlRow ¶ 

func NewCT_CustomXmlRow() *CT_CustomXmlRow

func (*CT_CustomXmlRow) MarshalXML ¶ 

func (m *CT_CustomXmlRow) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CustomXmlRow) UnmarshalXML ¶ 

func (m *CT_CustomXmlRow) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CustomXmlRow) Validate ¶ 

func (m *CT_CustomXmlRow) Validate() error

Validate validates the CT_CustomXmlRow and its children

func (*CT_CustomXmlRow) ValidateWithPath ¶ 

func (m *CT_CustomXmlRow) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CustomXmlRow and its children, prefixing error messages with path

type CT_CustomXmlRun ¶ 

type CT_CustomXmlRun struct {
	// Custom XML Markup Namespace
	UriAttr *string
	// Element name
	ElementAttr string
	// Custom XML Element Properties
	CustomXmlPr *CT_CustomXmlPr
	EG_PContent []*EG_PContent
}

func NewCT_CustomXmlRun ¶ 

func NewCT_CustomXmlRun() *CT_CustomXmlRun

func (*CT_CustomXmlRun) MarshalXML ¶ 

func (m *CT_CustomXmlRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_CustomXmlRun) UnmarshalXML ¶ 

func (m *CT_CustomXmlRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_CustomXmlRun) Validate ¶ 

func (m *CT_CustomXmlRun) Validate() error

Validate validates the CT_CustomXmlRun and its children

func (*CT_CustomXmlRun) ValidateWithPath ¶ 

func (m *CT_CustomXmlRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CustomXmlRun and its children, prefixing error messages with path

type CT_DataBinding ¶ 

type CT_DataBinding struct {
	// XML Namespace Prefix Mappings
	PrefixMappingsAttr *string
	// XPath
	XpathAttr string
	// Custom XML Data Storage ID
	StoreItemIDAttr string
}

func NewCT_DataBinding ¶ 

func NewCT_DataBinding() *CT_DataBinding

func (*CT_DataBinding) MarshalXML ¶ 

func (m *CT_DataBinding) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DataBinding) UnmarshalXML ¶ 

func (m *CT_DataBinding) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DataBinding) Validate ¶ 

func (m *CT_DataBinding) Validate() error

Validate validates the CT_DataBinding and its children

func (*CT_DataBinding) ValidateWithPath ¶ 

func (m *CT_DataBinding) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DataBinding and its children, prefixing error messages with path

type CT_DecimalNumber ¶ 

type CT_DecimalNumber struct {
	// Decimal Number Value
	ValAttr int64
}

func NewCT_DecimalNumber ¶ 

func NewCT_DecimalNumber() *CT_DecimalNumber

func (*CT_DecimalNumber) MarshalXML ¶ 

func (m *CT_DecimalNumber) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DecimalNumber) UnmarshalXML ¶ 

func (m *CT_DecimalNumber) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DecimalNumber) Validate ¶ 

func (m *CT_DecimalNumber) Validate() error

Validate validates the CT_DecimalNumber and its children

func (*CT_DecimalNumber) ValidateWithPath ¶ 

func (m *CT_DecimalNumber) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DecimalNumber and its children, prefixing error messages with path

type CT_DecimalNumberOrPrecent ¶ 

type CT_DecimalNumberOrPrecent struct {
	// Value in Percent
	ValAttr ST_DecimalNumberOrPercent
}

func NewCT_DecimalNumberOrPrecent ¶ 

func NewCT_DecimalNumberOrPrecent() *CT_DecimalNumberOrPrecent

func (*CT_DecimalNumberOrPrecent) MarshalXML ¶ 

func (m *CT_DecimalNumberOrPrecent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DecimalNumberOrPrecent) UnmarshalXML ¶ 

func (m *CT_DecimalNumberOrPrecent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DecimalNumberOrPrecent) Validate ¶ 

func (m *CT_DecimalNumberOrPrecent) Validate() error

Validate validates the CT_DecimalNumberOrPrecent and its children

func (*CT_DecimalNumberOrPrecent) ValidateWithPath ¶ 

func (m *CT_DecimalNumberOrPrecent) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DecimalNumberOrPrecent and its children, prefixing error messages with path

type CT_DirContentRun ¶ 

type CT_DirContentRun struct {
	// Direction of Embedding
	ValAttr ST_Direction
	// Simple Field
	FldSimple []*CT_SimpleField
	// Hyperlink
	Hyperlink *CT_Hyperlink
	// Anchor for Subdocument Location
	SubDoc               *CT_Rel
	EG_ContentRunContent []*EG_ContentRunContent
}

func NewCT_DirContentRun ¶ 

func NewCT_DirContentRun() *CT_DirContentRun

func (*CT_DirContentRun) MarshalXML ¶ 

func (m *CT_DirContentRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DirContentRun) UnmarshalXML ¶ 

func (m *CT_DirContentRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DirContentRun) Validate ¶ 

func (m *CT_DirContentRun) Validate() error

Validate validates the CT_DirContentRun and its children

func (*CT_DirContentRun) ValidateWithPath ¶ 

func (m *CT_DirContentRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DirContentRun and its children, prefixing error messages with path

type CT_Div ¶ 

type CT_Div struct {
	// div Data ID
	IdAttr int64
	// Data for HTML blockquote Element
	BlockQuote *CT_OnOff
	// Data for HTML body Element
	BodyDiv *CT_OnOff
	// Left Margin for HTML div
	MarLeft *CT_SignedTwipsMeasure
	// Right Margin for HTML div
	MarRight *CT_SignedTwipsMeasure
	// Top Margin for HTML div
	MarTop *CT_SignedTwipsMeasure
	// Bottom Margin for HTML div
	MarBottom *CT_SignedTwipsMeasure
	// Set of Borders for HTML div
	DivBdr *CT_DivBdr
	// Child div Elements Contained within Current div
	DivsChild []*CT_Divs
}

func NewCT_Div ¶ 

func NewCT_Div() *CT_Div

func (*CT_Div) MarshalXML ¶ 

func (m *CT_Div) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Div) UnmarshalXML ¶ 

func (m *CT_Div) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Div) Validate ¶ 

func (m *CT_Div) Validate() error

Validate validates the CT_Div and its children

func (*CT_Div) ValidateWithPath ¶ 

func (m *CT_Div) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Div and its children, prefixing error messages with path

type CT_DivBdr ¶ 

type CT_DivBdr struct {
	// Top Border for HTML div
	Top *CT_Border
	// Left Border for HTML div
	Left *CT_Border
	// Bottom Border for HTML div
	Bottom *CT_Border
	// Right Border for HTML div
	Right *CT_Border
}

func NewCT_DivBdr ¶ 

func NewCT_DivBdr() *CT_DivBdr

func (*CT_DivBdr) MarshalXML ¶ 

func (m *CT_DivBdr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DivBdr) UnmarshalXML ¶ 

func (m *CT_DivBdr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DivBdr) Validate ¶ 

func (m *CT_DivBdr) Validate() error

Validate validates the CT_DivBdr and its children

func (*CT_DivBdr) ValidateWithPath ¶ 

func (m *CT_DivBdr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DivBdr and its children, prefixing error messages with path

type CT_Divs ¶ 

type CT_Divs struct {
	// Information About Single HTML div Element
	Div []*CT_Div
}

func NewCT_Divs ¶ 

func NewCT_Divs() *CT_Divs

func (*CT_Divs) MarshalXML ¶ 

func (m *CT_Divs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Divs) UnmarshalXML ¶ 

func (m *CT_Divs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Divs) Validate ¶ 

func (m *CT_Divs) Validate() error

Validate validates the CT_Divs and its children

func (*CT_Divs) ValidateWithPath ¶ 

func (m *CT_Divs) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Divs and its children, prefixing error messages with path

type CT_DocDefaults ¶ 

type CT_DocDefaults struct {
	// Default Run Properties
	RPrDefault *CT_RPrDefault
	// Default Paragraph Properties
	PPrDefault *CT_PPrDefault
}

func NewCT_DocDefaults ¶ 

func NewCT_DocDefaults() *CT_DocDefaults

func (*CT_DocDefaults) MarshalXML ¶ 

func (m *CT_DocDefaults) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocDefaults) UnmarshalXML ¶ 

func (m *CT_DocDefaults) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocDefaults) Validate ¶ 

func (m *CT_DocDefaults) Validate() error

Validate validates the CT_DocDefaults and its children

func (*CT_DocDefaults) ValidateWithPath ¶ 

func (m *CT_DocDefaults) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocDefaults and its children, prefixing error messages with path

type CT_DocGrid ¶ 

type CT_DocGrid struct {
	// Document Grid Type
	TypeAttr ST_DocGrid
	// Document Grid Line Pitch
	LinePitchAttr *int64
	// Document Grid Character Pitch
	CharSpaceAttr *int64
}

func NewCT_DocGrid ¶ 

func NewCT_DocGrid() *CT_DocGrid

func (*CT_DocGrid) MarshalXML ¶ 

func (m *CT_DocGrid) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocGrid) UnmarshalXML ¶ 

func (m *CT_DocGrid) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocGrid) Validate ¶ 

func (m *CT_DocGrid) Validate() error

Validate validates the CT_DocGrid and its children

func (*CT_DocGrid) ValidateWithPath ¶ 

func (m *CT_DocGrid) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocGrid and its children, prefixing error messages with path

type CT_DocPart ¶ 

type CT_DocPart struct {
	// Glossary Document Entry Properties
	DocPartPr *CT_DocPartPr
	// Contents of Glossary Document Entry
	DocPartBody *CT_Body
}

func NewCT_DocPart ¶ 

func NewCT_DocPart() *CT_DocPart

func (*CT_DocPart) MarshalXML ¶ 

func (m *CT_DocPart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPart) UnmarshalXML ¶ 

func (m *CT_DocPart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPart) Validate ¶ 

func (m *CT_DocPart) Validate() error

Validate validates the CT_DocPart and its children

func (*CT_DocPart) ValidateWithPath ¶ 

func (m *CT_DocPart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPart and its children, prefixing error messages with path

type CT_DocPartBehavior ¶ 

type CT_DocPartBehavior struct {
	// Insertion Behavior Value
	ValAttr ST_DocPartBehavior
}

func NewCT_DocPartBehavior ¶ 

func NewCT_DocPartBehavior() *CT_DocPartBehavior

func (*CT_DocPartBehavior) MarshalXML ¶ 

func (m *CT_DocPartBehavior) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartBehavior) UnmarshalXML ¶ 

func (m *CT_DocPartBehavior) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartBehavior) Validate ¶ 

func (m *CT_DocPartBehavior) Validate() error

Validate validates the CT_DocPartBehavior and its children

func (*CT_DocPartBehavior) ValidateWithPath ¶ 

func (m *CT_DocPartBehavior) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartBehavior and its children, prefixing error messages with path

type CT_DocPartBehaviors ¶ 

type CT_DocPartBehaviors struct {
	// Entry Insertion Behavior
	Behavior []*CT_DocPartBehavior
}

func NewCT_DocPartBehaviors ¶ 

func NewCT_DocPartBehaviors() *CT_DocPartBehaviors

func (*CT_DocPartBehaviors) MarshalXML ¶ 

func (m *CT_DocPartBehaviors) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartBehaviors) UnmarshalXML ¶ 

func (m *CT_DocPartBehaviors) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartBehaviors) Validate ¶ 

func (m *CT_DocPartBehaviors) Validate() error

Validate validates the CT_DocPartBehaviors and its children

func (*CT_DocPartBehaviors) ValidateWithPath ¶ 

func (m *CT_DocPartBehaviors) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartBehaviors and its children, prefixing error messages with path

type CT_DocPartCategory ¶ 

type CT_DocPartCategory struct {
	// Category Associated With Entry
	Name *CT_String
	// Gallery Associated With Entry
	Gallery *CT_DocPartGallery
}

func NewCT_DocPartCategory ¶ 

func NewCT_DocPartCategory() *CT_DocPartCategory

func (*CT_DocPartCategory) MarshalXML ¶ 

func (m *CT_DocPartCategory) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartCategory) UnmarshalXML ¶ 

func (m *CT_DocPartCategory) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartCategory) Validate ¶ 

func (m *CT_DocPartCategory) Validate() error

Validate validates the CT_DocPartCategory and its children

func (*CT_DocPartCategory) ValidateWithPath ¶ 

func (m *CT_DocPartCategory) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartCategory and its children, prefixing error messages with path

type CT_DocPartGallery ¶ 

type CT_DocPartGallery struct {
	// Gallery Value
	ValAttr ST_DocPartGallery
}

func NewCT_DocPartGallery ¶ 

func NewCT_DocPartGallery() *CT_DocPartGallery

func (*CT_DocPartGallery) MarshalXML ¶ 

func (m *CT_DocPartGallery) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartGallery) UnmarshalXML ¶ 

func (m *CT_DocPartGallery) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartGallery) Validate ¶ 

func (m *CT_DocPartGallery) Validate() error

Validate validates the CT_DocPartGallery and its children

func (*CT_DocPartGallery) ValidateWithPath ¶ 

func (m *CT_DocPartGallery) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartGallery and its children, prefixing error messages with path

type CT_DocPartName ¶ 

type CT_DocPartName struct {
	// Name Value
	ValAttr string
	// Built-In Entry
	DecoratedAttr *sharedTypes.ST_OnOff
}

func NewCT_DocPartName ¶ 

func NewCT_DocPartName() *CT_DocPartName

func (*CT_DocPartName) MarshalXML ¶ 

func (m *CT_DocPartName) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartName) UnmarshalXML ¶ 

func (m *CT_DocPartName) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartName) Validate ¶ 

func (m *CT_DocPartName) Validate() error

Validate validates the CT_DocPartName and its children

func (*CT_DocPartName) ValidateWithPath ¶ 

func (m *CT_DocPartName) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartName and its children, prefixing error messages with path

type CT_DocPartPr ¶ 

type CT_DocPartPr struct {
	// Entry Name
	Name *CT_DocPartName
	// Associated Paragraph Style Name
	Style *CT_String
	// Entry Categorization
	Category *CT_DocPartCategory
	// Entry Types
	Types *CT_DocPartTypes
	// Entry Insertion Behaviors
	Behaviors *CT_DocPartBehaviors
	// Description for Entry
	Description *CT_String
	// Entry ID
	Guid *CT_Guid
}

func NewCT_DocPartPr ¶ 

func NewCT_DocPartPr() *CT_DocPartPr

func (*CT_DocPartPr) MarshalXML ¶ 

func (m *CT_DocPartPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartPr) UnmarshalXML ¶ 

func (m *CT_DocPartPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartPr) Validate ¶ 

func (m *CT_DocPartPr) Validate() error

Validate validates the CT_DocPartPr and its children

func (*CT_DocPartPr) ValidateWithPath ¶ 

func (m *CT_DocPartPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartPr and its children, prefixing error messages with path

type CT_DocPartType ¶ 

type CT_DocPartType struct {
	// Type Value
	ValAttr ST_DocPartType
}

func NewCT_DocPartType ¶ 

func NewCT_DocPartType() *CT_DocPartType

func (*CT_DocPartType) MarshalXML ¶ 

func (m *CT_DocPartType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartType) UnmarshalXML ¶ 

func (m *CT_DocPartType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartType) Validate ¶ 

func (m *CT_DocPartType) Validate() error

Validate validates the CT_DocPartType and its children

func (*CT_DocPartType) ValidateWithPath ¶ 

func (m *CT_DocPartType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartType and its children, prefixing error messages with path

type CT_DocPartTypes ¶ 

type CT_DocPartTypes struct {
	// Entry Is Of All Types
	AllAttr *sharedTypes.ST_OnOff
	// Entry Type
	Type []*CT_DocPartType
}

func NewCT_DocPartTypes ¶ 

func NewCT_DocPartTypes() *CT_DocPartTypes

func (*CT_DocPartTypes) MarshalXML ¶ 

func (m *CT_DocPartTypes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocPartTypes) UnmarshalXML ¶ 

func (m *CT_DocPartTypes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocPartTypes) Validate ¶ 

func (m *CT_DocPartTypes) Validate() error

Validate validates the CT_DocPartTypes and its children

func (*CT_DocPartTypes) ValidateWithPath ¶ 

func (m *CT_DocPartTypes) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocPartTypes and its children, prefixing error messages with path

type CT_DocParts ¶ 

type CT_DocParts struct {
	// Glossary Document Entry
	DocPart []*CT_DocPart
}

func NewCT_DocParts ¶ 

func NewCT_DocParts() *CT_DocParts

func (*CT_DocParts) MarshalXML ¶ 

func (m *CT_DocParts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocParts) UnmarshalXML ¶ 

func (m *CT_DocParts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocParts) Validate ¶ 

func (m *CT_DocParts) Validate() error

Validate validates the CT_DocParts and its children

func (*CT_DocParts) ValidateWithPath ¶ 

func (m *CT_DocParts) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocParts and its children, prefixing error messages with path

type CT_DocProtect ¶ 

type CT_DocProtect struct {
	// Document Editing Restrictions
	EditAttr ST_DocProtect
	// Only Allow Formatting With Unlocked Styles
	FormattingAttr *sharedTypes.ST_OnOff
	// Enforce Document Protection Settings
	EnforcementAttr                *sharedTypes.ST_OnOff
	AlgorithmNameAttr              *string
	HashValueAttr                  *string
	SaltValueAttr                  *string
	SpinCountAttr                  *int64
	CryptProviderTypeAttr          sharedTypes.ST_CryptProv
	CryptAlgorithmClassAttr        sharedTypes.ST_AlgClass
	CryptAlgorithmTypeAttr         sharedTypes.ST_AlgType
	CryptAlgorithmSidAttr          *int64
	CryptSpinCountAttr             *int64
	CryptProviderAttr              *string
	AlgIdExtAttr                   *string
	AlgIdExtSourceAttr             *string
	CryptProviderTypeExtAttr       *string
	CryptProviderTypeExtSourceAttr *string
	HashAttr                       *string
	SaltAttr                       *string
}

func NewCT_DocProtect ¶ 

func NewCT_DocProtect() *CT_DocProtect

func (*CT_DocProtect) MarshalXML ¶ 

func (m *CT_DocProtect) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocProtect) UnmarshalXML ¶ 

func (m *CT_DocProtect) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocProtect) Validate ¶ 

func (m *CT_DocProtect) Validate() error

Validate validates the CT_DocProtect and its children

func (*CT_DocProtect) ValidateWithPath ¶ 

func (m *CT_DocProtect) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocProtect and its children, prefixing error messages with path

type CT_DocRsids ¶ 

type CT_DocRsids struct {
	// Original Document Revision Save ID
	RsidRoot *CT_LongHexNumber
	// Single Session Revision Save ID
	Rsid []*CT_LongHexNumber
}

func NewCT_DocRsids ¶ 

func NewCT_DocRsids() *CT_DocRsids

func (*CT_DocRsids) MarshalXML ¶ 

func (m *CT_DocRsids) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocRsids) UnmarshalXML ¶ 

func (m *CT_DocRsids) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocRsids) Validate ¶ 

func (m *CT_DocRsids) Validate() error

Validate validates the CT_DocRsids and its children

func (*CT_DocRsids) ValidateWithPath ¶ 

func (m *CT_DocRsids) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocRsids and its children, prefixing error messages with path

type CT_DocType ¶ 

type CT_DocType struct {
	// Document Classification Value
	ValAttr string
}

func NewCT_DocType ¶ 

func NewCT_DocType() *CT_DocType

func (*CT_DocType) MarshalXML ¶ 

func (m *CT_DocType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocType) UnmarshalXML ¶ 

func (m *CT_DocType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocType) Validate ¶ 

func (m *CT_DocType) Validate() error

Validate validates the CT_DocType and its children

func (*CT_DocType) ValidateWithPath ¶ 

func (m *CT_DocType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocType and its children, prefixing error messages with path

type CT_DocVar ¶ 

type CT_DocVar struct {
	// Document Variable Name
	NameAttr string
	// Document Variable Value
	ValAttr string
}

func NewCT_DocVar ¶ 

func NewCT_DocVar() *CT_DocVar

func (*CT_DocVar) MarshalXML ¶ 

func (m *CT_DocVar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocVar) UnmarshalXML ¶ 

func (m *CT_DocVar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocVar) Validate ¶ 

func (m *CT_DocVar) Validate() error

Validate validates the CT_DocVar and its children

func (*CT_DocVar) ValidateWithPath ¶ 

func (m *CT_DocVar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocVar and its children, prefixing error messages with path

type CT_DocVars ¶ 

type CT_DocVars struct {
	// Single Document Variable
	DocVar []*CT_DocVar
}

func NewCT_DocVars ¶ 

func NewCT_DocVars() *CT_DocVars

func (*CT_DocVars) MarshalXML ¶ 

func (m *CT_DocVars) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocVars) UnmarshalXML ¶ 

func (m *CT_DocVars) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocVars) Validate ¶ 

func (m *CT_DocVars) Validate() error

Validate validates the CT_DocVars and its children

func (*CT_DocVars) ValidateWithPath ¶ 

func (m *CT_DocVars) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocVars and its children, prefixing error messages with path

type CT_Document ¶ 

type CT_Document struct {
	ConformanceAttr sharedTypes.ST_ConformanceClass
	// Document Background
	Background *CT_Background
	Body       *CT_Body
}

func NewCT_Document ¶ 

func NewCT_Document() *CT_Document

func (*CT_Document) MarshalXML ¶ 

func (m *CT_Document) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Document) UnmarshalXML ¶ 

func (m *CT_Document) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Document) Validate ¶ 

func (m *CT_Document) Validate() error

Validate validates the CT_Document and its children

func (*CT_Document) ValidateWithPath ¶ 

func (m *CT_Document) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Document and its children, prefixing error messages with path

type CT_DocumentBase ¶ 

type CT_DocumentBase struct {
	// Document Background
	Background *CT_Background
}

func NewCT_DocumentBase ¶ 

func NewCT_DocumentBase() *CT_DocumentBase

func (*CT_DocumentBase) MarshalXML ¶ 

func (m *CT_DocumentBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_DocumentBase) UnmarshalXML ¶ 

func (m *CT_DocumentBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_DocumentBase) Validate ¶ 

func (m *CT_DocumentBase) Validate() error

Validate validates the CT_DocumentBase and its children

func (*CT_DocumentBase) ValidateWithPath ¶ 

func (m *CT_DocumentBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DocumentBase and its children, prefixing error messages with path

type CT_Drawing ¶ 

type CT_Drawing struct {
	Anchor []*WdAnchor
	Inline []*WdInline
}

func NewCT_Drawing ¶ 

func NewCT_Drawing() *CT_Drawing

func (*CT_Drawing) MarshalXML ¶ 

func (m *CT_Drawing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Drawing) UnmarshalXML ¶ 

func (m *CT_Drawing) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Drawing) Validate ¶ 

func (m *CT_Drawing) Validate() error

Validate validates the CT_Drawing and its children

func (*CT_Drawing) ValidateWithPath ¶ 

func (m *CT_Drawing) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Drawing and its children, prefixing error messages with path

type CT_EastAsianLayout ¶ 

type CT_EastAsianLayout struct {
	// East Asian Typography Run ID
	IdAttr *int64
	// Two Lines in One
	CombineAttr *sharedTypes.ST_OnOff
	// Display Brackets Around Two Lines in One
	CombineBracketsAttr ST_CombineBrackets
	// Horizontal in Vertical (Rotate Text)
	VertAttr *sharedTypes.ST_OnOff
	// Compress Rotated Text to Line Height
	VertCompressAttr *sharedTypes.ST_OnOff
}

func NewCT_EastAsianLayout ¶ 

func NewCT_EastAsianLayout() *CT_EastAsianLayout

func (*CT_EastAsianLayout) MarshalXML ¶ 

func (m *CT_EastAsianLayout) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_EastAsianLayout) UnmarshalXML ¶ 

func (m *CT_EastAsianLayout) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_EastAsianLayout) Validate ¶ 

func (m *CT_EastAsianLayout) Validate() error

Validate validates the CT_EastAsianLayout and its children

func (*CT_EastAsianLayout) ValidateWithPath ¶ 

func (m *CT_EastAsianLayout) ValidateWithPath(path string) error

ValidateWithPath validates the CT_EastAsianLayout and its children, prefixing error messages with path

type CT_EdnDocProps ¶ 

type CT_EdnDocProps struct {
	// Endnote Placement
	Pos *CT_EdnPos
	// Endnote Numbering Format
	NumFmt *CT_NumFmt
	// Footnote and Endnote Numbering Starting Value
	NumStart *CT_DecimalNumber
	// Footnote and Endnote Numbering Restart Location
	NumRestart *CT_NumRestart
	Endnote    []*CT_FtnEdnSepRef
}

func NewCT_EdnDocProps ¶ 

func NewCT_EdnDocProps() *CT_EdnDocProps

func (*CT_EdnDocProps) MarshalXML ¶ 

func (m *CT_EdnDocProps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_EdnDocProps) UnmarshalXML ¶ 

func (m *CT_EdnDocProps) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_EdnDocProps) Validate ¶ 

func (m *CT_EdnDocProps) Validate() error

Validate validates the CT_EdnDocProps and its children

func (*CT_EdnDocProps) ValidateWithPath ¶ 

func (m *CT_EdnDocProps) ValidateWithPath(path string) error

ValidateWithPath validates the CT_EdnDocProps and its children, prefixing error messages with path

type CT_EdnPos ¶ 

type CT_EdnPos struct {
	// Endnote Position Type
	ValAttr ST_EdnPos
}

func NewCT_EdnPos ¶ 

func NewCT_EdnPos() *CT_EdnPos

func (*CT_EdnPos) MarshalXML ¶ 

func (m *CT_EdnPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_EdnPos) UnmarshalXML ¶ 

func (m *CT_EdnPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_EdnPos) Validate ¶ 

func (m *CT_EdnPos) Validate() error

Validate validates the CT_EdnPos and its children

func (*CT_EdnPos) ValidateWithPath ¶ 

func (m *CT_EdnPos) ValidateWithPath(path string) error

ValidateWithPath validates the CT_EdnPos and its children, prefixing error messages with path

type CT_EdnProps ¶ 

type CT_EdnProps struct {
	// Endnote Placement
	Pos *CT_EdnPos
	// Endnote Numbering Format
	NumFmt *CT_NumFmt
	// Footnote and Endnote Numbering Starting Value
	NumStart *CT_DecimalNumber
	// Footnote and Endnote Numbering Restart Location
	NumRestart *CT_NumRestart
}

func NewCT_EdnProps ¶ 

func NewCT_EdnProps() *CT_EdnProps

func (*CT_EdnProps) MarshalXML ¶ 

func (m *CT_EdnProps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_EdnProps) UnmarshalXML ¶ 

func (m *CT_EdnProps) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_EdnProps) Validate ¶ 

func (m *CT_EdnProps) Validate() error

Validate validates the CT_EdnProps and its children

func (*CT_EdnProps) ValidateWithPath ¶ 

func (m *CT_EdnProps) ValidateWithPath(path string) error

ValidateWithPath validates the CT_EdnProps and its children, prefixing error messages with path

type CT_Em ¶ 

type CT_Em struct {
	// Emphasis Mark Type
	ValAttr ST_Em
}

func NewCT_Em ¶ 

func NewCT_Em() *CT_Em

func (*CT_Em) MarshalXML ¶ 

func (m *CT_Em) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Em) UnmarshalXML ¶ 

func (m *CT_Em) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Em) Validate ¶ 

func (m *CT_Em) Validate() error

Validate validates the CT_Em and its children

func (*CT_Em) ValidateWithPath ¶ 

func (m *CT_Em) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Em and its children, prefixing error messages with path

type CT_Empty ¶ 

type CT_Empty struct {
}

func NewCT_Empty ¶ 

func NewCT_Empty() *CT_Empty

func (*CT_Empty) MarshalXML ¶ 

func (m *CT_Empty) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Empty) UnmarshalXML ¶ 

func (m *CT_Empty) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Empty) Validate ¶ 

func (m *CT_Empty) Validate() error

Validate validates the CT_Empty and its children

func (*CT_Empty) ValidateWithPath ¶ 

func (m *CT_Empty) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Empty and its children, prefixing error messages with path

type CT_Endnotes ¶ 

type CT_Endnotes struct {
	// Endnote Content
	Endnote []*CT_FtnEdn
}

func NewCT_Endnotes ¶ 

func NewCT_Endnotes() *CT_Endnotes

func (*CT_Endnotes) MarshalXML ¶ 

func (m *CT_Endnotes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Endnotes) UnmarshalXML ¶ 

func (m *CT_Endnotes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Endnotes) Validate ¶ 

func (m *CT_Endnotes) Validate() error

Validate validates the CT_Endnotes and its children

func (*CT_Endnotes) ValidateWithPath ¶ 

func (m *CT_Endnotes) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Endnotes and its children, prefixing error messages with path

type CT_FFCheckBox ¶ 

type CT_FFCheckBox struct {
	Choice *CT_FFCheckBoxChoice
	// Default Checkbox Form Field State
	Default *CT_OnOff
	// Checkbox Form Field State
	Checked *CT_OnOff
}

func NewCT_FFCheckBox ¶ 

func NewCT_FFCheckBox() *CT_FFCheckBox

func (*CT_FFCheckBox) MarshalXML ¶ 

func (m *CT_FFCheckBox) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFCheckBox) UnmarshalXML ¶ 

func (m *CT_FFCheckBox) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFCheckBox) Validate ¶ 

func (m *CT_FFCheckBox) Validate() error

Validate validates the CT_FFCheckBox and its children

func (*CT_FFCheckBox) ValidateWithPath ¶ 

func (m *CT_FFCheckBox) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFCheckBox and its children, prefixing error messages with path

type CT_FFCheckBoxChoice ¶ 

type CT_FFCheckBoxChoice struct {
	Size     *CT_HpsMeasure
	SizeAuto *CT_OnOff
}

func NewCT_FFCheckBoxChoice ¶ 

func NewCT_FFCheckBoxChoice() *CT_FFCheckBoxChoice

func (*CT_FFCheckBoxChoice) MarshalXML ¶ 

func (m *CT_FFCheckBoxChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFCheckBoxChoice) UnmarshalXML ¶ 

func (m *CT_FFCheckBoxChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFCheckBoxChoice) Validate ¶ 

func (m *CT_FFCheckBoxChoice) Validate() error

Validate validates the CT_FFCheckBoxChoice and its children

func (*CT_FFCheckBoxChoice) ValidateWithPath ¶ 

func (m *CT_FFCheckBoxChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFCheckBoxChoice and its children, prefixing error messages with path

type CT_FFDDList ¶ 

type CT_FFDDList struct {
	// Drop-Down List Selection
	Result *CT_DecimalNumber
	// Default Drop-Down List Item Index
	Default *CT_DecimalNumber
	// Drop-Down List Entry
	ListEntry []*CT_String
}

func NewCT_FFDDList ¶ 

func NewCT_FFDDList() *CT_FFDDList

func (*CT_FFDDList) MarshalXML ¶ 

func (m *CT_FFDDList) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFDDList) UnmarshalXML ¶ 

func (m *CT_FFDDList) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFDDList) Validate ¶ 

func (m *CT_FFDDList) Validate() error

Validate validates the CT_FFDDList and its children

func (*CT_FFDDList) ValidateWithPath ¶ 

func (m *CT_FFDDList) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFDDList and its children, prefixing error messages with path

type CT_FFData ¶ 

type CT_FFData struct {
	// Form Field Name
	Name []*CT_FFName
	// Form Field Label
	Label []*CT_DecimalNumber
	// Form Field Navigation Order Index
	TabIndex []*CT_UnsignedDecimalNumber
	// Form Field Enabled
	Enabled []*CT_OnOff
	// Recalculate Fields When Current Field Is Modified
	CalcOnExit []*CT_OnOff
	// Script Function to Execute on Form Field Entry
	EntryMacro []*CT_MacroName
	// Script Function to Execute on Form Field Exit
	ExitMacro []*CT_MacroName
	// Associated Help Text
	HelpText []*CT_FFHelpText
	// Associated Status Text
	StatusText []*CT_FFStatusText
	CheckBox   *CT_FFCheckBox
	DdList     *CT_FFDDList
	TextInput  *CT_FFTextInput
}

func NewCT_FFData ¶ 

func NewCT_FFData() *CT_FFData

func (*CT_FFData) MarshalXML ¶ 

func (m *CT_FFData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFData) UnmarshalXML ¶ 

func (m *CT_FFData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFData) Validate ¶ 

func (m *CT_FFData) Validate() error

Validate validates the CT_FFData and its children

func (*CT_FFData) ValidateWithPath ¶ 

func (m *CT_FFData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFData and its children, prefixing error messages with path

type CT_FFHelpText ¶ 

type CT_FFHelpText struct {
	// Help Text Type
	TypeAttr ST_InfoTextType
	// Help Text Value
	ValAttr *string
}

func NewCT_FFHelpText ¶ 

func NewCT_FFHelpText() *CT_FFHelpText

func (*CT_FFHelpText) MarshalXML ¶ 

func (m *CT_FFHelpText) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFHelpText) UnmarshalXML ¶ 

func (m *CT_FFHelpText) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFHelpText) Validate ¶ 

func (m *CT_FFHelpText) Validate() error

Validate validates the CT_FFHelpText and its children

func (*CT_FFHelpText) ValidateWithPath ¶ 

func (m *CT_FFHelpText) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFHelpText and its children, prefixing error messages with path

type CT_FFName ¶ 

type CT_FFName struct {
	// Form Field Name Value
	ValAttr *string
}

func NewCT_FFName ¶ 

func NewCT_FFName() *CT_FFName

func (*CT_FFName) MarshalXML ¶ 

func (m *CT_FFName) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFName) UnmarshalXML ¶ 

func (m *CT_FFName) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFName) Validate ¶ 

func (m *CT_FFName) Validate() error

Validate validates the CT_FFName and its children

func (*CT_FFName) ValidateWithPath ¶ 

func (m *CT_FFName) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFName and its children, prefixing error messages with path

type CT_FFStatusText ¶ 

type CT_FFStatusText struct {
	// Status Text Type
	TypeAttr ST_InfoTextType
	// Status Text Value
	ValAttr *string
}

func NewCT_FFStatusText ¶ 

func NewCT_FFStatusText() *CT_FFStatusText

func (*CT_FFStatusText) MarshalXML ¶ 

func (m *CT_FFStatusText) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFStatusText) UnmarshalXML ¶ 

func (m *CT_FFStatusText) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFStatusText) Validate ¶ 

func (m *CT_FFStatusText) Validate() error

Validate validates the CT_FFStatusText and its children

func (*CT_FFStatusText) ValidateWithPath ¶ 

func (m *CT_FFStatusText) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFStatusText and its children, prefixing error messages with path

type CT_FFTextInput ¶ 

type CT_FFTextInput struct {
	// Text Box Form Field Type
	Type *CT_FFTextType
	// Default Text Box Form Field String
	Default *CT_String
	// Text Box Form Field Maximum Length
	MaxLength *CT_DecimalNumber
	// Text Box Form Field Formatting
	Format *CT_String
}

func NewCT_FFTextInput ¶ 

func NewCT_FFTextInput() *CT_FFTextInput

func (*CT_FFTextInput) MarshalXML ¶ 

func (m *CT_FFTextInput) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFTextInput) UnmarshalXML ¶ 

func (m *CT_FFTextInput) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFTextInput) Validate ¶ 

func (m *CT_FFTextInput) Validate() error

Validate validates the CT_FFTextInput and its children

func (*CT_FFTextInput) ValidateWithPath ¶ 

func (m *CT_FFTextInput) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFTextInput and its children, prefixing error messages with path

type CT_FFTextType ¶ 

type CT_FFTextType struct {
	// Text Box Form Field Type Values
	ValAttr ST_FFTextType
}

func NewCT_FFTextType ¶ 

func NewCT_FFTextType() *CT_FFTextType

func (*CT_FFTextType) MarshalXML ¶ 

func (m *CT_FFTextType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FFTextType) UnmarshalXML ¶ 

func (m *CT_FFTextType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FFTextType) Validate ¶ 

func (m *CT_FFTextType) Validate() error

Validate validates the CT_FFTextType and its children

func (*CT_FFTextType) ValidateWithPath ¶ 

func (m *CT_FFTextType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FFTextType and its children, prefixing error messages with path

type CT_FitText ¶ 

type CT_FitText struct {
	// Value
	ValAttr sharedTypes.ST_TwipsMeasure
	// Fit Text Run ID
	IdAttr *int64
}

func NewCT_FitText ¶ 

func NewCT_FitText() *CT_FitText

func (*CT_FitText) MarshalXML ¶ 

func (m *CT_FitText) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FitText) UnmarshalXML ¶ 

func (m *CT_FitText) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FitText) Validate ¶ 

func (m *CT_FitText) Validate() error

Validate validates the CT_FitText and its children

func (*CT_FitText) ValidateWithPath ¶ 

func (m *CT_FitText) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FitText and its children, prefixing error messages with path

type CT_FldChar ¶ 

type CT_FldChar struct {
	// Field Character Type
	FldCharTypeAttr ST_FldCharType
	// Field Should Not Be Recalculated
	FldLockAttr *sharedTypes.ST_OnOff
	// Field Result Invalidated
	DirtyAttr *sharedTypes.ST_OnOff
	// Custom Field Data
	FldData *CT_Text
	// Form Field Properties
	FfData *CT_FFData
	// Previous Numbering Field Properties
	NumberingChange *CT_TrackChangeNumbering
}

func NewCT_FldChar ¶ 

func NewCT_FldChar() *CT_FldChar

func (*CT_FldChar) MarshalXML ¶ 

func (m *CT_FldChar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FldChar) UnmarshalXML ¶ 

func (m *CT_FldChar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FldChar) Validate ¶ 

func (m *CT_FldChar) Validate() error

Validate validates the CT_FldChar and its children

func (*CT_FldChar) ValidateWithPath ¶ 

func (m *CT_FldChar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FldChar and its children, prefixing error messages with path

type CT_Font ¶ 

type CT_Font struct {
	// Primary Font Name
	NameAttr string
	// Alternate Names for Font
	AltName *CT_String
	// Panose-1 Typeface Classification Number
	Panose1 *CT_Panose
	// Character Set Supported By Font
	Charset *CT_Charset
	// Font Family
	Family *CT_FontFamily
	// Raster or Vector Font
	NotTrueType *CT_OnOff
	// Font Pitch
	Pitch *CT_Pitch
	// Supported Unicode Subranges and Code Pages
	Sig *CT_FontSig
	// Regular Font Style Embedding
	EmbedRegular *CT_FontRel
	// Bold Style Font Style Embedding
	EmbedBold *CT_FontRel
	// Italic Font Style Embedding
	EmbedItalic *CT_FontRel
	// Bold Italic Font Style Embedding
	EmbedBoldItalic *CT_FontRel
}

func NewCT_Font ¶ 

func NewCT_Font() *CT_Font

func (*CT_Font) MarshalXML ¶ 

func (m *CT_Font) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Font) UnmarshalXML ¶ 

func (m *CT_Font) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Font) Validate ¶ 

func (m *CT_Font) Validate() error

Validate validates the CT_Font and its children

func (*CT_Font) ValidateWithPath ¶ 

func (m *CT_Font) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Font and its children, prefixing error messages with path

type CT_FontFamily ¶ 

type CT_FontFamily struct {
	// Font Family Value
	ValAttr ST_FontFamily
}

func NewCT_FontFamily ¶ 

func NewCT_FontFamily() *CT_FontFamily

func (*CT_FontFamily) MarshalXML ¶ 

func (m *CT_FontFamily) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FontFamily) UnmarshalXML ¶ 

func (m *CT_FontFamily) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FontFamily) Validate ¶ 

func (m *CT_FontFamily) Validate() error

Validate validates the CT_FontFamily and its children

func (*CT_FontFamily) ValidateWithPath ¶ 

func (m *CT_FontFamily) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FontFamily and its children, prefixing error messages with path

type CT_FontRel ¶ 

type CT_FontRel struct {
	FontKeyAttr   string
	SubsettedAttr sharedTypes.ST_OnOff
	IdAttr        string
}

func NewCT_FontRel ¶ 

func NewCT_FontRel() *CT_FontRel

func (*CT_FontRel) MarshalXML ¶ 

func (m *CT_FontRel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FontRel) UnmarshalXML ¶ 

func (m *CT_FontRel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FontRel) Validate ¶ 

func (m *CT_FontRel) Validate() error

Validate validates the CT_FontRel and its children

func (*CT_FontRel) ValidateWithPath ¶ 

func (m *CT_FontRel) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FontRel and its children, prefixing error messages with path

type CT_FontSig ¶ 

type CT_FontSig struct {
	// First 32 Bits of Unicode Subset Bitfield
	Usb0Attr string
	// Second 32 Bits of Unicode Subset Bitfield
	Usb1Attr string
	// Third 32 Bits of Unicode Subset Bitfield
	Usb2Attr string
	// Fourth 32 Bits of Unicode Subset Bitfield
	Usb3Attr string
	// Lower 32 Bits of Code Page Bit Field
	Csb0Attr string
	// Upper 32 Bits of Code Page Bit Field
	Csb1Attr string
}

func NewCT_FontSig ¶ 

func NewCT_FontSig() *CT_FontSig

func (*CT_FontSig) MarshalXML ¶ 

func (m *CT_FontSig) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FontSig) UnmarshalXML ¶ 

func (m *CT_FontSig) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FontSig) Validate ¶ 

func (m *CT_FontSig) Validate() error

Validate validates the CT_FontSig and its children

func (*CT_FontSig) ValidateWithPath ¶ 

func (m *CT_FontSig) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FontSig and its children, prefixing error messages with path

type CT_Fonts ¶ 

type CT_Fonts struct {
	// Font Content Type
	HintAttr ST_Hint
	// ASCII Font
	AsciiAttr *string
	// High ANSI Font
	HAnsiAttr *string
	// East Asian Font
	EastAsiaAttr *string
	// Complex Script Font
	CsAttr *string
	// ASCII Theme Font
	AsciiThemeAttr ST_Theme
	// High ANSI Theme Font
	HAnsiThemeAttr ST_Theme
	// East Asian Theme Font
	EastAsiaThemeAttr ST_Theme
	// Complex Script Theme Font
	CsthemeAttr ST_Theme
}

func NewCT_Fonts ¶ 

func NewCT_Fonts() *CT_Fonts

func (*CT_Fonts) MarshalXML ¶ 

func (m *CT_Fonts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Fonts) UnmarshalXML ¶ 

func (m *CT_Fonts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Fonts) Validate ¶ 

func (m *CT_Fonts) Validate() error

Validate validates the CT_Fonts and its children

func (*CT_Fonts) ValidateWithPath ¶ 

func (m *CT_Fonts) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Fonts and its children, prefixing error messages with path

type CT_FontsList ¶ 

type CT_FontsList struct {
	// Properties for a Single Font
	Font []*CT_Font
}

func NewCT_FontsList ¶ 

func NewCT_FontsList() *CT_FontsList

func (*CT_FontsList) MarshalXML ¶ 

func (m *CT_FontsList) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FontsList) UnmarshalXML ¶ 

func (m *CT_FontsList) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FontsList) Validate ¶ 

func (m *CT_FontsList) Validate() error

Validate validates the CT_FontsList and its children

func (*CT_FontsList) ValidateWithPath ¶ 

func (m *CT_FontsList) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FontsList and its children, prefixing error messages with path

type CT_Footnotes ¶ 

type CT_Footnotes struct {
	// Footnote Content
	Footnote []*CT_FtnEdn
}

func NewCT_Footnotes ¶ 

func NewCT_Footnotes() *CT_Footnotes

func (*CT_Footnotes) MarshalXML ¶ 

func (m *CT_Footnotes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Footnotes) UnmarshalXML ¶ 

func (m *CT_Footnotes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Footnotes) Validate ¶ 

func (m *CT_Footnotes) Validate() error

Validate validates the CT_Footnotes and its children

func (*CT_Footnotes) ValidateWithPath ¶ 

func (m *CT_Footnotes) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Footnotes and its children, prefixing error messages with path

type CT_Frame ¶ 

type CT_Frame struct {
	// Frame Size
	Sz *CT_String
	// Frame Name
	Name *CT_String
	// Frame or Frameset Title
	Title *CT_String
	// Frame Long Description
	LongDesc *CT_Rel
	// Source File for Frame
	SourceFileName *CT_Rel
	// Left and Right Margin for Frame
	MarW *CT_PixelsMeasure
	// Top and Bottom Margin for Frame
	MarH *CT_PixelsMeasure
	// Scrollbar Display Option
	Scrollbar *CT_FrameScrollbar
	// Frame Cannot Be Resized
	NoResizeAllowed *CT_OnOff
	// Maintain Link to Existing File
	LinkedToFile *CT_OnOff
}

func NewCT_Frame ¶ 

func NewCT_Frame() *CT_Frame

func (*CT_Frame) MarshalXML ¶ 

func (m *CT_Frame) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Frame) UnmarshalXML ¶ 

func (m *CT_Frame) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Frame) Validate ¶ 

func (m *CT_Frame) Validate() error

Validate validates the CT_Frame and its children

func (*CT_Frame) ValidateWithPath ¶ 

func (m *CT_Frame) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Frame and its children, prefixing error messages with path

type CT_FrameLayout ¶ 

type CT_FrameLayout struct {
	// Frameset Layout Value
	ValAttr ST_FrameLayout
}

func NewCT_FrameLayout ¶ 

func NewCT_FrameLayout() *CT_FrameLayout

func (*CT_FrameLayout) MarshalXML ¶ 

func (m *CT_FrameLayout) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FrameLayout) UnmarshalXML ¶ 

func (m *CT_FrameLayout) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FrameLayout) Validate ¶ 

func (m *CT_FrameLayout) Validate() error

Validate validates the CT_FrameLayout and its children

func (*CT_FrameLayout) ValidateWithPath ¶ 

func (m *CT_FrameLayout) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FrameLayout and its children, prefixing error messages with path

type CT_FramePr ¶ 

type CT_FramePr struct {
	// Drop Cap Frame
	DropCapAttr ST_DropCap
	// Drop Cap Vertical Height in Lines
	LinesAttr *int64
	// Frame Width
	WAttr *sharedTypes.ST_TwipsMeasure
	// Frame Height
	HAttr *sharedTypes.ST_TwipsMeasure
	// Vertical Frame Padding
	VSpaceAttr *sharedTypes.ST_TwipsMeasure
	// Horizontal Frame Padding
	HSpaceAttr *sharedTypes.ST_TwipsMeasure
	// Text Wrapping Around Frame
	WrapAttr ST_Wrap
	// Frame Horizontal Positioning Base
	HAnchorAttr ST_HAnchor
	// Frame Vertical Positioning Base
	VAnchorAttr ST_VAnchor
	// Absolute Horizontal Position
	XAttr *ST_SignedTwipsMeasure
	// Relative Horizontal Position
	XAlignAttr sharedTypes.ST_XAlign
	// Absolute Vertical Position
	YAttr *ST_SignedTwipsMeasure
	// Relative Vertical Position
	YAlignAttr sharedTypes.ST_YAlign
	// Frame Height Type
	HRuleAttr ST_HeightRule
	// Lock Frame Anchor to Paragraph
	AnchorLockAttr *sharedTypes.ST_OnOff
}

func NewCT_FramePr ¶ 

func NewCT_FramePr() *CT_FramePr

func (*CT_FramePr) MarshalXML ¶ 

func (m *CT_FramePr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FramePr) UnmarshalXML ¶ 

func (m *CT_FramePr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FramePr) Validate ¶ 

func (m *CT_FramePr) Validate() error

Validate validates the CT_FramePr and its children

func (*CT_FramePr) ValidateWithPath ¶ 

func (m *CT_FramePr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FramePr and its children, prefixing error messages with path

type CT_FrameScrollbar ¶ 

type CT_FrameScrollbar struct {
	// Scrollbar Display Option Value
	ValAttr ST_FrameScrollbar
}

func NewCT_FrameScrollbar ¶ 

func NewCT_FrameScrollbar() *CT_FrameScrollbar

func (*CT_FrameScrollbar) MarshalXML ¶ 

func (m *CT_FrameScrollbar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FrameScrollbar) UnmarshalXML ¶ 

func (m *CT_FrameScrollbar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FrameScrollbar) Validate ¶ 

func (m *CT_FrameScrollbar) Validate() error

Validate validates the CT_FrameScrollbar and its children

func (*CT_FrameScrollbar) ValidateWithPath ¶ 

func (m *CT_FrameScrollbar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FrameScrollbar and its children, prefixing error messages with path

type CT_Frameset ¶ 

type CT_Frameset struct {
	// Nested Frameset Size
	Sz *CT_String
	// Frameset Splitter Properties
	FramesetSplitbar *CT_FramesetSplitbar
	// Frameset Layout
	FrameLayout *CT_FrameLayout
	Title       *CT_String
	Choice      []*CT_FramesetChoice
}

func NewCT_Frameset ¶ 

func NewCT_Frameset() *CT_Frameset

func (*CT_Frameset) MarshalXML ¶ 

func (m *CT_Frameset) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Frameset) UnmarshalXML ¶ 

func (m *CT_Frameset) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Frameset) Validate ¶ 

func (m *CT_Frameset) Validate() error

Validate validates the CT_Frameset and its children

func (*CT_Frameset) ValidateWithPath ¶ 

func (m *CT_Frameset) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Frameset and its children, prefixing error messages with path

type CT_FramesetChoice ¶ 

type CT_FramesetChoice struct {
	Frameset []*CT_Frameset
	Frame    []*CT_Frame
}

func NewCT_FramesetChoice ¶ 

func NewCT_FramesetChoice() *CT_FramesetChoice

func (*CT_FramesetChoice) MarshalXML ¶ 

func (m *CT_FramesetChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FramesetChoice) UnmarshalXML ¶ 

func (m *CT_FramesetChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FramesetChoice) Validate ¶ 

func (m *CT_FramesetChoice) Validate() error

Validate validates the CT_FramesetChoice and its children

func (*CT_FramesetChoice) ValidateWithPath ¶ 

func (m *CT_FramesetChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FramesetChoice and its children, prefixing error messages with path

type CT_FramesetSplitbar ¶ 

type CT_FramesetSplitbar struct {
	// Frameset Splitter Width
	W *CT_TwipsMeasure
	// Frameset Splitter Color
	Color *CT_Color
	// Do Not Display Frameset Splitters
	NoBorder *CT_OnOff
	// Frameset Splitter Border Style
	FlatBorders *CT_OnOff
}

func NewCT_FramesetSplitbar ¶ 

func NewCT_FramesetSplitbar() *CT_FramesetSplitbar

func (*CT_FramesetSplitbar) MarshalXML ¶ 

func (m *CT_FramesetSplitbar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FramesetSplitbar) UnmarshalXML ¶ 

func (m *CT_FramesetSplitbar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FramesetSplitbar) Validate ¶ 

func (m *CT_FramesetSplitbar) Validate() error

Validate validates the CT_FramesetSplitbar and its children

func (*CT_FramesetSplitbar) ValidateWithPath ¶ 

func (m *CT_FramesetSplitbar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FramesetSplitbar and its children, prefixing error messages with path

type CT_FtnDocProps ¶ 

type CT_FtnDocProps struct {
	// Footnote Placement
	Pos *CT_FtnPos
	// Footnote Numbering Format
	NumFmt *CT_NumFmt
	// Footnote and Endnote Numbering Starting Value
	NumStart *CT_DecimalNumber
	// Footnote and Endnote Numbering Restart Location
	NumRestart *CT_NumRestart
	Footnote   []*CT_FtnEdnSepRef
}

func NewCT_FtnDocProps ¶ 

func NewCT_FtnDocProps() *CT_FtnDocProps

func (*CT_FtnDocProps) MarshalXML ¶ 

func (m *CT_FtnDocProps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FtnDocProps) UnmarshalXML ¶ 

func (m *CT_FtnDocProps) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FtnDocProps) Validate ¶ 

func (m *CT_FtnDocProps) Validate() error

Validate validates the CT_FtnDocProps and its children

func (*CT_FtnDocProps) ValidateWithPath ¶ 

func (m *CT_FtnDocProps) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FtnDocProps and its children, prefixing error messages with path

type CT_FtnEdn ¶ 

type CT_FtnEdn struct {
	// Footnote/Endnote Type
	TypeAttr ST_FtnEdn
	// Footnote/Endnote ID
	IdAttr            int64
	EG_BlockLevelElts []*EG_BlockLevelElts
}

func NewCT_FtnEdn ¶ 

func NewCT_FtnEdn() *CT_FtnEdn

func (*CT_FtnEdn) MarshalXML ¶ 

func (m *CT_FtnEdn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FtnEdn) UnmarshalXML ¶ 

func (m *CT_FtnEdn) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FtnEdn) Validate ¶ 

func (m *CT_FtnEdn) Validate() error

Validate validates the CT_FtnEdn and its children

func (*CT_FtnEdn) ValidateWithPath ¶ 

func (m *CT_FtnEdn) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FtnEdn and its children, prefixing error messages with path

type CT_FtnEdnRef ¶ 

type CT_FtnEdnRef struct {
	// Suppress Footnote/Endnote Reference Mark
	CustomMarkFollowsAttr *sharedTypes.ST_OnOff
	// Footnote/Endnote ID Reference
	IdAttr int64
}

func NewCT_FtnEdnRef ¶ 

func NewCT_FtnEdnRef() *CT_FtnEdnRef

func (*CT_FtnEdnRef) MarshalXML ¶ 

func (m *CT_FtnEdnRef) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FtnEdnRef) UnmarshalXML ¶ 

func (m *CT_FtnEdnRef) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FtnEdnRef) Validate ¶ 

func (m *CT_FtnEdnRef) Validate() error

Validate validates the CT_FtnEdnRef and its children

func (*CT_FtnEdnRef) ValidateWithPath ¶ 

func (m *CT_FtnEdnRef) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FtnEdnRef and its children, prefixing error messages with path

type CT_FtnEdnSepRef ¶ 

type CT_FtnEdnSepRef struct {
	// Footnote/Endnote ID
	IdAttr int64
}

func NewCT_FtnEdnSepRef ¶ 

func NewCT_FtnEdnSepRef() *CT_FtnEdnSepRef

func (*CT_FtnEdnSepRef) MarshalXML ¶ 

func (m *CT_FtnEdnSepRef) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FtnEdnSepRef) UnmarshalXML ¶ 

func (m *CT_FtnEdnSepRef) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FtnEdnSepRef) Validate ¶ 

func (m *CT_FtnEdnSepRef) Validate() error

Validate validates the CT_FtnEdnSepRef and its children

func (*CT_FtnEdnSepRef) ValidateWithPath ¶ 

func (m *CT_FtnEdnSepRef) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FtnEdnSepRef and its children, prefixing error messages with path

type CT_FtnPos ¶ 

type CT_FtnPos struct {
	// Footnote Position Type
	ValAttr ST_FtnPos
}

func NewCT_FtnPos ¶ 

func NewCT_FtnPos() *CT_FtnPos

func (*CT_FtnPos) MarshalXML ¶ 

func (m *CT_FtnPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FtnPos) UnmarshalXML ¶ 

func (m *CT_FtnPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FtnPos) Validate ¶ 

func (m *CT_FtnPos) Validate() error

Validate validates the CT_FtnPos and its children

func (*CT_FtnPos) ValidateWithPath ¶ 

func (m *CT_FtnPos) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FtnPos and its children, prefixing error messages with path

type CT_FtnProps ¶ 

type CT_FtnProps struct {
	// Footnote Placement
	Pos *CT_FtnPos
	// Footnote Numbering Format
	NumFmt *CT_NumFmt
	// Footnote and Endnote Numbering Starting Value
	NumStart *CT_DecimalNumber
	// Footnote and Endnote Numbering Restart Location
	NumRestart *CT_NumRestart
}

func NewCT_FtnProps ¶ 

func NewCT_FtnProps() *CT_FtnProps

func (*CT_FtnProps) MarshalXML ¶ 

func (m *CT_FtnProps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_FtnProps) UnmarshalXML ¶ 

func (m *CT_FtnProps) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_FtnProps) Validate ¶ 

func (m *CT_FtnProps) Validate() error

Validate validates the CT_FtnProps and its children

func (*CT_FtnProps) ValidateWithPath ¶ 

func (m *CT_FtnProps) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FtnProps and its children, prefixing error messages with path

type CT_GlossaryDocument ¶ 

type CT_GlossaryDocument struct {
	// Document Background
	Background *CT_Background
	DocParts   *CT_DocParts
}

func NewCT_GlossaryDocument ¶ 

func NewCT_GlossaryDocument() *CT_GlossaryDocument

func (*CT_GlossaryDocument) MarshalXML ¶ 

func (m *CT_GlossaryDocument) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_GlossaryDocument) UnmarshalXML ¶ 

func (m *CT_GlossaryDocument) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_GlossaryDocument) Validate ¶ 

func (m *CT_GlossaryDocument) Validate() error

Validate validates the CT_GlossaryDocument and its children

func (*CT_GlossaryDocument) ValidateWithPath ¶ 

func (m *CT_GlossaryDocument) ValidateWithPath(path string) error

ValidateWithPath validates the CT_GlossaryDocument and its children, prefixing error messages with path

type CT_Guid ¶ 

type CT_Guid struct {
	// GUID Value
	ValAttr *string
}

func NewCT_Guid ¶ 

func NewCT_Guid() *CT_Guid

func (*CT_Guid) MarshalXML ¶ 

func (m *CT_Guid) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Guid) UnmarshalXML ¶ 

func (m *CT_Guid) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Guid) Validate ¶ 

func (m *CT_Guid) Validate() error

Validate validates the CT_Guid and its children

func (*CT_Guid) ValidateWithPath ¶ 

func (m *CT_Guid) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Guid and its children, prefixing error messages with path

type CT_HMerge ¶ 

type CT_HMerge struct {
	// Horizontal Merge Type
	ValAttr ST_Merge
}

func NewCT_HMerge ¶ 

func NewCT_HMerge() *CT_HMerge

func (*CT_HMerge) MarshalXML ¶ 

func (m *CT_HMerge) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_HMerge) UnmarshalXML ¶ 

func (m *CT_HMerge) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_HMerge) Validate ¶ 

func (m *CT_HMerge) Validate() error

Validate validates the CT_HMerge and its children

func (*CT_HMerge) ValidateWithPath ¶ 

func (m *CT_HMerge) ValidateWithPath(path string) error

ValidateWithPath validates the CT_HMerge and its children, prefixing error messages with path

type CT_HdrFtr ¶ 

type CT_HdrFtr struct {
	// Anchor for Imported External Content
	AltChunk               []*CT_AltChunk
	EG_ContentBlockContent []*EG_ContentBlockContent
}

func NewCT_HdrFtr ¶ 

func NewCT_HdrFtr() *CT_HdrFtr

func (*CT_HdrFtr) MarshalXML ¶ 

func (m *CT_HdrFtr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_HdrFtr) UnmarshalXML ¶ 

func (m *CT_HdrFtr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_HdrFtr) Validate ¶ 

func (m *CT_HdrFtr) Validate() error

Validate validates the CT_HdrFtr and its children

func (*CT_HdrFtr) ValidateWithPath ¶ 

func (m *CT_HdrFtr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_HdrFtr and its children, prefixing error messages with path

type CT_HdrFtrRef ¶ 

type CT_HdrFtrRef struct {
	TypeAttr ST_HdrFtr
	IdAttr   string
}

func NewCT_HdrFtrRef ¶ 

func NewCT_HdrFtrRef() *CT_HdrFtrRef

func (*CT_HdrFtrRef) MarshalXML ¶ 

func (m *CT_HdrFtrRef) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_HdrFtrRef) UnmarshalXML ¶ 

func (m *CT_HdrFtrRef) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_HdrFtrRef) Validate ¶ 

func (m *CT_HdrFtrRef) Validate() error

Validate validates the CT_HdrFtrRef and its children

func (*CT_HdrFtrRef) ValidateWithPath ¶ 

func (m *CT_HdrFtrRef) ValidateWithPath(path string) error

ValidateWithPath validates the CT_HdrFtrRef and its children, prefixing error messages with path

type CT_Headers ¶ 

type CT_Headers struct {
	// Header Cell Reference
	Header []*CT_String
}

func NewCT_Headers ¶ 

func NewCT_Headers() *CT_Headers

func (*CT_Headers) MarshalXML ¶ 

func (m *CT_Headers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Headers) UnmarshalXML ¶ 

func (m *CT_Headers) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Headers) Validate ¶ 

func (m *CT_Headers) Validate() error

Validate validates the CT_Headers and its children

func (*CT_Headers) ValidateWithPath ¶ 

func (m *CT_Headers) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Headers and its children, prefixing error messages with path

type CT_Height ¶ 

type CT_Height struct {
	// Table Row Height
	ValAttr *sharedTypes.ST_TwipsMeasure
	// Table Row Height Type
	HRuleAttr ST_HeightRule
}

func NewCT_Height ¶ 

func NewCT_Height() *CT_Height

func (*CT_Height) MarshalXML ¶ 

func (m *CT_Height) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Height) UnmarshalXML ¶ 

func (m *CT_Height) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Height) Validate ¶ 

func (m *CT_Height) Validate() error

Validate validates the CT_Height and its children

func (*CT_Height) ValidateWithPath ¶ 

func (m *CT_Height) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Height and its children, prefixing error messages with path

type CT_Highlight ¶ 

type CT_Highlight struct {
	// Highlighting Color
	ValAttr ST_HighlightColor
}

func NewCT_Highlight ¶ 

func NewCT_Highlight() *CT_Highlight

func (*CT_Highlight) MarshalXML ¶ 

func (m *CT_Highlight) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Highlight) UnmarshalXML ¶ 

func (m *CT_Highlight) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Highlight) Validate ¶ 

func (m *CT_Highlight) Validate() error

Validate validates the CT_Highlight and its children

func (*CT_Highlight) ValidateWithPath ¶ 

func (m *CT_Highlight) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Highlight and its children, prefixing error messages with path

type CT_HpsMeasure ¶ 

type CT_HpsMeasure struct {
	// Half Point Measurement
	ValAttr ST_HpsMeasure
}

func NewCT_HpsMeasure ¶ 

func NewCT_HpsMeasure() *CT_HpsMeasure

func (*CT_HpsMeasure) MarshalXML ¶ 

func (m *CT_HpsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_HpsMeasure) UnmarshalXML ¶ 

func (m *CT_HpsMeasure) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_HpsMeasure) Validate ¶ 

func (m *CT_HpsMeasure) Validate() error

Validate validates the CT_HpsMeasure and its children

func (*CT_HpsMeasure) ValidateWithPath ¶ 

func (m *CT_HpsMeasure) ValidateWithPath(path string) error

ValidateWithPath validates the CT_HpsMeasure and its children, prefixing error messages with path 

type CT_Hyperlink struct {
	// Hyperlink Target Frame
	TgtFrameAttr *string
	// Associated String
	TooltipAttr *string
	// Location in Target Document
	DocLocationAttr *string
	// Add To Viewed Hyperlinks
	HistoryAttr *sharedTypes.ST_OnOff
	// Hyperlink Anchor
	AnchorAttr *string
	IdAttr     *string
	// Simple Field
	FldSimple []*CT_SimpleField
	// Hyperlink
	Hyperlink *CT_Hyperlink
	// Anchor for Subdocument Location
	SubDoc               *CT_Rel
	EG_ContentRunContent []*EG_ContentRunContent
}
func NewCT_Hyperlink() *CT_Hyperlink

func (*CT_Hyperlink) MarshalXML ¶ 

func (m *CT_Hyperlink) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Hyperlink) UnmarshalXML ¶ 

func (m *CT_Hyperlink) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Hyperlink) Validate ¶ 

func (m *CT_Hyperlink) Validate() error

Validate validates the CT_Hyperlink and its children

func (*CT_Hyperlink) ValidateWithPath ¶ 

func (m *CT_Hyperlink) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Hyperlink and its children, prefixing error messages with path

type CT_Ind ¶ 

type CT_Ind struct {
	// Start Indentation
	StartAttr *ST_SignedTwipsMeasure
	// Start Indentation in Character Units
	StartCharsAttr *int64
	// End Indentation
	EndAttr *ST_SignedTwipsMeasure
	// End Indentation in Character Units
	EndCharsAttr *int64
	// Start Indentation
	LeftAttr *ST_SignedTwipsMeasure
	// Start Indentation in Character Units
	LeftCharsAttr *int64
	// End Indentation
	RightAttr *ST_SignedTwipsMeasure
	// End Indentation in Character Units
	RightCharsAttr *int64
	// Indentation Removed from First Line
	HangingAttr *sharedTypes.ST_TwipsMeasure
	// Indentation Removed From First Line in Character Units
	HangingCharsAttr *int64
	// Additional First Line Indentation
	FirstLineAttr *sharedTypes.ST_TwipsMeasure
	// Additional First Line Indentation in Character Units
	FirstLineCharsAttr *int64
}

func NewCT_Ind ¶ 

func NewCT_Ind() *CT_Ind

func (*CT_Ind) MarshalXML ¶ 

func (m *CT_Ind) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Ind) UnmarshalXML ¶ 

func (m *CT_Ind) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Ind) Validate ¶ 

func (m *CT_Ind) Validate() error

Validate validates the CT_Ind and its children

func (*CT_Ind) ValidateWithPath ¶ 

func (m *CT_Ind) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Ind and its children, prefixing error messages with path

type CT_Jc ¶ 

type CT_Jc struct {
	// Alignment Type
	ValAttr ST_Jc
}

func NewCT_Jc ¶ 

func NewCT_Jc() *CT_Jc

func (*CT_Jc) MarshalXML ¶ 

func (m *CT_Jc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Jc) UnmarshalXML ¶ 

func (m *CT_Jc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Jc) Validate ¶ 

func (m *CT_Jc) Validate() error

Validate validates the CT_Jc and its children

func (*CT_Jc) ValidateWithPath ¶ 

func (m *CT_Jc) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Jc and its children, prefixing error messages with path

type CT_JcTable ¶ 

type CT_JcTable struct {
	// Alignment Type
	ValAttr ST_JcTable
}

func NewCT_JcTable ¶ 

func NewCT_JcTable() *CT_JcTable

func (*CT_JcTable) MarshalXML ¶ 

func (m *CT_JcTable) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_JcTable) UnmarshalXML ¶ 

func (m *CT_JcTable) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_JcTable) Validate ¶ 

func (m *CT_JcTable) Validate() error

Validate validates the CT_JcTable and its children

func (*CT_JcTable) ValidateWithPath ¶ 

func (m *CT_JcTable) ValidateWithPath(path string) error

ValidateWithPath validates the CT_JcTable and its children, prefixing error messages with path

type CT_Kinsoku ¶ 

type CT_Kinsoku struct {
	// Language For Which Custom Line Breaking Rule Applies
	LangAttr string
	// Characters For Custom Line Breaking Rule
	ValAttr string
}

func NewCT_Kinsoku ¶ 

func NewCT_Kinsoku() *CT_Kinsoku

func (*CT_Kinsoku) MarshalXML ¶ 

func (m *CT_Kinsoku) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Kinsoku) UnmarshalXML ¶ 

func (m *CT_Kinsoku) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Kinsoku) Validate ¶ 

func (m *CT_Kinsoku) Validate() error

Validate validates the CT_Kinsoku and its children

func (*CT_Kinsoku) ValidateWithPath ¶ 

func (m *CT_Kinsoku) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Kinsoku and its children, prefixing error messages with path

type CT_Lang ¶ 

type CT_Lang struct {
	// Language Code
	ValAttr string
}

func NewCT_Lang ¶ 

func NewCT_Lang() *CT_Lang

func (*CT_Lang) MarshalXML ¶ 

func (m *CT_Lang) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Lang) UnmarshalXML ¶ 

func (m *CT_Lang) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Lang) Validate ¶ 

func (m *CT_Lang) Validate() error

Validate validates the CT_Lang and its children

func (*CT_Lang) ValidateWithPath ¶ 

func (m *CT_Lang) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Lang and its children, prefixing error messages with path

type CT_Language ¶ 

type CT_Language struct {
	// Latin Language
	ValAttr *string
	// East Asian Language
	EastAsiaAttr *string
	// Complex Script Language
	BidiAttr *string
}

func NewCT_Language ¶ 

func NewCT_Language() *CT_Language

func (*CT_Language) MarshalXML ¶ 

func (m *CT_Language) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Language) UnmarshalXML ¶ 

func (m *CT_Language) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Language) Validate ¶ 

func (m *CT_Language) Validate() error

Validate validates the CT_Language and its children

func (*CT_Language) ValidateWithPath ¶ 

func (m *CT_Language) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Language and its children, prefixing error messages with path

type CT_LatentStyles ¶ 

type CT_LatentStyles struct {
	// Default Style Locking Setting
	DefLockedStateAttr *sharedTypes.ST_OnOff
	// Default User Interface Priority Setting
	DefUIPriorityAttr *int64
	// Default Semi-Hidden Setting
	DefSemiHiddenAttr *sharedTypes.ST_OnOff
	// Default Hidden Until Used Setting
	DefUnhideWhenUsedAttr *sharedTypes.ST_OnOff
	// Default Primary Style Setting
	DefQFormatAttr *sharedTypes.ST_OnOff
	// Latent Style Count
	CountAttr *int64
	// Latent Style Exception
	LsdException []*CT_LsdException
}

func NewCT_LatentStyles ¶ 

func NewCT_LatentStyles() *CT_LatentStyles

func (*CT_LatentStyles) MarshalXML ¶ 

func (m *CT_LatentStyles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_LatentStyles) UnmarshalXML ¶ 

func (m *CT_LatentStyles) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_LatentStyles) Validate ¶ 

func (m *CT_LatentStyles) Validate() error

Validate validates the CT_LatentStyles and its children

func (*CT_LatentStyles) ValidateWithPath ¶ 

func (m *CT_LatentStyles) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LatentStyles and its children, prefixing error messages with path

type CT_LevelSuffix ¶ 

type CT_LevelSuffix struct {
	// Character Type Between Numbering and Text
	ValAttr ST_LevelSuffix
}

func NewCT_LevelSuffix ¶ 

func NewCT_LevelSuffix() *CT_LevelSuffix

func (*CT_LevelSuffix) MarshalXML ¶ 

func (m *CT_LevelSuffix) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_LevelSuffix) UnmarshalXML ¶ 

func (m *CT_LevelSuffix) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_LevelSuffix) Validate ¶ 

func (m *CT_LevelSuffix) Validate() error

Validate validates the CT_LevelSuffix and its children

func (*CT_LevelSuffix) ValidateWithPath ¶ 

func (m *CT_LevelSuffix) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LevelSuffix and its children, prefixing error messages with path

type CT_LevelText ¶ 

type CT_LevelText struct {
	// Level Text
	ValAttr *string
	// Level Text Is Null Character
	NullAttr *sharedTypes.ST_OnOff
}

func NewCT_LevelText ¶ 

func NewCT_LevelText() *CT_LevelText

func (*CT_LevelText) MarshalXML ¶ 

func (m *CT_LevelText) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_LevelText) UnmarshalXML ¶ 

func (m *CT_LevelText) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_LevelText) Validate ¶ 

func (m *CT_LevelText) Validate() error

Validate validates the CT_LevelText and its children

func (*CT_LevelText) ValidateWithPath ¶ 

func (m *CT_LevelText) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LevelText and its children, prefixing error messages with path

type CT_LineNumber ¶ 

type CT_LineNumber struct {
	// Line Number Increments to Display
	CountByAttr *int64
	// Line Numbering Starting Value
	StartAttr *int64
	// Distance Between Text and Line Numbering
	DistanceAttr *sharedTypes.ST_TwipsMeasure
	// Line Numbering Restart Setting
	RestartAttr ST_LineNumberRestart
}

func NewCT_LineNumber ¶ 

func NewCT_LineNumber() *CT_LineNumber

func (*CT_LineNumber) MarshalXML ¶ 

func (m *CT_LineNumber) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_LineNumber) UnmarshalXML ¶ 

func (m *CT_LineNumber) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_LineNumber) Validate ¶ 

func (m *CT_LineNumber) Validate() error

Validate validates the CT_LineNumber and its children

func (*CT_LineNumber) ValidateWithPath ¶ 

func (m *CT_LineNumber) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LineNumber and its children, prefixing error messages with path

type CT_Lock ¶ 

type CT_Lock struct {
	// Locking Type
	ValAttr ST_Lock
}

func NewCT_Lock ¶ 

func NewCT_Lock() *CT_Lock

func (*CT_Lock) MarshalXML ¶ 

func (m *CT_Lock) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Lock) UnmarshalXML ¶ 

func (m *CT_Lock) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Lock) Validate ¶ 

func (m *CT_Lock) Validate() error

Validate validates the CT_Lock and its children

func (*CT_Lock) ValidateWithPath ¶ 

func (m *CT_Lock) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Lock and its children, prefixing error messages with path

type CT_LongHexNumber ¶ 

type CT_LongHexNumber struct {
	// Long Hexadecimal Number Value
	ValAttr string
}

func NewCT_LongHexNumber ¶ 

func NewCT_LongHexNumber() *CT_LongHexNumber

func (*CT_LongHexNumber) MarshalXML ¶ 

func (m *CT_LongHexNumber) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_LongHexNumber) UnmarshalXML ¶ 

func (m *CT_LongHexNumber) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_LongHexNumber) Validate ¶ 

func (m *CT_LongHexNumber) Validate() error

Validate validates the CT_LongHexNumber and its children

func (*CT_LongHexNumber) ValidateWithPath ¶ 

func (m *CT_LongHexNumber) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LongHexNumber and its children, prefixing error messages with path

type CT_LsdException ¶ 

type CT_LsdException struct {
	// Primary Style Name
	NameAttr string
	// Latent Style Locking Setting
	LockedAttr *sharedTypes.ST_OnOff
	// Override default sorting order
	UiPriorityAttr *int64
	// Semi hidden text override
	SemiHiddenAttr *sharedTypes.ST_OnOff
	// Unhide when used
	UnhideWhenUsedAttr *sharedTypes.ST_OnOff
	// Latent Style Primary Style Setting
	QFormatAttr *sharedTypes.ST_OnOff
}

func NewCT_LsdException ¶ 

func NewCT_LsdException() *CT_LsdException

func (*CT_LsdException) MarshalXML ¶ 

func (m *CT_LsdException) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_LsdException) UnmarshalXML ¶ 

func (m *CT_LsdException) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_LsdException) Validate ¶ 

func (m *CT_LsdException) Validate() error

Validate validates the CT_LsdException and its children

func (*CT_LsdException) ValidateWithPath ¶ 

func (m *CT_LsdException) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LsdException and its children, prefixing error messages with path

type CT_Lvl ¶ 

type CT_Lvl struct {
	// Numbering Level
	IlvlAttr int64
	// Template Code
	TplcAttr *string
	// Tentative Numbering
	TentativeAttr *sharedTypes.ST_OnOff
	// Starting Value
	Start *CT_DecimalNumber
	// Numbering Format
	NumFmt *CT_NumFmt
	// Restart Numbering Level Symbol
	LvlRestart *CT_DecimalNumber
	// Paragraph Style's Associated Numbering Level
	PStyle *CT_String
	// Display All Levels Using Arabic Numerals
	IsLgl *CT_OnOff
	// Content Between Numbering Symbol and Paragraph Text
	Suff *CT_LevelSuffix
	// Numbering Level Text
	LvlText *CT_LevelText
	// Picture Numbering Symbol Definition Reference
	LvlPicBulletId *CT_DecimalNumber
	// Legacy Numbering Level Properties
	Legacy *CT_LvlLegacy
	// Justification
	LvlJc *CT_Jc
	// Numbering Level Associated Paragraph Properties
	PPr *CT_PPrGeneral
	// Numbering Symbol Run Properties
	RPr *CT_RPr
}

func NewCT_Lvl ¶ 

func NewCT_Lvl() *CT_Lvl

func (*CT_Lvl) MarshalXML ¶ 

func (m *CT_Lvl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Lvl) UnmarshalXML ¶ 

func (m *CT_Lvl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Lvl) Validate ¶ 

func (m *CT_Lvl) Validate() error

Validate validates the CT_Lvl and its children

func (*CT_Lvl) ValidateWithPath ¶ 

func (m *CT_Lvl) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Lvl and its children, prefixing error messages with path

type CT_LvlLegacy ¶ 

type CT_LvlLegacy struct {
	// Use Legacy Numbering Properties
	LegacyAttr *sharedTypes.ST_OnOff
	// Legacy Spacing
	LegacySpaceAttr *sharedTypes.ST_TwipsMeasure
	// Legacy Indent
	LegacyIndentAttr *ST_SignedTwipsMeasure
}

func NewCT_LvlLegacy ¶ 

func NewCT_LvlLegacy() *CT_LvlLegacy

func (*CT_LvlLegacy) MarshalXML ¶ 

func (m *CT_LvlLegacy) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_LvlLegacy) UnmarshalXML ¶ 

func (m *CT_LvlLegacy) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_LvlLegacy) Validate ¶ 

func (m *CT_LvlLegacy) Validate() error

Validate validates the CT_LvlLegacy and its children

func (*CT_LvlLegacy) ValidateWithPath ¶ 

func (m *CT_LvlLegacy) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LvlLegacy and its children, prefixing error messages with path

type CT_MacroName ¶ 

type CT_MacroName struct {
	// Name of Script Function
	ValAttr string
}

func NewCT_MacroName ¶ 

func NewCT_MacroName() *CT_MacroName

func (*CT_MacroName) MarshalXML ¶ 

func (m *CT_MacroName) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MacroName) UnmarshalXML ¶ 

func (m *CT_MacroName) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MacroName) Validate ¶ 

func (m *CT_MacroName) Validate() error

Validate validates the CT_MacroName and its children

func (*CT_MacroName) ValidateWithPath ¶ 

func (m *CT_MacroName) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MacroName and its children, prefixing error messages with path

type CT_MailMerge ¶ 

type CT_MailMerge struct {
	// Source Document Type
	MainDocumentType *CT_MailMergeDocType
	// Query Contains Link to External Query File
	LinkToQuery *CT_OnOff
	// Data Source Type
	DataType *CT_MailMergeDataType
	// Data Source Connection String
	ConnectString *CT_String
	// Query For Data Source Records To Merge
	Query *CT_String
	// Data Source File Path
	DataSource *CT_Rel
	// Header Definition File Path
	HeaderSource *CT_Rel
	// Remove Blank Lines from Merged Documents
	DoNotSuppressBlankLines *CT_OnOff
	// Merged Document Destination
	Destination *CT_MailMergeDest
	// Column Containing E-mail Address
	AddressFieldName *CT_String
	// Merged E-mail or Fax Subject Line
	MailSubject *CT_String
	// Merged Document To E-Mail Attachment
	MailAsAttachment *CT_OnOff
	// View Merged Data Within Document
	ViewMergedData *CT_OnOff
	// Record Currently Displayed In Merged Document
	ActiveRecord *CT_DecimalNumber
	// Mail Merge Error Reporting Setting
	CheckErrors *CT_DecimalNumber
	// Office Data Source Object Settings
	Odso *CT_Odso
}

func NewCT_MailMerge ¶ 

func NewCT_MailMerge() *CT_MailMerge

func (*CT_MailMerge) MarshalXML ¶ 

func (m *CT_MailMerge) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MailMerge) UnmarshalXML ¶ 

func (m *CT_MailMerge) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MailMerge) Validate ¶ 

func (m *CT_MailMerge) Validate() error

Validate validates the CT_MailMerge and its children

func (*CT_MailMerge) ValidateWithPath ¶ 

func (m *CT_MailMerge) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MailMerge and its children, prefixing error messages with path

type CT_MailMergeDataType ¶ 

type CT_MailMergeDataType struct {
	// Value
	ValAttr string
}

func NewCT_MailMergeDataType ¶ 

func NewCT_MailMergeDataType() *CT_MailMergeDataType

func (*CT_MailMergeDataType) MarshalXML ¶ 

func (m *CT_MailMergeDataType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MailMergeDataType) UnmarshalXML ¶ 

func (m *CT_MailMergeDataType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MailMergeDataType) Validate ¶ 

func (m *CT_MailMergeDataType) Validate() error

Validate validates the CT_MailMergeDataType and its children

func (*CT_MailMergeDataType) ValidateWithPath ¶ 

func (m *CT_MailMergeDataType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MailMergeDataType and its children, prefixing error messages with path

type CT_MailMergeDest ¶ 

type CT_MailMergeDest struct {
	// Mail Merge Merged Document Type
	ValAttr ST_MailMergeDest
}

func NewCT_MailMergeDest ¶ 

func NewCT_MailMergeDest() *CT_MailMergeDest

func (*CT_MailMergeDest) MarshalXML ¶ 

func (m *CT_MailMergeDest) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MailMergeDest) UnmarshalXML ¶ 

func (m *CT_MailMergeDest) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MailMergeDest) Validate ¶ 

func (m *CT_MailMergeDest) Validate() error

Validate validates the CT_MailMergeDest and its children

func (*CT_MailMergeDest) ValidateWithPath ¶ 

func (m *CT_MailMergeDest) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MailMergeDest and its children, prefixing error messages with path

type CT_MailMergeDocType ¶ 

type CT_MailMergeDocType struct {
	// Mail Merge Source Document Type
	ValAttr ST_MailMergeDocType
}

func NewCT_MailMergeDocType ¶ 

func NewCT_MailMergeDocType() *CT_MailMergeDocType

func (*CT_MailMergeDocType) MarshalXML ¶ 

func (m *CT_MailMergeDocType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MailMergeDocType) UnmarshalXML ¶ 

func (m *CT_MailMergeDocType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MailMergeDocType) Validate ¶ 

func (m *CT_MailMergeDocType) Validate() error

Validate validates the CT_MailMergeDocType and its children

func (*CT_MailMergeDocType) ValidateWithPath ¶ 

func (m *CT_MailMergeDocType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MailMergeDocType and its children, prefixing error messages with path

type CT_MailMergeOdsoFMDFieldType ¶ 

type CT_MailMergeOdsoFMDFieldType struct {
	// Merge Field Mapping Type
	ValAttr ST_MailMergeOdsoFMDFieldType
}

func NewCT_MailMergeOdsoFMDFieldType ¶ 

func NewCT_MailMergeOdsoFMDFieldType() *CT_MailMergeOdsoFMDFieldType

func (*CT_MailMergeOdsoFMDFieldType) MarshalXML ¶ 

func (m *CT_MailMergeOdsoFMDFieldType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MailMergeOdsoFMDFieldType) UnmarshalXML ¶ 

func (m *CT_MailMergeOdsoFMDFieldType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MailMergeOdsoFMDFieldType) Validate ¶ 

func (m *CT_MailMergeOdsoFMDFieldType) Validate() error

Validate validates the CT_MailMergeOdsoFMDFieldType and its children

func (*CT_MailMergeOdsoFMDFieldType) ValidateWithPath ¶ 

func (m *CT_MailMergeOdsoFMDFieldType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MailMergeOdsoFMDFieldType and its children, prefixing error messages with path

type CT_MailMergeSourceType ¶ 

type CT_MailMergeSourceType struct {
	// Data Source Type Value
	ValAttr ST_MailMergeSourceType
}

func NewCT_MailMergeSourceType ¶ 

func NewCT_MailMergeSourceType() *CT_MailMergeSourceType

func (*CT_MailMergeSourceType) MarshalXML ¶ 

func (m *CT_MailMergeSourceType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MailMergeSourceType) UnmarshalXML ¶ 

func (m *CT_MailMergeSourceType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MailMergeSourceType) Validate ¶ 

func (m *CT_MailMergeSourceType) Validate() error

Validate validates the CT_MailMergeSourceType and its children

func (*CT_MailMergeSourceType) ValidateWithPath ¶ 

func (m *CT_MailMergeSourceType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MailMergeSourceType and its children, prefixing error messages with path

type CT_Markup ¶ 

type CT_Markup struct {
	// Annotation Identifier
	IdAttr int64
}

func NewCT_Markup ¶ 

func NewCT_Markup() *CT_Markup

func (*CT_Markup) MarshalXML ¶ 

func (m *CT_Markup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Markup) UnmarshalXML ¶ 

func (m *CT_Markup) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Markup) Validate ¶ 

func (m *CT_Markup) Validate() error

Validate validates the CT_Markup and its children

func (*CT_Markup) ValidateWithPath ¶ 

func (m *CT_Markup) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Markup and its children, prefixing error messages with path

type CT_MarkupRange ¶ 

type CT_MarkupRange struct {
	DisplacedByCustomXmlAttr ST_DisplacedByCustomXml
	// Annotation Identifier
	IdAttr int64
}

func NewCT_MarkupRange ¶ 

func NewCT_MarkupRange() *CT_MarkupRange

func (*CT_MarkupRange) MarshalXML ¶ 

func (m *CT_MarkupRange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MarkupRange) UnmarshalXML ¶ 

func (m *CT_MarkupRange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MarkupRange) Validate ¶ 

func (m *CT_MarkupRange) Validate() error

Validate validates the CT_MarkupRange and its children

func (*CT_MarkupRange) ValidateWithPath ¶ 

func (m *CT_MarkupRange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MarkupRange and its children, prefixing error messages with path

type CT_MathCtrlDel ¶ 

type CT_MathCtrlDel struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
}

func NewCT_MathCtrlDel ¶ 

func NewCT_MathCtrlDel() *CT_MathCtrlDel

func (*CT_MathCtrlDel) MarshalXML ¶ 

func (m *CT_MathCtrlDel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MathCtrlDel) UnmarshalXML ¶ 

func (m *CT_MathCtrlDel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MathCtrlDel) Validate ¶ 

func (m *CT_MathCtrlDel) Validate() error

Validate validates the CT_MathCtrlDel and its children

func (*CT_MathCtrlDel) ValidateWithPath ¶ 

func (m *CT_MathCtrlDel) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MathCtrlDel and its children, prefixing error messages with path

type CT_MathCtrlIns ¶ 

type CT_MathCtrlIns struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
}

func NewCT_MathCtrlIns ¶ 

func NewCT_MathCtrlIns() *CT_MathCtrlIns

func (*CT_MathCtrlIns) MarshalXML ¶ 

func (m *CT_MathCtrlIns) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MathCtrlIns) UnmarshalXML ¶ 

func (m *CT_MathCtrlIns) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MathCtrlIns) Validate ¶ 

func (m *CT_MathCtrlIns) Validate() error

Validate validates the CT_MathCtrlIns and its children

func (*CT_MathCtrlIns) ValidateWithPath ¶ 

func (m *CT_MathCtrlIns) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MathCtrlIns and its children, prefixing error messages with path

type CT_MoveBookmark ¶ 

type CT_MoveBookmark struct {
	AuthorAttr               string
	DateAttr                 time.Time
	NameAttr                 string
	ColFirstAttr             *int64
	ColLastAttr              *int64
	DisplacedByCustomXmlAttr ST_DisplacedByCustomXml
	// Annotation Identifier
	IdAttr int64
}

func NewCT_MoveBookmark ¶ 

func NewCT_MoveBookmark() *CT_MoveBookmark

func (*CT_MoveBookmark) MarshalXML ¶ 

func (m *CT_MoveBookmark) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MoveBookmark) UnmarshalXML ¶ 

func (m *CT_MoveBookmark) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MoveBookmark) Validate ¶ 

func (m *CT_MoveBookmark) Validate() error

Validate validates the CT_MoveBookmark and its children

func (*CT_MoveBookmark) ValidateWithPath ¶ 

func (m *CT_MoveBookmark) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MoveBookmark and its children, prefixing error messages with path

type CT_MultiLevelType ¶ 

type CT_MultiLevelType struct {
	// Abstract Numbering Definition Type
	ValAttr ST_MultiLevelType
}

func NewCT_MultiLevelType ¶ 

func NewCT_MultiLevelType() *CT_MultiLevelType

func (*CT_MultiLevelType) MarshalXML ¶ 

func (m *CT_MultiLevelType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_MultiLevelType) UnmarshalXML ¶ 

func (m *CT_MultiLevelType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_MultiLevelType) Validate ¶ 

func (m *CT_MultiLevelType) Validate() error

Validate validates the CT_MultiLevelType and its children

func (*CT_MultiLevelType) ValidateWithPath ¶ 

func (m *CT_MultiLevelType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MultiLevelType and its children, prefixing error messages with path

type CT_Num ¶ 

type CT_Num struct {
	// Numbering Definition Instance ID
	NumIdAttr int64
	// Abstract Numbering Definition Reference
	AbstractNumId *CT_DecimalNumber
	// Numbering Level Definition Override
	LvlOverride []*CT_NumLvl
}

func NewCT_Num ¶ 

func NewCT_Num() *CT_Num

func (*CT_Num) MarshalXML ¶ 

func (m *CT_Num) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Num) UnmarshalXML ¶ 

func (m *CT_Num) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Num) Validate ¶ 

func (m *CT_Num) Validate() error

Validate validates the CT_Num and its children

func (*CT_Num) ValidateWithPath ¶ 

func (m *CT_Num) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Num and its children, prefixing error messages with path

type CT_NumFmt ¶ 

type CT_NumFmt struct {
	// Numbering Format Type
	ValAttr ST_NumberFormat
	// Custom Defined Number Format
	FormatAttr *string
}

func NewCT_NumFmt ¶ 

func NewCT_NumFmt() *CT_NumFmt

func (*CT_NumFmt) MarshalXML ¶ 

func (m *CT_NumFmt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_NumFmt) UnmarshalXML ¶ 

func (m *CT_NumFmt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_NumFmt) Validate ¶ 

func (m *CT_NumFmt) Validate() error

Validate validates the CT_NumFmt and its children

func (*CT_NumFmt) ValidateWithPath ¶ 

func (m *CT_NumFmt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumFmt and its children, prefixing error messages with path

type CT_NumLvl ¶ 

type CT_NumLvl struct {
	// Numbering Level ID
	IlvlAttr int64
	// Numbering Level Starting Value Override
	StartOverride *CT_DecimalNumber
	// Numbering Level Override Definition
	Lvl *CT_Lvl
}

func NewCT_NumLvl ¶ 

func NewCT_NumLvl() *CT_NumLvl

func (*CT_NumLvl) MarshalXML ¶ 

func (m *CT_NumLvl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_NumLvl) UnmarshalXML ¶ 

func (m *CT_NumLvl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_NumLvl) Validate ¶ 

func (m *CT_NumLvl) Validate() error

Validate validates the CT_NumLvl and its children

func (*CT_NumLvl) ValidateWithPath ¶ 

func (m *CT_NumLvl) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumLvl and its children, prefixing error messages with path

type CT_NumPicBullet ¶ 

type CT_NumPicBullet struct {
	// Picture Numbering Symbol ID
	NumPicBulletIdAttr int64
	// Picture Numbering Symbol Properties
	Pict    *CT_Picture
	Drawing *CT_Drawing
}

func NewCT_NumPicBullet ¶ 

func NewCT_NumPicBullet() *CT_NumPicBullet

func (*CT_NumPicBullet) MarshalXML ¶ 

func (m *CT_NumPicBullet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_NumPicBullet) UnmarshalXML ¶ 

func (m *CT_NumPicBullet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_NumPicBullet) Validate ¶ 

func (m *CT_NumPicBullet) Validate() error

Validate validates the CT_NumPicBullet and its children

func (*CT_NumPicBullet) ValidateWithPath ¶ 

func (m *CT_NumPicBullet) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumPicBullet and its children, prefixing error messages with path

type CT_NumPr ¶ 

type CT_NumPr struct {
	// Numbering Level Reference
	Ilvl *CT_DecimalNumber
	// Numbering Definition Instance Reference
	NumId *CT_DecimalNumber
	// Previous Paragraph Numbering Properties
	NumberingChange *CT_TrackChangeNumbering
	// Inserted Numbering Properties
	Ins *CT_TrackChange
}

func NewCT_NumPr ¶ 

func NewCT_NumPr() *CT_NumPr

func (*CT_NumPr) MarshalXML ¶ 

func (m *CT_NumPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_NumPr) UnmarshalXML ¶ 

func (m *CT_NumPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_NumPr) Validate ¶ 

func (m *CT_NumPr) Validate() error

Validate validates the CT_NumPr and its children

func (*CT_NumPr) ValidateWithPath ¶ 

func (m *CT_NumPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumPr and its children, prefixing error messages with path

type CT_NumRestart ¶ 

type CT_NumRestart struct {
	// Automatic Numbering Restart Value
	ValAttr ST_RestartNumber
}

func NewCT_NumRestart ¶ 

func NewCT_NumRestart() *CT_NumRestart

func (*CT_NumRestart) MarshalXML ¶ 

func (m *CT_NumRestart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_NumRestart) UnmarshalXML ¶ 

func (m *CT_NumRestart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_NumRestart) Validate ¶ 

func (m *CT_NumRestart) Validate() error

Validate validates the CT_NumRestart and its children

func (*CT_NumRestart) ValidateWithPath ¶ 

func (m *CT_NumRestart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumRestart and its children, prefixing error messages with path

type CT_Numbering ¶ 

type CT_Numbering struct {
	// Picture Numbering Symbol Definition
	NumPicBullet []*CT_NumPicBullet
	// Abstract Numbering Definition
	AbstractNum []*CT_AbstractNum
	// Numbering Definition Instance
	Num []*CT_Num
	// Last Reviewed Abstract Numbering Definition
	NumIdMacAtCleanup *CT_DecimalNumber
}

func NewCT_Numbering ¶ 

func NewCT_Numbering() *CT_Numbering

func (*CT_Numbering) MarshalXML ¶ 

func (m *CT_Numbering) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Numbering) UnmarshalXML ¶ 

func (m *CT_Numbering) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Numbering) Validate ¶ 

func (m *CT_Numbering) Validate() error

Validate validates the CT_Numbering and its children

func (*CT_Numbering) ValidateWithPath ¶ 

func (m *CT_Numbering) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Numbering and its children, prefixing error messages with path

type CT_Object ¶ 

type CT_Object struct {
	// Original Image Width
	DxaOrigAttr *sharedTypes.ST_TwipsMeasure
	// Original Image Height
	DyaOrigAttr *sharedTypes.ST_TwipsMeasure
	Drawing     *CT_Drawing
	Choice      *CT_ObjectChoice
}

func NewCT_Object ¶ 

func NewCT_Object() *CT_Object

func (*CT_Object) MarshalXML ¶ 

func (m *CT_Object) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Object) UnmarshalXML ¶ 

func (m *CT_Object) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Object) Validate ¶ 

func (m *CT_Object) Validate() error

Validate validates the CT_Object and its children

func (*CT_Object) ValidateWithPath ¶ 

func (m *CT_Object) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Object and its children, prefixing error messages with path

type CT_ObjectChoice ¶ 

type CT_ObjectChoice struct {
	Control     *CT_Control
	ObjectLink  *CT_ObjectLink
	ObjectEmbed *CT_ObjectEmbed
	Movie       *CT_Rel
}

func NewCT_ObjectChoice ¶ 

func NewCT_ObjectChoice() *CT_ObjectChoice

func (*CT_ObjectChoice) MarshalXML ¶ 

func (m *CT_ObjectChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ObjectChoice) UnmarshalXML ¶ 

func (m *CT_ObjectChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ObjectChoice) Validate ¶ 

func (m *CT_ObjectChoice) Validate() error

Validate validates the CT_ObjectChoice and its children

func (*CT_ObjectChoice) ValidateWithPath ¶ 

func (m *CT_ObjectChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ObjectChoice and its children, prefixing error messages with path

type CT_ObjectEmbed ¶ 

type CT_ObjectEmbed struct {
	// Object Representation
	DrawAspectAttr ST_ObjectDrawAspect
	IdAttr         string
	// Object Application
	ProgIdAttr *string
	// Object Shape
	ShapeIdAttr *string
	// Field Switches
	FieldCodesAttr *string
}

func NewCT_ObjectEmbed ¶ 

func NewCT_ObjectEmbed() *CT_ObjectEmbed

func (*CT_ObjectEmbed) MarshalXML ¶ 

func (m *CT_ObjectEmbed) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ObjectEmbed) UnmarshalXML ¶ 

func (m *CT_ObjectEmbed) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ObjectEmbed) Validate ¶ 

func (m *CT_ObjectEmbed) Validate() error

Validate validates the CT_ObjectEmbed and its children

func (*CT_ObjectEmbed) ValidateWithPath ¶ 

func (m *CT_ObjectEmbed) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ObjectEmbed and its children, prefixing error messages with path 

type CT_ObjectLink struct {
	UpdateModeAttr  ST_ObjectUpdateMode
	LockedFieldAttr *sharedTypes.ST_OnOff
	// Object Representation
	DrawAspectAttr ST_ObjectDrawAspect
	IdAttr         string
	// Object Application
	ProgIdAttr *string
	// Object Shape
	ShapeIdAttr *string
	// Field Switches
	FieldCodesAttr *string
}
func NewCT_ObjectLink() *CT_ObjectLink

func (*CT_ObjectLink) MarshalXML ¶ 

func (m *CT_ObjectLink) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ObjectLink) UnmarshalXML ¶ 

func (m *CT_ObjectLink) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ObjectLink) Validate ¶ 

func (m *CT_ObjectLink) Validate() error

Validate validates the CT_ObjectLink and its children

func (*CT_ObjectLink) ValidateWithPath ¶ 

func (m *CT_ObjectLink) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ObjectLink and its children, prefixing error messages with path

type CT_Odso ¶ 

type CT_Odso struct {
	// UDL Connection String
	Udl *CT_String
	// Data Source Table Name
	Table *CT_String
	// ODSO Data Source File Path
	Src *CT_Rel
	// Column Delimiter for Data Source
	ColDelim *CT_DecimalNumber
	// ODSO Data Source Type
	Type *CT_MailMergeSourceType
	// First Row of Data Source Contains Column Names
	FHdr *CT_OnOff
	// External Data Source to Merge Field Mapping
	FieldMapData []*CT_OdsoFieldMapData
	// Reference to Inclusion/Exclusion Data for Data Source
	RecipientData []*CT_Rel
}

func NewCT_Odso ¶ 

func NewCT_Odso() *CT_Odso

func (*CT_Odso) MarshalXML ¶ 

func (m *CT_Odso) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Odso) UnmarshalXML ¶ 

func (m *CT_Odso) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Odso) Validate ¶ 

func (m *CT_Odso) Validate() error

Validate validates the CT_Odso and its children

func (*CT_Odso) ValidateWithPath ¶ 

func (m *CT_Odso) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Odso and its children, prefixing error messages with path

type CT_OdsoFieldMapData ¶ 

type CT_OdsoFieldMapData struct {
	// Merge Field Mapping
	Type *CT_MailMergeOdsoFMDFieldType
	// Data Source Name for Column
	Name *CT_String
	// Predefined Merge Field Name
	MappedName *CT_String
	// Index of Column Being Mapped
	Column *CT_DecimalNumber
	// Merge Field Name Language ID
	Lid *CT_Lang
	// Use Country-Based Address Field Ordering
	DynamicAddress *CT_OnOff
}

func NewCT_OdsoFieldMapData ¶ 

func NewCT_OdsoFieldMapData() *CT_OdsoFieldMapData

func (*CT_OdsoFieldMapData) MarshalXML ¶ 

func (m *CT_OdsoFieldMapData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OdsoFieldMapData) UnmarshalXML ¶ 

func (m *CT_OdsoFieldMapData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OdsoFieldMapData) Validate ¶ 

func (m *CT_OdsoFieldMapData) Validate() error

Validate validates the CT_OdsoFieldMapData and its children

func (*CT_OdsoFieldMapData) ValidateWithPath ¶ 

func (m *CT_OdsoFieldMapData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OdsoFieldMapData and its children, prefixing error messages with path

type CT_OnOff ¶ 

type CT_OnOff struct {
	// On/Off Value
	ValAttr *sharedTypes.ST_OnOff
}

func NewCT_OnOff ¶ 

func NewCT_OnOff() *CT_OnOff

func (*CT_OnOff) MarshalXML ¶ 

func (m *CT_OnOff) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OnOff) UnmarshalXML ¶ 

func (m *CT_OnOff) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OnOff) Validate ¶ 

func (m *CT_OnOff) Validate() error

Validate validates the CT_OnOff and its children

func (*CT_OnOff) ValidateWithPath ¶ 

func (m *CT_OnOff) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OnOff and its children, prefixing error messages with path

type CT_OptimizeForBrowser ¶ 

type CT_OptimizeForBrowser struct {
	TargetAttr *string
	// On/Off Value
	ValAttr *sharedTypes.ST_OnOff
}

func NewCT_OptimizeForBrowser ¶ 

func NewCT_OptimizeForBrowser() *CT_OptimizeForBrowser

func (*CT_OptimizeForBrowser) MarshalXML ¶ 

func (m *CT_OptimizeForBrowser) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OptimizeForBrowser) UnmarshalXML ¶ 

func (m *CT_OptimizeForBrowser) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OptimizeForBrowser) Validate ¶ 

func (m *CT_OptimizeForBrowser) Validate() error

Validate validates the CT_OptimizeForBrowser and its children

func (*CT_OptimizeForBrowser) ValidateWithPath ¶ 

func (m *CT_OptimizeForBrowser) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OptimizeForBrowser and its children, prefixing error messages with path

type CT_P ¶ 

type CT_P struct {
	// Revision Identifier for Paragraph Glyph Formatting
	RsidRPrAttr *string
	// Revision Identifier for Paragraph
	RsidRAttr *string
	// Revision Identifier for Paragraph Deletion
	RsidDelAttr *string
	// Revision Identifier for Paragraph Properties
	RsidPAttr *string
	// Default Revision Identifier for Runs
	RsidRDefaultAttr *string
	// Paragraph Properties
	PPr         *CT_PPr
	EG_PContent []*EG_PContent
}

func NewCT_P ¶ 

func NewCT_P() *CT_P

func (*CT_P) MarshalXML ¶ 

func (m *CT_P) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_P) UnmarshalXML ¶ 

func (m *CT_P) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_P) Validate ¶ 

func (m *CT_P) Validate() error

Validate validates the CT_P and its children

func (*CT_P) ValidateWithPath ¶ 

func (m *CT_P) ValidateWithPath(path string) error

ValidateWithPath validates the CT_P and its children, prefixing error messages with path

type CT_PBdr ¶ 

type CT_PBdr struct {
	// Paragraph Border Above Identical Paragraphs
	Top *CT_Border
	// Left Paragraph Border
	Left *CT_Border
	// Paragraph Border Below Identical Paragraphs
	Bottom *CT_Border
	// Right Paragraph Border
	Right *CT_Border
	// Paragraph Border Between Identical Paragraphs
	Between *CT_Border
	// Paragraph Border Between Facing Pages
	Bar *CT_Border
}

func NewCT_PBdr ¶ 

func NewCT_PBdr() *CT_PBdr

func (*CT_PBdr) MarshalXML ¶ 

func (m *CT_PBdr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PBdr) UnmarshalXML ¶ 

func (m *CT_PBdr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PBdr) Validate ¶ 

func (m *CT_PBdr) Validate() error

Validate validates the CT_PBdr and its children

func (*CT_PBdr) ValidateWithPath ¶ 

func (m *CT_PBdr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PBdr and its children, prefixing error messages with path

type CT_PPr ¶ 

type CT_PPr struct {
	// Referenced Paragraph Style
	PStyle *CT_String
	// Keep Paragraph With Next Paragraph
	KeepNext *CT_OnOff
	// Keep All Lines On One Page
	KeepLines *CT_OnOff
	// Start Paragraph on Next Page
	PageBreakBefore *CT_OnOff
	// Text Frame Properties
	FramePr *CT_FramePr
	// Allow First/Last Line to Display on a Separate Page
	WidowControl *CT_OnOff
	// Numbering Definition Instance Reference
	NumPr *CT_NumPr
	// Suppress Line Numbers for Paragraph
	SuppressLineNumbers *CT_OnOff
	// Paragraph Borders
	PBdr *CT_PBdr
	// Paragraph Shading
	Shd *CT_Shd
	// Set of Custom Tab Stops
	Tabs *CT_Tabs
	// Suppress Hyphenation for Paragraph
	SuppressAutoHyphens *CT_OnOff
	// Use East Asian Typography Rules for First and Last Character per Line
	Kinsoku *CT_OnOff
	// Allow Line Breaking At Character Level
	WordWrap *CT_OnOff
	// Allow Punctuation to Extend Past Text Extents
	OverflowPunct *CT_OnOff
	// Compress Punctuation at Start of a Line
	TopLinePunct *CT_OnOff
	// Automatically Adjust Spacing of Latin and East Asian Text
	AutoSpaceDE *CT_OnOff
	// Automatically Adjust Spacing of East Asian Text and Numbers
	AutoSpaceDN *CT_OnOff
	// Right to Left Paragraph Layout
	Bidi *CT_OnOff
	// Automatically Adjust Right Indent When Using Document Grid
	AdjustRightInd *CT_OnOff
	// Use Document Grid Settings for Inter-Line Paragraph Spacing
	SnapToGrid *CT_OnOff
	// Spacing Between Lines and Above/Below Paragraph
	Spacing *CT_Spacing
	// Paragraph Indentation
	Ind *CT_Ind
	// Ignore Spacing Above and Below When Using Identical Styles
	ContextualSpacing *CT_OnOff
	// Use Left/Right Indents as Inside/Outside Indents
	MirrorIndents *CT_OnOff
	// Prevent Text Frames From Overlapping
	SuppressOverlap *CT_OnOff
	// Paragraph Alignment
	Jc *CT_Jc
	// Paragraph Text Flow Direction
	TextDirection *CT_TextDirection
	// Vertical Character Alignment on Line
	TextAlignment *CT_TextAlignment
	// Allow Surrounding Paragraphs to Tight Wrap to Text Box Contents
	TextboxTightWrap *CT_TextboxTightWrap
	// Associated Outline Level
	OutlineLvl *CT_DecimalNumber
	// Associated HTML div ID
	DivId *CT_DecimalNumber
	// Paragraph Conditional Formatting
	CnfStyle  *CT_Cnf
	RPr       *CT_ParaRPr
	SectPr    *CT_SectPr
	PPrChange *CT_PPrChange
}

func NewCT_PPr ¶ 

func NewCT_PPr() *CT_PPr

func (*CT_PPr) MarshalXML ¶ 

func (m *CT_PPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PPr) UnmarshalXML ¶ 

func (m *CT_PPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PPr) Validate ¶ 

func (m *CT_PPr) Validate() error

Validate validates the CT_PPr and its children

func (*CT_PPr) ValidateWithPath ¶ 

func (m *CT_PPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PPr and its children, prefixing error messages with path

type CT_PPrBase ¶ 

type CT_PPrBase struct {
	// Referenced Paragraph Style
	PStyle *CT_String
	// Keep Paragraph With Next Paragraph
	KeepNext *CT_OnOff
	// Keep All Lines On One Page
	KeepLines *CT_OnOff
	// Start Paragraph on Next Page
	PageBreakBefore *CT_OnOff
	// Text Frame Properties
	FramePr *CT_FramePr
	// Allow First/Last Line to Display on a Separate Page
	WidowControl *CT_OnOff
	// Numbering Definition Instance Reference
	NumPr *CT_NumPr
	// Suppress Line Numbers for Paragraph
	SuppressLineNumbers *CT_OnOff
	// Paragraph Borders
	PBdr *CT_PBdr
	// Paragraph Shading
	Shd *CT_Shd
	// Set of Custom Tab Stops
	Tabs *CT_Tabs
	// Suppress Hyphenation for Paragraph
	SuppressAutoHyphens *CT_OnOff
	// Use East Asian Typography Rules for First and Last Character per Line
	Kinsoku *CT_OnOff
	// Allow Line Breaking At Character Level
	WordWrap *CT_OnOff
	// Allow Punctuation to Extend Past Text Extents
	OverflowPunct *CT_OnOff
	// Compress Punctuation at Start of a Line
	TopLinePunct *CT_OnOff
	// Automatically Adjust Spacing of Latin and East Asian Text
	AutoSpaceDE *CT_OnOff
	// Automatically Adjust Spacing of East Asian Text and Numbers
	AutoSpaceDN *CT_OnOff
	// Right to Left Paragraph Layout
	Bidi *CT_OnOff
	// Automatically Adjust Right Indent When Using Document Grid
	AdjustRightInd *CT_OnOff
	// Use Document Grid Settings for Inter-Line Paragraph Spacing
	SnapToGrid *CT_OnOff
	// Spacing Between Lines and Above/Below Paragraph
	Spacing *CT_Spacing
	// Paragraph Indentation
	Ind *CT_Ind
	// Ignore Spacing Above and Below When Using Identical Styles
	ContextualSpacing *CT_OnOff
	// Use Left/Right Indents as Inside/Outside Indents
	MirrorIndents *CT_OnOff
	// Prevent Text Frames From Overlapping
	SuppressOverlap *CT_OnOff
	// Paragraph Alignment
	Jc *CT_Jc
	// Paragraph Text Flow Direction
	TextDirection *CT_TextDirection
	// Vertical Character Alignment on Line
	TextAlignment *CT_TextAlignment
	// Allow Surrounding Paragraphs to Tight Wrap to Text Box Contents
	TextboxTightWrap *CT_TextboxTightWrap
	// Associated Outline Level
	OutlineLvl *CT_DecimalNumber
	// Associated HTML div ID
	DivId *CT_DecimalNumber
	// Paragraph Conditional Formatting
	CnfStyle *CT_Cnf
}

func NewCT_PPrBase ¶ 

func NewCT_PPrBase() *CT_PPrBase

func (*CT_PPrBase) MarshalXML ¶ 

func (m *CT_PPrBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PPrBase) UnmarshalXML ¶ 

func (m *CT_PPrBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PPrBase) Validate ¶ 

func (m *CT_PPrBase) Validate() error

Validate validates the CT_PPrBase and its children

func (*CT_PPrBase) ValidateWithPath ¶ 

func (m *CT_PPrBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PPrBase and its children, prefixing error messages with path

type CT_PPrChange ¶ 

type CT_PPrChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
	PPr    *CT_PPrBase
}

func NewCT_PPrChange ¶ 

func NewCT_PPrChange() *CT_PPrChange

func (*CT_PPrChange) MarshalXML ¶ 

func (m *CT_PPrChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PPrChange) UnmarshalXML ¶ 

func (m *CT_PPrChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PPrChange) Validate ¶ 

func (m *CT_PPrChange) Validate() error

Validate validates the CT_PPrChange and its children

func (*CT_PPrChange) ValidateWithPath ¶ 

func (m *CT_PPrChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PPrChange and its children, prefixing error messages with path

type CT_PPrDefault ¶ 

type CT_PPrDefault struct {
	// Paragraph Properties
	PPr *CT_PPrGeneral
}

func NewCT_PPrDefault ¶ 

func NewCT_PPrDefault() *CT_PPrDefault

func (*CT_PPrDefault) MarshalXML ¶ 

func (m *CT_PPrDefault) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PPrDefault) UnmarshalXML ¶ 

func (m *CT_PPrDefault) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PPrDefault) Validate ¶ 

func (m *CT_PPrDefault) Validate() error

Validate validates the CT_PPrDefault and its children

func (*CT_PPrDefault) ValidateWithPath ¶ 

func (m *CT_PPrDefault) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PPrDefault and its children, prefixing error messages with path

type CT_PPrGeneral ¶ 

type CT_PPrGeneral struct {
	// Referenced Paragraph Style
	PStyle *CT_String
	// Keep Paragraph With Next Paragraph
	KeepNext *CT_OnOff
	// Keep All Lines On One Page
	KeepLines *CT_OnOff
	// Start Paragraph on Next Page
	PageBreakBefore *CT_OnOff
	// Text Frame Properties
	FramePr *CT_FramePr
	// Allow First/Last Line to Display on a Separate Page
	WidowControl *CT_OnOff
	// Numbering Definition Instance Reference
	NumPr *CT_NumPr
	// Suppress Line Numbers for Paragraph
	SuppressLineNumbers *CT_OnOff
	// Paragraph Borders
	PBdr *CT_PBdr
	// Paragraph Shading
	Shd *CT_Shd
	// Set of Custom Tab Stops
	Tabs *CT_Tabs
	// Suppress Hyphenation for Paragraph
	SuppressAutoHyphens *CT_OnOff
	// Use East Asian Typography Rules for First and Last Character per Line
	Kinsoku *CT_OnOff
	// Allow Line Breaking At Character Level
	WordWrap *CT_OnOff
	// Allow Punctuation to Extend Past Text Extents
	OverflowPunct *CT_OnOff
	// Compress Punctuation at Start of a Line
	TopLinePunct *CT_OnOff
	// Automatically Adjust Spacing of Latin and East Asian Text
	AutoSpaceDE *CT_OnOff
	// Automatically Adjust Spacing of East Asian Text and Numbers
	AutoSpaceDN *CT_OnOff
	// Right to Left Paragraph Layout
	Bidi *CT_OnOff
	// Automatically Adjust Right Indent When Using Document Grid
	AdjustRightInd *CT_OnOff
	// Use Document Grid Settings for Inter-Line Paragraph Spacing
	SnapToGrid *CT_OnOff
	// Spacing Between Lines and Above/Below Paragraph
	Spacing *CT_Spacing
	// Paragraph Indentation
	Ind *CT_Ind
	// Ignore Spacing Above and Below When Using Identical Styles
	ContextualSpacing *CT_OnOff
	// Use Left/Right Indents as Inside/Outside Indents
	MirrorIndents *CT_OnOff
	// Prevent Text Frames From Overlapping
	SuppressOverlap *CT_OnOff
	// Paragraph Alignment
	Jc *CT_Jc
	// Paragraph Text Flow Direction
	TextDirection *CT_TextDirection
	// Vertical Character Alignment on Line
	TextAlignment *CT_TextAlignment
	// Allow Surrounding Paragraphs to Tight Wrap to Text Box Contents
	TextboxTightWrap *CT_TextboxTightWrap
	// Associated Outline Level
	OutlineLvl *CT_DecimalNumber
	// Associated HTML div ID
	DivId *CT_DecimalNumber
	// Paragraph Conditional Formatting
	CnfStyle  *CT_Cnf
	PPrChange *CT_PPrChange
}

func NewCT_PPrGeneral ¶ 

func NewCT_PPrGeneral() *CT_PPrGeneral

func (*CT_PPrGeneral) MarshalXML ¶ 

func (m *CT_PPrGeneral) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PPrGeneral) UnmarshalXML ¶ 

func (m *CT_PPrGeneral) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PPrGeneral) Validate ¶ 

func (m *CT_PPrGeneral) Validate() error

Validate validates the CT_PPrGeneral and its children

func (*CT_PPrGeneral) ValidateWithPath ¶ 

func (m *CT_PPrGeneral) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PPrGeneral and its children, prefixing error messages with path

type CT_PTab ¶ 

type CT_PTab struct {
	// Positional Tab Stop Alignment
	AlignmentAttr ST_PTabAlignment
	// Positional Tab Base
	RelativeToAttr ST_PTabRelativeTo
	// Tab Leader Character
	LeaderAttr ST_PTabLeader
}

func NewCT_PTab ¶ 

func NewCT_PTab() *CT_PTab

func (*CT_PTab) MarshalXML ¶ 

func (m *CT_PTab) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PTab) UnmarshalXML ¶ 

func (m *CT_PTab) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PTab) Validate ¶ 

func (m *CT_PTab) Validate() error

Validate validates the CT_PTab and its children

func (*CT_PTab) ValidateWithPath ¶ 

func (m *CT_PTab) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PTab and its children, prefixing error messages with path

type CT_PageBorder ¶ 

type CT_PageBorder struct {
	IdAttr *string
	// Border Style
	ValAttr ST_Border
	// Border Color
	ColorAttr *ST_HexColor
	// Border Theme Color
	ThemeColorAttr ST_ThemeColor
	// Border Theme Color Tint
	ThemeTintAttr *string
	// Border Theme Color Shade
	ThemeShadeAttr *string
	// Border Width
	SzAttr *uint64
	// Border Spacing Measurement
	SpaceAttr *uint64
	// Border Shadow
	ShadowAttr *sharedTypes.ST_OnOff
	// Create Frame Effect
	FrameAttr *sharedTypes.ST_OnOff
}

func NewCT_PageBorder ¶ 

func NewCT_PageBorder() *CT_PageBorder

func (*CT_PageBorder) MarshalXML ¶ 

func (m *CT_PageBorder) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageBorder) UnmarshalXML ¶ 

func (m *CT_PageBorder) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageBorder) Validate ¶ 

func (m *CT_PageBorder) Validate() error

Validate validates the CT_PageBorder and its children

func (*CT_PageBorder) ValidateWithPath ¶ 

func (m *CT_PageBorder) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageBorder and its children, prefixing error messages with path

type CT_PageBorders ¶ 

type CT_PageBorders struct {
	// Z-Ordering of Page Border
	ZOrderAttr ST_PageBorderZOrder
	// Pages to Display Page Borders
	DisplayAttr ST_PageBorderDisplay
	// Page Border Positioning
	OffsetFromAttr ST_PageBorderOffset
	// Top Border
	Top *CT_TopPageBorder
	// Left Border
	Left *CT_PageBorder
	// Bottom Border
	Bottom *CT_BottomPageBorder
	// Right Border
	Right *CT_PageBorder
}

func NewCT_PageBorders ¶ 

func NewCT_PageBorders() *CT_PageBorders

func (*CT_PageBorders) MarshalXML ¶ 

func (m *CT_PageBorders) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageBorders) UnmarshalXML ¶ 

func (m *CT_PageBorders) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageBorders) Validate ¶ 

func (m *CT_PageBorders) Validate() error

Validate validates the CT_PageBorders and its children

func (*CT_PageBorders) ValidateWithPath ¶ 

func (m *CT_PageBorders) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageBorders and its children, prefixing error messages with path

type CT_PageMar ¶ 

type CT_PageMar struct {
	// Top Margin Spacing
	TopAttr ST_SignedTwipsMeasure
	// Right Margin Spacing
	RightAttr sharedTypes.ST_TwipsMeasure
	// Page Bottom Spacing
	BottomAttr ST_SignedTwipsMeasure
	// Left Margin Spacing
	LeftAttr sharedTypes.ST_TwipsMeasure
	// Spacing to Top of Header
	HeaderAttr sharedTypes.ST_TwipsMeasure
	// Spacing to Bottom of Footer
	FooterAttr sharedTypes.ST_TwipsMeasure
	// Page Gutter Spacing
	GutterAttr sharedTypes.ST_TwipsMeasure
}

func NewCT_PageMar ¶ 

func NewCT_PageMar() *CT_PageMar

func (*CT_PageMar) MarshalXML ¶ 

func (m *CT_PageMar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageMar) UnmarshalXML ¶ 

func (m *CT_PageMar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageMar) Validate ¶ 

func (m *CT_PageMar) Validate() error

Validate validates the CT_PageMar and its children

func (*CT_PageMar) ValidateWithPath ¶ 

func (m *CT_PageMar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageMar and its children, prefixing error messages with path

type CT_PageNumber ¶ 

type CT_PageNumber struct {
	// Page Number Format
	FmtAttr ST_NumberFormat
	// Starting Page Number
	StartAttr *int64
	// Chapter Heading Style
	ChapStyleAttr *int64
	// Chapter Separator Character
	ChapSepAttr ST_ChapterSep
}

func NewCT_PageNumber ¶ 

func NewCT_PageNumber() *CT_PageNumber

func (*CT_PageNumber) MarshalXML ¶ 

func (m *CT_PageNumber) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageNumber) UnmarshalXML ¶ 

func (m *CT_PageNumber) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageNumber) Validate ¶ 

func (m *CT_PageNumber) Validate() error

Validate validates the CT_PageNumber and its children

func (*CT_PageNumber) ValidateWithPath ¶ 

func (m *CT_PageNumber) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageNumber and its children, prefixing error messages with path

type CT_PageSz ¶ 

type CT_PageSz struct {
	// Page Width
	WAttr *sharedTypes.ST_TwipsMeasure
	// Page Height
	HAttr *sharedTypes.ST_TwipsMeasure
	// Page Orientation
	OrientAttr ST_PageOrientation
	// Printer Paper Code
	CodeAttr *int64
}

func NewCT_PageSz ¶ 

func NewCT_PageSz() *CT_PageSz

func (*CT_PageSz) MarshalXML ¶ 

func (m *CT_PageSz) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageSz) UnmarshalXML ¶ 

func (m *CT_PageSz) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageSz) Validate ¶ 

func (m *CT_PageSz) Validate() error

Validate validates the CT_PageSz and its children

func (*CT_PageSz) ValidateWithPath ¶ 

func (m *CT_PageSz) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageSz and its children, prefixing error messages with path

type CT_Panose ¶ 

type CT_Panose struct {
	// Value
	ValAttr string
}

func NewCT_Panose ¶ 

func NewCT_Panose() *CT_Panose

func (*CT_Panose) MarshalXML ¶ 

func (m *CT_Panose) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Panose) UnmarshalXML ¶ 

func (m *CT_Panose) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Panose) Validate ¶ 

func (m *CT_Panose) Validate() error

Validate validates the CT_Panose and its children

func (*CT_Panose) ValidateWithPath ¶ 

func (m *CT_Panose) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Panose and its children, prefixing error messages with path

type CT_PaperSource ¶ 

type CT_PaperSource struct {
	// First Page Printer Tray Code
	FirstAttr *int64
	// Non-First Page Printer Tray Code
	OtherAttr *int64
}

func NewCT_PaperSource ¶ 

func NewCT_PaperSource() *CT_PaperSource

func (*CT_PaperSource) MarshalXML ¶ 

func (m *CT_PaperSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PaperSource) UnmarshalXML ¶ 

func (m *CT_PaperSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PaperSource) Validate ¶ 

func (m *CT_PaperSource) Validate() error

Validate validates the CT_PaperSource and its children

func (*CT_PaperSource) ValidateWithPath ¶ 

func (m *CT_PaperSource) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PaperSource and its children, prefixing error messages with path

type CT_ParaRPr ¶ 

type CT_ParaRPr struct {
	// Inserted Paragraph
	Ins *CT_TrackChange
	// Deleted Paragraph
	Del *CT_TrackChange
	// Move Source Paragraph
	MoveFrom *CT_TrackChange
	// Move Destination Paragraph
	MoveTo *CT_TrackChange
	// Referenced Character Style
	RStyle *CT_String
	// Run Fonts
	RFonts *CT_Fonts
	// Bold
	B *CT_OnOff
	// Complex Script Bold
	BCs *CT_OnOff
	// Italics
	I *CT_OnOff
	// Complex Script Italics
	ICs *CT_OnOff
	// Display All Characters As Capital Letters
	Caps *CT_OnOff
	// Small Caps
	SmallCaps *CT_OnOff
	// Single Strikethrough
	Strike *CT_OnOff
	// Double Strikethrough
	Dstrike *CT_OnOff
	// Display Character Outline
	Outline *CT_OnOff
	// Shadow
	Shadow *CT_OnOff
	// Embossing
	Emboss *CT_OnOff
	// Imprinting
	Imprint *CT_OnOff
	// Do Not Check Spelling or Grammar
	NoProof *CT_OnOff
	// Use Document Grid Settings For Inter-Character Spacing
	SnapToGrid *CT_OnOff
	// Hidden Text
	Vanish *CT_OnOff
	// Web Hidden Text
	WebHidden *CT_OnOff
	// Run Content Color
	Color *CT_Color
	// Character Spacing Adjustment
	Spacing *CT_SignedTwipsMeasure
	// Expanded/Compressed Text
	W *CT_TextScale
	// Font Kerning
	Kern *CT_HpsMeasure
	// Vertically Raised or Lowered Text
	Position *CT_SignedHpsMeasure
	// Non-Complex Script Font Size
	Sz *CT_HpsMeasure
	// Complex Script Font Size
	SzCs *CT_HpsMeasure
	// Text Highlighting
	Highlight *CT_Highlight
	// Underline
	U *CT_Underline
	// Animated Text Effect
	Effect *CT_TextEffect
	// Text Border
	Bdr *CT_Border
	// Run Shading
	Shd *CT_Shd
	// Manual Run Width
	FitText *CT_FitText
	// Subscript/Superscript Text
	VertAlign *CT_VerticalAlignRun
	// Right To Left Text
	Rtl *CT_OnOff
	// Use Complex Script Formatting on Run
	Cs *CT_OnOff
	// Emphasis Mark
	Em *CT_Em
	// Languages for Run Content
	Lang *CT_Language
	// East Asian Typography Settings
	EastAsianLayout *CT_EastAsianLayout
	// Paragraph Mark Is Always Hidden
	SpecVanish *CT_OnOff
	// Office Open XML Math
	OMath *CT_OnOff
	// Revision Information for Run Properties on the Paragraph Mark
	RPrChange *CT_ParaRPrChange
}

func NewCT_ParaRPr ¶ 

func NewCT_ParaRPr() *CT_ParaRPr

func (*CT_ParaRPr) MarshalXML ¶ 

func (m *CT_ParaRPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ParaRPr) UnmarshalXML ¶ 

func (m *CT_ParaRPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ParaRPr) Validate ¶ 

func (m *CT_ParaRPr) Validate() error

Validate validates the CT_ParaRPr and its children

func (*CT_ParaRPr) ValidateWithPath ¶ 

func (m *CT_ParaRPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ParaRPr and its children, prefixing error messages with path

type CT_ParaRPrChange ¶ 

type CT_ParaRPrChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
	RPr    *CT_ParaRPrOriginal
}

func NewCT_ParaRPrChange ¶ 

func NewCT_ParaRPrChange() *CT_ParaRPrChange

func (*CT_ParaRPrChange) MarshalXML ¶ 

func (m *CT_ParaRPrChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ParaRPrChange) UnmarshalXML ¶ 

func (m *CT_ParaRPrChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ParaRPrChange) Validate ¶ 

func (m *CT_ParaRPrChange) Validate() error

Validate validates the CT_ParaRPrChange and its children

func (*CT_ParaRPrChange) ValidateWithPath ¶ 

func (m *CT_ParaRPrChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ParaRPrChange and its children, prefixing error messages with path

type CT_ParaRPrOriginal ¶ 

type CT_ParaRPrOriginal struct {
	// Inserted Paragraph
	Ins *CT_TrackChange
	// Deleted Paragraph
	Del *CT_TrackChange
	// Move Source Paragraph
	MoveFrom *CT_TrackChange
	// Move Destination Paragraph
	MoveTo *CT_TrackChange
	// Referenced Character Style
	RStyle *CT_String
	// Run Fonts
	RFonts *CT_Fonts
	// Bold
	B *CT_OnOff
	// Complex Script Bold
	BCs *CT_OnOff
	// Italics
	I *CT_OnOff
	// Complex Script Italics
	ICs *CT_OnOff
	// Display All Characters As Capital Letters
	Caps *CT_OnOff
	// Small Caps
	SmallCaps *CT_OnOff
	// Single Strikethrough
	Strike *CT_OnOff
	// Double Strikethrough
	Dstrike *CT_OnOff
	// Display Character Outline
	Outline *CT_OnOff
	// Shadow
	Shadow *CT_OnOff
	// Embossing
	Emboss *CT_OnOff
	// Imprinting
	Imprint *CT_OnOff
	// Do Not Check Spelling or Grammar
	NoProof *CT_OnOff
	// Use Document Grid Settings For Inter-Character Spacing
	SnapToGrid *CT_OnOff
	// Hidden Text
	Vanish *CT_OnOff
	// Web Hidden Text
	WebHidden *CT_OnOff
	// Run Content Color
	Color *CT_Color
	// Character Spacing Adjustment
	Spacing *CT_SignedTwipsMeasure
	// Expanded/Compressed Text
	W *CT_TextScale
	// Font Kerning
	Kern *CT_HpsMeasure
	// Vertically Raised or Lowered Text
	Position *CT_SignedHpsMeasure
	// Non-Complex Script Font Size
	Sz *CT_HpsMeasure
	// Complex Script Font Size
	SzCs *CT_HpsMeasure
	// Text Highlighting
	Highlight *CT_Highlight
	// Underline
	U *CT_Underline
	// Animated Text Effect
	Effect *CT_TextEffect
	// Text Border
	Bdr *CT_Border
	// Run Shading
	Shd *CT_Shd
	// Manual Run Width
	FitText *CT_FitText
	// Subscript/Superscript Text
	VertAlign *CT_VerticalAlignRun
	// Right To Left Text
	Rtl *CT_OnOff
	// Use Complex Script Formatting on Run
	Cs *CT_OnOff
	// Emphasis Mark
	Em *CT_Em
	// Languages for Run Content
	Lang *CT_Language
	// East Asian Typography Settings
	EastAsianLayout *CT_EastAsianLayout
	// Paragraph Mark Is Always Hidden
	SpecVanish *CT_OnOff
	// Office Open XML Math
	OMath *CT_OnOff
}

func NewCT_ParaRPrOriginal ¶ 

func NewCT_ParaRPrOriginal() *CT_ParaRPrOriginal

func (*CT_ParaRPrOriginal) MarshalXML ¶ 

func (m *CT_ParaRPrOriginal) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ParaRPrOriginal) UnmarshalXML ¶ 

func (m *CT_ParaRPrOriginal) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ParaRPrOriginal) Validate ¶ 

func (m *CT_ParaRPrOriginal) Validate() error

Validate validates the CT_ParaRPrOriginal and its children

func (*CT_ParaRPrOriginal) ValidateWithPath ¶ 

func (m *CT_ParaRPrOriginal) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ParaRPrOriginal and its children, prefixing error messages with path

type CT_Perm ¶ 

type CT_Perm struct {
	// Annotation ID
	IdAttr string
	// Annotation Displaced By Custom XML Markup
	DisplacedByCustomXmlAttr ST_DisplacedByCustomXml
}

func NewCT_Perm ¶ 

func NewCT_Perm() *CT_Perm

func (*CT_Perm) MarshalXML ¶ 

func (m *CT_Perm) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Perm) UnmarshalXML ¶ 

func (m *CT_Perm) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Perm) Validate ¶ 

func (m *CT_Perm) Validate() error

Validate validates the CT_Perm and its children

func (*CT_Perm) ValidateWithPath ¶ 

func (m *CT_Perm) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Perm and its children, prefixing error messages with path

type CT_PermStart ¶ 

type CT_PermStart struct {
	EdGrpAttr    ST_EdGrp
	EdAttr       *string
	ColFirstAttr *int64
	ColLastAttr  *int64
	// Annotation ID
	IdAttr string
	// Annotation Displaced By Custom XML Markup
	DisplacedByCustomXmlAttr ST_DisplacedByCustomXml
}

func NewCT_PermStart ¶ 

func NewCT_PermStart() *CT_PermStart

func (*CT_PermStart) MarshalXML ¶ 

func (m *CT_PermStart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PermStart) UnmarshalXML ¶ 

func (m *CT_PermStart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PermStart) Validate ¶ 

func (m *CT_PermStart) Validate() error

Validate validates the CT_PermStart and its children

func (*CT_PermStart) ValidateWithPath ¶ 

func (m *CT_PermStart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PermStart and its children, prefixing error messages with path

type CT_Picture ¶ 

type CT_Picture struct {
	// Embedded Video
	Movie *CT_Rel
	// Floating Embedded Control
	Control *CT_Control
}

func NewCT_Picture ¶ 

func NewCT_Picture() *CT_Picture

func (*CT_Picture) MarshalXML ¶ 

func (m *CT_Picture) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Picture) UnmarshalXML ¶ 

func (m *CT_Picture) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Picture) Validate ¶ 

func (m *CT_Picture) Validate() error

Validate validates the CT_Picture and its children

func (*CT_Picture) ValidateWithPath ¶ 

func (m *CT_Picture) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Picture and its children, prefixing error messages with path

type CT_Pitch ¶ 

type CT_Pitch struct {
	// Value
	ValAttr ST_Pitch
}

func NewCT_Pitch ¶ 

func NewCT_Pitch() *CT_Pitch

func (*CT_Pitch) MarshalXML ¶ 

func (m *CT_Pitch) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Pitch) UnmarshalXML ¶ 

func (m *CT_Pitch) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Pitch) Validate ¶ 

func (m *CT_Pitch) Validate() error

Validate validates the CT_Pitch and its children

func (*CT_Pitch) ValidateWithPath ¶ 

func (m *CT_Pitch) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Pitch and its children, prefixing error messages with path

type CT_PixelsMeasure ¶ 

type CT_PixelsMeasure struct {
	// Measurement in Pixels
	ValAttr uint64
}

func NewCT_PixelsMeasure ¶ 

func NewCT_PixelsMeasure() *CT_PixelsMeasure

func (*CT_PixelsMeasure) MarshalXML ¶ 

func (m *CT_PixelsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PixelsMeasure) UnmarshalXML ¶ 

func (m *CT_PixelsMeasure) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PixelsMeasure) Validate ¶ 

func (m *CT_PixelsMeasure) Validate() error

Validate validates the CT_PixelsMeasure and its children

func (*CT_PixelsMeasure) ValidateWithPath ¶ 

func (m *CT_PixelsMeasure) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PixelsMeasure and its children, prefixing error messages with path

type CT_Placeholder ¶ 

type CT_Placeholder struct {
	// Document Part Reference
	DocPart *CT_String
}

func NewCT_Placeholder ¶ 

func NewCT_Placeholder() *CT_Placeholder

func (*CT_Placeholder) MarshalXML ¶ 

func (m *CT_Placeholder) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Placeholder) UnmarshalXML ¶ 

func (m *CT_Placeholder) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Placeholder) Validate ¶ 

func (m *CT_Placeholder) Validate() error

Validate validates the CT_Placeholder and its children

func (*CT_Placeholder) ValidateWithPath ¶ 

func (m *CT_Placeholder) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Placeholder and its children, prefixing error messages with path

type CT_Proof ¶ 

type CT_Proof struct {
	// Spell Checking State
	SpellingAttr ST_Proof
	// Grammatical Checking State
	GrammarAttr ST_Proof
}

func NewCT_Proof ¶ 

func NewCT_Proof() *CT_Proof

func (*CT_Proof) MarshalXML ¶ 

func (m *CT_Proof) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Proof) UnmarshalXML ¶ 

func (m *CT_Proof) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Proof) Validate ¶ 

func (m *CT_Proof) Validate() error

Validate validates the CT_Proof and its children

func (*CT_Proof) ValidateWithPath ¶ 

func (m *CT_Proof) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Proof and its children, prefixing error messages with path

type CT_ProofErr ¶ 

type CT_ProofErr struct {
	// Proofing Error Anchor Type
	TypeAttr ST_ProofErr
}

func NewCT_ProofErr ¶ 

func NewCT_ProofErr() *CT_ProofErr

func (*CT_ProofErr) MarshalXML ¶ 

func (m *CT_ProofErr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ProofErr) UnmarshalXML ¶ 

func (m *CT_ProofErr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ProofErr) Validate ¶ 

func (m *CT_ProofErr) Validate() error

Validate validates the CT_ProofErr and its children

func (*CT_ProofErr) ValidateWithPath ¶ 

func (m *CT_ProofErr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ProofErr and its children, prefixing error messages with path

type CT_R ¶ 

type CT_R struct {
	// Revision Identifier for Run Properties
	RsidRPrAttr *string
	// Revision Identifier for Run Deletion
	RsidDelAttr *string
	// Revision Identifier for Run
	RsidRAttr *string
	// Run Properties
	RPr                *CT_RPr
	EG_RunInnerContent []*EG_RunInnerContent
	Extra              []gooxml.Any
}

func NewCT_R ¶ 

func NewCT_R() *CT_R

func (*CT_R) MarshalXML ¶ 

func (m *CT_R) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_R) UnmarshalXML ¶ 

func (m *CT_R) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_R) Validate ¶ 

func (m *CT_R) Validate() error

Validate validates the CT_R and its children

func (*CT_R) ValidateWithPath ¶ 

func (m *CT_R) ValidateWithPath(path string) error

ValidateWithPath validates the CT_R and its children, prefixing error messages with path

type CT_RPr ¶ 

type CT_RPr struct {
	// Referenced Character Style
	RStyle *CT_String
	// Run Fonts
	RFonts *CT_Fonts
	// Bold
	B *CT_OnOff
	// Complex Script Bold
	BCs *CT_OnOff
	// Italics
	I *CT_OnOff
	// Complex Script Italics
	ICs *CT_OnOff
	// Display All Characters As Capital Letters
	Caps *CT_OnOff
	// Small Caps
	SmallCaps *CT_OnOff
	// Single Strikethrough
	Strike *CT_OnOff
	// Double Strikethrough
	Dstrike *CT_OnOff
	// Display Character Outline
	Outline *CT_OnOff
	// Shadow
	Shadow *CT_OnOff
	// Embossing
	Emboss *CT_OnOff
	// Imprinting
	Imprint *CT_OnOff
	// Do Not Check Spelling or Grammar
	NoProof *CT_OnOff
	// Use Document Grid Settings For Inter-Character Spacing
	SnapToGrid *CT_OnOff
	// Hidden Text
	Vanish *CT_OnOff
	// Web Hidden Text
	WebHidden *CT_OnOff
	// Run Content Color
	Color *CT_Color
	// Character Spacing Adjustment
	Spacing *CT_SignedTwipsMeasure
	// Expanded/Compressed Text
	W *CT_TextScale
	// Font Kerning
	Kern *CT_HpsMeasure
	// Vertically Raised or Lowered Text
	Position *CT_SignedHpsMeasure
	// Non-Complex Script Font Size
	Sz *CT_HpsMeasure
	// Complex Script Font Size
	SzCs *CT_HpsMeasure
	// Text Highlighting
	Highlight *CT_Highlight
	// Underline
	U *CT_Underline
	// Animated Text Effect
	Effect *CT_TextEffect
	// Text Border
	Bdr *CT_Border
	// Run Shading
	Shd *CT_Shd
	// Manual Run Width
	FitText *CT_FitText
	// Subscript/Superscript Text
	VertAlign *CT_VerticalAlignRun
	// Right To Left Text
	Rtl *CT_OnOff
	// Use Complex Script Formatting on Run
	Cs *CT_OnOff
	// Emphasis Mark
	Em *CT_Em
	// Languages for Run Content
	Lang *CT_Language
	// East Asian Typography Settings
	EastAsianLayout *CT_EastAsianLayout
	// Paragraph Mark Is Always Hidden
	SpecVanish *CT_OnOff
	// Office Open XML Math
	OMath *CT_OnOff
	// Revision Information for Run Properties
	RPrChange *CT_RPrChange
}

func NewCT_RPr ¶ 

func NewCT_RPr() *CT_RPr

func (*CT_RPr) MarshalXML ¶ 

func (m *CT_RPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RPr) UnmarshalXML ¶ 

func (m *CT_RPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RPr) Validate ¶ 

func (m *CT_RPr) Validate() error

Validate validates the CT_RPr and its children

func (*CT_RPr) ValidateWithPath ¶ 

func (m *CT_RPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RPr and its children, prefixing error messages with path

type CT_RPrChange ¶ 

type CT_RPrChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
	RPr    *CT_RPrOriginal
}

func NewCT_RPrChange ¶ 

func NewCT_RPrChange() *CT_RPrChange

func (*CT_RPrChange) MarshalXML ¶ 

func (m *CT_RPrChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RPrChange) UnmarshalXML ¶ 

func (m *CT_RPrChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RPrChange) Validate ¶ 

func (m *CT_RPrChange) Validate() error

Validate validates the CT_RPrChange and its children

func (*CT_RPrChange) ValidateWithPath ¶ 

func (m *CT_RPrChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RPrChange and its children, prefixing error messages with path

type CT_RPrDefault ¶ 

type CT_RPrDefault struct {
	// Run Properties
	RPr *CT_RPr
}

func NewCT_RPrDefault ¶ 

func NewCT_RPrDefault() *CT_RPrDefault

func (*CT_RPrDefault) MarshalXML ¶ 

func (m *CT_RPrDefault) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RPrDefault) UnmarshalXML ¶ 

func (m *CT_RPrDefault) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RPrDefault) Validate ¶ 

func (m *CT_RPrDefault) Validate() error

Validate validates the CT_RPrDefault and its children

func (*CT_RPrDefault) ValidateWithPath ¶ 

func (m *CT_RPrDefault) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RPrDefault and its children, prefixing error messages with path

type CT_RPrOriginal ¶ 

type CT_RPrOriginal struct {
	// Referenced Character Style
	RStyle *CT_String
	// Run Fonts
	RFonts *CT_Fonts
	// Bold
	B *CT_OnOff
	// Complex Script Bold
	BCs *CT_OnOff
	// Italics
	I *CT_OnOff
	// Complex Script Italics
	ICs *CT_OnOff
	// Display All Characters As Capital Letters
	Caps *CT_OnOff
	// Small Caps
	SmallCaps *CT_OnOff
	// Single Strikethrough
	Strike *CT_OnOff
	// Double Strikethrough
	Dstrike *CT_OnOff
	// Display Character Outline
	Outline *CT_OnOff
	// Shadow
	Shadow *CT_OnOff
	// Embossing
	Emboss *CT_OnOff
	// Imprinting
	Imprint *CT_OnOff
	// Do Not Check Spelling or Grammar
	NoProof *CT_OnOff
	// Use Document Grid Settings For Inter-Character Spacing
	SnapToGrid *CT_OnOff
	// Hidden Text
	Vanish *CT_OnOff
	// Web Hidden Text
	WebHidden *CT_OnOff
	// Run Content Color
	Color *CT_Color
	// Character Spacing Adjustment
	Spacing *CT_SignedTwipsMeasure
	// Expanded/Compressed Text
	W *CT_TextScale
	// Font Kerning
	Kern *CT_HpsMeasure
	// Vertically Raised or Lowered Text
	Position *CT_SignedHpsMeasure
	// Non-Complex Script Font Size
	Sz *CT_HpsMeasure
	// Complex Script Font Size
	SzCs *CT_HpsMeasure
	// Text Highlighting
	Highlight *CT_Highlight
	// Underline
	U *CT_Underline
	// Animated Text Effect
	Effect *CT_TextEffect
	// Text Border
	Bdr *CT_Border
	// Run Shading
	Shd *CT_Shd
	// Manual Run Width
	FitText *CT_FitText
	// Subscript/Superscript Text
	VertAlign *CT_VerticalAlignRun
	// Right To Left Text
	Rtl *CT_OnOff
	// Use Complex Script Formatting on Run
	Cs *CT_OnOff
	// Emphasis Mark
	Em *CT_Em
	// Languages for Run Content
	Lang *CT_Language
	// East Asian Typography Settings
	EastAsianLayout *CT_EastAsianLayout
	// Paragraph Mark Is Always Hidden
	SpecVanish *CT_OnOff
	// Office Open XML Math
	OMath *CT_OnOff
}

func NewCT_RPrOriginal ¶ 

func NewCT_RPrOriginal() *CT_RPrOriginal

func (*CT_RPrOriginal) MarshalXML ¶ 

func (m *CT_RPrOriginal) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RPrOriginal) UnmarshalXML ¶ 

func (m *CT_RPrOriginal) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RPrOriginal) Validate ¶ 

func (m *CT_RPrOriginal) Validate() error

Validate validates the CT_RPrOriginal and its children

func (*CT_RPrOriginal) ValidateWithPath ¶ 

func (m *CT_RPrOriginal) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RPrOriginal and its children, prefixing error messages with path

type CT_ReadingModeInkLockDown ¶ 

type CT_ReadingModeInkLockDown struct {
	// Use Actual Pages, Not Virtual Pages
	ActualPgAttr sharedTypes.ST_OnOff
	// Virtual Page Width
	WAttr uint64
	// Virtual Page Height
	HAttr uint64
	// Font Size Scaling
	FontSzAttr ST_DecimalNumberOrPercent
}

func NewCT_ReadingModeInkLockDown ¶ 

func NewCT_ReadingModeInkLockDown() *CT_ReadingModeInkLockDown

func (*CT_ReadingModeInkLockDown) MarshalXML ¶ 

func (m *CT_ReadingModeInkLockDown) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ReadingModeInkLockDown) UnmarshalXML ¶ 

func (m *CT_ReadingModeInkLockDown) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ReadingModeInkLockDown) Validate ¶ 

func (m *CT_ReadingModeInkLockDown) Validate() error

Validate validates the CT_ReadingModeInkLockDown and its children

func (*CT_ReadingModeInkLockDown) ValidateWithPath ¶ 

func (m *CT_ReadingModeInkLockDown) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ReadingModeInkLockDown and its children, prefixing error messages with path

type CT_RecipientData ¶ 

type CT_RecipientData struct {
	// Record Is Included in Mail Merge
	Active *CT_OnOff
	// Index of Column Containing Unique Values for Record
	Column *CT_DecimalNumber
	// Unique Value for Record
	UniqueTag *CT_Base64Binary
}

func NewCT_RecipientData ¶ 

func NewCT_RecipientData() *CT_RecipientData

func (*CT_RecipientData) MarshalXML ¶ 

func (m *CT_RecipientData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RecipientData) UnmarshalXML ¶ 

func (m *CT_RecipientData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RecipientData) Validate ¶ 

func (m *CT_RecipientData) Validate() error

Validate validates the CT_RecipientData and its children

func (*CT_RecipientData) ValidateWithPath ¶ 

func (m *CT_RecipientData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RecipientData and its children, prefixing error messages with path

type CT_Recipients ¶ 

type CT_Recipients struct {
	// Data About Single Data Source Record
	RecipientData []*CT_RecipientData
}

func NewCT_Recipients ¶ 

func NewCT_Recipients() *CT_Recipients

func (*CT_Recipients) MarshalXML ¶ 

func (m *CT_Recipients) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Recipients) UnmarshalXML ¶ 

func (m *CT_Recipients) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Recipients) Validate ¶ 

func (m *CT_Recipients) Validate() error

Validate validates the CT_Recipients and its children

func (*CT_Recipients) ValidateWithPath ¶ 

func (m *CT_Recipients) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Recipients and its children, prefixing error messages with path

type CT_Rel ¶ 

type CT_Rel struct {
	IdAttr string
}

func NewCT_Rel ¶ 

func NewCT_Rel() *CT_Rel

func (*CT_Rel) MarshalXML ¶ 

func (m *CT_Rel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Rel) UnmarshalXML ¶ 

func (m *CT_Rel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Rel) Validate ¶ 

func (m *CT_Rel) Validate() error

Validate validates the CT_Rel and its children

func (*CT_Rel) ValidateWithPath ¶ 

func (m *CT_Rel) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Rel and its children, prefixing error messages with path

type CT_Row ¶ 

type CT_Row struct {
	// Revision Identifier for Table Row Glyph Formatting
	RsidRPrAttr *string
	// Revision Identifier for Table Row
	RsidRAttr *string
	// Revision Identifier for Table Row Deletion
	RsidDelAttr *string
	// Revision Identifier for Table Row Properties
	RsidTrAttr *string
	// Table-Level Property Exceptions
	TblPrEx *CT_TblPrEx
	// Table Row Properties
	TrPr                  *CT_TrPr
	EG_ContentCellContent []*EG_ContentCellContent
}

func NewCT_Row ¶ 

func NewCT_Row() *CT_Row

func (*CT_Row) MarshalXML ¶ 

func (m *CT_Row) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Row) UnmarshalXML ¶ 

func (m *CT_Row) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Row) Validate ¶ 

func (m *CT_Row) Validate() error

Validate validates the CT_Row and its children

func (*CT_Row) ValidateWithPath ¶ 

func (m *CT_Row) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Row and its children, prefixing error messages with path

type CT_Ruby ¶ 

type CT_Ruby struct {
	// Phonetic Guide Properties
	RubyPr *CT_RubyPr
	// Phonetic Guide Text
	Rt *CT_RubyContent
	// Phonetic Guide Base Text
	RubyBase *CT_RubyContent
}

func NewCT_Ruby ¶ 

func NewCT_Ruby() *CT_Ruby

func (*CT_Ruby) MarshalXML ¶ 

func (m *CT_Ruby) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Ruby) UnmarshalXML ¶ 

func (m *CT_Ruby) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Ruby) Validate ¶ 

func (m *CT_Ruby) Validate() error

Validate validates the CT_Ruby and its children

func (*CT_Ruby) ValidateWithPath ¶ 

func (m *CT_Ruby) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Ruby and its children, prefixing error messages with path

type CT_RubyAlign ¶ 

type CT_RubyAlign struct {
	// Phonetic Guide Text Alignment Value
	ValAttr ST_RubyAlign
}

func NewCT_RubyAlign ¶ 

func NewCT_RubyAlign() *CT_RubyAlign

func (*CT_RubyAlign) MarshalXML ¶ 

func (m *CT_RubyAlign) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RubyAlign) UnmarshalXML ¶ 

func (m *CT_RubyAlign) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RubyAlign) Validate ¶ 

func (m *CT_RubyAlign) Validate() error

Validate validates the CT_RubyAlign and its children

func (*CT_RubyAlign) ValidateWithPath ¶ 

func (m *CT_RubyAlign) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RubyAlign and its children, prefixing error messages with path

type CT_RubyContent ¶ 

type CT_RubyContent struct {
	// Phonetic Guide Text Run
	R               *CT_R
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewCT_RubyContent ¶ 

func NewCT_RubyContent() *CT_RubyContent

func (*CT_RubyContent) MarshalXML ¶ 

func (m *CT_RubyContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RubyContent) UnmarshalXML ¶ 

func (m *CT_RubyContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RubyContent) Validate ¶ 

func (m *CT_RubyContent) Validate() error

Validate validates the CT_RubyContent and its children

func (*CT_RubyContent) ValidateWithPath ¶ 

func (m *CT_RubyContent) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RubyContent and its children, prefixing error messages with path

type CT_RubyPr ¶ 

type CT_RubyPr struct {
	// Phonetic Guide Text Alignment
	RubyAlign *CT_RubyAlign
	// Phonetic Guide Text Font Size
	Hps *CT_HpsMeasure
	// Distance Between Phonetic Guide Text and Phonetic Guide Base Text
	HpsRaise *CT_HpsMeasure
	// Phonetic Guide Base Text Font Size
	HpsBaseText *CT_HpsMeasure
	// Language ID for Phonetic Guide
	Lid *CT_Lang
	// Invalidated Field Cache
	Dirty *CT_OnOff
}

func NewCT_RubyPr ¶ 

func NewCT_RubyPr() *CT_RubyPr

func (*CT_RubyPr) MarshalXML ¶ 

func (m *CT_RubyPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RubyPr) UnmarshalXML ¶ 

func (m *CT_RubyPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RubyPr) Validate ¶ 

func (m *CT_RubyPr) Validate() error

Validate validates the CT_RubyPr and its children

func (*CT_RubyPr) ValidateWithPath ¶ 

func (m *CT_RubyPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RubyPr and its children, prefixing error messages with path

type CT_RunTrackChange ¶ 

type CT_RunTrackChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
}

func NewCT_RunTrackChange ¶ 

func NewCT_RunTrackChange() *CT_RunTrackChange

func (*CT_RunTrackChange) MarshalXML ¶ 

func (m *CT_RunTrackChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RunTrackChange) UnmarshalXML ¶ 

func (m *CT_RunTrackChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RunTrackChange) Validate ¶ 

func (m *CT_RunTrackChange) Validate() error

Validate validates the CT_RunTrackChange and its children

func (*CT_RunTrackChange) ValidateWithPath ¶ 

func (m *CT_RunTrackChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RunTrackChange and its children, prefixing error messages with path

type CT_SaveThroughXslt ¶ 

type CT_SaveThroughXslt struct {
	IdAttr *string
	// Local Identifier for XSL Transform
	SolutionIDAttr *string
}

func NewCT_SaveThroughXslt ¶ 

func NewCT_SaveThroughXslt() *CT_SaveThroughXslt

func (*CT_SaveThroughXslt) MarshalXML ¶ 

func (m *CT_SaveThroughXslt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SaveThroughXslt) UnmarshalXML ¶ 

func (m *CT_SaveThroughXslt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SaveThroughXslt) Validate ¶ 

func (m *CT_SaveThroughXslt) Validate() error

Validate validates the CT_SaveThroughXslt and its children

func (*CT_SaveThroughXslt) ValidateWithPath ¶ 

func (m *CT_SaveThroughXslt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SaveThroughXslt and its children, prefixing error messages with path

type CT_SdtBlock ¶ 

type CT_SdtBlock struct {
	// Structured Document Tag Properties
	SdtPr *CT_SdtPr
	// Structured Document Tag End Character Properties
	SdtEndPr *CT_SdtEndPr
	// Block-Level Structured Document Tag Content
	SdtContent *CT_SdtContentBlock
}

func NewCT_SdtBlock ¶ 

func NewCT_SdtBlock() *CT_SdtBlock

func (*CT_SdtBlock) MarshalXML ¶ 

func (m *CT_SdtBlock) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtBlock) UnmarshalXML ¶ 

func (m *CT_SdtBlock) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtBlock) Validate ¶ 

func (m *CT_SdtBlock) Validate() error

Validate validates the CT_SdtBlock and its children

func (*CT_SdtBlock) ValidateWithPath ¶ 

func (m *CT_SdtBlock) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtBlock and its children, prefixing error messages with path

type CT_SdtCell ¶ 

type CT_SdtCell struct {
	// Structured Document Tag Properties
	SdtPr *CT_SdtPr
	// Structured Document Tag End Character Properties
	SdtEndPr *CT_SdtEndPr
	// Cell-Level Structured Document Tag Content
	SdtContent *CT_SdtContentCell
}

func NewCT_SdtCell ¶ 

func NewCT_SdtCell() *CT_SdtCell

func (*CT_SdtCell) MarshalXML ¶ 

func (m *CT_SdtCell) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtCell) UnmarshalXML ¶ 

func (m *CT_SdtCell) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtCell) Validate ¶ 

func (m *CT_SdtCell) Validate() error

Validate validates the CT_SdtCell and its children

func (*CT_SdtCell) ValidateWithPath ¶ 

func (m *CT_SdtCell) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtCell and its children, prefixing error messages with path

type CT_SdtComboBox ¶ 

type CT_SdtComboBox struct {
	// Combo Box Last Saved Value
	LastValueAttr *string
	// Combo Box List Item
	ListItem []*CT_SdtListItem
}

func NewCT_SdtComboBox ¶ 

func NewCT_SdtComboBox() *CT_SdtComboBox

func (*CT_SdtComboBox) MarshalXML ¶ 

func (m *CT_SdtComboBox) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtComboBox) UnmarshalXML ¶ 

func (m *CT_SdtComboBox) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtComboBox) Validate ¶ 

func (m *CT_SdtComboBox) Validate() error

Validate validates the CT_SdtComboBox and its children

func (*CT_SdtComboBox) ValidateWithPath ¶ 

func (m *CT_SdtComboBox) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtComboBox and its children, prefixing error messages with path

type CT_SdtContentBlock ¶ 

type CT_SdtContentBlock struct {
	// Block-Level Custom XML Element
	CustomXml *CT_CustomXmlBlock
	// Block-Level Structured Document Tag
	Sdt *CT_SdtBlock
	// Paragraph
	P []*CT_P
	// Table
	Tbl             []*CT_Tbl
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewCT_SdtContentBlock ¶ 

func NewCT_SdtContentBlock() *CT_SdtContentBlock

func (*CT_SdtContentBlock) MarshalXML ¶ 

func (m *CT_SdtContentBlock) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtContentBlock) UnmarshalXML ¶ 

func (m *CT_SdtContentBlock) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtContentBlock) Validate ¶ 

func (m *CT_SdtContentBlock) Validate() error

Validate validates the CT_SdtContentBlock and its children

func (*CT_SdtContentBlock) ValidateWithPath ¶ 

func (m *CT_SdtContentBlock) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtContentBlock and its children, prefixing error messages with path

type CT_SdtContentCell ¶ 

type CT_SdtContentCell struct {
	// Table Cell
	Tc []*CT_Tc
	// Cell-Level Custom XML Element
	CustomXml *CT_CustomXmlCell
	// Cell-Level Structured Document Tag
	Sdt             *CT_SdtCell
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewCT_SdtContentCell ¶ 

func NewCT_SdtContentCell() *CT_SdtContentCell

func (*CT_SdtContentCell) MarshalXML ¶ 

func (m *CT_SdtContentCell) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtContentCell) UnmarshalXML ¶ 

func (m *CT_SdtContentCell) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtContentCell) Validate ¶ 

func (m *CT_SdtContentCell) Validate() error

Validate validates the CT_SdtContentCell and its children

func (*CT_SdtContentCell) ValidateWithPath ¶ 

func (m *CT_SdtContentCell) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtContentCell and its children, prefixing error messages with path

type CT_SdtContentRow ¶ 

type CT_SdtContentRow struct {
	// Table Row
	Tr []*CT_Row
	// Row-Level Custom XML Element
	CustomXml *CT_CustomXmlRow
	// Row-Level Structured Document Tag
	Sdt             *CT_SdtRow
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewCT_SdtContentRow ¶ 

func NewCT_SdtContentRow() *CT_SdtContentRow

func (*CT_SdtContentRow) MarshalXML ¶ 

func (m *CT_SdtContentRow) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtContentRow) UnmarshalXML ¶ 

func (m *CT_SdtContentRow) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtContentRow) Validate ¶ 

func (m *CT_SdtContentRow) Validate() error

Validate validates the CT_SdtContentRow and its children

func (*CT_SdtContentRow) ValidateWithPath ¶ 

func (m *CT_SdtContentRow) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtContentRow and its children, prefixing error messages with path

type CT_SdtContentRun ¶ 

type CT_SdtContentRun struct {
	// Simple Field
	FldSimple []*CT_SimpleField
	// Hyperlink
	Hyperlink *CT_Hyperlink
	// Anchor for Subdocument Location
	SubDoc               *CT_Rel
	EG_ContentRunContent []*EG_ContentRunContent
}

func NewCT_SdtContentRun ¶ 

func NewCT_SdtContentRun() *CT_SdtContentRun

func (*CT_SdtContentRun) MarshalXML ¶ 

func (m *CT_SdtContentRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtContentRun) UnmarshalXML ¶ 

func (m *CT_SdtContentRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtContentRun) Validate ¶ 

func (m *CT_SdtContentRun) Validate() error

Validate validates the CT_SdtContentRun and its children

func (*CT_SdtContentRun) ValidateWithPath ¶ 

func (m *CT_SdtContentRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtContentRun and its children, prefixing error messages with path

type CT_SdtDate ¶ 

type CT_SdtDate struct {
	// Last Known Date in XML Schema DateTime Format
	FullDateAttr *time.Time
	// Date Display Mask
	DateFormat *CT_String
	// Date Picker Language ID
	Lid *CT_Lang
	// Custom XML Data Date Storage Format
	StoreMappedDataAs *CT_SdtDateMappingType
	// Date Picker Calendar Type
	Calendar *CT_CalendarType
}

func NewCT_SdtDate ¶ 

func NewCT_SdtDate() *CT_SdtDate

func (*CT_SdtDate) MarshalXML ¶ 

func (m *CT_SdtDate) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtDate) UnmarshalXML ¶ 

func (m *CT_SdtDate) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtDate) Validate ¶ 

func (m *CT_SdtDate) Validate() error

Validate validates the CT_SdtDate and its children

func (*CT_SdtDate) ValidateWithPath ¶ 

func (m *CT_SdtDate) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtDate and its children, prefixing error messages with path

type CT_SdtDateMappingType ¶ 

type CT_SdtDateMappingType struct {
	// Date Storage Type
	ValAttr ST_SdtDateMappingType
}

func NewCT_SdtDateMappingType ¶ 

func NewCT_SdtDateMappingType() *CT_SdtDateMappingType

func (*CT_SdtDateMappingType) MarshalXML ¶ 

func (m *CT_SdtDateMappingType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtDateMappingType) UnmarshalXML ¶ 

func (m *CT_SdtDateMappingType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtDateMappingType) Validate ¶ 

func (m *CT_SdtDateMappingType) Validate() error

Validate validates the CT_SdtDateMappingType and its children

func (*CT_SdtDateMappingType) ValidateWithPath ¶ 

func (m *CT_SdtDateMappingType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtDateMappingType and its children, prefixing error messages with path

type CT_SdtDocPart ¶ 

type CT_SdtDocPart struct {
	// Document Part Gallery Filter
	DocPartGallery *CT_String
	// Document Part Category Filter
	DocPartCategory *CT_String
	// Built-In Document Part
	DocPartUnique *CT_OnOff
}

func NewCT_SdtDocPart ¶ 

func NewCT_SdtDocPart() *CT_SdtDocPart

func (*CT_SdtDocPart) MarshalXML ¶ 

func (m *CT_SdtDocPart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtDocPart) UnmarshalXML ¶ 

func (m *CT_SdtDocPart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtDocPart) Validate ¶ 

func (m *CT_SdtDocPart) Validate() error

Validate validates the CT_SdtDocPart and its children

func (*CT_SdtDocPart) ValidateWithPath ¶ 

func (m *CT_SdtDocPart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtDocPart and its children, prefixing error messages with path

type CT_SdtDropDownList ¶ 

type CT_SdtDropDownList struct {
	// Drop-down List Last Saved Value
	LastValueAttr *string
	// Drop-Down List Item
	ListItem []*CT_SdtListItem
}

func NewCT_SdtDropDownList ¶ 

func NewCT_SdtDropDownList() *CT_SdtDropDownList

func (*CT_SdtDropDownList) MarshalXML ¶ 

func (m *CT_SdtDropDownList) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtDropDownList) UnmarshalXML ¶ 

func (m *CT_SdtDropDownList) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtDropDownList) Validate ¶ 

func (m *CT_SdtDropDownList) Validate() error

Validate validates the CT_SdtDropDownList and its children

func (*CT_SdtDropDownList) ValidateWithPath ¶ 

func (m *CT_SdtDropDownList) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtDropDownList and its children, prefixing error messages with path

type CT_SdtEndPr ¶ 

type CT_SdtEndPr struct {
	// Structured Document Tag End Character Run Properties
	RPr []*CT_RPr
}

func NewCT_SdtEndPr ¶ 

func NewCT_SdtEndPr() *CT_SdtEndPr

func (*CT_SdtEndPr) MarshalXML ¶ 

func (m *CT_SdtEndPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtEndPr) UnmarshalXML ¶ 

func (m *CT_SdtEndPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtEndPr) Validate ¶ 

func (m *CT_SdtEndPr) Validate() error

Validate validates the CT_SdtEndPr and its children

func (*CT_SdtEndPr) ValidateWithPath ¶ 

func (m *CT_SdtEndPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtEndPr and its children, prefixing error messages with path

type CT_SdtListItem ¶ 

type CT_SdtListItem struct {
	// List Entry Display Text
	DisplayTextAttr *string
	// List Entry Value
	ValueAttr *string
}

func NewCT_SdtListItem ¶ 

func NewCT_SdtListItem() *CT_SdtListItem

func (*CT_SdtListItem) MarshalXML ¶ 

func (m *CT_SdtListItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtListItem) UnmarshalXML ¶ 

func (m *CT_SdtListItem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtListItem) Validate ¶ 

func (m *CT_SdtListItem) Validate() error

Validate validates the CT_SdtListItem and its children

func (*CT_SdtListItem) ValidateWithPath ¶ 

func (m *CT_SdtListItem) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtListItem and its children, prefixing error messages with path

type CT_SdtPr ¶ 

type CT_SdtPr struct {
	// Run Properties For Structured Document Tag Contents
	RPr *CT_RPr
	// Friendly Name
	Alias *CT_String
	// Programmatic Tag
	Tag *CT_String
	// Unique ID
	Id *CT_DecimalNumber
	// Locking Setting
	Lock *CT_Lock
	// Structured Document Tag Placeholder Text
	Placeholder *CT_Placeholder
	// Remove Structured Document Tag When Contents Are Edited
	Temporary *CT_OnOff
	// Current Contents Are Placeholder Text
	ShowingPlcHdr *CT_OnOff
	// XML Mapping
	DataBinding *CT_DataBinding
	// Structured Document Tag Label
	Label *CT_DecimalNumber
	// Structured Document Tag Navigation Order Index
	TabIndex *CT_UnsignedDecimalNumber
	Choice   *CT_SdtPrChoice
	Extra    []gooxml.Any
}

func NewCT_SdtPr ¶ 

func NewCT_SdtPr() *CT_SdtPr

func (*CT_SdtPr) MarshalXML ¶ 

func (m *CT_SdtPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtPr) UnmarshalXML ¶ 

func (m *CT_SdtPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtPr) Validate ¶ 

func (m *CT_SdtPr) Validate() error

Validate validates the CT_SdtPr and its children

func (*CT_SdtPr) ValidateWithPath ¶ 

func (m *CT_SdtPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtPr and its children, prefixing error messages with path

type CT_SdtPrChoice ¶ 

type CT_SdtPrChoice struct {
	Equation     *CT_Empty
	ComboBox     *CT_SdtComboBox
	Date         *CT_SdtDate
	DocPartObj   *CT_SdtDocPart
	DocPartList  *CT_SdtDocPart
	DropDownList *CT_SdtDropDownList
	Picture      *CT_Empty
	RichText     *CT_Empty
	Text         *CT_SdtText
	Citation     *CT_Empty
	Group        *CT_Empty
	Bibliography *CT_Empty
}

func NewCT_SdtPrChoice ¶ 

func NewCT_SdtPrChoice() *CT_SdtPrChoice

func (*CT_SdtPrChoice) MarshalXML ¶ 

func (m *CT_SdtPrChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtPrChoice) UnmarshalXML ¶ 

func (m *CT_SdtPrChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtPrChoice) Validate ¶ 

func (m *CT_SdtPrChoice) Validate() error

Validate validates the CT_SdtPrChoice and its children

func (*CT_SdtPrChoice) ValidateWithPath ¶ 

func (m *CT_SdtPrChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtPrChoice and its children, prefixing error messages with path

type CT_SdtRow ¶ 

type CT_SdtRow struct {
	// Structured Document Tag Properties
	SdtPr *CT_SdtPr
	// Structured Document Tag End Character Properties
	SdtEndPr *CT_SdtEndPr
	// Row-Level Structured Document Tag Content
	SdtContent *CT_SdtContentRow
}

func NewCT_SdtRow ¶ 

func NewCT_SdtRow() *CT_SdtRow

func (*CT_SdtRow) MarshalXML ¶ 

func (m *CT_SdtRow) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtRow) UnmarshalXML ¶ 

func (m *CT_SdtRow) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtRow) Validate ¶ 

func (m *CT_SdtRow) Validate() error

Validate validates the CT_SdtRow and its children

func (*CT_SdtRow) ValidateWithPath ¶ 

func (m *CT_SdtRow) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtRow and its children, prefixing error messages with path

type CT_SdtRun ¶ 

type CT_SdtRun struct {
	// Structured Document Tag Properties
	SdtPr *CT_SdtPr
	// Structured Document Tag End Character Properties
	SdtEndPr *CT_SdtEndPr
	// Inline-Level Structured Document Tag Content
	SdtContent *CT_SdtContentRun
}

func NewCT_SdtRun ¶ 

func NewCT_SdtRun() *CT_SdtRun

func (*CT_SdtRun) MarshalXML ¶ 

func (m *CT_SdtRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtRun) UnmarshalXML ¶ 

func (m *CT_SdtRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtRun) Validate ¶ 

func (m *CT_SdtRun) Validate() error

Validate validates the CT_SdtRun and its children

func (*CT_SdtRun) ValidateWithPath ¶ 

func (m *CT_SdtRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtRun and its children, prefixing error messages with path

type CT_SdtText ¶ 

type CT_SdtText struct {
	// Allow Soft Line Breaks
	MultiLineAttr *sharedTypes.ST_OnOff
}

func NewCT_SdtText ¶ 

func NewCT_SdtText() *CT_SdtText

func (*CT_SdtText) MarshalXML ¶ 

func (m *CT_SdtText) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SdtText) UnmarshalXML ¶ 

func (m *CT_SdtText) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SdtText) Validate ¶ 

func (m *CT_SdtText) Validate() error

Validate validates the CT_SdtText and its children

func (*CT_SdtText) ValidateWithPath ¶ 

func (m *CT_SdtText) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SdtText and its children, prefixing error messages with path

type CT_SectPr ¶ 

type CT_SectPr struct {
	EG_HdrFtrReferences []*EG_HdrFtrReferences
	// Section-Wide Footnote Properties
	FootnotePr *CT_FtnProps
	// Section-Wide Endnote Properties
	EndnotePr *CT_EdnProps
	// Section Type
	Type *CT_SectType
	// Page Size
	PgSz *CT_PageSz
	// Page Margins
	PgMar *CT_PageMar
	// Paper Source Information
	PaperSrc *CT_PaperSource
	// Page Borders
	PgBorders *CT_PageBorders
	// Line Numbering Settings
	LnNumType *CT_LineNumber
	// Page Numbering Settings
	PgNumType *CT_PageNumber
	// Column Definitions
	Cols *CT_Columns
	// Only Allow Editing of Form Fields
	FormProt *CT_OnOff
	// Vertical Text Alignment on Page
	VAlign *CT_VerticalJc
	// Suppress Endnotes In Document
	NoEndnote *CT_OnOff
	// Different First Page Headers and Footers
	TitlePg *CT_OnOff
	// Text Flow Direction
	TextDirection *CT_TextDirection
	// Right to Left Section Layout
	Bidi *CT_OnOff
	// Gutter on Right Side of Page
	RtlGutter *CT_OnOff
	// Document Grid
	DocGrid *CT_DocGrid
	// Reference to Printer Settings Data
	PrinterSettings *CT_Rel
	// Revision Information for Section Properties
	SectPrChange *CT_SectPrChange
	RsidRPrAttr  *string
	RsidDelAttr  *string
	RsidRAttr    *string
	RsidSectAttr *string
}

func NewCT_SectPr ¶ 

func NewCT_SectPr() *CT_SectPr

func (*CT_SectPr) MarshalXML ¶ 

func (m *CT_SectPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SectPr) UnmarshalXML ¶ 

func (m *CT_SectPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SectPr) Validate ¶ 

func (m *CT_SectPr) Validate() error

Validate validates the CT_SectPr and its children

func (*CT_SectPr) ValidateWithPath ¶ 

func (m *CT_SectPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SectPr and its children, prefixing error messages with path

type CT_SectPrBase ¶ 

type CT_SectPrBase struct {
	// Section-Wide Footnote Properties
	FootnotePr *CT_FtnProps
	// Section-Wide Endnote Properties
	EndnotePr *CT_EdnProps
	// Section Type
	Type *CT_SectType
	// Page Size
	PgSz *CT_PageSz
	// Page Margins
	PgMar *CT_PageMar
	// Paper Source Information
	PaperSrc *CT_PaperSource
	// Page Borders
	PgBorders *CT_PageBorders
	// Line Numbering Settings
	LnNumType *CT_LineNumber
	// Page Numbering Settings
	PgNumType *CT_PageNumber
	// Column Definitions
	Cols *CT_Columns
	// Only Allow Editing of Form Fields
	FormProt *CT_OnOff
	// Vertical Text Alignment on Page
	VAlign *CT_VerticalJc
	// Suppress Endnotes In Document
	NoEndnote *CT_OnOff
	// Different First Page Headers and Footers
	TitlePg *CT_OnOff
	// Text Flow Direction
	TextDirection *CT_TextDirection
	// Right to Left Section Layout
	Bidi *CT_OnOff
	// Gutter on Right Side of Page
	RtlGutter *CT_OnOff
	// Document Grid
	DocGrid *CT_DocGrid
	// Reference to Printer Settings Data
	PrinterSettings *CT_Rel
	RsidRPrAttr     *string
	RsidDelAttr     *string
	RsidRAttr       *string
	RsidSectAttr    *string
}

func NewCT_SectPrBase ¶ 

func NewCT_SectPrBase() *CT_SectPrBase

func (*CT_SectPrBase) MarshalXML ¶ 

func (m *CT_SectPrBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SectPrBase) UnmarshalXML ¶ 

func (m *CT_SectPrBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SectPrBase) Validate ¶ 

func (m *CT_SectPrBase) Validate() error

Validate validates the CT_SectPrBase and its children

func (*CT_SectPrBase) ValidateWithPath ¶ 

func (m *CT_SectPrBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SectPrBase and its children, prefixing error messages with path

type CT_SectPrChange ¶ 

type CT_SectPrChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
	SectPr *CT_SectPrBase
}

func NewCT_SectPrChange ¶ 

func NewCT_SectPrChange() *CT_SectPrChange

func (*CT_SectPrChange) MarshalXML ¶ 

func (m *CT_SectPrChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SectPrChange) UnmarshalXML ¶ 

func (m *CT_SectPrChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SectPrChange) Validate ¶ 

func (m *CT_SectPrChange) Validate() error

Validate validates the CT_SectPrChange and its children

func (*CT_SectPrChange) ValidateWithPath ¶ 

func (m *CT_SectPrChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SectPrChange and its children, prefixing error messages with path

type CT_SectType ¶ 

type CT_SectType struct {
	// Section Type Setting
	ValAttr ST_SectionMark
}

func NewCT_SectType ¶ 

func NewCT_SectType() *CT_SectType

func (*CT_SectType) MarshalXML ¶ 

func (m *CT_SectType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SectType) UnmarshalXML ¶ 

func (m *CT_SectType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SectType) Validate ¶ 

func (m *CT_SectType) Validate() error

Validate validates the CT_SectType and its children

func (*CT_SectType) ValidateWithPath ¶ 

func (m *CT_SectType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SectType and its children, prefixing error messages with path

type CT_Settings ¶ 

type CT_Settings struct {
	// Write Protection
	WriteProtection *CT_WriteProtection
	// Document View Setting
	View *CT_View
	// Magnification Setting
	Zoom *CT_Zoom
	// Remove Personal Information from Document Properties
	RemovePersonalInformation *CT_OnOff
	// Remove Date and Time from Annotations
	RemoveDateAndTime *CT_OnOff
	// Do Not Display Visual Boundary For Header/Footer or Between Pages
	DoNotDisplayPageBoundaries *CT_OnOff
	// Display Background Objects When Displaying Document
	DisplayBackgroundShape *CT_OnOff
	// Print PostScript Codes With Document Text
	PrintPostScriptOverText *CT_OnOff
	// Print Fractional Character Widths
	PrintFractionalCharacterWidth *CT_OnOff
	// Only Print Form Field Content
	PrintFormsData *CT_OnOff
	// Embed TrueType Fonts
	EmbedTrueTypeFonts *CT_OnOff
	// Embed Common System Fonts
	EmbedSystemFonts *CT_OnOff
	// Subset Fonts When Embedding
	SaveSubsetFonts *CT_OnOff
	// Only Save Form Field Content
	SaveFormsData *CT_OnOff
	// Mirror Page Margins
	MirrorMargins *CT_OnOff
	// Align Paragraph and Table Borders with Page Border
	AlignBordersAndEdges *CT_OnOff
	// Page Border Excludes Header
	BordersDoNotSurroundHeader *CT_OnOff
	// Page Border Excludes Footer
	BordersDoNotSurroundFooter *CT_OnOff
	// Position Gutter At Top of Page
	GutterAtTop *CT_OnOff
	// Do Not Display Visual Indication of Spelling Errors
	HideSpellingErrors *CT_OnOff
	// Do Not Display Visual Indication of Grammatical Errors
	HideGrammaticalErrors *CT_OnOff
	// Grammar Checking Settings
	ActiveWritingStyle []*CT_WritingStyle
	// Spelling and Grammatical Checking State
	ProofState *CT_Proof
	// Structured Document Tag Placeholder Text Should be Resaved
	FormsDesign *CT_OnOff
	// Attached Document Template
	AttachedTemplate *CT_Rel
	// Automatically Update Styles From Document Template
	LinkStyles *CT_OnOff
	// Suggested Filtering for List of Document Styles
	StylePaneFormatFilter *CT_StylePaneFilter
	// Suggested Sorting for List of Document Styles
	StylePaneSortMethod *CT_StyleSort
	// Document Classification
	DocumentType *CT_DocType
	// Mail Merge Settings
	MailMerge *CT_MailMerge
	// Visibility of Annotation Types
	RevisionView *CT_TrackChangesView
	// Track Revisions to Document
	TrackRevisions *CT_OnOff
	// Do Not Use Move Syntax When Tracking Revisions
	DoNotTrackMoves *CT_OnOff
	// Do Not Track Formatting Revisions When Tracking Revisions
	DoNotTrackFormatting *CT_OnOff
	// Document Editing Restrictions
	DocumentProtection *CT_DocProtect
	// Allow Automatic Formatting to Override Formatting Protection Settings
	AutoFormatOverride *CT_OnOff
	// Prevent Modification of Themes Part
	StyleLockTheme *CT_OnOff
	// Prevent Replacement of Styles Part
	StyleLockQFSet *CT_OnOff
	// Distance Between Automatic Tab Stops
	DefaultTabStop *CT_TwipsMeasure
	// Automatically Hyphenate Document Contents When Displayed
	AutoHyphenation *CT_OnOff
	// Maximum Number of Consecutively Hyphenated Lines
	ConsecutiveHyphenLimit *CT_DecimalNumber
	// Hyphenation Zone
	HyphenationZone *CT_TwipsMeasure
	// Do Not Hyphenate Words in ALL CAPITAL LETTERS
	DoNotHyphenateCaps *CT_OnOff
	// Show E-Mail Message Header
	ShowEnvelope *CT_OnOff
	// Percentage of Document to Use When Generating Summary
	SummaryLength *CT_DecimalNumberOrPrecent
	// Paragraph Style Applied to Automatically Generated Paragraphs
	ClickAndTypeStyle *CT_String
	// Default Table Style for Newly Inserted Tables
	DefaultTableStyle *CT_String
	// Different Even/Odd Page Headers and Footers
	EvenAndOddHeaders *CT_OnOff
	// Reverse Book Fold Printing
	BookFoldRevPrinting *CT_OnOff
	// Book Fold Printing
	BookFoldPrinting *CT_OnOff
	// Number of Pages Per Booklet
	BookFoldPrintingSheets *CT_DecimalNumber
	// Drawing Grid Horizontal Grid Unit Size
	DrawingGridHorizontalSpacing *CT_TwipsMeasure
	// Drawing Grid Vertical Grid Unit Size
	DrawingGridVerticalSpacing *CT_TwipsMeasure
	// Distance between Horizontal Gridlines
	DisplayHorizontalDrawingGridEvery *CT_DecimalNumber
	// Distance between Vertical Gridlines
	DisplayVerticalDrawingGridEvery *CT_DecimalNumber
	// Do Not Use Margins for Drawing Grid Origin
	DoNotUseMarginsForDrawingGridOrigin *CT_OnOff
	// Drawing Grid Horizontal Origin Point
	DrawingGridHorizontalOrigin *CT_TwipsMeasure
	// Drawing Grid Vertical Origin Point
	DrawingGridVerticalOrigin *CT_TwipsMeasure
	// Do Not Show Visual Indicator For Form Fields
	DoNotShadeFormData *CT_OnOff
	// Never Kern Punctuation Characters
	NoPunctuationKerning *CT_OnOff
	// Character-Level Whitespace Compression
	CharacterSpacingControl *CT_CharacterSpacing
	// Print Two Pages Per Sheet
	PrintTwoOnOne *CT_OnOff
	// Use Strict Kinsoku Rules for Japanese Text
	StrictFirstAndLastChars *CT_OnOff
	// Custom Set of Characters Which Cannot End a Line
	NoLineBreaksAfter *CT_Kinsoku
	// Custom Set Of Characters Which Cannot Begin A Line
	NoLineBreaksBefore *CT_Kinsoku
	// Generate Thumbnail For Document On Save
	SavePreviewPicture *CT_OnOff
	// Do Not Validate Custom XML Markup Against Schemas
	DoNotValidateAgainstSchema *CT_OnOff
	// Allow Saving Document As XML File When Custom XML Markup Is Invalid
	SaveInvalidXml *CT_OnOff
	// Ignore Mixed Content When Validating Custom XML Markup
	IgnoreMixedContent *CT_OnOff
	// Use Custom XML Element Names as Default Placeholder Text
	AlwaysShowPlaceholderText *CT_OnOff
	// Do Not Show Visual Indicator For Invalid Custom XML Markup
	DoNotDemarcateInvalidXml *CT_OnOff
	// Only Save Custom XML Markup
	SaveXmlDataOnly *CT_OnOff
	// Save Document as XML File through Custom XSL Transform
	UseXSLTWhenSaving *CT_OnOff
	// Custom XSL Transform To Use When Saving As XML File
	SaveThroughXslt *CT_SaveThroughXslt
	// Show Visual Indicators for Custom XML Markup Start/End Locations
	ShowXMLTags *CT_OnOff
	// Do Not Mark Custom XML Elements With No Namespace As Invalid
	AlwaysMergeEmptyNamespace *CT_OnOff
	// Automatically Recalculate Fields on Open
	UpdateFields *CT_OnOff
	// Default Properties for VML Objects in Header and Footer
	HdrShapeDefaults *CT_ShapeDefaults
	// Document-Wide Footnote Properties
	FootnotePr *CT_FtnDocProps
	// Document-Wide Endnote Properties
	EndnotePr *CT_EdnDocProps
	// Compatibility Settings
	Compat *CT_Compat
	// Document Variables
	DocVars *CT_DocVars
	// Listing of All Revision Save ID Values
	Rsids  *CT_DocRsids
	MathPr *math.MathPr
	// Attached Custom XML Schema
	AttachedSchema []*CT_String
	// Theme Font Languages
	ThemeFontLang *CT_Language
	// Theme Color Mappings
	ClrSchemeMapping *CT_ColorSchemeMapping
	// Do Not Include Content in Text Boxes, Footnotes, and Endnotes in Document Statistics
	DoNotIncludeSubdocsInStats *CT_OnOff
	// Do Not Automatically Compress Images
	DoNotAutoCompressPictures *CT_OnOff
	// Upgrade Document on Open
	ForceUpgrade *CT_Empty
	// Caption Settings
	Captions *CT_Captions
	// Freeze Document Layout
	ReadModeInkLockDown *CT_ReadingModeInkLockDown
	// Supplementary Smart Tag Information
	SmartTagType  []*CT_SmartTagType
	SchemaLibrary *schemaLibrary.SchemaLibrary
	// Default Properties for VML Objects in Main Document
	ShapeDefaults *CT_ShapeDefaults
	// Remove Smart Tags When Saving
	DoNotEmbedSmartTags *CT_OnOff
	// Radix Point for Field Code Evaluation
	DecimalSymbol *CT_String
	// List Separator for Field Code Evaluation
	ListSeparator *CT_String
	Extra         []gooxml.Any
}

func NewCT_Settings ¶ 

func NewCT_Settings() *CT_Settings

func (*CT_Settings) MarshalXML ¶ 

func (m *CT_Settings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Settings) UnmarshalXML ¶ 

func (m *CT_Settings) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Settings) Validate ¶ 

func (m *CT_Settings) Validate() error

Validate validates the CT_Settings and its children

func (*CT_Settings) ValidateWithPath ¶ 

func (m *CT_Settings) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Settings and its children, prefixing error messages with path

type CT_ShapeDefaults ¶ 

type CT_ShapeDefaults struct {
	Any []gooxml.Any
}

func NewCT_ShapeDefaults ¶ 

func NewCT_ShapeDefaults() *CT_ShapeDefaults

func (*CT_ShapeDefaults) MarshalXML ¶ 

func (m *CT_ShapeDefaults) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ShapeDefaults) UnmarshalXML ¶ 

func (m *CT_ShapeDefaults) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ShapeDefaults) Validate ¶ 

func (m *CT_ShapeDefaults) Validate() error

Validate validates the CT_ShapeDefaults and its children

func (*CT_ShapeDefaults) ValidateWithPath ¶ 

func (m *CT_ShapeDefaults) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ShapeDefaults and its children, prefixing error messages with path

type CT_Shd ¶ 

type CT_Shd struct {
	// Shading Pattern
	ValAttr ST_Shd
	// Shading Pattern Color
	ColorAttr *ST_HexColor
	// Shading Pattern Theme Color
	ThemeColorAttr ST_ThemeColor
	// Shading Pattern Theme Color Tint
	ThemeTintAttr *string
	// Shading Pattern Theme Color Shade
	ThemeShadeAttr *string
	// Shading Background Color
	FillAttr *ST_HexColor
	// Shading Background Theme Color
	ThemeFillAttr ST_ThemeColor
	// Shading Background Theme Color Tint
	ThemeFillTintAttr *string
	// Shading Background Theme Color Shade
	ThemeFillShadeAttr *string
}

func NewCT_Shd ¶ 

func NewCT_Shd() *CT_Shd

func (*CT_Shd) MarshalXML ¶ 

func (m *CT_Shd) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Shd) UnmarshalXML ¶ 

func (m *CT_Shd) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Shd) Validate ¶ 

func (m *CT_Shd) Validate() error

Validate validates the CT_Shd and its children

func (*CT_Shd) ValidateWithPath ¶ 

func (m *CT_Shd) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Shd and its children, prefixing error messages with path

type CT_SignedHpsMeasure ¶ 

type CT_SignedHpsMeasure struct {
	// Signed Half-Point Measurement
	ValAttr ST_SignedHpsMeasure
}

func NewCT_SignedHpsMeasure ¶ 

func NewCT_SignedHpsMeasure() *CT_SignedHpsMeasure

func (*CT_SignedHpsMeasure) MarshalXML ¶ 

func (m *CT_SignedHpsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SignedHpsMeasure) UnmarshalXML ¶ 

func (m *CT_SignedHpsMeasure) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SignedHpsMeasure) Validate ¶ 

func (m *CT_SignedHpsMeasure) Validate() error

Validate validates the CT_SignedHpsMeasure and its children

func (*CT_SignedHpsMeasure) ValidateWithPath ¶ 

func (m *CT_SignedHpsMeasure) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SignedHpsMeasure and its children, prefixing error messages with path

type CT_SignedTwipsMeasure ¶ 

type CT_SignedTwipsMeasure struct {
	// Positive or Negative Value in Twentieths of a Point
	ValAttr ST_SignedTwipsMeasure
}

func NewCT_SignedTwipsMeasure ¶ 

func NewCT_SignedTwipsMeasure() *CT_SignedTwipsMeasure

func (*CT_SignedTwipsMeasure) MarshalXML ¶ 

func (m *CT_SignedTwipsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SignedTwipsMeasure) UnmarshalXML ¶ 

func (m *CT_SignedTwipsMeasure) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SignedTwipsMeasure) Validate ¶ 

func (m *CT_SignedTwipsMeasure) Validate() error

Validate validates the CT_SignedTwipsMeasure and its children

func (*CT_SignedTwipsMeasure) ValidateWithPath ¶ 

func (m *CT_SignedTwipsMeasure) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SignedTwipsMeasure and its children, prefixing error messages with path

type CT_SimpleField ¶ 

type CT_SimpleField struct {
	// Field Codes
	InstrAttr string
	// Field Should Not Be Recalculated
	FldLockAttr *sharedTypes.ST_OnOff
	// Field Result Invalidated
	DirtyAttr *sharedTypes.ST_OnOff
	// Custom Field Data
	FldData     *CT_Text
	EG_PContent []*EG_PContent
}

func NewCT_SimpleField ¶ 

func NewCT_SimpleField() *CT_SimpleField

func (*CT_SimpleField) MarshalXML ¶ 

func (m *CT_SimpleField) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SimpleField) UnmarshalXML ¶ 

func (m *CT_SimpleField) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SimpleField) Validate ¶ 

func (m *CT_SimpleField) Validate() error

Validate validates the CT_SimpleField and its children

func (*CT_SimpleField) ValidateWithPath ¶ 

func (m *CT_SimpleField) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SimpleField and its children, prefixing error messages with path

type CT_SmartTagPr ¶ 

type CT_SmartTagPr struct {
	// Smart Tag Property
	Attr []*CT_Attr
}

func NewCT_SmartTagPr ¶ 

func NewCT_SmartTagPr() *CT_SmartTagPr

func (*CT_SmartTagPr) MarshalXML ¶ 

func (m *CT_SmartTagPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SmartTagPr) UnmarshalXML ¶ 

func (m *CT_SmartTagPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SmartTagPr) Validate ¶ 

func (m *CT_SmartTagPr) Validate() error

Validate validates the CT_SmartTagPr and its children

func (*CT_SmartTagPr) ValidateWithPath ¶ 

func (m *CT_SmartTagPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SmartTagPr and its children, prefixing error messages with path

type CT_SmartTagRun ¶ 

type CT_SmartTagRun struct {
	// Smart Tag Namespace
	UriAttr *string
	// Smart Tag Name
	ElementAttr string
	// Smart Tag Properties
	SmartTagPr  *CT_SmartTagPr
	EG_PContent []*EG_PContent
}

func NewCT_SmartTagRun ¶ 

func NewCT_SmartTagRun() *CT_SmartTagRun

func (*CT_SmartTagRun) MarshalXML ¶ 

func (m *CT_SmartTagRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SmartTagRun) UnmarshalXML ¶ 

func (m *CT_SmartTagRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SmartTagRun) Validate ¶ 

func (m *CT_SmartTagRun) Validate() error

Validate validates the CT_SmartTagRun and its children

func (*CT_SmartTagRun) ValidateWithPath ¶ 

func (m *CT_SmartTagRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SmartTagRun and its children, prefixing error messages with path

type CT_SmartTagType ¶ 

type CT_SmartTagType struct {
	// Smart Tag Namespace
	NamespaceuriAttr *string
	// Smart Tag Name
	NameAttr *string
	// Smart Tag Supplementary URL
	UrlAttr *string
}

func NewCT_SmartTagType ¶ 

func NewCT_SmartTagType() *CT_SmartTagType

func (*CT_SmartTagType) MarshalXML ¶ 

func (m *CT_SmartTagType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SmartTagType) UnmarshalXML ¶ 

func (m *CT_SmartTagType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SmartTagType) Validate ¶ 

func (m *CT_SmartTagType) Validate() error

Validate validates the CT_SmartTagType and its children

func (*CT_SmartTagType) ValidateWithPath ¶ 

func (m *CT_SmartTagType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SmartTagType and its children, prefixing error messages with path

type CT_Spacing ¶ 

type CT_Spacing struct {
	// Spacing Above Paragraph
	BeforeAttr *sharedTypes.ST_TwipsMeasure
	// Spacing Above Paragraph IN Line Units
	BeforeLinesAttr *int64
	// Automatically Determine Spacing Above Paragraph
	BeforeAutospacingAttr *sharedTypes.ST_OnOff
	// Spacing Below Paragraph
	AfterAttr *sharedTypes.ST_TwipsMeasure
	// Spacing Below Paragraph in Line Units
	AfterLinesAttr *int64
	// Automatically Determine Spacing Below Paragraph
	AfterAutospacingAttr *sharedTypes.ST_OnOff
	// Spacing Between Lines in Paragraph
	LineAttr *ST_SignedTwipsMeasure
	// Spacing Between Lines
	LineRuleAttr ST_LineSpacingRule
}

func NewCT_Spacing ¶ 

func NewCT_Spacing() *CT_Spacing

func (*CT_Spacing) MarshalXML ¶ 

func (m *CT_Spacing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Spacing) UnmarshalXML ¶ 

func (m *CT_Spacing) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Spacing) Validate ¶ 

func (m *CT_Spacing) Validate() error

Validate validates the CT_Spacing and its children

func (*CT_Spacing) ValidateWithPath ¶ 

func (m *CT_Spacing) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Spacing and its children, prefixing error messages with path

type CT_String ¶ 

type CT_String struct {
	// String Value
	ValAttr string
}

func NewCT_String ¶ 

func NewCT_String() *CT_String

func (*CT_String) MarshalXML ¶ 

func (m *CT_String) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_String) UnmarshalXML ¶ 

func (m *CT_String) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_String) Validate ¶ 

func (m *CT_String) Validate() error

Validate validates the CT_String and its children

func (*CT_String) ValidateWithPath ¶ 

func (m *CT_String) ValidateWithPath(path string) error

ValidateWithPath validates the CT_String and its children, prefixing error messages with path

type CT_Style ¶ 

type CT_Style struct {
	// Style Type
	TypeAttr ST_StyleType
	// Style ID
	StyleIdAttr *string
	// Default Style
	DefaultAttr *sharedTypes.ST_OnOff
	// User-Defined Style
	CustomStyleAttr *sharedTypes.ST_OnOff
	// Primary Style Name
	Name *CT_String
	// Alternate Style Names
	Aliases *CT_String
	// Parent Style ID
	BasedOn *CT_String
	// Style For Next Paragraph
	Next *CT_String
	// Linked Style Reference
	Link *CT_String
	// Automatically Merge User Formatting Into Style Definition
	AutoRedefine *CT_OnOff
	// Hide Style From User Interface
	Hidden *CT_OnOff
	// Optional User Interface Sorting Order
	UiPriority *CT_DecimalNumber
	// Hide Style From Main User Interface
	SemiHidden *CT_OnOff
	// Remove Semi-Hidden Property When Style Is Used
	UnhideWhenUsed *CT_OnOff
	// Primary Style
	QFormat *CT_OnOff
	// Style Cannot Be Applied
	Locked *CT_OnOff
	// E-Mail Message Text Style
	Personal *CT_OnOff
	// E-Mail Message Composition Style
	PersonalCompose *CT_OnOff
	// E-Mail Message Reply Style
	PersonalReply *CT_OnOff
	// Revision Identifier for Style Definition
	Rsid *CT_LongHexNumber
	// Style Paragraph Properties
	PPr *CT_PPrGeneral
	// Run Properties
	RPr *CT_RPr
	// Style Table Properties
	TblPr *CT_TblPrBase
	// Style Table Row Properties
	TrPr *CT_TrPr
	// Style Table Cell Properties
	TcPr *CT_TcPr
	// Style Conditional Table Formatting Properties
	TblStylePr []*CT_TblStylePr
}

func NewCT_Style ¶ 

func NewCT_Style() *CT_Style

func (*CT_Style) MarshalXML ¶ 

func (m *CT_Style) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Style) UnmarshalXML ¶ 

func (m *CT_Style) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Style) Validate ¶ 

func (m *CT_Style) Validate() error

Validate validates the CT_Style and its children

func (*CT_Style) ValidateWithPath ¶ 

func (m *CT_Style) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Style and its children, prefixing error messages with path

type CT_StylePaneFilter ¶ 

type CT_StylePaneFilter struct {
	// Display All Styles
	AllStylesAttr *sharedTypes.ST_OnOff
	// Display Only Custom Styles
	CustomStylesAttr *sharedTypes.ST_OnOff
	// Display Latent Styles
	LatentStylesAttr *sharedTypes.ST_OnOff
	// Display Styles in Use
	StylesInUseAttr *sharedTypes.ST_OnOff
	// Display Heading Styles
	HeadingStylesAttr *sharedTypes.ST_OnOff
	// Display Numbering Styles
	NumberingStylesAttr *sharedTypes.ST_OnOff
	// Display Table Styles
	TableStylesAttr *sharedTypes.ST_OnOff
	// Display Run Level Direct Formatting
	DirectFormattingOnRunsAttr *sharedTypes.ST_OnOff
	// Display Paragraph Level Direct Formatting
	DirectFormattingOnParagraphsAttr *sharedTypes.ST_OnOff
	// Display Direct Formatting on Numbering Data
	DirectFormattingOnNumberingAttr *sharedTypes.ST_OnOff
	// Display Direct Formatting on Tables
	DirectFormattingOnTablesAttr *sharedTypes.ST_OnOff
	// Display Styles to Remove Formatting
	ClearFormattingAttr *sharedTypes.ST_OnOff
	// Display Heading 1 through 3
	Top3HeadingStylesAttr *sharedTypes.ST_OnOff
	// Only Show Visible Styles
	VisibleStylesAttr *sharedTypes.ST_OnOff
	// Use the Alternate Style Name
	AlternateStyleNamesAttr *sharedTypes.ST_OnOff
	// Bitmask of Suggested Filtering Options
	ValAttr *string
}

func NewCT_StylePaneFilter ¶ 

func NewCT_StylePaneFilter() *CT_StylePaneFilter

func (*CT_StylePaneFilter) MarshalXML ¶ 

func (m *CT_StylePaneFilter) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_StylePaneFilter) UnmarshalXML ¶ 

func (m *CT_StylePaneFilter) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_StylePaneFilter) Validate ¶ 

func (m *CT_StylePaneFilter) Validate() error

Validate validates the CT_StylePaneFilter and its children

func (*CT_StylePaneFilter) ValidateWithPath ¶ 

func (m *CT_StylePaneFilter) ValidateWithPath(path string) error

ValidateWithPath validates the CT_StylePaneFilter and its children, prefixing error messages with path

type CT_StyleSort ¶ 

type CT_StyleSort struct {
	// Style Sorting
	ValAttr ST_StyleSort
}

func NewCT_StyleSort ¶ 

func NewCT_StyleSort() *CT_StyleSort

func (*CT_StyleSort) MarshalXML ¶ 

func (m *CT_StyleSort) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_StyleSort) UnmarshalXML ¶ 

func (m *CT_StyleSort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_StyleSort) Validate ¶ 

func (m *CT_StyleSort) Validate() error

Validate validates the CT_StyleSort and its children

func (*CT_StyleSort) ValidateWithPath ¶ 

func (m *CT_StyleSort) ValidateWithPath(path string) error

ValidateWithPath validates the CT_StyleSort and its children, prefixing error messages with path

type CT_Styles ¶ 

type CT_Styles struct {
	// Document Default Paragraph and Run Properties
	DocDefaults *CT_DocDefaults
	// Latent Style Information
	LatentStyles *CT_LatentStyles
	// Style Definition
	Style []*CT_Style
}

func NewCT_Styles ¶ 

func NewCT_Styles() *CT_Styles

func (*CT_Styles) MarshalXML ¶ 

func (m *CT_Styles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Styles) UnmarshalXML ¶ 

func (m *CT_Styles) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Styles) Validate ¶ 

func (m *CT_Styles) Validate() error

Validate validates the CT_Styles and its children

func (*CT_Styles) ValidateWithPath ¶ 

func (m *CT_Styles) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Styles and its children, prefixing error messages with path

type CT_Sym ¶ 

type CT_Sym struct {
	// Symbol Character Font
	FontAttr *string
	// Symbol Character Code
	CharAttr *string
}

func NewCT_Sym ¶ 

func NewCT_Sym() *CT_Sym

func (*CT_Sym) MarshalXML ¶ 

func (m *CT_Sym) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Sym) UnmarshalXML ¶ 

func (m *CT_Sym) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Sym) Validate ¶ 

func (m *CT_Sym) Validate() error

Validate validates the CT_Sym and its children

func (*CT_Sym) ValidateWithPath ¶ 

func (m *CT_Sym) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Sym and its children, prefixing error messages with path

type CT_TabStop ¶ 

type CT_TabStop struct {
	// Tab Stop Type
	ValAttr ST_TabJc
	// Tab Leader Character
	LeaderAttr ST_TabTlc
	// Tab Stop Position
	PosAttr ST_SignedTwipsMeasure
}

func NewCT_TabStop ¶ 

func NewCT_TabStop() *CT_TabStop

func (*CT_TabStop) MarshalXML ¶ 

func (m *CT_TabStop) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TabStop) UnmarshalXML ¶ 

func (m *CT_TabStop) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TabStop) Validate ¶ 

func (m *CT_TabStop) Validate() error

Validate validates the CT_TabStop and its children

func (*CT_TabStop) ValidateWithPath ¶ 

func (m *CT_TabStop) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TabStop and its children, prefixing error messages with path

type CT_Tabs ¶ 

type CT_Tabs struct {
	// Custom Tab Stop
	Tab []*CT_TabStop
}

func NewCT_Tabs ¶ 

func NewCT_Tabs() *CT_Tabs

func (*CT_Tabs) MarshalXML ¶ 

func (m *CT_Tabs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Tabs) UnmarshalXML ¶ 

func (m *CT_Tabs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Tabs) Validate ¶ 

func (m *CT_Tabs) Validate() error

Validate validates the CT_Tabs and its children

func (*CT_Tabs) ValidateWithPath ¶ 

func (m *CT_Tabs) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Tabs and its children, prefixing error messages with path

type CT_TargetScreenSz ¶ 

type CT_TargetScreenSz struct {
	// Target Screen Size Value
	ValAttr ST_TargetScreenSz
}

func NewCT_TargetScreenSz ¶ 

func NewCT_TargetScreenSz() *CT_TargetScreenSz

func (*CT_TargetScreenSz) MarshalXML ¶ 

func (m *CT_TargetScreenSz) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TargetScreenSz) UnmarshalXML ¶ 

func (m *CT_TargetScreenSz) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TargetScreenSz) Validate ¶ 

func (m *CT_TargetScreenSz) Validate() error

Validate validates the CT_TargetScreenSz and its children

func (*CT_TargetScreenSz) ValidateWithPath ¶ 

func (m *CT_TargetScreenSz) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TargetScreenSz and its children, prefixing error messages with path

type CT_Tbl ¶ 

type CT_Tbl struct {
	EG_RangeMarkupElements []*EG_RangeMarkupElements
	// Table Properties
	TblPr *CT_TblPr
	// Table Grid
	TblGrid              *CT_TblGrid
	EG_ContentRowContent []*EG_ContentRowContent
}

func NewCT_Tbl ¶ 

func NewCT_Tbl() *CT_Tbl

func (*CT_Tbl) MarshalXML ¶ 

func (m *CT_Tbl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Tbl) UnmarshalXML ¶ 

func (m *CT_Tbl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Tbl) Validate ¶ 

func (m *CT_Tbl) Validate() error

Validate validates the CT_Tbl and its children

func (*CT_Tbl) ValidateWithPath ¶ 

func (m *CT_Tbl) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Tbl and its children, prefixing error messages with path

type CT_TblBorders ¶ 

type CT_TblBorders struct {
	// Table Top Border
	Top *CT_Border
	// Table Leading Edge Border
	Start *CT_Border
	// Table Leading Edge Border
	Left *CT_Border
	// Table Bottom Border
	Bottom *CT_Border
	// Table Trailing Edge Border
	End *CT_Border
	// Table Trailing Edge Border
	Right *CT_Border
	// Table Inside Horizontal Edges Border
	InsideH *CT_Border
	// Table Inside Vertical Edges Border
	InsideV *CT_Border
}

func NewCT_TblBorders ¶ 

func NewCT_TblBorders() *CT_TblBorders

func (*CT_TblBorders) MarshalXML ¶ 

func (m *CT_TblBorders) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblBorders) UnmarshalXML ¶ 

func (m *CT_TblBorders) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblBorders) Validate ¶ 

func (m *CT_TblBorders) Validate() error

Validate validates the CT_TblBorders and its children

func (*CT_TblBorders) ValidateWithPath ¶ 

func (m *CT_TblBorders) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblBorders and its children, prefixing error messages with path

type CT_TblCellMar ¶ 

type CT_TblCellMar struct {
	// Table Cell Top Margin Default
	Top *CT_TblWidth
	// Table Cell Leading Margin Default
	Start *CT_TblWidth
	// Table Cell Leading Margin Default
	Left *CT_TblWidth
	// Table Cell Bottom Margin Default
	Bottom *CT_TblWidth
	// Table Cell Trailing Margin Default
	End *CT_TblWidth
	// Table Cell Trailing Margin Default
	Right *CT_TblWidth
}

func NewCT_TblCellMar ¶ 

func NewCT_TblCellMar() *CT_TblCellMar

func (*CT_TblCellMar) MarshalXML ¶ 

func (m *CT_TblCellMar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblCellMar) UnmarshalXML ¶ 

func (m *CT_TblCellMar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblCellMar) Validate ¶ 

func (m *CT_TblCellMar) Validate() error

Validate validates the CT_TblCellMar and its children

func (*CT_TblCellMar) ValidateWithPath ¶ 

func (m *CT_TblCellMar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblCellMar and its children, prefixing error messages with path

type CT_TblGrid ¶ 

type CT_TblGrid struct {
	// Grid Column Definition
	GridCol       []*CT_TblGridCol
	TblGridChange *CT_TblGridChange
}

func NewCT_TblGrid ¶ 

func NewCT_TblGrid() *CT_TblGrid

func (*CT_TblGrid) MarshalXML ¶ 

func (m *CT_TblGrid) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblGrid) UnmarshalXML ¶ 

func (m *CT_TblGrid) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblGrid) Validate ¶ 

func (m *CT_TblGrid) Validate() error

Validate validates the CT_TblGrid and its children

func (*CT_TblGrid) ValidateWithPath ¶ 

func (m *CT_TblGrid) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblGrid and its children, prefixing error messages with path

type CT_TblGridBase ¶ 

type CT_TblGridBase struct {
	// Grid Column Definition
	GridCol []*CT_TblGridCol
}

func NewCT_TblGridBase ¶ 

func NewCT_TblGridBase() *CT_TblGridBase

func (*CT_TblGridBase) MarshalXML ¶ 

func (m *CT_TblGridBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblGridBase) UnmarshalXML ¶ 

func (m *CT_TblGridBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblGridBase) Validate ¶ 

func (m *CT_TblGridBase) Validate() error

Validate validates the CT_TblGridBase and its children

func (*CT_TblGridBase) ValidateWithPath ¶ 

func (m *CT_TblGridBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblGridBase and its children, prefixing error messages with path

type CT_TblGridChange ¶ 

type CT_TblGridChange struct {
	// Annotation Identifier
	IdAttr  int64
	TblGrid *CT_TblGridBase
}

func NewCT_TblGridChange ¶ 

func NewCT_TblGridChange() *CT_TblGridChange

func (*CT_TblGridChange) MarshalXML ¶ 

func (m *CT_TblGridChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblGridChange) UnmarshalXML ¶ 

func (m *CT_TblGridChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblGridChange) Validate ¶ 

func (m *CT_TblGridChange) Validate() error

Validate validates the CT_TblGridChange and its children

func (*CT_TblGridChange) ValidateWithPath ¶ 

func (m *CT_TblGridChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblGridChange and its children, prefixing error messages with path

type CT_TblGridCol ¶ 

type CT_TblGridCol struct {
	// Grid Column Width
	WAttr *sharedTypes.ST_TwipsMeasure
}

func NewCT_TblGridCol ¶ 

func NewCT_TblGridCol() *CT_TblGridCol

func (*CT_TblGridCol) MarshalXML ¶ 

func (m *CT_TblGridCol) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblGridCol) UnmarshalXML ¶ 

func (m *CT_TblGridCol) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblGridCol) Validate ¶ 

func (m *CT_TblGridCol) Validate() error

Validate validates the CT_TblGridCol and its children

func (*CT_TblGridCol) ValidateWithPath ¶ 

func (m *CT_TblGridCol) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblGridCol and its children, prefixing error messages with path

type CT_TblLayoutType ¶ 

type CT_TblLayoutType struct {
	// Table Layout Setting
	TypeAttr ST_TblLayoutType
}

func NewCT_TblLayoutType ¶ 

func NewCT_TblLayoutType() *CT_TblLayoutType

func (*CT_TblLayoutType) MarshalXML ¶ 

func (m *CT_TblLayoutType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblLayoutType) UnmarshalXML ¶ 

func (m *CT_TblLayoutType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblLayoutType) Validate ¶ 

func (m *CT_TblLayoutType) Validate() error

Validate validates the CT_TblLayoutType and its children

func (*CT_TblLayoutType) ValidateWithPath ¶ 

func (m *CT_TblLayoutType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblLayoutType and its children, prefixing error messages with path

type CT_TblLook ¶ 

type CT_TblLook struct {
	// First Row
	FirstRowAttr *sharedTypes.ST_OnOff
	// Last Row
	LastRowAttr *sharedTypes.ST_OnOff
	// First Column
	FirstColumnAttr *sharedTypes.ST_OnOff
	// Last Column
	LastColumnAttr *sharedTypes.ST_OnOff
	// No Horizontal Banding
	NoHBandAttr *sharedTypes.ST_OnOff
	// No Vertical Banding
	NoVBandAttr *sharedTypes.ST_OnOff
	// Bitmask of Table Conditional Formatting
	ValAttr *string
}

func NewCT_TblLook ¶ 

func NewCT_TblLook() *CT_TblLook

func (*CT_TblLook) MarshalXML ¶ 

func (m *CT_TblLook) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblLook) UnmarshalXML ¶ 

func (m *CT_TblLook) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblLook) Validate ¶ 

func (m *CT_TblLook) Validate() error

Validate validates the CT_TblLook and its children

func (*CT_TblLook) ValidateWithPath ¶ 

func (m *CT_TblLook) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblLook and its children, prefixing error messages with path

type CT_TblOverlap ¶ 

type CT_TblOverlap struct {
	// Floating Table Overlap Setting
	ValAttr ST_TblOverlap
}

func NewCT_TblOverlap ¶ 

func NewCT_TblOverlap() *CT_TblOverlap

func (*CT_TblOverlap) MarshalXML ¶ 

func (m *CT_TblOverlap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblOverlap) UnmarshalXML ¶ 

func (m *CT_TblOverlap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblOverlap) Validate ¶ 

func (m *CT_TblOverlap) Validate() error

Validate validates the CT_TblOverlap and its children

func (*CT_TblOverlap) ValidateWithPath ¶ 

func (m *CT_TblOverlap) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblOverlap and its children, prefixing error messages with path

type CT_TblPPr ¶ 

type CT_TblPPr struct {
	// Distance From Left of Table to Text
	LeftFromTextAttr *sharedTypes.ST_TwipsMeasure
	// (Distance From Right of Table to Text
	RightFromTextAttr *sharedTypes.ST_TwipsMeasure
	// Distance From Top of Table to Text
	TopFromTextAttr *sharedTypes.ST_TwipsMeasure
	// Distance From Bottom of Table to Text
	BottomFromTextAttr *sharedTypes.ST_TwipsMeasure
	// Table Vertical Anchor
	VertAnchorAttr ST_VAnchor
	// Table Horizontal Anchor
	HorzAnchorAttr ST_HAnchor
	// Relative Horizontal Alignment From Anchor
	TblpXSpecAttr sharedTypes.ST_XAlign
	// Absolute Horizontal Distance From Anchor
	TblpXAttr *ST_SignedTwipsMeasure
	// Relative Vertical Alignment from Anchor
	TblpYSpecAttr sharedTypes.ST_YAlign
	// Absolute Vertical Distance From Anchor
	TblpYAttr *ST_SignedTwipsMeasure
}

func NewCT_TblPPr ¶ 

func NewCT_TblPPr() *CT_TblPPr

func (*CT_TblPPr) MarshalXML ¶ 

func (m *CT_TblPPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblPPr) UnmarshalXML ¶ 

func (m *CT_TblPPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblPPr) Validate ¶ 

func (m *CT_TblPPr) Validate() error

Validate validates the CT_TblPPr and its children

func (*CT_TblPPr) ValidateWithPath ¶ 

func (m *CT_TblPPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblPPr and its children, prefixing error messages with path

type CT_TblPr ¶ 

type CT_TblPr struct {
	// Referenced Table Style
	TblStyle *CT_String
	// Floating Table Positioning
	TblpPr *CT_TblPPr
	// Floating Table Allows Other Tables to Overlap
	TblOverlap *CT_TblOverlap
	// Visually Right to Left Table
	BidiVisual *CT_OnOff
	// Number of Rows in Row Band
	TblStyleRowBandSize *CT_DecimalNumber
	// Number of Columns in Column Band
	TblStyleColBandSize *CT_DecimalNumber
	// Preferred Table Width
	TblW *CT_TblWidth
	// Table Alignment
	Jc *CT_JcTable
	// Table Cell Spacing Default
	TblCellSpacing *CT_TblWidth
	// Table Indent from Leading Margin
	TblInd *CT_TblWidth
	// Table Borders
	TblBorders *CT_TblBorders
	// Table Shading
	Shd *CT_Shd
	// Table Layout
	TblLayout *CT_TblLayoutType
	// Table Cell Margin Defaults
	TblCellMar *CT_TblCellMar
	// Table Style Conditional Formatting Settings
	TblLook *CT_TblLook
	// Table Caption
	TblCaption *CT_String
	// Table Description
	TblDescription *CT_String
	TblPrChange    *CT_TblPrChange
}

func NewCT_TblPr ¶ 

func NewCT_TblPr() *CT_TblPr

func (*CT_TblPr) MarshalXML ¶ 

func (m *CT_TblPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblPr) UnmarshalXML ¶ 

func (m *CT_TblPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblPr) Validate ¶ 

func (m *CT_TblPr) Validate() error

Validate validates the CT_TblPr and its children

func (*CT_TblPr) ValidateWithPath ¶ 

func (m *CT_TblPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblPr and its children, prefixing error messages with path

type CT_TblPrBase ¶ 

type CT_TblPrBase struct {
	// Referenced Table Style
	TblStyle *CT_String
	// Floating Table Positioning
	TblpPr *CT_TblPPr
	// Floating Table Allows Other Tables to Overlap
	TblOverlap *CT_TblOverlap
	// Visually Right to Left Table
	BidiVisual *CT_OnOff
	// Number of Rows in Row Band
	TblStyleRowBandSize *CT_DecimalNumber
	// Number of Columns in Column Band
	TblStyleColBandSize *CT_DecimalNumber
	// Preferred Table Width
	TblW *CT_TblWidth
	// Table Alignment
	Jc *CT_JcTable
	// Table Cell Spacing Default
	TblCellSpacing *CT_TblWidth
	// Table Indent from Leading Margin
	TblInd *CT_TblWidth
	// Table Borders
	TblBorders *CT_TblBorders
	// Table Shading
	Shd *CT_Shd
	// Table Layout
	TblLayout *CT_TblLayoutType
	// Table Cell Margin Defaults
	TblCellMar *CT_TblCellMar
	// Table Style Conditional Formatting Settings
	TblLook *CT_TblLook
	// Table Caption
	TblCaption *CT_String
	// Table Description
	TblDescription *CT_String
}

func NewCT_TblPrBase ¶ 

func NewCT_TblPrBase() *CT_TblPrBase

func (*CT_TblPrBase) MarshalXML ¶ 

func (m *CT_TblPrBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblPrBase) UnmarshalXML ¶ 

func (m *CT_TblPrBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblPrBase) Validate ¶ 

func (m *CT_TblPrBase) Validate() error

Validate validates the CT_TblPrBase and its children

func (*CT_TblPrBase) ValidateWithPath ¶ 

func (m *CT_TblPrBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblPrBase and its children, prefixing error messages with path

type CT_TblPrChange ¶ 

type CT_TblPrChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
	TblPr  *CT_TblPrBase
}

func NewCT_TblPrChange ¶ 

func NewCT_TblPrChange() *CT_TblPrChange

func (*CT_TblPrChange) MarshalXML ¶ 

func (m *CT_TblPrChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblPrChange) UnmarshalXML ¶ 

func (m *CT_TblPrChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblPrChange) Validate ¶ 

func (m *CT_TblPrChange) Validate() error

Validate validates the CT_TblPrChange and its children

func (*CT_TblPrChange) ValidateWithPath ¶ 

func (m *CT_TblPrChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblPrChange and its children, prefixing error messages with path

type CT_TblPrEx ¶ 

type CT_TblPrEx struct {
	// Preferred Table Width Exception
	TblW *CT_TblWidth
	// Table Alignment Exception
	Jc *CT_JcTable
	// Table Cell Spacing Exception
	TblCellSpacing *CT_TblWidth
	// Table Indent from Leading Margin Exception
	TblInd *CT_TblWidth
	// Table Borders Exceptions
	TblBorders *CT_TblBorders
	// Table Shading Exception
	Shd *CT_Shd
	// Table Layout Exception
	TblLayout *CT_TblLayoutType
	// Table Cell Margin Exceptions
	TblCellMar *CT_TblCellMar
	// Table Style Conditional Formatting Settings Exception
	TblLook       *CT_TblLook
	TblPrExChange *CT_TblPrExChange
}

func NewCT_TblPrEx ¶ 

func NewCT_TblPrEx() *CT_TblPrEx

func (*CT_TblPrEx) MarshalXML ¶ 

func (m *CT_TblPrEx) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblPrEx) UnmarshalXML ¶ 

func (m *CT_TblPrEx) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblPrEx) Validate ¶ 

func (m *CT_TblPrEx) Validate() error

Validate validates the CT_TblPrEx and its children

func (*CT_TblPrEx) ValidateWithPath ¶ 

func (m *CT_TblPrEx) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblPrEx and its children, prefixing error messages with path

type CT_TblPrExBase ¶ 

type CT_TblPrExBase struct {
	// Preferred Table Width Exception
	TblW *CT_TblWidth
	// Table Alignment Exception
	Jc *CT_JcTable
	// Table Cell Spacing Exception
	TblCellSpacing *CT_TblWidth
	// Table Indent from Leading Margin Exception
	TblInd *CT_TblWidth
	// Table Borders Exceptions
	TblBorders *CT_TblBorders
	// Table Shading Exception
	Shd *CT_Shd
	// Table Layout Exception
	TblLayout *CT_TblLayoutType
	// Table Cell Margin Exceptions
	TblCellMar *CT_TblCellMar
	// Table Style Conditional Formatting Settings Exception
	TblLook *CT_TblLook
}

func NewCT_TblPrExBase ¶ 

func NewCT_TblPrExBase() *CT_TblPrExBase

func (*CT_TblPrExBase) MarshalXML ¶ 

func (m *CT_TblPrExBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblPrExBase) UnmarshalXML ¶ 

func (m *CT_TblPrExBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblPrExBase) Validate ¶ 

func (m *CT_TblPrExBase) Validate() error

Validate validates the CT_TblPrExBase and its children

func (*CT_TblPrExBase) ValidateWithPath ¶ 

func (m *CT_TblPrExBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblPrExBase and its children, prefixing error messages with path

type CT_TblPrExChange ¶ 

type CT_TblPrExChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr  int64
	TblPrEx *CT_TblPrExBase
}

func NewCT_TblPrExChange ¶ 

func NewCT_TblPrExChange() *CT_TblPrExChange

func (*CT_TblPrExChange) MarshalXML ¶ 

func (m *CT_TblPrExChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblPrExChange) UnmarshalXML ¶ 

func (m *CT_TblPrExChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblPrExChange) Validate ¶ 

func (m *CT_TblPrExChange) Validate() error

Validate validates the CT_TblPrExChange and its children

func (*CT_TblPrExChange) ValidateWithPath ¶ 

func (m *CT_TblPrExChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblPrExChange and its children, prefixing error messages with path

type CT_TblStylePr ¶ 

type CT_TblStylePr struct {
	// Table Style Conditional Formatting Type
	TypeAttr ST_TblStyleOverrideType
	// Table Style Conditional Formatting Paragraph Properties
	PPr *CT_PPrGeneral
	// Table Style Conditional Formatting Run Properties
	RPr *CT_RPr
	// Table Style Conditional Formatting Table Properties
	TblPr *CT_TblPrBase
	// Table Style Conditional Formatting Table Row Properties
	TrPr *CT_TrPr
	// Table Style Conditional Formatting Table Cell Properties
	TcPr *CT_TcPr
}

func NewCT_TblStylePr ¶ 

func NewCT_TblStylePr() *CT_TblStylePr

func (*CT_TblStylePr) MarshalXML ¶ 

func (m *CT_TblStylePr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblStylePr) UnmarshalXML ¶ 

func (m *CT_TblStylePr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblStylePr) Validate ¶ 

func (m *CT_TblStylePr) Validate() error

Validate validates the CT_TblStylePr and its children

func (*CT_TblStylePr) ValidateWithPath ¶ 

func (m *CT_TblStylePr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblStylePr and its children, prefixing error messages with path

type CT_TblWidth ¶ 

type CT_TblWidth struct {
	// Table Width Value
	WAttr *ST_MeasurementOrPercent
	// Table Width Type
	TypeAttr ST_TblWidth
}

func NewCT_TblWidth ¶ 

func NewCT_TblWidth() *CT_TblWidth

func (*CT_TblWidth) MarshalXML ¶ 

func (m *CT_TblWidth) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TblWidth) UnmarshalXML ¶ 

func (m *CT_TblWidth) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TblWidth) Validate ¶ 

func (m *CT_TblWidth) Validate() error

Validate validates the CT_TblWidth and its children

func (*CT_TblWidth) ValidateWithPath ¶ 

func (m *CT_TblWidth) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TblWidth and its children, prefixing error messages with path

type CT_Tc ¶ 

type CT_Tc struct {
	// Table Cell Identifier
	IdAttr *string
	// Table Cell Properties
	TcPr              *CT_TcPr
	EG_BlockLevelElts []*EG_BlockLevelElts
}

func NewCT_Tc ¶ 

func NewCT_Tc() *CT_Tc

func (*CT_Tc) MarshalXML ¶ 

func (m *CT_Tc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Tc) UnmarshalXML ¶ 

func (m *CT_Tc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Tc) Validate ¶ 

func (m *CT_Tc) Validate() error

Validate validates the CT_Tc and its children

func (*CT_Tc) ValidateWithPath ¶ 

func (m *CT_Tc) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Tc and its children, prefixing error messages with path

type CT_TcBorders ¶ 

type CT_TcBorders struct {
	// Table Cell Top Border
	Top *CT_Border
	// Table Cell Leading Edge Border
	Start *CT_Border
	// Table Cell Leading Edge Border
	Left *CT_Border
	// Table Cell Bottom Border
	Bottom *CT_Border
	// Table Cell Trailing Edge Border
	End *CT_Border
	// Table Cell Trailing Edge Border
	Right *CT_Border
	// Table Cell Inside Horizontal Edges Border
	InsideH *CT_Border
	// Table Cell Inside Vertical Edges Border
	InsideV *CT_Border
	// Table Cell Top Left to Bottom Right Diagonal Border
	Tl2br *CT_Border
	// Table Cell Top Right to Bottom Left Diagonal Border
	Tr2bl *CT_Border
}

func NewCT_TcBorders ¶ 

func NewCT_TcBorders() *CT_TcBorders

func (*CT_TcBorders) MarshalXML ¶ 

func (m *CT_TcBorders) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TcBorders) UnmarshalXML ¶ 

func (m *CT_TcBorders) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TcBorders) Validate ¶ 

func (m *CT_TcBorders) Validate() error

Validate validates the CT_TcBorders and its children

func (*CT_TcBorders) ValidateWithPath ¶ 

func (m *CT_TcBorders) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TcBorders and its children, prefixing error messages with path

type CT_TcMar ¶ 

type CT_TcMar struct {
	// Table Cell Top Margin Exception
	Top *CT_TblWidth
	// Table Cell Leading Margin Exception
	Start *CT_TblWidth
	// Table Cell Leading Margin Exception
	Left *CT_TblWidth
	// Table Cell Bottom Margin Exception
	Bottom *CT_TblWidth
	// Table Cell Trailing Margin Exception
	End *CT_TblWidth
	// Table Cell Trailing Margin Exception
	Right *CT_TblWidth
}

func NewCT_TcMar ¶ 

func NewCT_TcMar() *CT_TcMar

func (*CT_TcMar) MarshalXML ¶ 

func (m *CT_TcMar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TcMar) UnmarshalXML ¶ 

func (m *CT_TcMar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TcMar) Validate ¶ 

func (m *CT_TcMar) Validate() error

Validate validates the CT_TcMar and its children

func (*CT_TcMar) ValidateWithPath ¶ 

func (m *CT_TcMar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TcMar and its children, prefixing error messages with path

type CT_TcPr ¶ 

type CT_TcPr struct {
	// Table Cell Conditional Formatting
	CnfStyle *CT_Cnf
	// Preferred Table Cell Width
	TcW *CT_TblWidth
	// Grid Columns Spanned by Current Table Cell
	GridSpan *CT_DecimalNumber
	// Horizontally Merged Cell
	HMerge *CT_HMerge
	// Vertically Merged Cell
	VMerge *CT_VMerge
	// Table Cell Borders
	TcBorders *CT_TcBorders
	// Table Cell Shading
	Shd *CT_Shd
	// Don't Wrap Cell Content
	NoWrap *CT_OnOff
	// Single Table Cell Margins
	TcMar *CT_TcMar
	// Table Cell Text Flow Direction
	TextDirection *CT_TextDirection
	// Fit Text Within Cell
	TcFitText *CT_OnOff
	// Table Cell Vertical Alignment
	VAlign *CT_VerticalJc
	// Ignore End Of Cell Marker In Row Height Calculation
	HideMark *CT_OnOff
	// Header Cells Associated With Table Cell
	Headers *CT_Headers
	// Table Cell Insertion
	CellIns *CT_TrackChange
	// Table Cell Deletion
	CellDel *CT_TrackChange
	// Vertically Merged/Split Table Cells
	CellMerge  *CT_CellMergeTrackChange
	TcPrChange *CT_TcPrChange
}

func NewCT_TcPr ¶ 

func NewCT_TcPr() *CT_TcPr

func (*CT_TcPr) MarshalXML ¶ 

func (m *CT_TcPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TcPr) UnmarshalXML ¶ 

func (m *CT_TcPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TcPr) Validate ¶ 

func (m *CT_TcPr) Validate() error

Validate validates the CT_TcPr and its children

func (*CT_TcPr) ValidateWithPath ¶ 

func (m *CT_TcPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TcPr and its children, prefixing error messages with path

type CT_TcPrBase ¶ 

type CT_TcPrBase struct {
	// Table Cell Conditional Formatting
	CnfStyle *CT_Cnf
	// Preferred Table Cell Width
	TcW *CT_TblWidth
	// Grid Columns Spanned by Current Table Cell
	GridSpan *CT_DecimalNumber
	// Horizontally Merged Cell
	HMerge *CT_HMerge
	// Vertically Merged Cell
	VMerge *CT_VMerge
	// Table Cell Borders
	TcBorders *CT_TcBorders
	// Table Cell Shading
	Shd *CT_Shd
	// Don't Wrap Cell Content
	NoWrap *CT_OnOff
	// Single Table Cell Margins
	TcMar *CT_TcMar
	// Table Cell Text Flow Direction
	TextDirection *CT_TextDirection
	// Fit Text Within Cell
	TcFitText *CT_OnOff
	// Table Cell Vertical Alignment
	VAlign *CT_VerticalJc
	// Ignore End Of Cell Marker In Row Height Calculation
	HideMark *CT_OnOff
	// Header Cells Associated With Table Cell
	Headers *CT_Headers
}

func NewCT_TcPrBase ¶ 

func NewCT_TcPrBase() *CT_TcPrBase

func (*CT_TcPrBase) MarshalXML ¶ 

func (m *CT_TcPrBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TcPrBase) UnmarshalXML ¶ 

func (m *CT_TcPrBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TcPrBase) Validate ¶ 

func (m *CT_TcPrBase) Validate() error

Validate validates the CT_TcPrBase and its children

func (*CT_TcPrBase) ValidateWithPath ¶ 

func (m *CT_TcPrBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TcPrBase and its children, prefixing error messages with path

type CT_TcPrChange ¶ 

type CT_TcPrChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
	TcPr   *CT_TcPrInner
}

func NewCT_TcPrChange ¶ 

func NewCT_TcPrChange() *CT_TcPrChange

func (*CT_TcPrChange) MarshalXML ¶ 

func (m *CT_TcPrChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TcPrChange) UnmarshalXML ¶ 

func (m *CT_TcPrChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TcPrChange) Validate ¶ 

func (m *CT_TcPrChange) Validate() error

Validate validates the CT_TcPrChange and its children

func (*CT_TcPrChange) ValidateWithPath ¶ 

func (m *CT_TcPrChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TcPrChange and its children, prefixing error messages with path

type CT_TcPrInner ¶ 

type CT_TcPrInner struct {
	// Table Cell Conditional Formatting
	CnfStyle *CT_Cnf
	// Preferred Table Cell Width
	TcW *CT_TblWidth
	// Grid Columns Spanned by Current Table Cell
	GridSpan *CT_DecimalNumber
	// Horizontally Merged Cell
	HMerge *CT_HMerge
	// Vertically Merged Cell
	VMerge *CT_VMerge
	// Table Cell Borders
	TcBorders *CT_TcBorders
	// Table Cell Shading
	Shd *CT_Shd
	// Don't Wrap Cell Content
	NoWrap *CT_OnOff
	// Single Table Cell Margins
	TcMar *CT_TcMar
	// Table Cell Text Flow Direction
	TextDirection *CT_TextDirection
	// Fit Text Within Cell
	TcFitText *CT_OnOff
	// Table Cell Vertical Alignment
	VAlign *CT_VerticalJc
	// Ignore End Of Cell Marker In Row Height Calculation
	HideMark *CT_OnOff
	// Header Cells Associated With Table Cell
	Headers *CT_Headers
	// Table Cell Insertion
	CellIns *CT_TrackChange
	// Table Cell Deletion
	CellDel *CT_TrackChange
	// Vertically Merged/Split Table Cells
	CellMerge *CT_CellMergeTrackChange
}

func NewCT_TcPrInner ¶ 

func NewCT_TcPrInner() *CT_TcPrInner

func (*CT_TcPrInner) MarshalXML ¶ 

func (m *CT_TcPrInner) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TcPrInner) UnmarshalXML ¶ 

func (m *CT_TcPrInner) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TcPrInner) Validate ¶ 

func (m *CT_TcPrInner) Validate() error

Validate validates the CT_TcPrInner and its children

func (*CT_TcPrInner) ValidateWithPath ¶ 

func (m *CT_TcPrInner) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TcPrInner and its children, prefixing error messages with path

type CT_Text ¶ 

type CT_Text struct {
	SpaceAttr *string
	Content   string
}

func NewCT_Text ¶ 

func NewCT_Text() *CT_Text

func (*CT_Text) MarshalXML ¶ 

func (m *CT_Text) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Text) UnmarshalXML ¶ 

func (m *CT_Text) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Text) Validate ¶ 

func (m *CT_Text) Validate() error

Validate validates the CT_Text and its children

func (*CT_Text) ValidateWithPath ¶ 

func (m *CT_Text) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Text and its children, prefixing error messages with path

type CT_TextAlignment ¶ 

type CT_TextAlignment struct {
	// Vertical Character Alignment Position
	ValAttr ST_TextAlignment
}

func NewCT_TextAlignment ¶ 

func NewCT_TextAlignment() *CT_TextAlignment

func (*CT_TextAlignment) MarshalXML ¶ 

func (m *CT_TextAlignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextAlignment) UnmarshalXML ¶ 

func (m *CT_TextAlignment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextAlignment) Validate ¶ 

func (m *CT_TextAlignment) Validate() error

Validate validates the CT_TextAlignment and its children

func (*CT_TextAlignment) ValidateWithPath ¶ 

func (m *CT_TextAlignment) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextAlignment and its children, prefixing error messages with path

type CT_TextDirection ¶ 

type CT_TextDirection struct {
	// Direction of Text Flow
	ValAttr ST_TextDirection
}

func NewCT_TextDirection ¶ 

func NewCT_TextDirection() *CT_TextDirection

func (*CT_TextDirection) MarshalXML ¶ 

func (m *CT_TextDirection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextDirection) UnmarshalXML ¶ 

func (m *CT_TextDirection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextDirection) Validate ¶ 

func (m *CT_TextDirection) Validate() error

Validate validates the CT_TextDirection and its children

func (*CT_TextDirection) ValidateWithPath ¶ 

func (m *CT_TextDirection) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextDirection and its children, prefixing error messages with path

type CT_TextEffect ¶ 

type CT_TextEffect struct {
	// Animated Text Effect Type
	ValAttr ST_TextEffect
}

func NewCT_TextEffect ¶ 

func NewCT_TextEffect() *CT_TextEffect

func (*CT_TextEffect) MarshalXML ¶ 

func (m *CT_TextEffect) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextEffect) UnmarshalXML ¶ 

func (m *CT_TextEffect) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextEffect) Validate ¶ 

func (m *CT_TextEffect) Validate() error

Validate validates the CT_TextEffect and its children

func (*CT_TextEffect) ValidateWithPath ¶ 

func (m *CT_TextEffect) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextEffect and its children, prefixing error messages with path

type CT_TextScale ¶ 

type CT_TextScale struct {
	// Text Expansion/Compression Value
	ValAttr *ST_TextScale
}

func NewCT_TextScale ¶ 

func NewCT_TextScale() *CT_TextScale

func (*CT_TextScale) MarshalXML ¶ 

func (m *CT_TextScale) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextScale) UnmarshalXML ¶ 

func (m *CT_TextScale) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextScale) Validate ¶ 

func (m *CT_TextScale) Validate() error

Validate validates the CT_TextScale and its children

func (*CT_TextScale) ValidateWithPath ¶ 

func (m *CT_TextScale) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextScale and its children, prefixing error messages with path

type CT_TextboxTightWrap ¶ 

type CT_TextboxTightWrap struct {
	// Lines to Tight Wrap to Paragraph Extents
	ValAttr ST_TextboxTightWrap
}

func NewCT_TextboxTightWrap ¶ 

func NewCT_TextboxTightWrap() *CT_TextboxTightWrap

func (*CT_TextboxTightWrap) MarshalXML ¶ 

func (m *CT_TextboxTightWrap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextboxTightWrap) UnmarshalXML ¶ 

func (m *CT_TextboxTightWrap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextboxTightWrap) Validate ¶ 

func (m *CT_TextboxTightWrap) Validate() error

Validate validates the CT_TextboxTightWrap and its children

func (*CT_TextboxTightWrap) ValidateWithPath ¶ 

func (m *CT_TextboxTightWrap) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextboxTightWrap and its children, prefixing error messages with path

type CT_TopPageBorder ¶ 

type CT_TopPageBorder struct {
	TopLeftAttr  *string
	TopRightAttr *string
	IdAttr       *string
	// Border Style
	ValAttr ST_Border
	// Border Color
	ColorAttr *ST_HexColor
	// Border Theme Color
	ThemeColorAttr ST_ThemeColor
	// Border Theme Color Tint
	ThemeTintAttr *string
	// Border Theme Color Shade
	ThemeShadeAttr *string
	// Border Width
	SzAttr *uint64
	// Border Spacing Measurement
	SpaceAttr *uint64
	// Border Shadow
	ShadowAttr *sharedTypes.ST_OnOff
	// Create Frame Effect
	FrameAttr *sharedTypes.ST_OnOff
}

func NewCT_TopPageBorder ¶ 

func NewCT_TopPageBorder() *CT_TopPageBorder

func (*CT_TopPageBorder) MarshalXML ¶ 

func (m *CT_TopPageBorder) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TopPageBorder) UnmarshalXML ¶ 

func (m *CT_TopPageBorder) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TopPageBorder) Validate ¶ 

func (m *CT_TopPageBorder) Validate() error

Validate validates the CT_TopPageBorder and its children

func (*CT_TopPageBorder) ValidateWithPath ¶ 

func (m *CT_TopPageBorder) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TopPageBorder and its children, prefixing error messages with path

type CT_TrPr ¶ 

type CT_TrPr struct {
	// Table Row Conditional Formatting
	CnfStyle []*CT_Cnf
	// Associated HTML div ID
	DivId []*CT_DecimalNumber
	// Grid Columns Before First Cell
	GridBefore []*CT_DecimalNumber
	// Grid Columns After Last Cell
	GridAfter []*CT_DecimalNumber
	// Preferred Width Before Table Row
	WBefore []*CT_TblWidth
	// Preferred Width After Table Row
	WAfter []*CT_TblWidth
	// Table Row Cannot Break Across Pages
	CantSplit []*CT_OnOff
	// Table Row Height
	TrHeight []*CT_Height
	// Repeat Table Row on Every New Page
	TblHeader []*CT_OnOff
	// Table Row Cell Spacing
	TblCellSpacing []*CT_TblWidth
	// Table Row Alignment
	Jc []*CT_JcTable
	// Hidden Table Row Marker
	Hidden     []*CT_OnOff
	Ins        *CT_TrackChange
	Del        *CT_TrackChange
	TrPrChange *CT_TrPrChange
}

func NewCT_TrPr ¶ 

func NewCT_TrPr() *CT_TrPr

func (*CT_TrPr) MarshalXML ¶ 

func (m *CT_TrPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TrPr) UnmarshalXML ¶ 

func (m *CT_TrPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TrPr) Validate ¶ 

func (m *CT_TrPr) Validate() error

Validate validates the CT_TrPr and its children

func (*CT_TrPr) ValidateWithPath ¶ 

func (m *CT_TrPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrPr and its children, prefixing error messages with path

type CT_TrPrBase ¶ 

type CT_TrPrBase struct {
	// Table Row Conditional Formatting
	CnfStyle []*CT_Cnf
	// Associated HTML div ID
	DivId []*CT_DecimalNumber
	// Grid Columns Before First Cell
	GridBefore []*CT_DecimalNumber
	// Grid Columns After Last Cell
	GridAfter []*CT_DecimalNumber
	// Preferred Width Before Table Row
	WBefore []*CT_TblWidth
	// Preferred Width After Table Row
	WAfter []*CT_TblWidth
	// Table Row Cannot Break Across Pages
	CantSplit []*CT_OnOff
	// Table Row Height
	TrHeight []*CT_Height
	// Repeat Table Row on Every New Page
	TblHeader []*CT_OnOff
	// Table Row Cell Spacing
	TblCellSpacing []*CT_TblWidth
	// Table Row Alignment
	Jc []*CT_JcTable
	// Hidden Table Row Marker
	Hidden []*CT_OnOff
}

func NewCT_TrPrBase ¶ 

func NewCT_TrPrBase() *CT_TrPrBase

func (*CT_TrPrBase) MarshalXML ¶ 

func (m *CT_TrPrBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TrPrBase) UnmarshalXML ¶ 

func (m *CT_TrPrBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TrPrBase) Validate ¶ 

func (m *CT_TrPrBase) Validate() error

Validate validates the CT_TrPrBase and its children

func (*CT_TrPrBase) ValidateWithPath ¶ 

func (m *CT_TrPrBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrPrBase and its children, prefixing error messages with path

type CT_TrPrChange ¶ 

type CT_TrPrChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
	TrPr   *CT_TrPrBase
}

func NewCT_TrPrChange ¶ 

func NewCT_TrPrChange() *CT_TrPrChange

func (*CT_TrPrChange) MarshalXML ¶ 

func (m *CT_TrPrChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TrPrChange) UnmarshalXML ¶ 

func (m *CT_TrPrChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TrPrChange) Validate ¶ 

func (m *CT_TrPrChange) Validate() error

Validate validates the CT_TrPrChange and its children

func (*CT_TrPrChange) ValidateWithPath ¶ 

func (m *CT_TrPrChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrPrChange and its children, prefixing error messages with path

type CT_TrackChange ¶ 

type CT_TrackChange struct {
	AuthorAttr string
	DateAttr   *time.Time
	// Annotation Identifier
	IdAttr int64
}

func NewCT_TrackChange ¶ 

func NewCT_TrackChange() *CT_TrackChange

func (*CT_TrackChange) MarshalXML ¶ 

func (m *CT_TrackChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TrackChange) UnmarshalXML ¶ 

func (m *CT_TrackChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TrackChange) Validate ¶ 

func (m *CT_TrackChange) Validate() error

Validate validates the CT_TrackChange and its children

func (*CT_TrackChange) ValidateWithPath ¶ 

func (m *CT_TrackChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrackChange and its children, prefixing error messages with path

type CT_TrackChangeNumbering ¶ 

type CT_TrackChangeNumbering struct {
	OriginalAttr *string
	AuthorAttr   string
	DateAttr     *time.Time
	// Annotation Identifier
	IdAttr int64
}

func NewCT_TrackChangeNumbering ¶ 

func NewCT_TrackChangeNumbering() *CT_TrackChangeNumbering

func (*CT_TrackChangeNumbering) MarshalXML ¶ 

func (m *CT_TrackChangeNumbering) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TrackChangeNumbering) UnmarshalXML ¶ 

func (m *CT_TrackChangeNumbering) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TrackChangeNumbering) Validate ¶ 

func (m *CT_TrackChangeNumbering) Validate() error

Validate validates the CT_TrackChangeNumbering and its children

func (*CT_TrackChangeNumbering) ValidateWithPath ¶ 

func (m *CT_TrackChangeNumbering) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrackChangeNumbering and its children, prefixing error messages with path

type CT_TrackChangeRange ¶ 

type CT_TrackChangeRange struct {
	DisplacedByCustomXmlAttr ST_DisplacedByCustomXml
	AuthorAttr               string
	DateAttr                 *time.Time
	// Annotation Identifier
	IdAttr int64
}

func NewCT_TrackChangeRange ¶ 

func NewCT_TrackChangeRange() *CT_TrackChangeRange

func (*CT_TrackChangeRange) MarshalXML ¶ 

func (m *CT_TrackChangeRange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TrackChangeRange) UnmarshalXML ¶ 

func (m *CT_TrackChangeRange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TrackChangeRange) Validate ¶ 

func (m *CT_TrackChangeRange) Validate() error

Validate validates the CT_TrackChangeRange and its children

func (*CT_TrackChangeRange) ValidateWithPath ¶ 

func (m *CT_TrackChangeRange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrackChangeRange and its children, prefixing error messages with path

type CT_TrackChangesView ¶ 

type CT_TrackChangesView struct {
	// Display Visual Indicator Of Markup Area
	MarkupAttr *sharedTypes.ST_OnOff
	// Display Comments
	CommentsAttr *sharedTypes.ST_OnOff
	// Display Content Revisions
	InsDelAttr *sharedTypes.ST_OnOff
	// Display Formatting Revisions
	FormattingAttr *sharedTypes.ST_OnOff
	// Display Ink Annotations
	InkAnnotationsAttr *sharedTypes.ST_OnOff
}

func NewCT_TrackChangesView ¶ 

func NewCT_TrackChangesView() *CT_TrackChangesView

func (*CT_TrackChangesView) MarshalXML ¶ 

func (m *CT_TrackChangesView) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TrackChangesView) UnmarshalXML ¶ 

func (m *CT_TrackChangesView) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TrackChangesView) Validate ¶ 

func (m *CT_TrackChangesView) Validate() error

Validate validates the CT_TrackChangesView and its children

func (*CT_TrackChangesView) ValidateWithPath ¶ 

func (m *CT_TrackChangesView) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrackChangesView and its children, prefixing error messages with path

type CT_TwipsMeasure ¶ 

type CT_TwipsMeasure struct {
	// Measurement in Twentieths of a Point
	ValAttr sharedTypes.ST_TwipsMeasure
}

func NewCT_TwipsMeasure ¶ 

func NewCT_TwipsMeasure() *CT_TwipsMeasure

func (*CT_TwipsMeasure) MarshalXML ¶ 

func (m *CT_TwipsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TwipsMeasure) UnmarshalXML ¶ 

func (m *CT_TwipsMeasure) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TwipsMeasure) Validate ¶ 

func (m *CT_TwipsMeasure) Validate() error

Validate validates the CT_TwipsMeasure and its children

func (*CT_TwipsMeasure) ValidateWithPath ¶ 

func (m *CT_TwipsMeasure) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TwipsMeasure and its children, prefixing error messages with path

type CT_TxbxContent ¶ 

type CT_TxbxContent struct {
	// Anchor for Imported External Content
	AltChunk               []*CT_AltChunk
	EG_ContentBlockContent []*EG_ContentBlockContent
}

func NewCT_TxbxContent ¶ 

func NewCT_TxbxContent() *CT_TxbxContent

func (*CT_TxbxContent) MarshalXML ¶ 

func (m *CT_TxbxContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TxbxContent) UnmarshalXML ¶ 

func (m *CT_TxbxContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TxbxContent) Validate ¶ 

func (m *CT_TxbxContent) Validate() error

Validate validates the CT_TxbxContent and its children

func (*CT_TxbxContent) ValidateWithPath ¶ 

func (m *CT_TxbxContent) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TxbxContent and its children, prefixing error messages with path

type CT_Underline ¶ 

type CT_Underline struct {
	// Underline Style
	ValAttr ST_Underline
	// Underline Color
	ColorAttr *ST_HexColor
	// Underline Theme Color
	ThemeColorAttr ST_ThemeColor
	// Underline Theme Color Tint
	ThemeTintAttr *string
	// Underline Theme Color Shade
	ThemeShadeAttr *string
}

func NewCT_Underline ¶ 

func NewCT_Underline() *CT_Underline

func (*CT_Underline) MarshalXML ¶ 

func (m *CT_Underline) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Underline) UnmarshalXML ¶ 

func (m *CT_Underline) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Underline) Validate ¶ 

func (m *CT_Underline) Validate() error

Validate validates the CT_Underline and its children

func (*CT_Underline) ValidateWithPath ¶ 

func (m *CT_Underline) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Underline and its children, prefixing error messages with path

type CT_UnsignedDecimalNumber ¶ 

type CT_UnsignedDecimalNumber struct {
	// Positive Decimal Number Value
	ValAttr uint64
}

func NewCT_UnsignedDecimalNumber ¶ 

func NewCT_UnsignedDecimalNumber() *CT_UnsignedDecimalNumber

func (*CT_UnsignedDecimalNumber) MarshalXML ¶ 

func (m *CT_UnsignedDecimalNumber) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_UnsignedDecimalNumber) UnmarshalXML ¶ 

func (m *CT_UnsignedDecimalNumber) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_UnsignedDecimalNumber) Validate ¶ 

func (m *CT_UnsignedDecimalNumber) Validate() error

Validate validates the CT_UnsignedDecimalNumber and its children

func (*CT_UnsignedDecimalNumber) ValidateWithPath ¶ 

func (m *CT_UnsignedDecimalNumber) ValidateWithPath(path string) error

ValidateWithPath validates the CT_UnsignedDecimalNumber and its children, prefixing error messages with path

type CT_VMerge ¶ 

type CT_VMerge struct {
	// Vertical Merge Type
	ValAttr ST_Merge
}

func NewCT_VMerge ¶ 

func NewCT_VMerge() *CT_VMerge

func (*CT_VMerge) MarshalXML ¶ 

func (m *CT_VMerge) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VMerge) UnmarshalXML ¶ 

func (m *CT_VMerge) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VMerge) Validate ¶ 

func (m *CT_VMerge) Validate() error

Validate validates the CT_VMerge and its children

func (*CT_VMerge) ValidateWithPath ¶ 

func (m *CT_VMerge) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VMerge and its children, prefixing error messages with path

type CT_VerticalAlignRun ¶ 

type CT_VerticalAlignRun struct {
	// Subscript/Superscript Value
	ValAttr sharedTypes.ST_VerticalAlignRun
}

func NewCT_VerticalAlignRun ¶ 

func NewCT_VerticalAlignRun() *CT_VerticalAlignRun

func (*CT_VerticalAlignRun) MarshalXML ¶ 

func (m *CT_VerticalAlignRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VerticalAlignRun) UnmarshalXML ¶ 

func (m *CT_VerticalAlignRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VerticalAlignRun) Validate ¶ 

func (m *CT_VerticalAlignRun) Validate() error

Validate validates the CT_VerticalAlignRun and its children

func (*CT_VerticalAlignRun) ValidateWithPath ¶ 

func (m *CT_VerticalAlignRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VerticalAlignRun and its children, prefixing error messages with path

type CT_VerticalJc ¶ 

type CT_VerticalJc struct {
	// Vertical Alignment Setting
	ValAttr ST_VerticalJc
}

func NewCT_VerticalJc ¶ 

func NewCT_VerticalJc() *CT_VerticalJc

func (*CT_VerticalJc) MarshalXML ¶ 

func (m *CT_VerticalJc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VerticalJc) UnmarshalXML ¶ 

func (m *CT_VerticalJc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VerticalJc) Validate ¶ 

func (m *CT_VerticalJc) Validate() error

Validate validates the CT_VerticalJc and its children

func (*CT_VerticalJc) ValidateWithPath ¶ 

func (m *CT_VerticalJc) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VerticalJc and its children, prefixing error messages with path

type CT_View ¶ 

type CT_View struct {
	// Document View Setting Value
	ValAttr ST_View
}

func NewCT_View ¶ 

func NewCT_View() *CT_View

func (*CT_View) MarshalXML ¶ 

func (m *CT_View) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_View) UnmarshalXML ¶ 

func (m *CT_View) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_View) Validate ¶ 

func (m *CT_View) Validate() error

Validate validates the CT_View and its children

func (*CT_View) ValidateWithPath ¶ 

func (m *CT_View) ValidateWithPath(path string) error

ValidateWithPath validates the CT_View and its children, prefixing error messages with path

type CT_WebSettings ¶ 

type CT_WebSettings struct {
	// Root Frameset Definition
	Frameset *CT_Frameset
	// Information about HTML div Elements
	Divs *CT_Divs
	// Output Encoding When Saving as Web Page
	Encoding *CT_String
	// Disable Features Not Supported by Target Web Browser
	OptimizeForBrowser *CT_OptimizeForBrowser
	// Utilize VML When Saving as Web Page
	RelyOnVML *CT_OnOff
	// Allow PNG as Graphic Format
	AllowPNG *CT_OnOff
	// Do Not Rely on CSS for Font Face Formatting
	DoNotRelyOnCSS *CT_OnOff
	// Recommend Web Page Format over Single File Web Page Format
	DoNotSaveAsSingleFile *CT_OnOff
	// Do Not Place Supporting Files in Subdirectory
	DoNotOrganizeInFolder *CT_OnOff
	// Do Not Use File Names Longer than 8.3 Characters
	DoNotUseLongFileNames *CT_OnOff
	// Pixels per Inch for Graphics/Images
	PixelsPerInch *CT_DecimalNumber
	// Target Screen Size for Web Page
	TargetScreenSz *CT_TargetScreenSz
	// Save Smart Tag Data in XML Property Bag
	SaveSmartTagsAsXml *CT_OnOff
}

func NewCT_WebSettings ¶ 

func NewCT_WebSettings() *CT_WebSettings

func (*CT_WebSettings) MarshalXML ¶ 

func (m *CT_WebSettings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WebSettings) UnmarshalXML ¶ 

func (m *CT_WebSettings) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WebSettings) Validate ¶ 

func (m *CT_WebSettings) Validate() error

Validate validates the CT_WebSettings and its children

func (*CT_WebSettings) ValidateWithPath ¶ 

func (m *CT_WebSettings) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WebSettings and its children, prefixing error messages with path

type CT_WriteProtection ¶ 

type CT_WriteProtection struct {
	// Recommend Write Protection in User Interface
	RecommendedAttr                *sharedTypes.ST_OnOff
	AlgorithmNameAttr              *string
	HashValueAttr                  *string
	SaltValueAttr                  *string
	SpinCountAttr                  *int64
	CryptProviderTypeAttr          sharedTypes.ST_CryptProv
	CryptAlgorithmClassAttr        sharedTypes.ST_AlgClass
	CryptAlgorithmTypeAttr         sharedTypes.ST_AlgType
	CryptAlgorithmSidAttr          *int64
	CryptSpinCountAttr             *int64
	CryptProviderAttr              *string
	AlgIdExtAttr                   *string
	AlgIdExtSourceAttr             *string
	CryptProviderTypeExtAttr       *string
	CryptProviderTypeExtSourceAttr *string
	HashAttr                       *string
	SaltAttr                       *string
}

func NewCT_WriteProtection ¶ 

func NewCT_WriteProtection() *CT_WriteProtection

func (*CT_WriteProtection) MarshalXML ¶ 

func (m *CT_WriteProtection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WriteProtection) UnmarshalXML ¶ 

func (m *CT_WriteProtection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WriteProtection) Validate ¶ 

func (m *CT_WriteProtection) Validate() error

Validate validates the CT_WriteProtection and its children

func (*CT_WriteProtection) ValidateWithPath ¶ 

func (m *CT_WriteProtection) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WriteProtection and its children, prefixing error messages with path

type CT_WritingStyle ¶ 

type CT_WritingStyle struct {
	// Writing Style Language
	LangAttr string
	// Grammatical Engine ID
	VendorIDAttr string
	// Grammatical Check Engine Version
	DllVersionAttr string
	// Natural Language Grammar Check
	NlCheckAttr *sharedTypes.ST_OnOff
	// Check Stylistic Rules With Grammar
	CheckStyleAttr sharedTypes.ST_OnOff
	// Application Name
	AppNameAttr string
}

func NewCT_WritingStyle ¶ 

func NewCT_WritingStyle() *CT_WritingStyle

func (*CT_WritingStyle) MarshalXML ¶ 

func (m *CT_WritingStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WritingStyle) UnmarshalXML ¶ 

func (m *CT_WritingStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WritingStyle) Validate ¶ 

func (m *CT_WritingStyle) Validate() error

Validate validates the CT_WritingStyle and its children

func (*CT_WritingStyle) ValidateWithPath ¶ 

func (m *CT_WritingStyle) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WritingStyle and its children, prefixing error messages with path

type CT_Zoom ¶ 

type CT_Zoom struct {
	// Zoom Type
	ValAttr ST_Zoom
	// Zoom Percentage
	PercentAttr ST_DecimalNumberOrPercent
}

func NewCT_Zoom ¶ 

func NewCT_Zoom() *CT_Zoom

func (*CT_Zoom) MarshalXML ¶ 

func (m *CT_Zoom) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Zoom) UnmarshalXML ¶ 

func (m *CT_Zoom) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Zoom) Validate ¶ 

func (m *CT_Zoom) Validate() error

Validate validates the CT_Zoom and its children

func (*CT_Zoom) ValidateWithPath ¶ 

func (m *CT_Zoom) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Zoom and its children, prefixing error messages with path

type Comments ¶ 

type Comments struct {
	CT_Comments
}

func NewComments ¶ 

func NewComments() *Comments

func (*Comments) MarshalXML ¶ 

func (m *Comments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Comments) UnmarshalXML ¶ 

func (m *Comments) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Comments) Validate ¶ 

func (m *Comments) Validate() error

Validate validates the Comments and its children

func (*Comments) ValidateWithPath ¶ 

func (m *Comments) ValidateWithPath(path string) error

ValidateWithPath validates the Comments and its children, prefixing error messages with path

type Document ¶ 

type Document struct {
	CT_Document
}

func NewDocument ¶ 

func NewDocument() *Document

func (*Document) MarshalXML ¶ 

func (m *Document) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Document) UnmarshalXML ¶ 

func (m *Document) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Document) Validate ¶ 

func (m *Document) Validate() error

Validate validates the Document and its children

func (*Document) ValidateWithPath ¶ 

func (m *Document) ValidateWithPath(path string) error

ValidateWithPath validates the Document and its children, prefixing error messages with path

type EG_BlockLevelChunkElts ¶ 

type EG_BlockLevelChunkElts struct {
	EG_ContentBlockContent []*EG_ContentBlockContent
}

func NewEG_BlockLevelChunkElts ¶ 

func NewEG_BlockLevelChunkElts() *EG_BlockLevelChunkElts

func (*EG_BlockLevelChunkElts) MarshalXML ¶ 

func (m *EG_BlockLevelChunkElts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_BlockLevelChunkElts) UnmarshalXML ¶ 

func (m *EG_BlockLevelChunkElts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_BlockLevelChunkElts) Validate ¶ 

func (m *EG_BlockLevelChunkElts) Validate() error

Validate validates the EG_BlockLevelChunkElts and its children

func (*EG_BlockLevelChunkElts) ValidateWithPath ¶ 

func (m *EG_BlockLevelChunkElts) ValidateWithPath(path string) error

ValidateWithPath validates the EG_BlockLevelChunkElts and its children, prefixing error messages with path

type EG_BlockLevelElts ¶ 

type EG_BlockLevelElts struct {
	// Anchor for Imported External Content
	AltChunk               []*CT_AltChunk
	EG_ContentBlockContent []*EG_ContentBlockContent
}

func NewEG_BlockLevelElts ¶ 

func NewEG_BlockLevelElts() *EG_BlockLevelElts

func (*EG_BlockLevelElts) MarshalXML ¶ 

func (m *EG_BlockLevelElts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_BlockLevelElts) UnmarshalXML ¶ 

func (m *EG_BlockLevelElts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_BlockLevelElts) Validate ¶ 

func (m *EG_BlockLevelElts) Validate() error

Validate validates the EG_BlockLevelElts and its children

func (*EG_BlockLevelElts) ValidateWithPath ¶ 

func (m *EG_BlockLevelElts) ValidateWithPath(path string) error

ValidateWithPath validates the EG_BlockLevelElts and its children, prefixing error messages with path

type EG_CellMarkupElements ¶ 

type EG_CellMarkupElements struct {
	// Table Cell Insertion
	CellIns *CT_TrackChange
	// Table Cell Deletion
	CellDel *CT_TrackChange
	// Vertically Merged/Split Table Cells
	CellMerge *CT_CellMergeTrackChange
}

func NewEG_CellMarkupElements ¶ 

func NewEG_CellMarkupElements() *EG_CellMarkupElements

func (*EG_CellMarkupElements) MarshalXML ¶ 

func (m *EG_CellMarkupElements) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_CellMarkupElements) UnmarshalXML ¶ 

func (m *EG_CellMarkupElements) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_CellMarkupElements) Validate ¶ 

func (m *EG_CellMarkupElements) Validate() error

Validate validates the EG_CellMarkupElements and its children

func (*EG_CellMarkupElements) ValidateWithPath ¶ 

func (m *EG_CellMarkupElements) ValidateWithPath(path string) error

ValidateWithPath validates the EG_CellMarkupElements and its children, prefixing error messages with path

type EG_ContentBlockContent ¶ 

type EG_ContentBlockContent struct {
	// Block-Level Custom XML Element
	CustomXml *CT_CustomXmlBlock
	// Block-Level Structured Document Tag
	Sdt *CT_SdtBlock
	// Paragraph
	P []*CT_P
	// Table
	Tbl             []*CT_Tbl
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewEG_ContentBlockContent ¶ 

func NewEG_ContentBlockContent() *EG_ContentBlockContent

func (*EG_ContentBlockContent) MarshalXML ¶ 

func (m *EG_ContentBlockContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_ContentBlockContent) UnmarshalXML ¶ 

func (m *EG_ContentBlockContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_ContentBlockContent) Validate ¶ 

func (m *EG_ContentBlockContent) Validate() error

Validate validates the EG_ContentBlockContent and its children

func (*EG_ContentBlockContent) ValidateWithPath ¶ 

func (m *EG_ContentBlockContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_ContentBlockContent and its children, prefixing error messages with path

type EG_ContentCellContent ¶ 

type EG_ContentCellContent struct {
	// Table Cell
	Tc []*CT_Tc
	// Cell-Level Custom XML Element
	CustomXml *CT_CustomXmlCell
	// Cell-Level Structured Document Tag
	Sdt             *CT_SdtCell
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewEG_ContentCellContent ¶ 

func NewEG_ContentCellContent() *EG_ContentCellContent

func (*EG_ContentCellContent) MarshalXML ¶ 

func (m *EG_ContentCellContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_ContentCellContent) UnmarshalXML ¶ 

func (m *EG_ContentCellContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_ContentCellContent) Validate ¶ 

func (m *EG_ContentCellContent) Validate() error

Validate validates the EG_ContentCellContent and its children

func (*EG_ContentCellContent) ValidateWithPath ¶ 

func (m *EG_ContentCellContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_ContentCellContent and its children, prefixing error messages with path

type EG_ContentRowContent ¶ 

type EG_ContentRowContent struct {
	// Table Row
	Tr []*CT_Row
	// Row-Level Custom XML Element
	CustomXml *CT_CustomXmlRow
	// Row-Level Structured Document Tag
	Sdt             *CT_SdtRow
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewEG_ContentRowContent ¶ 

func NewEG_ContentRowContent() *EG_ContentRowContent

func (*EG_ContentRowContent) MarshalXML ¶ 

func (m *EG_ContentRowContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_ContentRowContent) UnmarshalXML ¶ 

func (m *EG_ContentRowContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_ContentRowContent) Validate ¶ 

func (m *EG_ContentRowContent) Validate() error

Validate validates the EG_ContentRowContent and its children

func (*EG_ContentRowContent) ValidateWithPath ¶ 

func (m *EG_ContentRowContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_ContentRowContent and its children, prefixing error messages with path

type EG_ContentRunContent ¶ 

type EG_ContentRunContent struct {
	// Inline-Level Custom XML Element
	CustomXml *CT_CustomXmlRun
	// Inline-Level Smart Tag
	SmartTag *CT_SmartTagRun
	// Inline-Level Structured Document Tag
	Sdt *CT_SdtRun
	// Bidirectional Embedding Level
	Dir *CT_DirContentRun
	// Bidirectional Override
	Bdo *CT_BdoContentRun
	// Text Run
	R               *CT_R
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewEG_ContentRunContent ¶ 

func NewEG_ContentRunContent() *EG_ContentRunContent

func (*EG_ContentRunContent) MarshalXML ¶ 

func (m *EG_ContentRunContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_ContentRunContent) UnmarshalXML ¶ 

func (m *EG_ContentRunContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_ContentRunContent) Validate ¶ 

func (m *EG_ContentRunContent) Validate() error

Validate validates the EG_ContentRunContent and its children

func (*EG_ContentRunContent) ValidateWithPath ¶ 

func (m *EG_ContentRunContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_ContentRunContent and its children, prefixing error messages with path

type EG_ContentRunContentBase ¶ 

type EG_ContentRunContentBase struct {
	SmartTag        *CT_SmartTagRun
	Sdt             *CT_SdtRun
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewEG_ContentRunContentBase ¶ 

func NewEG_ContentRunContentBase() *EG_ContentRunContentBase

func (*EG_ContentRunContentBase) MarshalXML ¶ 

func (m *EG_ContentRunContentBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_ContentRunContentBase) UnmarshalXML ¶ 

func (m *EG_ContentRunContentBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_ContentRunContentBase) Validate ¶ 

func (m *EG_ContentRunContentBase) Validate() error

Validate validates the EG_ContentRunContentBase and its children

func (*EG_ContentRunContentBase) ValidateWithPath ¶ 

func (m *EG_ContentRunContentBase) ValidateWithPath(path string) error

ValidateWithPath validates the EG_ContentRunContentBase and its children, prefixing error messages with path

type EG_FtnEdnNumProps ¶ 

type EG_FtnEdnNumProps struct {
	// Footnote and Endnote Numbering Starting Value
	NumStart *CT_DecimalNumber
	// Footnote and Endnote Numbering Restart Location
	NumRestart *CT_NumRestart
}

func NewEG_FtnEdnNumProps ¶ 

func NewEG_FtnEdnNumProps() *EG_FtnEdnNumProps

func (*EG_FtnEdnNumProps) MarshalXML ¶ 

func (m *EG_FtnEdnNumProps) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_FtnEdnNumProps) UnmarshalXML ¶ 

func (m *EG_FtnEdnNumProps) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_FtnEdnNumProps) Validate ¶ 

func (m *EG_FtnEdnNumProps) Validate() error

Validate validates the EG_FtnEdnNumProps and its children

func (*EG_FtnEdnNumProps) ValidateWithPath ¶ 

func (m *EG_FtnEdnNumProps) ValidateWithPath(path string) error

ValidateWithPath validates the EG_FtnEdnNumProps and its children, prefixing error messages with path

type EG_HdrFtrReferences ¶ 

type EG_HdrFtrReferences struct {
	// Header Reference
	HeaderReference *CT_HdrFtrRef
	// Footer Reference
	FooterReference *CT_HdrFtrRef
}

func NewEG_HdrFtrReferences ¶ 

func NewEG_HdrFtrReferences() *EG_HdrFtrReferences

func (*EG_HdrFtrReferences) MarshalXML ¶ 

func (m *EG_HdrFtrReferences) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_HdrFtrReferences) UnmarshalXML ¶ 

func (m *EG_HdrFtrReferences) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_HdrFtrReferences) Validate ¶ 

func (m *EG_HdrFtrReferences) Validate() error

Validate validates the EG_HdrFtrReferences and its children

func (*EG_HdrFtrReferences) ValidateWithPath ¶ 

func (m *EG_HdrFtrReferences) ValidateWithPath(path string) error

ValidateWithPath validates the EG_HdrFtrReferences and its children, prefixing error messages with path

type EG_MathContent ¶ 

type EG_MathContent struct {
	OMathPara *math.OMathPara
	OMath     *math.OMath
}

func NewEG_MathContent ¶ 

func NewEG_MathContent() *EG_MathContent

func (*EG_MathContent) MarshalXML ¶ 

func (m *EG_MathContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_MathContent) UnmarshalXML ¶ 

func (m *EG_MathContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_MathContent) Validate ¶ 

func (m *EG_MathContent) Validate() error

Validate validates the EG_MathContent and its children

func (*EG_MathContent) ValidateWithPath ¶ 

func (m *EG_MathContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_MathContent and its children, prefixing error messages with path

type EG_PContent ¶ 

type EG_PContent struct {
	// Simple Field
	FldSimple []*CT_SimpleField
	// Hyperlink
	Hyperlink *CT_Hyperlink
	// Anchor for Subdocument Location
	SubDoc               *CT_Rel
	EG_ContentRunContent []*EG_ContentRunContent
}

func NewEG_PContent ¶ 

func NewEG_PContent() *EG_PContent

func (*EG_PContent) MarshalXML ¶ 

func (m *EG_PContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_PContent) UnmarshalXML ¶ 

func (m *EG_PContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_PContent) Validate ¶ 

func (m *EG_PContent) Validate() error

Validate validates the EG_PContent and its children

func (*EG_PContent) ValidateWithPath ¶ 

func (m *EG_PContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_PContent and its children, prefixing error messages with path

type EG_PContentBase ¶ 

type EG_PContentBase struct {
	CustomXml *CT_CustomXmlRun
	FldSimple []*CT_SimpleField
	Hyperlink *CT_Hyperlink
}

func NewEG_PContentBase ¶ 

func NewEG_PContentBase() *EG_PContentBase

func (*EG_PContentBase) MarshalXML ¶ 

func (m *EG_PContentBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_PContentBase) UnmarshalXML ¶ 

func (m *EG_PContentBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_PContentBase) Validate ¶ 

func (m *EG_PContentBase) Validate() error

Validate validates the EG_PContentBase and its children

func (*EG_PContentBase) ValidateWithPath ¶ 

func (m *EG_PContentBase) ValidateWithPath(path string) error

ValidateWithPath validates the EG_PContentBase and its children, prefixing error messages with path

type EG_PContentMath ¶ 

type EG_PContentMath struct {
	EG_PContentBase          []*EG_PContentBase
	EG_ContentRunContentBase []*EG_ContentRunContentBase
}

func NewEG_PContentMath ¶ 

func NewEG_PContentMath() *EG_PContentMath

func (*EG_PContentMath) MarshalXML ¶ 

func (m *EG_PContentMath) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_PContentMath) UnmarshalXML ¶ 

func (m *EG_PContentMath) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_PContentMath) Validate ¶ 

func (m *EG_PContentMath) Validate() error

Validate validates the EG_PContentMath and its children

func (*EG_PContentMath) ValidateWithPath ¶ 

func (m *EG_PContentMath) ValidateWithPath(path string) error

ValidateWithPath validates the EG_PContentMath and its children, prefixing error messages with path

type EG_ParaRPrTrackChanges ¶ 

type EG_ParaRPrTrackChanges struct {
	// Inserted Paragraph
	Ins *CT_TrackChange
	// Deleted Paragraph
	Del *CT_TrackChange
	// Move Source Paragraph
	MoveFrom *CT_TrackChange
	// Move Destination Paragraph
	MoveTo *CT_TrackChange
}

func NewEG_ParaRPrTrackChanges ¶ 

func NewEG_ParaRPrTrackChanges() *EG_ParaRPrTrackChanges

func (*EG_ParaRPrTrackChanges) MarshalXML ¶ 

func (m *EG_ParaRPrTrackChanges) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_ParaRPrTrackChanges) UnmarshalXML ¶ 

func (m *EG_ParaRPrTrackChanges) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_ParaRPrTrackChanges) Validate ¶ 

func (m *EG_ParaRPrTrackChanges) Validate() error

Validate validates the EG_ParaRPrTrackChanges and its children

func (*EG_ParaRPrTrackChanges) ValidateWithPath ¶ 

func (m *EG_ParaRPrTrackChanges) ValidateWithPath(path string) error

ValidateWithPath validates the EG_ParaRPrTrackChanges and its children, prefixing error messages with path

type EG_RPr ¶ 

type EG_RPr struct {
	// Run Properties
	RPr *CT_RPr
}

func NewEG_RPr ¶ 

func NewEG_RPr() *EG_RPr

func (*EG_RPr) MarshalXML ¶ 

func (m *EG_RPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RPr) UnmarshalXML ¶ 

func (m *EG_RPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RPr) Validate ¶ 

func (m *EG_RPr) Validate() error

Validate validates the EG_RPr and its children

func (*EG_RPr) ValidateWithPath ¶ 

func (m *EG_RPr) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RPr and its children, prefixing error messages with path

type EG_RPrBase ¶ 

type EG_RPrBase struct {
	// Referenced Character Style
	RStyle *CT_String
	// Run Fonts
	RFonts *CT_Fonts
	// Bold
	B *CT_OnOff
	// Complex Script Bold
	BCs *CT_OnOff
	// Italics
	I *CT_OnOff
	// Complex Script Italics
	ICs *CT_OnOff
	// Display All Characters As Capital Letters
	Caps *CT_OnOff
	// Small Caps
	SmallCaps *CT_OnOff
	// Single Strikethrough
	Strike *CT_OnOff
	// Double Strikethrough
	Dstrike *CT_OnOff
	// Display Character Outline
	Outline *CT_OnOff
	// Shadow
	Shadow *CT_OnOff
	// Embossing
	Emboss *CT_OnOff
	// Imprinting
	Imprint *CT_OnOff
	// Do Not Check Spelling or Grammar
	NoProof *CT_OnOff
	// Use Document Grid Settings For Inter-Character Spacing
	SnapToGrid *CT_OnOff
	// Hidden Text
	Vanish *CT_OnOff
	// Web Hidden Text
	WebHidden *CT_OnOff
	// Run Content Color
	Color *CT_Color
	// Character Spacing Adjustment
	Spacing *CT_SignedTwipsMeasure
	// Expanded/Compressed Text
	W *CT_TextScale
	// Font Kerning
	Kern *CT_HpsMeasure
	// Vertically Raised or Lowered Text
	Position *CT_SignedHpsMeasure
	// Non-Complex Script Font Size
	Sz *CT_HpsMeasure
	// Complex Script Font Size
	SzCs *CT_HpsMeasure
	// Text Highlighting
	Highlight *CT_Highlight
	// Underline
	U *CT_Underline
	// Animated Text Effect
	Effect *CT_TextEffect
	// Text Border
	Bdr *CT_Border
	// Run Shading
	Shd *CT_Shd
	// Manual Run Width
	FitText *CT_FitText
	// Subscript/Superscript Text
	VertAlign *CT_VerticalAlignRun
	// Right To Left Text
	Rtl *CT_OnOff
	// Use Complex Script Formatting on Run
	Cs *CT_OnOff
	// Emphasis Mark
	Em *CT_Em
	// Languages for Run Content
	Lang *CT_Language
	// East Asian Typography Settings
	EastAsianLayout *CT_EastAsianLayout
	// Paragraph Mark Is Always Hidden
	SpecVanish *CT_OnOff
	// Office Open XML Math
	OMath *CT_OnOff
}

func NewEG_RPrBase ¶ 

func NewEG_RPrBase() *EG_RPrBase

func (*EG_RPrBase) MarshalXML ¶ 

func (m *EG_RPrBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RPrBase) UnmarshalXML ¶ 

func (m *EG_RPrBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RPrBase) Validate ¶ 

func (m *EG_RPrBase) Validate() error

Validate validates the EG_RPrBase and its children

func (*EG_RPrBase) ValidateWithPath ¶ 

func (m *EG_RPrBase) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RPrBase and its children, prefixing error messages with path

type EG_RPrContent ¶ 

type EG_RPrContent struct {
	// Referenced Character Style
	RStyle *CT_String
	// Run Fonts
	RFonts *CT_Fonts
	// Bold
	B *CT_OnOff
	// Complex Script Bold
	BCs *CT_OnOff
	// Italics
	I *CT_OnOff
	// Complex Script Italics
	ICs *CT_OnOff
	// Display All Characters As Capital Letters
	Caps *CT_OnOff
	// Small Caps
	SmallCaps *CT_OnOff
	// Single Strikethrough
	Strike *CT_OnOff
	// Double Strikethrough
	Dstrike *CT_OnOff
	// Display Character Outline
	Outline *CT_OnOff
	// Shadow
	Shadow *CT_OnOff
	// Embossing
	Emboss *CT_OnOff
	// Imprinting
	Imprint *CT_OnOff
	// Do Not Check Spelling or Grammar
	NoProof *CT_OnOff
	// Use Document Grid Settings For Inter-Character Spacing
	SnapToGrid *CT_OnOff
	// Hidden Text
	Vanish *CT_OnOff
	// Web Hidden Text
	WebHidden *CT_OnOff
	// Run Content Color
	Color *CT_Color
	// Character Spacing Adjustment
	Spacing *CT_SignedTwipsMeasure
	// Expanded/Compressed Text
	W *CT_TextScale
	// Font Kerning
	Kern *CT_HpsMeasure
	// Vertically Raised or Lowered Text
	Position *CT_SignedHpsMeasure
	// Non-Complex Script Font Size
	Sz *CT_HpsMeasure
	// Complex Script Font Size
	SzCs *CT_HpsMeasure
	// Text Highlighting
	Highlight *CT_Highlight
	// Underline
	U *CT_Underline
	// Animated Text Effect
	Effect *CT_TextEffect
	// Text Border
	Bdr *CT_Border
	// Run Shading
	Shd *CT_Shd
	// Manual Run Width
	FitText *CT_FitText
	// Subscript/Superscript Text
	VertAlign *CT_VerticalAlignRun
	// Right To Left Text
	Rtl *CT_OnOff
	// Use Complex Script Formatting on Run
	Cs *CT_OnOff
	// Emphasis Mark
	Em *CT_Em
	// Languages for Run Content
	Lang *CT_Language
	// East Asian Typography Settings
	EastAsianLayout *CT_EastAsianLayout
	// Paragraph Mark Is Always Hidden
	SpecVanish *CT_OnOff
	// Office Open XML Math
	OMath *CT_OnOff
	// Revision Information for Run Properties
	RPrChange *CT_RPrChange
}

func NewEG_RPrContent ¶ 

func NewEG_RPrContent() *EG_RPrContent

func (*EG_RPrContent) MarshalXML ¶ 

func (m *EG_RPrContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RPrContent) UnmarshalXML ¶ 

func (m *EG_RPrContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RPrContent) Validate ¶ 

func (m *EG_RPrContent) Validate() error

Validate validates the EG_RPrContent and its children

func (*EG_RPrContent) ValidateWithPath ¶ 

func (m *EG_RPrContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RPrContent and its children, prefixing error messages with path

type EG_RPrMath ¶ 

type EG_RPrMath struct {
	// Inserted Math Control Character
	Ins *CT_MathCtrlIns
	// Deleted Math Control Character
	Del *CT_MathCtrlDel
	// Run Properties
	RPr *CT_RPr
}

func NewEG_RPrMath ¶ 

func NewEG_RPrMath() *EG_RPrMath

func (*EG_RPrMath) MarshalXML ¶ 

func (m *EG_RPrMath) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RPrMath) UnmarshalXML ¶ 

func (m *EG_RPrMath) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RPrMath) Validate ¶ 

func (m *EG_RPrMath) Validate() error

Validate validates the EG_RPrMath and its children

func (*EG_RPrMath) ValidateWithPath ¶ 

func (m *EG_RPrMath) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RPrMath and its children, prefixing error messages with path

type EG_RangeMarkupElements ¶ 

type EG_RangeMarkupElements struct {
	// Bookmark Start
	BookmarkStart *CT_Bookmark
	// Bookmark End
	BookmarkEnd *CT_MarkupRange
	// Move Source Location Container - Start
	MoveFromRangeStart *CT_MoveBookmark
	// Move Source Location Container - End
	MoveFromRangeEnd *CT_MarkupRange
	// Move Destination Location Container - Start
	MoveToRangeStart *CT_MoveBookmark
	// Move Destination Location Container - End
	MoveToRangeEnd *CT_MarkupRange
	// Comment Anchor Range Start
	CommentRangeStart *CT_MarkupRange
	// Comment Anchor Range End
	CommentRangeEnd *CT_MarkupRange
	// Custom XML Markup Insertion Start
	CustomXmlInsRangeStart *CT_TrackChange
	// Custom XML Markup Insertion End
	CustomXmlInsRangeEnd *CT_Markup
	// Custom XML Markup Deletion Start
	CustomXmlDelRangeStart *CT_TrackChange
	// Custom XML Markup Deletion End
	CustomXmlDelRangeEnd *CT_Markup
	// Custom XML Markup Move Source Start
	CustomXmlMoveFromRangeStart *CT_TrackChange
	// Custom XML Markup Move Source End
	CustomXmlMoveFromRangeEnd *CT_Markup
	// Custom XML Markup Move Destination Location Start
	CustomXmlMoveToRangeStart *CT_TrackChange
	// Custom XML Markup Move Destination Location End
	CustomXmlMoveToRangeEnd *CT_Markup
}

func NewEG_RangeMarkupElements ¶ 

func NewEG_RangeMarkupElements() *EG_RangeMarkupElements

func (*EG_RangeMarkupElements) MarshalXML ¶ 

func (m *EG_RangeMarkupElements) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RangeMarkupElements) UnmarshalXML ¶ 

func (m *EG_RangeMarkupElements) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RangeMarkupElements) Validate ¶ 

func (m *EG_RangeMarkupElements) Validate() error

Validate validates the EG_RangeMarkupElements and its children

func (*EG_RangeMarkupElements) ValidateWithPath ¶ 

func (m *EG_RangeMarkupElements) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RangeMarkupElements and its children, prefixing error messages with path

type EG_RubyContent ¶ 

type EG_RubyContent struct {
	// Phonetic Guide Text Run
	R               *CT_R
	EG_RunLevelElts []*EG_RunLevelElts
}

func NewEG_RubyContent ¶ 

func NewEG_RubyContent() *EG_RubyContent

func (*EG_RubyContent) MarshalXML ¶ 

func (m *EG_RubyContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RubyContent) UnmarshalXML ¶ 

func (m *EG_RubyContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RubyContent) Validate ¶ 

func (m *EG_RubyContent) Validate() error

Validate validates the EG_RubyContent and its children

func (*EG_RubyContent) ValidateWithPath ¶ 

func (m *EG_RubyContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RubyContent and its children, prefixing error messages with path

type EG_RunInnerContent ¶ 

type EG_RunInnerContent struct {
	// Break
	Br *CT_Br
	// Text
	T *CT_Text
	// Content Part
	ContentPart *CT_Rel
	// Deleted Text
	DelText *CT_Text
	// Field Code
	InstrText *CT_Text
	// Deleted Field Code
	DelInstrText *CT_Text
	// Non Breaking Hyphen Character
	NoBreakHyphen *CT_Empty
	// Optional Hyphen Character
	SoftHyphen *CT_Empty
	// Date Block - Short Day Format
	DayShort *CT_Empty
	// Date Block - Short Month Format
	MonthShort *CT_Empty
	// Date Block - Short Year Format
	YearShort *CT_Empty
	// Date Block - Long Day Format
	DayLong *CT_Empty
	// Date Block - Long Month Format
	MonthLong *CT_Empty
	// Date Block - Long Year Format
	YearLong *CT_Empty
	// Comment Information Block
	AnnotationRef *CT_Empty
	// Footnote Reference Mark
	FootnoteRef *CT_Empty
	// Endnote Reference Mark
	EndnoteRef *CT_Empty
	// Footnote/Endnote Separator Mark
	Separator *CT_Empty
	// Continuation Separator Mark
	ContinuationSeparator *CT_Empty
	// Symbol Character
	Sym *CT_Sym
	// Page Number Block
	PgNum *CT_Empty
	// Carriage Return
	Cr *CT_Empty
	// Tab Character
	Tab *CT_Empty
	// Embedded Object
	Object *CT_Object
	// VML Object
	Pict *CT_Picture
	// Complex Field Character
	FldChar *CT_FldChar
	// Phonetic Guide
	Ruby *CT_Ruby
	// Footnote Reference
	FootnoteReference *CT_FtnEdnRef
	// Endnote Reference
	EndnoteReference *CT_FtnEdnRef
	// Comment Content Reference Mark
	CommentReference *CT_Markup
	// DrawingML Object
	Drawing *CT_Drawing
	// Absolute Position Tab Character
	Ptab *CT_PTab
	// Position of Last Calculated Page Break
	LastRenderedPageBreak *CT_Empty
}

func NewEG_RunInnerContent ¶ 

func NewEG_RunInnerContent() *EG_RunInnerContent

func (*EG_RunInnerContent) MarshalXML ¶ 

func (m *EG_RunInnerContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RunInnerContent) UnmarshalXML ¶ 

func (m *EG_RunInnerContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RunInnerContent) Validate ¶ 

func (m *EG_RunInnerContent) Validate() error

Validate validates the EG_RunInnerContent and its children

func (*EG_RunInnerContent) ValidateWithPath ¶ 

func (m *EG_RunInnerContent) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RunInnerContent and its children, prefixing error messages with path

type EG_RunLevelElts ¶ 

type EG_RunLevelElts struct {
	// Proofing Error Anchor
	ProofErr *CT_ProofErr
	// Range Permission Start
	PermStart *CT_PermStart
	// Range Permission End
	PermEnd *CT_Perm
	// Inserted Run Content
	Ins *CT_RunTrackChange
	// Deleted Run Content
	Del *CT_RunTrackChange
	// Move Source Run Content
	MoveFrom *CT_RunTrackChange
	// Move Destination Run Content
	MoveTo                 *CT_RunTrackChange
	EG_RangeMarkupElements []*EG_RangeMarkupElements
	EG_MathContent         []*EG_MathContent
}

func NewEG_RunLevelElts ¶ 

func NewEG_RunLevelElts() *EG_RunLevelElts

func (*EG_RunLevelElts) MarshalXML ¶ 

func (m *EG_RunLevelElts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_RunLevelElts) UnmarshalXML ¶ 

func (m *EG_RunLevelElts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_RunLevelElts) Validate ¶ 

func (m *EG_RunLevelElts) Validate() error

Validate validates the EG_RunLevelElts and its children

func (*EG_RunLevelElts) ValidateWithPath ¶ 

func (m *EG_RunLevelElts) ValidateWithPath(path string) error

ValidateWithPath validates the EG_RunLevelElts and its children, prefixing error messages with path

type EG_SectPrContents ¶ 

type EG_SectPrContents struct {
	// Section-Wide Footnote Properties
	FootnotePr *CT_FtnProps
	// Section-Wide Endnote Properties
	EndnotePr *CT_EdnProps
	// Section Type
	Type *CT_SectType
	// Page Size
	PgSz *CT_PageSz
	// Page Margins
	PgMar *CT_PageMar
	// Paper Source Information
	PaperSrc *CT_PaperSource
	// Page Borders
	PgBorders *CT_PageBorders
	// Line Numbering Settings
	LnNumType *CT_LineNumber
	// Page Numbering Settings
	PgNumType *CT_PageNumber
	// Column Definitions
	Cols *CT_Columns
	// Only Allow Editing of Form Fields
	FormProt *CT_OnOff
	// Vertical Text Alignment on Page
	VAlign *CT_VerticalJc
	// Suppress Endnotes In Document
	NoEndnote *CT_OnOff
	// Different First Page Headers and Footers
	TitlePg *CT_OnOff
	// Text Flow Direction
	TextDirection *CT_TextDirection
	// Right to Left Section Layout
	Bidi *CT_OnOff
	// Gutter on Right Side of Page
	RtlGutter *CT_OnOff
	// Document Grid
	DocGrid *CT_DocGrid
	// Reference to Printer Settings Data
	PrinterSettings *CT_Rel
}

func NewEG_SectPrContents ¶ 

func NewEG_SectPrContents() *EG_SectPrContents

func (*EG_SectPrContents) MarshalXML ¶ 

func (m *EG_SectPrContents) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_SectPrContents) UnmarshalXML ¶ 

func (m *EG_SectPrContents) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_SectPrContents) Validate ¶ 

func (m *EG_SectPrContents) Validate() error

Validate validates the EG_SectPrContents and its children

func (*EG_SectPrContents) ValidateWithPath ¶ 

func (m *EG_SectPrContents) ValidateWithPath(path string) error

ValidateWithPath validates the EG_SectPrContents and its children, prefixing error messages with path

type Endnotes ¶ 

type Endnotes struct {
	CT_Endnotes
}

func NewEndnotes ¶ 

func NewEndnotes() *Endnotes

func (*Endnotes) MarshalXML ¶ 

func (m *Endnotes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Endnotes) UnmarshalXML ¶ 

func (m *Endnotes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Endnotes) Validate ¶ 

func (m *Endnotes) Validate() error

Validate validates the Endnotes and its children

func (*Endnotes) ValidateWithPath ¶ 

func (m *Endnotes) ValidateWithPath(path string) error

ValidateWithPath validates the Endnotes and its children, prefixing error messages with path

type Fonts ¶ 

type Fonts struct {
	CT_FontsList
}

func NewFonts ¶ 

func NewFonts() *Fonts

func (*Fonts) MarshalXML ¶ 

func (m *Fonts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Fonts) UnmarshalXML ¶ 

func (m *Fonts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Fonts) Validate ¶ 

func (m *Fonts) Validate() error

Validate validates the Fonts and its children

func (*Fonts) ValidateWithPath ¶ 

func (m *Fonts) ValidateWithPath(path string) error

ValidateWithPath validates the Fonts and its children, prefixing error messages with path

type Footnotes ¶ 

type Footnotes struct {
	CT_Footnotes
}

func NewFootnotes ¶ 

func NewFootnotes() *Footnotes

func (*Footnotes) MarshalXML ¶ 

func (m *Footnotes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Footnotes) UnmarshalXML ¶ 

func (m *Footnotes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Footnotes) Validate ¶ 

func (m *Footnotes) Validate() error

Validate validates the Footnotes and its children

func (*Footnotes) ValidateWithPath ¶ 

func (m *Footnotes) ValidateWithPath(path string) error

ValidateWithPath validates the Footnotes and its children, prefixing error messages with path

type Ftr ¶ 

type Ftr struct {
	CT_HdrFtr
}

func NewFtr ¶ 

func NewFtr() *Ftr

func (*Ftr) MarshalXML ¶ 

func (m *Ftr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Ftr) UnmarshalXML ¶ 

func (m *Ftr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Ftr) Validate ¶ 

func (m *Ftr) Validate() error

Validate validates the Ftr and its children

func (*Ftr) ValidateWithPath ¶ 

func (m *Ftr) ValidateWithPath(path string) error

ValidateWithPath validates the Ftr and its children, prefixing error messages with path

type GlossaryDocument ¶ 

type GlossaryDocument struct {
	CT_GlossaryDocument
}

func NewGlossaryDocument ¶ 

func NewGlossaryDocument() *GlossaryDocument

func (*GlossaryDocument) MarshalXML ¶ 

func (m *GlossaryDocument) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*GlossaryDocument) UnmarshalXML ¶ 

func (m *GlossaryDocument) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*GlossaryDocument) Validate ¶ 

func (m *GlossaryDocument) Validate() error

Validate validates the GlossaryDocument and its children

func (*GlossaryDocument) ValidateWithPath ¶ 

func (m *GlossaryDocument) ValidateWithPath(path string) error

ValidateWithPath validates the GlossaryDocument and its children, prefixing error messages with path

type Hdr ¶ 

type Hdr struct {
	CT_HdrFtr
}

func NewHdr ¶ 

func NewHdr() *Hdr

func (*Hdr) MarshalXML ¶ 

func (m *Hdr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Hdr) UnmarshalXML ¶ 

func (m *Hdr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Hdr) Validate ¶ 

func (m *Hdr) Validate() error

Validate validates the Hdr and its children

func (*Hdr) ValidateWithPath ¶ 

func (m *Hdr) ValidateWithPath(path string) error

ValidateWithPath validates the Hdr and its children, prefixing error messages with path

type Numbering ¶ 

type Numbering struct {
	CT_Numbering
}

func NewNumbering ¶ 

func NewNumbering() *Numbering

func (*Numbering) MarshalXML ¶ 

func (m *Numbering) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Numbering) UnmarshalXML ¶ 

func (m *Numbering) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Numbering) Validate ¶ 

func (m *Numbering) Validate() error

Validate validates the Numbering and its children

func (*Numbering) ValidateWithPath ¶ 

func (m *Numbering) ValidateWithPath(path string) error

ValidateWithPath validates the Numbering and its children, prefixing error messages with path

type Recipients ¶ 

type Recipients struct {
	CT_Recipients
}

func NewRecipients ¶ 

func NewRecipients() *Recipients

func (*Recipients) MarshalXML ¶ 

func (m *Recipients) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Recipients) UnmarshalXML ¶ 

func (m *Recipients) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Recipients) Validate ¶ 

func (m *Recipients) Validate() error

Validate validates the Recipients and its children

func (*Recipients) ValidateWithPath ¶ 

func (m *Recipients) ValidateWithPath(path string) error

ValidateWithPath validates the Recipients and its children, prefixing error messages with path

type ST_AnnotationVMerge ¶ 

type ST_AnnotationVMerge byte
const (
	ST_AnnotationVMergeUnset ST_AnnotationVMerge = 0
	ST_AnnotationVMergeCont  ST_AnnotationVMerge = 1
	ST_AnnotationVMergeRest  ST_AnnotationVMerge = 2
)

func (ST_AnnotationVMerge) MarshalXML ¶ 

func (m ST_AnnotationVMerge) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_AnnotationVMerge) MarshalXMLAttr ¶ 

func (e ST_AnnotationVMerge) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_AnnotationVMerge) String ¶ 

func (m ST_AnnotationVMerge) String() string

func (*ST_AnnotationVMerge) UnmarshalXML ¶ 

func (m *ST_AnnotationVMerge) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_AnnotationVMerge) UnmarshalXMLAttr ¶ 

func (e *ST_AnnotationVMerge) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_AnnotationVMerge) Validate ¶ 

func (m ST_AnnotationVMerge) Validate() error

func (ST_AnnotationVMerge) ValidateWithPath ¶ 

func (m ST_AnnotationVMerge) ValidateWithPath(path string) error

type ST_Border ¶ 

type ST_Border byte
const (
	ST_BorderUnset                  ST_Border = 0
	ST_BorderNil                    ST_Border = 1
	ST_BorderNone                   ST_Border = 2
	ST_BorderSingle                 ST_Border = 3
	ST_BorderThick                  ST_Border = 4
	ST_BorderDouble                 ST_Border = 5
	ST_BorderDotted                 ST_Border = 6
	ST_BorderDashed                 ST_Border = 7
	ST_BorderDotDash                ST_Border = 8
	ST_BorderDotDotDash             ST_Border = 9
	ST_BorderTriple                 ST_Border = 10
	ST_BorderThinThickSmallGap      ST_Border = 11
	ST_BorderThickThinSmallGap      ST_Border = 12
	ST_BorderThinThickThinSmallGap  ST_Border = 13
	ST_BorderThinThickMediumGap     ST_Border = 14
	ST_BorderThickThinMediumGap     ST_Border = 15
	ST_BorderThinThickThinMediumGap ST_Border = 16
	ST_BorderThinThickLargeGap      ST_Border = 17
	ST_BorderThickThinLargeGap      ST_Border = 18
	ST_BorderThinThickThinLargeGap  ST_Border = 19
	ST_BorderWave                   ST_Border = 20
	ST_BorderDoubleWave             ST_Border = 21
	ST_BorderDashSmallGap           ST_Border = 22
	ST_BorderDashDotStroked         ST_Border = 23
	ST_BorderThreeDEmboss           ST_Border = 24
	ST_BorderThreeDEngrave          ST_Border = 25
	ST_BorderOutset                 ST_Border = 26
	ST_BorderInset                  ST_Border = 27
	ST_BorderApples                 ST_Border = 28
	ST_BorderArchedScallops         ST_Border = 29
	ST_BorderBabyPacifier           ST_Border = 30
	ST_BorderBabyRattle             ST_Border = 31
	ST_BorderBalloons3Colors        ST_Border = 32
	ST_BorderBalloonsHotAir         ST_Border = 33
	ST_BorderBasicBlackDashes       ST_Border = 34
	ST_BorderBasicBlackDots         ST_Border = 35
	ST_BorderBasicBlackSquares      ST_Border = 36
	ST_BorderBasicThinLines         ST_Border = 37
	ST_BorderBasicWhiteDashes       ST_Border = 38
	ST_BorderBasicWhiteDots         ST_Border = 39
	ST_BorderBasicWhiteSquares      ST_Border = 40
	ST_BorderBasicWideInline        ST_Border = 41
	ST_BorderBasicWideMidline       ST_Border = 42
	ST_BorderBasicWideOutline       ST_Border = 43
	ST_BorderBats                   ST_Border = 44
	ST_BorderBirds                  ST_Border = 45
	ST_BorderBirdsFlight            ST_Border = 46
	ST_BorderCabins                 ST_Border = 47
	ST_BorderCakeSlice              ST_Border = 48
	ST_BorderCandyCorn              ST_Border = 49
	ST_BorderCelticKnotwork         ST_Border = 50
	ST_BorderCertificateBanner      ST_Border = 51
	ST_BorderChainLink              ST_Border = 52
	ST_BorderChampagneBottle        ST_Border = 53
	ST_BorderCheckedBarBlack        ST_Border = 54
	ST_BorderCheckedBarColor        ST_Border = 55
	ST_BorderCheckered              ST_Border = 56
	ST_BorderChristmasTree          ST_Border = 57
	ST_BorderCirclesLines           ST_Border = 58
	ST_BorderCirclesRectangles      ST_Border = 59
	ST_BorderClassicalWave          ST_Border = 60
	ST_BorderClocks                 ST_Border = 61
	ST_BorderCompass                ST_Border = 62
	ST_BorderConfetti               ST_Border = 63
	ST_BorderConfettiGrays          ST_Border = 64
	ST_BorderConfettiOutline        ST_Border = 65
	ST_BorderConfettiStreamers      ST_Border = 66
	ST_BorderConfettiWhite          ST_Border = 67
	ST_BorderCornerTriangles        ST_Border = 68
	ST_BorderCouponCutoutDashes     ST_Border = 69
	ST_BorderCouponCutoutDots       ST_Border = 70
	ST_BorderCrazyMaze              ST_Border = 71
	ST_BorderCreaturesButterfly     ST_Border = 72
	ST_BorderCreaturesFish          ST_Border = 73
	ST_BorderCreaturesInsects       ST_Border = 74
	ST_BorderCreaturesLadyBug       ST_Border = 75
	ST_BorderCrossStitch            ST_Border = 76
	ST_BorderCup                    ST_Border = 77
	ST_BorderDecoArch               ST_Border = 78
	ST_BorderDecoArchColor          ST_Border = 79
	ST_BorderDecoBlocks             ST_Border = 80
	ST_BorderDiamondsGray           ST_Border = 81
	ST_BorderDoubleD                ST_Border = 82
	ST_BorderDoubleDiamonds         ST_Border = 83
	ST_BorderEarth1                 ST_Border = 84
	ST_BorderEarth2                 ST_Border = 85
	ST_BorderEarth3                 ST_Border = 86
	ST_BorderEclipsingSquares1      ST_Border = 87
	ST_BorderEclipsingSquares2      ST_Border = 88
	ST_BorderEggsBlack              ST_Border = 89
	ST_BorderFans                   ST_Border = 90
	ST_BorderFilm                   ST_Border = 91
	ST_BorderFirecrackers           ST_Border = 92
	ST_BorderFlowersBlockPrint      ST_Border = 93
	ST_BorderFlowersDaisies         ST_Border = 94
	ST_BorderFlowersModern1         ST_Border = 95
	ST_BorderFlowersModern2         ST_Border = 96
	ST_BorderFlowersPansy           ST_Border = 97
	ST_BorderFlowersRedRose         ST_Border = 98
	ST_BorderFlowersRoses           ST_Border = 99
	ST_BorderFlowersTeacup          ST_Border = 100
	ST_BorderFlowersTiny            ST_Border = 101
	ST_BorderGems                   ST_Border = 102
	ST_BorderGingerbreadMan         ST_Border = 103
	ST_BorderGradient               ST_Border = 104
	ST_BorderHandmade1              ST_Border = 105
	ST_BorderHandmade2              ST_Border = 106
	ST_BorderHeartBalloon           ST_Border = 107
	ST_BorderHeartGray              ST_Border = 108
	ST_BorderHearts                 ST_Border = 109
	ST_BorderHeebieJeebies          ST_Border = 110
	ST_BorderHolly                  ST_Border = 111
	ST_BorderHouseFunky             ST_Border = 112
	ST_BorderHypnotic               ST_Border = 113
	ST_BorderIceCreamCones          ST_Border = 114
	ST_BorderLightBulb              ST_Border = 115
	ST_BorderLightning1             ST_Border = 116
	ST_BorderLightning2             ST_Border = 117
	ST_BorderMapPins                ST_Border = 118
	ST_BorderMapleLeaf              ST_Border = 119
	ST_BorderMapleMuffins           ST_Border = 120
	ST_BorderMarquee                ST_Border = 121
	ST_BorderMarqueeToothed         ST_Border = 122
	ST_BorderMoons                  ST_Border = 123
	ST_BorderMosaic                 ST_Border = 124
	ST_BorderMusicNotes             ST_Border = 125
	ST_BorderNorthwest              ST_Border = 126
	ST_BorderOvals                  ST_Border = 127
	ST_BorderPackages               ST_Border = 128
	ST_BorderPalmsBlack             ST_Border = 129
	ST_BorderPalmsColor             ST_Border = 130
	ST_BorderPaperClips             ST_Border = 131
	ST_BorderPapyrus                ST_Border = 132
	ST_BorderPartyFavor             ST_Border = 133
	ST_BorderPartyGlass             ST_Border = 134
	ST_BorderPencils                ST_Border = 135
	ST_BorderPeople                 ST_Border = 136
	ST_BorderPeopleWaving           ST_Border = 137
	ST_BorderPeopleHats             ST_Border = 138
	ST_BorderPoinsettias            ST_Border = 139
	ST_BorderPostageStamp           ST_Border = 140
	ST_BorderPumpkin1               ST_Border = 141
	ST_BorderPushPinNote2           ST_Border = 142
	ST_BorderPushPinNote1           ST_Border = 143
	ST_BorderPyramids               ST_Border = 144
	ST_BorderPyramidsAbove          ST_Border = 145
	ST_BorderQuadrants              ST_Border = 146
	ST_BorderRings                  ST_Border = 147
	ST_BorderSafari                 ST_Border = 148
	ST_BorderSawtooth               ST_Border = 149
	ST_BorderSawtoothGray           ST_Border = 150
	ST_BorderScaredCat              ST_Border = 151
	ST_BorderSeattle                ST_Border = 152
	ST_BorderShadowedSquares        ST_Border = 153
	ST_BorderSharksTeeth            ST_Border = 154
	ST_BorderShorebirdTracks        ST_Border = 155
	ST_BorderSkyrocket              ST_Border = 156
	ST_BorderSnowflakeFancy         ST_Border = 157
	ST_BorderSnowflakes             ST_Border = 158
	ST_BorderSombrero               ST_Border = 159
	ST_BorderSouthwest              ST_Border = 160
	ST_BorderStars                  ST_Border = 161
	ST_BorderStarsTop               ST_Border = 162
	ST_BorderStars3d                ST_Border = 163
	ST_BorderStarsBlack             ST_Border = 164
	ST_BorderStarsShadowed          ST_Border = 165
	ST_BorderSun                    ST_Border = 166
	ST_BorderSwirligig              ST_Border = 167
	ST_BorderTornPaper              ST_Border = 168
	ST_BorderTornPaperBlack         ST_Border = 169
	ST_BorderTrees                  ST_Border = 170
	ST_BorderTriangleParty          ST_Border = 171
	ST_BorderTriangles              ST_Border = 172
	ST_BorderTriangle1              ST_Border = 173
	ST_BorderTriangle2              ST_Border = 174
	ST_BorderTriangleCircle1        ST_Border = 175
	ST_BorderTriangleCircle2        ST_Border = 176
	ST_BorderShapes1                ST_Border = 177
	ST_BorderShapes2                ST_Border = 178
	ST_BorderTwistedLines1          ST_Border = 179
	ST_BorderTwistedLines2          ST_Border = 180
	ST_BorderVine                   ST_Border = 181
	ST_BorderWaveline               ST_Border = 182
	ST_BorderWeavingAngles          ST_Border = 183
	ST_BorderWeavingBraid           ST_Border = 184
	ST_BorderWeavingRibbon          ST_Border = 185
	ST_BorderWeavingStrips          ST_Border = 186
	ST_BorderWhiteFlowers           ST_Border = 187
	ST_BorderWoodwork               ST_Border = 188
	ST_BorderXIllusions             ST_Border = 189
	ST_BorderZanyTriangles          ST_Border = 190
	ST_BorderZigZag                 ST_Border = 191
	ST_BorderZigZagStitch           ST_Border = 192
	ST_BorderCustom                 ST_Border = 193
)

func (ST_Border) MarshalXML ¶ 

func (m ST_Border) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Border) MarshalXMLAttr ¶ 

func (e ST_Border) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Border) String ¶ 

func (m ST_Border) String() string

func (*ST_Border) UnmarshalXML ¶ 

func (m *ST_Border) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Border) UnmarshalXMLAttr ¶ 

func (e *ST_Border) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Border) Validate ¶ 

func (m ST_Border) Validate() error

func (ST_Border) ValidateWithPath ¶ 

func (m ST_Border) ValidateWithPath(path string) error

type ST_BrClear ¶ 

type ST_BrClear byte
const (
	ST_BrClearUnset ST_BrClear = 0
	ST_BrClearNone  ST_BrClear = 1
	ST_BrClearLeft  ST_BrClear = 2
	ST_BrClearRight ST_BrClear = 3
	ST_BrClearAll   ST_BrClear = 4
)

func (ST_BrClear) MarshalXML ¶ 

func (m ST_BrClear) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_BrClear) MarshalXMLAttr ¶ 

func (e ST_BrClear) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_BrClear) String ¶ 

func (m ST_BrClear) String() string

func (*ST_BrClear) UnmarshalXML ¶ 

func (m *ST_BrClear) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_BrClear) UnmarshalXMLAttr ¶ 

func (e *ST_BrClear) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_BrClear) Validate ¶ 

func (m ST_BrClear) Validate() error

func (ST_BrClear) ValidateWithPath ¶ 

func (m ST_BrClear) ValidateWithPath(path string) error

type ST_BrType ¶ 

type ST_BrType byte
const (
	ST_BrTypeUnset        ST_BrType = 0
	ST_BrTypePage         ST_BrType = 1
	ST_BrTypeColumn       ST_BrType = 2
	ST_BrTypeTextWrapping ST_BrType = 3
)

func (ST_BrType) MarshalXML ¶ 

func (m ST_BrType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_BrType) MarshalXMLAttr ¶ 

func (e ST_BrType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_BrType) String ¶ 

func (m ST_BrType) String() string

func (*ST_BrType) UnmarshalXML ¶ 

func (m *ST_BrType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_BrType) UnmarshalXMLAttr ¶ 

func (e *ST_BrType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_BrType) Validate ¶ 

func (m ST_BrType) Validate() error

func (ST_BrType) ValidateWithPath ¶ 

func (m ST_BrType) ValidateWithPath(path string) error

type ST_CaptionPos ¶ 

type ST_CaptionPos byte
const (
	ST_CaptionPosUnset ST_CaptionPos = 0
	ST_CaptionPosAbove ST_CaptionPos = 1
	ST_CaptionPosBelow ST_CaptionPos = 2
	ST_CaptionPosLeft  ST_CaptionPos = 3
	ST_CaptionPosRight ST_CaptionPos = 4
)

func (ST_CaptionPos) MarshalXML ¶ 

func (m ST_CaptionPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CaptionPos) MarshalXMLAttr ¶ 

func (e ST_CaptionPos) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CaptionPos) String ¶ 

func (m ST_CaptionPos) String() string

func (*ST_CaptionPos) UnmarshalXML ¶ 

func (m *ST_CaptionPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CaptionPos) UnmarshalXMLAttr ¶ 

func (e *ST_CaptionPos) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CaptionPos) Validate ¶ 

func (m ST_CaptionPos) Validate() error

func (ST_CaptionPos) ValidateWithPath ¶ 

func (m ST_CaptionPos) ValidateWithPath(path string) error

type ST_ChapterSep ¶ 

type ST_ChapterSep byte
const (
	ST_ChapterSepUnset  ST_ChapterSep = 0
	ST_ChapterSepHyphen ST_ChapterSep = 1
	ST_ChapterSepPeriod ST_ChapterSep = 2
	ST_ChapterSepColon  ST_ChapterSep = 3
	ST_ChapterSepEmDash ST_ChapterSep = 4
	ST_ChapterSepEnDash ST_ChapterSep = 5
)

func (ST_ChapterSep) MarshalXML ¶ 

func (m ST_ChapterSep) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ChapterSep) MarshalXMLAttr ¶ 

func (e ST_ChapterSep) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ChapterSep) String ¶ 

func (m ST_ChapterSep) String() string

func (*ST_ChapterSep) UnmarshalXML ¶ 

func (m *ST_ChapterSep) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ChapterSep) UnmarshalXMLAttr ¶ 

func (e *ST_ChapterSep) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ChapterSep) Validate ¶ 

func (m ST_ChapterSep) Validate() error

func (ST_ChapterSep) ValidateWithPath ¶ 

func (m ST_ChapterSep) ValidateWithPath(path string) error

type ST_CharacterSpacing ¶ 

type ST_CharacterSpacing byte
const (
	ST_CharacterSpacingUnset                              ST_CharacterSpacing = 0
	ST_CharacterSpacingDoNotCompress                      ST_CharacterSpacing = 1
	ST_CharacterSpacingCompressPunctuation                ST_CharacterSpacing = 2
	ST_CharacterSpacingCompressPunctuationAndJapaneseKana ST_CharacterSpacing = 3
)

func (ST_CharacterSpacing) MarshalXML ¶ 

func (m ST_CharacterSpacing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CharacterSpacing) MarshalXMLAttr ¶ 

func (e ST_CharacterSpacing) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CharacterSpacing) String ¶ 

func (m ST_CharacterSpacing) String() string

func (*ST_CharacterSpacing) UnmarshalXML ¶ 

func (m *ST_CharacterSpacing) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CharacterSpacing) UnmarshalXMLAttr ¶ 

func (e *ST_CharacterSpacing) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CharacterSpacing) Validate ¶ 

func (m ST_CharacterSpacing) Validate() error

func (ST_CharacterSpacing) ValidateWithPath ¶ 

func (m ST_CharacterSpacing) ValidateWithPath(path string) error

type ST_CombineBrackets ¶ 

type ST_CombineBrackets byte
const (
	ST_CombineBracketsUnset  ST_CombineBrackets = 0
	ST_CombineBracketsNone   ST_CombineBrackets = 1
	ST_CombineBracketsRound  ST_CombineBrackets = 2
	ST_CombineBracketsSquare ST_CombineBrackets = 3
	ST_CombineBracketsAngle  ST_CombineBrackets = 4
	ST_CombineBracketsCurly  ST_CombineBrackets = 5
)

func (ST_CombineBrackets) MarshalXML ¶ 

func (m ST_CombineBrackets) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CombineBrackets) MarshalXMLAttr ¶ 

func (e ST_CombineBrackets) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CombineBrackets) String ¶ 

func (m ST_CombineBrackets) String() string

func (*ST_CombineBrackets) UnmarshalXML ¶ 

func (m *ST_CombineBrackets) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CombineBrackets) UnmarshalXMLAttr ¶ 

func (e *ST_CombineBrackets) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CombineBrackets) Validate ¶ 

func (m ST_CombineBrackets) Validate() error

func (ST_CombineBrackets) ValidateWithPath ¶ 

func (m ST_CombineBrackets) ValidateWithPath(path string) error

type ST_DecimalNumberOrPercent ¶ 

type ST_DecimalNumberOrPercent struct {
	ST_UnqualifiedPercentage *int64
	ST_Percentage            *string
}

ST_DecimalNumberOrPercent is a union type

func ParseUnionST_DecimalNumberOrPercent ¶ 

func ParseUnionST_DecimalNumberOrPercent(s string) (ST_DecimalNumberOrPercent, error)

func (ST_DecimalNumberOrPercent) MarshalXML ¶ 

func (m ST_DecimalNumberOrPercent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DecimalNumberOrPercent) String ¶ 

func (m ST_DecimalNumberOrPercent) String() string

func (*ST_DecimalNumberOrPercent) Validate ¶ 

func (m *ST_DecimalNumberOrPercent) Validate() error

func (*ST_DecimalNumberOrPercent) ValidateWithPath ¶ 

func (m *ST_DecimalNumberOrPercent) ValidateWithPath(path string) error

type ST_Direction ¶ 

type ST_Direction byte
const (
	ST_DirectionUnset ST_Direction = 0
	ST_DirectionLtr   ST_Direction = 1
	ST_DirectionRtl   ST_Direction = 2
)

func (ST_Direction) MarshalXML ¶ 

func (m ST_Direction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Direction) MarshalXMLAttr ¶ 

func (e ST_Direction) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Direction) String ¶ 

func (m ST_Direction) String() string

func (*ST_Direction) UnmarshalXML ¶ 

func (m *ST_Direction) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Direction) UnmarshalXMLAttr ¶ 

func (e *ST_Direction) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Direction) Validate ¶ 

func (m ST_Direction) Validate() error

func (ST_Direction) ValidateWithPath ¶ 

func (m ST_Direction) ValidateWithPath(path string) error

type ST_DisplacedByCustomXml ¶ 

type ST_DisplacedByCustomXml byte
const (
	ST_DisplacedByCustomXmlUnset ST_DisplacedByCustomXml = 0
	ST_DisplacedByCustomXmlNext  ST_DisplacedByCustomXml = 1
	ST_DisplacedByCustomXmlPrev  ST_DisplacedByCustomXml = 2
)

func (ST_DisplacedByCustomXml) MarshalXML ¶ 

func (m ST_DisplacedByCustomXml) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DisplacedByCustomXml) MarshalXMLAttr ¶ 

func (e ST_DisplacedByCustomXml) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DisplacedByCustomXml) String ¶ 

func (m ST_DisplacedByCustomXml) String() string

func (*ST_DisplacedByCustomXml) UnmarshalXML ¶ 

func (m *ST_DisplacedByCustomXml) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DisplacedByCustomXml) UnmarshalXMLAttr ¶ 

func (e *ST_DisplacedByCustomXml) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DisplacedByCustomXml) Validate ¶ 

func (m ST_DisplacedByCustomXml) Validate() error

func (ST_DisplacedByCustomXml) ValidateWithPath ¶ 

func (m ST_DisplacedByCustomXml) ValidateWithPath(path string) error

type ST_DocGrid ¶ 

type ST_DocGrid byte
const (
	ST_DocGridUnset         ST_DocGrid = 0
	ST_DocGridDefault       ST_DocGrid = 1
	ST_DocGridLines         ST_DocGrid = 2
	ST_DocGridLinesAndChars ST_DocGrid = 3
	ST_DocGridSnapToChars   ST_DocGrid = 4
)

func (ST_DocGrid) MarshalXML ¶ 

func (m ST_DocGrid) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DocGrid) MarshalXMLAttr ¶ 

func (e ST_DocGrid) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DocGrid) String ¶ 

func (m ST_DocGrid) String() string

func (*ST_DocGrid) UnmarshalXML ¶ 

func (m *ST_DocGrid) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DocGrid) UnmarshalXMLAttr ¶ 

func (e *ST_DocGrid) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DocGrid) Validate ¶ 

func (m ST_DocGrid) Validate() error

func (ST_DocGrid) ValidateWithPath ¶ 

func (m ST_DocGrid) ValidateWithPath(path string) error

type ST_DocPartBehavior ¶ 

type ST_DocPartBehavior byte
const (
	ST_DocPartBehaviorUnset   ST_DocPartBehavior = 0
	ST_DocPartBehaviorContent ST_DocPartBehavior = 1
	ST_DocPartBehaviorP       ST_DocPartBehavior = 2
	ST_DocPartBehaviorPg      ST_DocPartBehavior = 3
)

func (ST_DocPartBehavior) MarshalXML ¶ 

func (m ST_DocPartBehavior) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DocPartBehavior) MarshalXMLAttr ¶ 

func (e ST_DocPartBehavior) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DocPartBehavior) String ¶ 

func (m ST_DocPartBehavior) String() string

func (*ST_DocPartBehavior) UnmarshalXML ¶ 

func (m *ST_DocPartBehavior) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DocPartBehavior) UnmarshalXMLAttr ¶ 

func (e *ST_DocPartBehavior) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DocPartBehavior) Validate ¶ 

func (m ST_DocPartBehavior) Validate() error

func (ST_DocPartBehavior) ValidateWithPath ¶ 

func (m ST_DocPartBehavior) ValidateWithPath(path string) error

type ST_DocPartGallery ¶ 

type ST_DocPartGallery byte
const (
	ST_DocPartGalleryUnset             ST_DocPartGallery = 0
	ST_DocPartGalleryPlaceholder       ST_DocPartGallery = 1
	ST_DocPartGalleryAny               ST_DocPartGallery = 2
	ST_DocPartGalleryDefault           ST_DocPartGallery = 3
	ST_DocPartGalleryDocParts          ST_DocPartGallery = 4
	ST_DocPartGalleryCoverPg           ST_DocPartGallery = 5
	ST_DocPartGalleryEq                ST_DocPartGallery = 6
	ST_DocPartGalleryFtrs              ST_DocPartGallery = 7
	ST_DocPartGalleryHdrs              ST_DocPartGallery = 8
	ST_DocPartGalleryPgNum             ST_DocPartGallery = 9
	ST_DocPartGalleryTbls              ST_DocPartGallery = 10
	ST_DocPartGalleryWatermarks        ST_DocPartGallery = 11
	ST_DocPartGalleryAutoTxt           ST_DocPartGallery = 12
	ST_DocPartGalleryTxtBox            ST_DocPartGallery = 13
	ST_DocPartGalleryPgNumT            ST_DocPartGallery = 14
	ST_DocPartGalleryPgNumB            ST_DocPartGallery = 15
	ST_DocPartGalleryPgNumMargins      ST_DocPartGallery = 16
	ST_DocPartGalleryTblOfContents     ST_DocPartGallery = 17
	ST_DocPartGalleryBib               ST_DocPartGallery = 18
	ST_DocPartGalleryCustQuickParts    ST_DocPartGallery = 19
	ST_DocPartGalleryCustCoverPg       ST_DocPartGallery = 20
	ST_DocPartGalleryCustEq            ST_DocPartGallery = 21
	ST_DocPartGalleryCustFtrs          ST_DocPartGallery = 22
	ST_DocPartGalleryCustHdrs          ST_DocPartGallery = 23
	ST_DocPartGalleryCustPgNum         ST_DocPartGallery = 24
	ST_DocPartGalleryCustTbls          ST_DocPartGallery = 25
	ST_DocPartGalleryCustWatermarks    ST_DocPartGallery = 26
	ST_DocPartGalleryCustAutoTxt       ST_DocPartGallery = 27
	ST_DocPartGalleryCustTxtBox        ST_DocPartGallery = 28
	ST_DocPartGalleryCustPgNumT        ST_DocPartGallery = 29
	ST_DocPartGalleryCustPgNumB        ST_DocPartGallery = 30
	ST_DocPartGalleryCustPgNumMargins  ST_DocPartGallery = 31
	ST_DocPartGalleryCustTblOfContents ST_DocPartGallery = 32
	ST_DocPartGalleryCustBib           ST_DocPartGallery = 33
	ST_DocPartGalleryCustom1           ST_DocPartGallery = 34
	ST_DocPartGalleryCustom2           ST_DocPartGallery = 35
	ST_DocPartGalleryCustom3           ST_DocPartGallery = 36
	ST_DocPartGalleryCustom4           ST_DocPartGallery = 37
	ST_DocPartGalleryCustom5           ST_DocPartGallery = 38
)

func (ST_DocPartGallery) MarshalXML ¶ 

func (m ST_DocPartGallery) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DocPartGallery) MarshalXMLAttr ¶ 

func (e ST_DocPartGallery) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DocPartGallery) String ¶ 

func (m ST_DocPartGallery) String() string

func (*ST_DocPartGallery) UnmarshalXML ¶ 

func (m *ST_DocPartGallery) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DocPartGallery) UnmarshalXMLAttr ¶ 

func (e *ST_DocPartGallery) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DocPartGallery) Validate ¶ 

func (m ST_DocPartGallery) Validate() error

func (ST_DocPartGallery) ValidateWithPath ¶ 

func (m ST_DocPartGallery) ValidateWithPath(path string) error

type ST_DocPartType ¶ 

type ST_DocPartType byte
const (
	ST_DocPartTypeUnset    ST_DocPartType = 0
	ST_DocPartTypeNone     ST_DocPartType = 1
	ST_DocPartTypeNormal   ST_DocPartType = 2
	ST_DocPartTypeAutoExp  ST_DocPartType = 3
	ST_DocPartTypeToolbar  ST_DocPartType = 4
	ST_DocPartTypeSpeller  ST_DocPartType = 5
	ST_DocPartTypeFormFld  ST_DocPartType = 6
	ST_DocPartTypeBbPlcHdr ST_DocPartType = 7
)

func (ST_DocPartType) MarshalXML ¶ 

func (m ST_DocPartType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DocPartType) MarshalXMLAttr ¶ 

func (e ST_DocPartType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DocPartType) String ¶ 

func (m ST_DocPartType) String() string

func (*ST_DocPartType) UnmarshalXML ¶ 

func (m *ST_DocPartType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DocPartType) UnmarshalXMLAttr ¶ 

func (e *ST_DocPartType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DocPartType) Validate ¶ 

func (m ST_DocPartType) Validate() error

func (ST_DocPartType) ValidateWithPath ¶ 

func (m ST_DocPartType) ValidateWithPath(path string) error

type ST_DocProtect ¶ 

type ST_DocProtect byte
const (
	ST_DocProtectUnset          ST_DocProtect = 0
	ST_DocProtectNone           ST_DocProtect = 1
	ST_DocProtectReadOnly       ST_DocProtect = 2
	ST_DocProtectComments       ST_DocProtect = 3
	ST_DocProtectTrackedChanges ST_DocProtect = 4
	ST_DocProtectForms          ST_DocProtect = 5
)

func (ST_DocProtect) MarshalXML ¶ 

func (m ST_DocProtect) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DocProtect) MarshalXMLAttr ¶ 

func (e ST_DocProtect) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DocProtect) String ¶ 

func (m ST_DocProtect) String() string

func (*ST_DocProtect) UnmarshalXML ¶ 

func (m *ST_DocProtect) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DocProtect) UnmarshalXMLAttr ¶ 

func (e *ST_DocProtect) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DocProtect) Validate ¶ 

func (m ST_DocProtect) Validate() error

func (ST_DocProtect) ValidateWithPath ¶ 

func (m ST_DocProtect) ValidateWithPath(path string) error

type ST_DropCap ¶ 

type ST_DropCap byte
const (
	ST_DropCapUnset  ST_DropCap = 0
	ST_DropCapNone   ST_DropCap = 1
	ST_DropCapDrop   ST_DropCap = 2
	ST_DropCapMargin ST_DropCap = 3
)

func (ST_DropCap) MarshalXML ¶ 

func (m ST_DropCap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DropCap) MarshalXMLAttr ¶ 

func (e ST_DropCap) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DropCap) String ¶ 

func (m ST_DropCap) String() string

func (*ST_DropCap) UnmarshalXML ¶ 

func (m *ST_DropCap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DropCap) UnmarshalXMLAttr ¶ 

func (e *ST_DropCap) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DropCap) Validate ¶ 

func (m ST_DropCap) Validate() error

func (ST_DropCap) ValidateWithPath ¶ 

func (m ST_DropCap) ValidateWithPath(path string) error

type ST_EdGrp ¶ 

type ST_EdGrp byte
const (
	ST_EdGrpUnset          ST_EdGrp = 0
	ST_EdGrpNone           ST_EdGrp = 1
	ST_EdGrpEveryone       ST_EdGrp = 2
	ST_EdGrpAdministrators ST_EdGrp = 3
	ST_EdGrpContributors   ST_EdGrp = 4
	ST_EdGrpEditors        ST_EdGrp = 5
	ST_EdGrpOwners         ST_EdGrp = 6
	ST_EdGrpCurrent        ST_EdGrp = 7
)

func (ST_EdGrp) MarshalXML ¶ 

func (m ST_EdGrp) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_EdGrp) MarshalXMLAttr ¶ 

func (e ST_EdGrp) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_EdGrp) String ¶ 

func (m ST_EdGrp) String() string

func (*ST_EdGrp) UnmarshalXML ¶ 

func (m *ST_EdGrp) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_EdGrp) UnmarshalXMLAttr ¶ 

func (e *ST_EdGrp) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_EdGrp) Validate ¶ 

func (m ST_EdGrp) Validate() error

func (ST_EdGrp) ValidateWithPath ¶ 

func (m ST_EdGrp) ValidateWithPath(path string) error

type ST_EdnPos ¶ 

type ST_EdnPos byte
const (
	ST_EdnPosUnset   ST_EdnPos = 0
	ST_EdnPosSectEnd ST_EdnPos = 1
	ST_EdnPosDocEnd  ST_EdnPos = 2
)

func (ST_EdnPos) MarshalXML ¶ 

func (m ST_EdnPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_EdnPos) MarshalXMLAttr ¶ 

func (e ST_EdnPos) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_EdnPos) String ¶ 

func (m ST_EdnPos) String() string

func (*ST_EdnPos) UnmarshalXML ¶ 

func (m *ST_EdnPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_EdnPos) UnmarshalXMLAttr ¶ 

func (e *ST_EdnPos) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_EdnPos) Validate ¶ 

func (m ST_EdnPos) Validate() error

func (ST_EdnPos) ValidateWithPath ¶ 

func (m ST_EdnPos) ValidateWithPath(path string) error

type ST_Em ¶ 

type ST_Em byte
const (
	ST_EmUnset    ST_Em = 0
	ST_EmNone     ST_Em = 1
	ST_EmDot      ST_Em = 2
	ST_EmComma    ST_Em = 3
	ST_EmCircle   ST_Em = 4
	ST_EmUnderDot ST_Em = 5
)

func (ST_Em) MarshalXML ¶ 

func (m ST_Em) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Em) MarshalXMLAttr ¶ 

func (e ST_Em) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Em) String ¶ 

func (m ST_Em) String() string

func (*ST_Em) UnmarshalXML ¶ 

func (m *ST_Em) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Em) UnmarshalXMLAttr ¶ 

func (e *ST_Em) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Em) Validate ¶ 

func (m ST_Em) Validate() error

func (ST_Em) ValidateWithPath ¶ 

func (m ST_Em) ValidateWithPath(path string) error

type ST_FFTextType ¶ 

type ST_FFTextType byte
const (
	ST_FFTextTypeUnset       ST_FFTextType = 0
	ST_FFTextTypeRegular     ST_FFTextType = 1
	ST_FFTextTypeNumber      ST_FFTextType = 2
	ST_FFTextTypeDate        ST_FFTextType = 3
	ST_FFTextTypeCurrentTime ST_FFTextType = 4
	ST_FFTextTypeCurrentDate ST_FFTextType = 5
	ST_FFTextTypeCalculated  ST_FFTextType = 6
)

func (ST_FFTextType) MarshalXML ¶ 

func (m ST_FFTextType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FFTextType) MarshalXMLAttr ¶ 

func (e ST_FFTextType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FFTextType) String ¶ 

func (m ST_FFTextType) String() string

func (*ST_FFTextType) UnmarshalXML ¶ 

func (m *ST_FFTextType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FFTextType) UnmarshalXMLAttr ¶ 

func (e *ST_FFTextType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FFTextType) Validate ¶ 

func (m ST_FFTextType) Validate() error

func (ST_FFTextType) ValidateWithPath ¶ 

func (m ST_FFTextType) ValidateWithPath(path string) error

type ST_FldCharType ¶ 

type ST_FldCharType byte
const (
	ST_FldCharTypeUnset    ST_FldCharType = 0
	ST_FldCharTypeBegin    ST_FldCharType = 1
	ST_FldCharTypeSeparate ST_FldCharType = 2
	ST_FldCharTypeEnd      ST_FldCharType = 3
)

func (ST_FldCharType) MarshalXML ¶ 

func (m ST_FldCharType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FldCharType) MarshalXMLAttr ¶ 

func (e ST_FldCharType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FldCharType) String ¶ 

func (m ST_FldCharType) String() string

func (*ST_FldCharType) UnmarshalXML ¶ 

func (m *ST_FldCharType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FldCharType) UnmarshalXMLAttr ¶ 

func (e *ST_FldCharType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FldCharType) Validate ¶ 

func (m ST_FldCharType) Validate() error

func (ST_FldCharType) ValidateWithPath ¶ 

func (m ST_FldCharType) ValidateWithPath(path string) error

type ST_FontFamily ¶ 

type ST_FontFamily byte
const (
	ST_FontFamilyUnset      ST_FontFamily = 0
	ST_FontFamilyDecorative ST_FontFamily = 1
	ST_FontFamilyModern     ST_FontFamily = 2
	ST_FontFamilyRoman      ST_FontFamily = 3
	ST_FontFamilyScript     ST_FontFamily = 4
	ST_FontFamilySwiss      ST_FontFamily = 5
	ST_FontFamilyAuto       ST_FontFamily = 6
)

func (ST_FontFamily) MarshalXML ¶ 

func (m ST_FontFamily) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FontFamily) MarshalXMLAttr ¶ 

func (e ST_FontFamily) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FontFamily) String ¶ 

func (m ST_FontFamily) String() string

func (*ST_FontFamily) UnmarshalXML ¶ 

func (m *ST_FontFamily) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FontFamily) UnmarshalXMLAttr ¶ 

func (e *ST_FontFamily) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FontFamily) Validate ¶ 

func (m ST_FontFamily) Validate() error

func (ST_FontFamily) ValidateWithPath ¶ 

func (m ST_FontFamily) ValidateWithPath(path string) error

type ST_FrameLayout ¶ 

type ST_FrameLayout byte
const (
	ST_FrameLayoutUnset ST_FrameLayout = 0
	ST_FrameLayoutRows  ST_FrameLayout = 1
	ST_FrameLayoutCols  ST_FrameLayout = 2
	ST_FrameLayoutNone  ST_FrameLayout = 3
)

func (ST_FrameLayout) MarshalXML ¶ 

func (m ST_FrameLayout) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FrameLayout) MarshalXMLAttr ¶ 

func (e ST_FrameLayout) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FrameLayout) String ¶ 

func (m ST_FrameLayout) String() string

func (*ST_FrameLayout) UnmarshalXML ¶ 

func (m *ST_FrameLayout) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FrameLayout) UnmarshalXMLAttr ¶ 

func (e *ST_FrameLayout) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FrameLayout) Validate ¶ 

func (m ST_FrameLayout) Validate() error

func (ST_FrameLayout) ValidateWithPath ¶ 

func (m ST_FrameLayout) ValidateWithPath(path string) error

type ST_FrameScrollbar ¶ 

type ST_FrameScrollbar byte
const (
	ST_FrameScrollbarUnset ST_FrameScrollbar = 0
	ST_FrameScrollbarOn    ST_FrameScrollbar = 1
	ST_FrameScrollbarOff   ST_FrameScrollbar = 2
	ST_FrameScrollbarAuto  ST_FrameScrollbar = 3
)

func (ST_FrameScrollbar) MarshalXML ¶ 

func (m ST_FrameScrollbar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FrameScrollbar) MarshalXMLAttr ¶ 

func (e ST_FrameScrollbar) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FrameScrollbar) String ¶ 

func (m ST_FrameScrollbar) String() string

func (*ST_FrameScrollbar) UnmarshalXML ¶ 

func (m *ST_FrameScrollbar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FrameScrollbar) UnmarshalXMLAttr ¶ 

func (e *ST_FrameScrollbar) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FrameScrollbar) Validate ¶ 

func (m ST_FrameScrollbar) Validate() error

func (ST_FrameScrollbar) ValidateWithPath ¶ 

func (m ST_FrameScrollbar) ValidateWithPath(path string) error

type ST_FtnEdn ¶ 

type ST_FtnEdn byte
const (
	ST_FtnEdnUnset                 ST_FtnEdn = 0
	ST_FtnEdnNormal                ST_FtnEdn = 1
	ST_FtnEdnSeparator             ST_FtnEdn = 2
	ST_FtnEdnContinuationSeparator ST_FtnEdn = 3
	ST_FtnEdnContinuationNotice    ST_FtnEdn = 4
)

func (ST_FtnEdn) MarshalXML ¶ 

func (m ST_FtnEdn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FtnEdn) MarshalXMLAttr ¶ 

func (e ST_FtnEdn) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FtnEdn) String ¶ 

func (m ST_FtnEdn) String() string

func (*ST_FtnEdn) UnmarshalXML ¶ 

func (m *ST_FtnEdn) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FtnEdn) UnmarshalXMLAttr ¶ 

func (e *ST_FtnEdn) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FtnEdn) Validate ¶ 

func (m ST_FtnEdn) Validate() error

func (ST_FtnEdn) ValidateWithPath ¶ 

func (m ST_FtnEdn) ValidateWithPath(path string) error

type ST_FtnPos ¶ 

type ST_FtnPos byte
const (
	ST_FtnPosUnset       ST_FtnPos = 0
	ST_FtnPosPageBottom  ST_FtnPos = 1
	ST_FtnPosBeneathText ST_FtnPos = 2
	ST_FtnPosSectEnd     ST_FtnPos = 3
	ST_FtnPosDocEnd      ST_FtnPos = 4
)

func (ST_FtnPos) MarshalXML ¶ 

func (m ST_FtnPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FtnPos) MarshalXMLAttr ¶ 

func (e ST_FtnPos) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FtnPos) String ¶ 

func (m ST_FtnPos) String() string

func (*ST_FtnPos) UnmarshalXML ¶ 

func (m *ST_FtnPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FtnPos) UnmarshalXMLAttr ¶ 

func (e *ST_FtnPos) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FtnPos) Validate ¶ 

func (m ST_FtnPos) Validate() error

func (ST_FtnPos) ValidateWithPath ¶ 

func (m ST_FtnPos) ValidateWithPath(path string) error

type ST_HAnchor ¶ 

type ST_HAnchor byte
const (
	ST_HAnchorUnset  ST_HAnchor = 0
	ST_HAnchorText   ST_HAnchor = 1
	ST_HAnchorMargin ST_HAnchor = 2
	ST_HAnchorPage   ST_HAnchor = 3
)

func (ST_HAnchor) MarshalXML ¶ 

func (m ST_HAnchor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HAnchor) MarshalXMLAttr ¶ 

func (e ST_HAnchor) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_HAnchor) String ¶ 

func (m ST_HAnchor) String() string

func (*ST_HAnchor) UnmarshalXML ¶ 

func (m *ST_HAnchor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_HAnchor) UnmarshalXMLAttr ¶ 

func (e *ST_HAnchor) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_HAnchor) Validate ¶ 

func (m ST_HAnchor) Validate() error

func (ST_HAnchor) ValidateWithPath ¶ 

func (m ST_HAnchor) ValidateWithPath(path string) error

type ST_HdrFtr ¶ 

type ST_HdrFtr byte
const (
	ST_HdrFtrUnset   ST_HdrFtr = 0
	ST_HdrFtrEven    ST_HdrFtr = 1
	ST_HdrFtrDefault ST_HdrFtr = 2
	ST_HdrFtrFirst   ST_HdrFtr = 3
)

func (ST_HdrFtr) MarshalXML ¶ 

func (m ST_HdrFtr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HdrFtr) MarshalXMLAttr ¶ 

func (e ST_HdrFtr) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_HdrFtr) String ¶ 

func (m ST_HdrFtr) String() string

func (*ST_HdrFtr) UnmarshalXML ¶ 

func (m *ST_HdrFtr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_HdrFtr) UnmarshalXMLAttr ¶ 

func (e *ST_HdrFtr) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_HdrFtr) Validate ¶ 

func (m ST_HdrFtr) Validate() error

func (ST_HdrFtr) ValidateWithPath ¶ 

func (m ST_HdrFtr) ValidateWithPath(path string) error

type ST_HeightRule ¶ 

type ST_HeightRule byte
const (
	ST_HeightRuleUnset   ST_HeightRule = 0
	ST_HeightRuleAuto    ST_HeightRule = 1
	ST_HeightRuleExact   ST_HeightRule = 2
	ST_HeightRuleAtLeast ST_HeightRule = 3
)

func (ST_HeightRule) MarshalXML ¶ 

func (m ST_HeightRule) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HeightRule) MarshalXMLAttr ¶ 

func (e ST_HeightRule) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_HeightRule) String ¶ 

func (m ST_HeightRule) String() string

func (*ST_HeightRule) UnmarshalXML ¶ 

func (m *ST_HeightRule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_HeightRule) UnmarshalXMLAttr ¶ 

func (e *ST_HeightRule) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_HeightRule) Validate ¶ 

func (m ST_HeightRule) Validate() error

func (ST_HeightRule) ValidateWithPath ¶ 

func (m ST_HeightRule) ValidateWithPath(path string) error

type ST_HexColor ¶ 

type ST_HexColor struct {
	ST_HexColorAuto ST_HexColorAuto
	ST_HexColorRGB  *string
}

ST_HexColor is a union type

func ParseUnionST_HexColor ¶ 

func ParseUnionST_HexColor(s string) (ST_HexColor, error)

func (ST_HexColor) MarshalXML ¶ 

func (m ST_HexColor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HexColor) String ¶ 

func (m ST_HexColor) String() string

func (*ST_HexColor) Validate ¶ 

func (m *ST_HexColor) Validate() error

func (*ST_HexColor) ValidateWithPath ¶ 

func (m *ST_HexColor) ValidateWithPath(path string) error

type ST_HexColorAuto ¶ 

type ST_HexColorAuto byte
const (
	ST_HexColorAutoUnset ST_HexColorAuto = 0
	ST_HexColorAutoAuto  ST_HexColorAuto = 1
)

func (ST_HexColorAuto) MarshalXML ¶ 

func (m ST_HexColorAuto) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HexColorAuto) MarshalXMLAttr ¶ 

func (e ST_HexColorAuto) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_HexColorAuto) String ¶ 

func (m ST_HexColorAuto) String() string

func (*ST_HexColorAuto) UnmarshalXML ¶ 

func (m *ST_HexColorAuto) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_HexColorAuto) UnmarshalXMLAttr ¶ 

func (e *ST_HexColorAuto) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_HexColorAuto) Validate ¶ 

func (m ST_HexColorAuto) Validate() error

func (ST_HexColorAuto) ValidateWithPath ¶ 

func (m ST_HexColorAuto) ValidateWithPath(path string) error

type ST_HighlightColor ¶ 

type ST_HighlightColor byte
const (
	ST_HighlightColorUnset       ST_HighlightColor = 0
	ST_HighlightColorBlack       ST_HighlightColor = 1
	ST_HighlightColorBlue        ST_HighlightColor = 2
	ST_HighlightColorCyan        ST_HighlightColor = 3
	ST_HighlightColorGreen       ST_HighlightColor = 4
	ST_HighlightColorMagenta     ST_HighlightColor = 5
	ST_HighlightColorRed         ST_HighlightColor = 6
	ST_HighlightColorYellow      ST_HighlightColor = 7
	ST_HighlightColorWhite       ST_HighlightColor = 8
	ST_HighlightColorDarkBlue    ST_HighlightColor = 9
	ST_HighlightColorDarkCyan    ST_HighlightColor = 10
	ST_HighlightColorDarkGreen   ST_HighlightColor = 11
	ST_HighlightColorDarkMagenta ST_HighlightColor = 12
	ST_HighlightColorDarkRed     ST_HighlightColor = 13
	ST_HighlightColorDarkYellow  ST_HighlightColor = 14
	ST_HighlightColorDarkGray    ST_HighlightColor = 15
	ST_HighlightColorLightGray   ST_HighlightColor = 16
	ST_HighlightColorNone        ST_HighlightColor = 17
)

func (ST_HighlightColor) MarshalXML ¶ 

func (m ST_HighlightColor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HighlightColor) MarshalXMLAttr ¶ 

func (e ST_HighlightColor) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_HighlightColor) String ¶ 

func (m ST_HighlightColor) String() string

func (*ST_HighlightColor) UnmarshalXML ¶ 

func (m *ST_HighlightColor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_HighlightColor) UnmarshalXMLAttr ¶ 

func (e *ST_HighlightColor) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_HighlightColor) Validate ¶ 

func (m ST_HighlightColor) Validate() error

func (ST_HighlightColor) ValidateWithPath ¶ 

func (m ST_HighlightColor) ValidateWithPath(path string) error

type ST_Hint ¶ 

type ST_Hint byte
const (
	ST_HintUnset    ST_Hint = 0
	ST_HintDefault  ST_Hint = 1
	ST_HintEastAsia ST_Hint = 2
)

func (ST_Hint) MarshalXML ¶ 

func (m ST_Hint) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Hint) MarshalXMLAttr ¶ 

func (e ST_Hint) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Hint) String ¶ 

func (m ST_Hint) String() string

func (*ST_Hint) UnmarshalXML ¶ 

func (m *ST_Hint) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Hint) UnmarshalXMLAttr ¶ 

func (e *ST_Hint) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Hint) Validate ¶ 

func (m ST_Hint) Validate() error

func (ST_Hint) ValidateWithPath ¶ 

func (m ST_Hint) ValidateWithPath(path string) error

type ST_HpsMeasure ¶ 

type ST_HpsMeasure struct {
	ST_UnsignedDecimalNumber    *uint64
	ST_PositiveUniversalMeasure *string
}

ST_HpsMeasure is a union type

func ParseUnionST_HpsMeasure ¶ 

func ParseUnionST_HpsMeasure(s string) (ST_HpsMeasure, error)

func (ST_HpsMeasure) MarshalXML ¶ 

func (m ST_HpsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HpsMeasure) String ¶ 

func (m ST_HpsMeasure) String() string

func (*ST_HpsMeasure) Validate ¶ 

func (m *ST_HpsMeasure) Validate() error

func (*ST_HpsMeasure) ValidateWithPath ¶ 

func (m *ST_HpsMeasure) ValidateWithPath(path string) error

type ST_InfoTextType ¶ 

type ST_InfoTextType byte
const (
	ST_InfoTextTypeUnset    ST_InfoTextType = 0
	ST_InfoTextTypeText     ST_InfoTextType = 1
	ST_InfoTextTypeAutoText ST_InfoTextType = 2
)

func (ST_InfoTextType) MarshalXML ¶ 

func (m ST_InfoTextType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_InfoTextType) MarshalXMLAttr ¶ 

func (e ST_InfoTextType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_InfoTextType) String ¶ 

func (m ST_InfoTextType) String() string

func (*ST_InfoTextType) UnmarshalXML ¶ 

func (m *ST_InfoTextType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_InfoTextType) UnmarshalXMLAttr ¶ 

func (e *ST_InfoTextType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_InfoTextType) Validate ¶ 

func (m ST_InfoTextType) Validate() error

func (ST_InfoTextType) ValidateWithPath ¶ 

func (m ST_InfoTextType) ValidateWithPath(path string) error

type ST_Jc ¶ 

type ST_Jc byte
const (
	ST_JcUnset          ST_Jc = 0
	ST_JcStart          ST_Jc = 1
	ST_JcCenter         ST_Jc = 2
	ST_JcEnd            ST_Jc = 3
	ST_JcBoth           ST_Jc = 4
	ST_JcMediumKashida  ST_Jc = 5
	ST_JcDistribute     ST_Jc = 6
	ST_JcNumTab         ST_Jc = 7
	ST_JcHighKashida    ST_Jc = 8
	ST_JcLowKashida     ST_Jc = 9
	ST_JcThaiDistribute ST_Jc = 10
	ST_JcLeft           ST_Jc = 11
	ST_JcRight          ST_Jc = 12
)

func (ST_Jc) MarshalXML ¶ 

func (m ST_Jc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Jc) MarshalXMLAttr ¶ 

func (e ST_Jc) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Jc) String ¶ 

func (m ST_Jc) String() string

func (*ST_Jc) UnmarshalXML ¶ 

func (m *ST_Jc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Jc) UnmarshalXMLAttr ¶ 

func (e *ST_Jc) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Jc) Validate ¶ 

func (m ST_Jc) Validate() error

func (ST_Jc) ValidateWithPath ¶ 

func (m ST_Jc) ValidateWithPath(path string) error

type ST_JcTable ¶ 

type ST_JcTable byte
const (
	ST_JcTableUnset  ST_JcTable = 0
	ST_JcTableCenter ST_JcTable = 1
	ST_JcTableEnd    ST_JcTable = 2
	ST_JcTableLeft   ST_JcTable = 3
	ST_JcTableRight  ST_JcTable = 4
	ST_JcTableStart  ST_JcTable = 5
)

func (ST_JcTable) MarshalXML ¶ 

func (m ST_JcTable) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_JcTable) MarshalXMLAttr ¶ 

func (e ST_JcTable) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_JcTable) String ¶ 

func (m ST_JcTable) String() string

func (*ST_JcTable) UnmarshalXML ¶ 

func (m *ST_JcTable) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_JcTable) UnmarshalXMLAttr ¶ 

func (e *ST_JcTable) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_JcTable) Validate ¶ 

func (m ST_JcTable) Validate() error

func (ST_JcTable) ValidateWithPath ¶ 

func (m ST_JcTable) ValidateWithPath(path string) error

type ST_LevelSuffix ¶ 

type ST_LevelSuffix byte
const (
	ST_LevelSuffixUnset   ST_LevelSuffix = 0
	ST_LevelSuffixTab     ST_LevelSuffix = 1
	ST_LevelSuffixSpace   ST_LevelSuffix = 2
	ST_LevelSuffixNothing ST_LevelSuffix = 3
)

func (ST_LevelSuffix) MarshalXML ¶ 

func (m ST_LevelSuffix) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_LevelSuffix) MarshalXMLAttr ¶ 

func (e ST_LevelSuffix) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_LevelSuffix) String ¶ 

func (m ST_LevelSuffix) String() string

func (*ST_LevelSuffix) UnmarshalXML ¶ 

func (m *ST_LevelSuffix) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_LevelSuffix) UnmarshalXMLAttr ¶ 

func (e *ST_LevelSuffix) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_LevelSuffix) Validate ¶ 

func (m ST_LevelSuffix) Validate() error

func (ST_LevelSuffix) ValidateWithPath ¶ 

func (m ST_LevelSuffix) ValidateWithPath(path string) error

type ST_LineNumberRestart ¶ 

type ST_LineNumberRestart byte
const (
	ST_LineNumberRestartUnset      ST_LineNumberRestart = 0
	ST_LineNumberRestartNewPage    ST_LineNumberRestart = 1
	ST_LineNumberRestartNewSection ST_LineNumberRestart = 2
	ST_LineNumberRestartContinuous ST_LineNumberRestart = 3
)

func (ST_LineNumberRestart) MarshalXML ¶ 

func (m ST_LineNumberRestart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_LineNumberRestart) MarshalXMLAttr ¶ 

func (e ST_LineNumberRestart) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_LineNumberRestart) String ¶ 

func (m ST_LineNumberRestart) String() string

func (*ST_LineNumberRestart) UnmarshalXML ¶ 

func (m *ST_LineNumberRestart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_LineNumberRestart) UnmarshalXMLAttr ¶ 

func (e *ST_LineNumberRestart) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_LineNumberRestart) Validate ¶ 

func (m ST_LineNumberRestart) Validate() error

func (ST_LineNumberRestart) ValidateWithPath ¶ 

func (m ST_LineNumberRestart) ValidateWithPath(path string) error

type ST_LineSpacingRule ¶ 

type ST_LineSpacingRule byte
const (
	ST_LineSpacingRuleUnset   ST_LineSpacingRule = 0
	ST_LineSpacingRuleAuto    ST_LineSpacingRule = 1
	ST_LineSpacingRuleExact   ST_LineSpacingRule = 2
	ST_LineSpacingRuleAtLeast ST_LineSpacingRule = 3
)

func (ST_LineSpacingRule) MarshalXML ¶ 

func (m ST_LineSpacingRule) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_LineSpacingRule) MarshalXMLAttr ¶ 

func (e ST_LineSpacingRule) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_LineSpacingRule) String ¶ 

func (m ST_LineSpacingRule) String() string

func (*ST_LineSpacingRule) UnmarshalXML ¶ 

func (m *ST_LineSpacingRule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_LineSpacingRule) UnmarshalXMLAttr ¶ 

func (e *ST_LineSpacingRule) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_LineSpacingRule) Validate ¶ 

func (m ST_LineSpacingRule) Validate() error

func (ST_LineSpacingRule) ValidateWithPath ¶ 

func (m ST_LineSpacingRule) ValidateWithPath(path string) error

type ST_Lock ¶ 

type ST_Lock byte
const (
	ST_LockUnset            ST_Lock = 0
	ST_LockSdtLocked        ST_Lock = 1
	ST_LockContentLocked    ST_Lock = 2
	ST_LockUnlocked         ST_Lock = 3
	ST_LockSdtContentLocked ST_Lock = 4
)

func (ST_Lock) MarshalXML ¶ 

func (m ST_Lock) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Lock) MarshalXMLAttr ¶ 

func (e ST_Lock) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Lock) String ¶ 

func (m ST_Lock) String() string

func (*ST_Lock) UnmarshalXML ¶ 

func (m *ST_Lock) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Lock) UnmarshalXMLAttr ¶ 

func (e *ST_Lock) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Lock) Validate ¶ 

func (m ST_Lock) Validate() error

func (ST_Lock) ValidateWithPath ¶ 

func (m ST_Lock) ValidateWithPath(path string) error

type ST_MailMergeDest ¶ 

type ST_MailMergeDest byte
const (
	ST_MailMergeDestUnset       ST_MailMergeDest = 0
	ST_MailMergeDestNewDocument ST_MailMergeDest = 1
	ST_MailMergeDestPrinter     ST_MailMergeDest = 2
	ST_MailMergeDestEmail       ST_MailMergeDest = 3
	ST_MailMergeDestFax         ST_MailMergeDest = 4
)

func (ST_MailMergeDest) MarshalXML ¶ 

func (m ST_MailMergeDest) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MailMergeDest) MarshalXMLAttr ¶ 

func (e ST_MailMergeDest) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MailMergeDest) String ¶ 

func (m ST_MailMergeDest) String() string

func (*ST_MailMergeDest) UnmarshalXML ¶ 

func (m *ST_MailMergeDest) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MailMergeDest) UnmarshalXMLAttr ¶ 

func (e *ST_MailMergeDest) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MailMergeDest) Validate ¶ 

func (m ST_MailMergeDest) Validate() error

func (ST_MailMergeDest) ValidateWithPath ¶ 

func (m ST_MailMergeDest) ValidateWithPath(path string) error

type ST_MailMergeDocType ¶ 

type ST_MailMergeDocType byte
const (
	ST_MailMergeDocTypeUnset         ST_MailMergeDocType = 0
	ST_MailMergeDocTypeCatalog       ST_MailMergeDocType = 1
	ST_MailMergeDocTypeEnvelopes     ST_MailMergeDocType = 2
	ST_MailMergeDocTypeMailingLabels ST_MailMergeDocType = 3
	ST_MailMergeDocTypeFormLetters   ST_MailMergeDocType = 4
	ST_MailMergeDocTypeEmail         ST_MailMergeDocType = 5
	ST_MailMergeDocTypeFax           ST_MailMergeDocType = 6
)

func (ST_MailMergeDocType) MarshalXML ¶ 

func (m ST_MailMergeDocType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MailMergeDocType) MarshalXMLAttr ¶ 

func (e ST_MailMergeDocType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MailMergeDocType) String ¶ 

func (m ST_MailMergeDocType) String() string

func (*ST_MailMergeDocType) UnmarshalXML ¶ 

func (m *ST_MailMergeDocType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MailMergeDocType) UnmarshalXMLAttr ¶ 

func (e *ST_MailMergeDocType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MailMergeDocType) Validate ¶ 

func (m ST_MailMergeDocType) Validate() error

func (ST_MailMergeDocType) ValidateWithPath ¶ 

func (m ST_MailMergeDocType) ValidateWithPath(path string) error

type ST_MailMergeOdsoFMDFieldType ¶ 

type ST_MailMergeOdsoFMDFieldType byte
const (
	ST_MailMergeOdsoFMDFieldTypeUnset    ST_MailMergeOdsoFMDFieldType = 0
	ST_MailMergeOdsoFMDFieldTypeNull     ST_MailMergeOdsoFMDFieldType = 1
	ST_MailMergeOdsoFMDFieldTypeDbColumn ST_MailMergeOdsoFMDFieldType = 2
)

func (ST_MailMergeOdsoFMDFieldType) MarshalXML ¶ 

func (m ST_MailMergeOdsoFMDFieldType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MailMergeOdsoFMDFieldType) MarshalXMLAttr ¶ 

func (e ST_MailMergeOdsoFMDFieldType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MailMergeOdsoFMDFieldType) String ¶ 

func (m ST_MailMergeOdsoFMDFieldType) String() string

func (*ST_MailMergeOdsoFMDFieldType) UnmarshalXML ¶ 

func (m *ST_MailMergeOdsoFMDFieldType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MailMergeOdsoFMDFieldType) UnmarshalXMLAttr ¶ 

func (e *ST_MailMergeOdsoFMDFieldType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MailMergeOdsoFMDFieldType) Validate ¶ 

func (m ST_MailMergeOdsoFMDFieldType) Validate() error

func (ST_MailMergeOdsoFMDFieldType) ValidateWithPath ¶ 

func (m ST_MailMergeOdsoFMDFieldType) ValidateWithPath(path string) error

type ST_MailMergeSourceType ¶ 

type ST_MailMergeSourceType byte
const (
	ST_MailMergeSourceTypeUnset       ST_MailMergeSourceType = 0
	ST_MailMergeSourceTypeDatabase    ST_MailMergeSourceType = 1
	ST_MailMergeSourceTypeAddressBook ST_MailMergeSourceType = 2
	ST_MailMergeSourceTypeDocument1   ST_MailMergeSourceType = 3
	ST_MailMergeSourceTypeDocument2   ST_MailMergeSourceType = 4
	ST_MailMergeSourceTypeText        ST_MailMergeSourceType = 5
	ST_MailMergeSourceTypeEmail       ST_MailMergeSourceType = 6
	ST_MailMergeSourceTypeNative      ST_MailMergeSourceType = 7
	ST_MailMergeSourceTypeLegacy      ST_MailMergeSourceType = 8
	ST_MailMergeSourceTypeMaster      ST_MailMergeSourceType = 9
)

func (ST_MailMergeSourceType) MarshalXML ¶ 

func (m ST_MailMergeSourceType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MailMergeSourceType) MarshalXMLAttr ¶ 

func (e ST_MailMergeSourceType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MailMergeSourceType) String ¶ 

func (m ST_MailMergeSourceType) String() string

func (*ST_MailMergeSourceType) UnmarshalXML ¶ 

func (m *ST_MailMergeSourceType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MailMergeSourceType) UnmarshalXMLAttr ¶ 

func (e *ST_MailMergeSourceType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MailMergeSourceType) Validate ¶ 

func (m ST_MailMergeSourceType) Validate() error

func (ST_MailMergeSourceType) ValidateWithPath ¶ 

func (m ST_MailMergeSourceType) ValidateWithPath(path string) error

type ST_MeasurementOrPercent ¶ 

type ST_MeasurementOrPercent struct {
	ST_DecimalNumberOrPercent *ST_DecimalNumberOrPercent
	ST_UniversalMeasure       *string
}

ST_MeasurementOrPercent is a union type

func ParseUnionST_MeasurementOrPercent ¶ 

func ParseUnionST_MeasurementOrPercent(s string) (ST_MeasurementOrPercent, error)

func (ST_MeasurementOrPercent) MarshalXML ¶ 

func (m ST_MeasurementOrPercent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MeasurementOrPercent) String ¶ 

func (m ST_MeasurementOrPercent) String() string

func (*ST_MeasurementOrPercent) Validate ¶ 

func (m *ST_MeasurementOrPercent) Validate() error

func (*ST_MeasurementOrPercent) ValidateWithPath ¶ 

func (m *ST_MeasurementOrPercent) ValidateWithPath(path string) error

type ST_Merge ¶ 

type ST_Merge byte
const (
	ST_MergeUnset    ST_Merge = 0
	ST_MergeContinue ST_Merge = 1
	ST_MergeRestart  ST_Merge = 2
)

func (ST_Merge) MarshalXML ¶ 

func (m ST_Merge) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Merge) MarshalXMLAttr ¶ 

func (e ST_Merge) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Merge) String ¶ 

func (m ST_Merge) String() string

func (*ST_Merge) UnmarshalXML ¶ 

func (m *ST_Merge) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Merge) UnmarshalXMLAttr ¶ 

func (e *ST_Merge) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Merge) Validate ¶ 

func (m ST_Merge) Validate() error

func (ST_Merge) ValidateWithPath ¶ 

func (m ST_Merge) ValidateWithPath(path string) error

type ST_MultiLevelType ¶ 

type ST_MultiLevelType byte
const (
	ST_MultiLevelTypeUnset            ST_MultiLevelType = 0
	ST_MultiLevelTypeSingleLevel      ST_MultiLevelType = 1
	ST_MultiLevelTypeMultilevel       ST_MultiLevelType = 2
	ST_MultiLevelTypeHybridMultilevel ST_MultiLevelType = 3
)

func (ST_MultiLevelType) MarshalXML ¶ 

func (m ST_MultiLevelType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MultiLevelType) MarshalXMLAttr ¶ 

func (e ST_MultiLevelType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MultiLevelType) String ¶ 

func (m ST_MultiLevelType) String() string

func (*ST_MultiLevelType) UnmarshalXML ¶ 

func (m *ST_MultiLevelType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MultiLevelType) UnmarshalXMLAttr ¶ 

func (e *ST_MultiLevelType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MultiLevelType) Validate ¶ 

func (m ST_MultiLevelType) Validate() error

func (ST_MultiLevelType) ValidateWithPath ¶ 

func (m ST_MultiLevelType) ValidateWithPath(path string) error

type ST_NumberFormat ¶ 

type ST_NumberFormat byte
const (
	ST_NumberFormatUnset                        ST_NumberFormat = 0
	ST_NumberFormatDecimal                      ST_NumberFormat = 1
	ST_NumberFormatUpperRoman                   ST_NumberFormat = 2
	ST_NumberFormatLowerRoman                   ST_NumberFormat = 3
	ST_NumberFormatUpperLetter                  ST_NumberFormat = 4
	ST_NumberFormatLowerLetter                  ST_NumberFormat = 5
	ST_NumberFormatOrdinal                      ST_NumberFormat = 6
	ST_NumberFormatCardinalText                 ST_NumberFormat = 7
	ST_NumberFormatOrdinalText                  ST_NumberFormat = 8
	ST_NumberFormatHex                          ST_NumberFormat = 9
	ST_NumberFormatChicago                      ST_NumberFormat = 10
	ST_NumberFormatIdeographDigital             ST_NumberFormat = 11
	ST_NumberFormatJapaneseCounting             ST_NumberFormat = 12
	ST_NumberFormatAiueo                        ST_NumberFormat = 13
	ST_NumberFormatIroha                        ST_NumberFormat = 14
	ST_NumberFormatDecimalFullWidth             ST_NumberFormat = 15
	ST_NumberFormatDecimalHalfWidth             ST_NumberFormat = 16
	ST_NumberFormatJapaneseLegal                ST_NumberFormat = 17
	ST_NumberFormatJapaneseDigitalTenThousand   ST_NumberFormat = 18
	ST_NumberFormatDecimalEnclosedCircle        ST_NumberFormat = 19
	ST_NumberFormatDecimalFullWidth2            ST_NumberFormat = 20
	ST_NumberFormatAiueoFullWidth               ST_NumberFormat = 21
	ST_NumberFormatIrohaFullWidth               ST_NumberFormat = 22
	ST_NumberFormatDecimalZero                  ST_NumberFormat = 23
	ST_NumberFormatBullet                       ST_NumberFormat = 24
	ST_NumberFormatGanada                       ST_NumberFormat = 25
	ST_NumberFormatChosung                      ST_NumberFormat = 26
	ST_NumberFormatDecimalEnclosedFullstop      ST_NumberFormat = 27
	ST_NumberFormatDecimalEnclosedParen         ST_NumberFormat = 28
	ST_NumberFormatDecimalEnclosedCircleChinese ST_NumberFormat = 29
	ST_NumberFormatIdeographEnclosedCircle      ST_NumberFormat = 30
	ST_NumberFormatIdeographTraditional         ST_NumberFormat = 31
	ST_NumberFormatIdeographZodiac              ST_NumberFormat = 32
	ST_NumberFormatIdeographZodiacTraditional   ST_NumberFormat = 33
	ST_NumberFormatTaiwaneseCounting            ST_NumberFormat = 34
	ST_NumberFormatIdeographLegalTraditional    ST_NumberFormat = 35
	ST_NumberFormatTaiwaneseCountingThousand    ST_NumberFormat = 36
	ST_NumberFormatTaiwaneseDigital             ST_NumberFormat = 37
	ST_NumberFormatChineseCounting              ST_NumberFormat = 38
	ST_NumberFormatChineseLegalSimplified       ST_NumberFormat = 39
	ST_NumberFormatChineseCountingThousand      ST_NumberFormat = 40
	ST_NumberFormatKoreanDigital                ST_NumberFormat = 41
	ST_NumberFormatKoreanCounting               ST_NumberFormat = 42
	ST_NumberFormatKoreanLegal                  ST_NumberFormat = 43
	ST_NumberFormatKoreanDigital2               ST_NumberFormat = 44
	ST_NumberFormatVietnameseCounting           ST_NumberFormat = 45
	ST_NumberFormatRussianLower                 ST_NumberFormat = 46
	ST_NumberFormatRussianUpper                 ST_NumberFormat = 47
	ST_NumberFormatNone                         ST_NumberFormat = 48
	ST_NumberFormatNumberInDash                 ST_NumberFormat = 49
	ST_NumberFormatHebrew1                      ST_NumberFormat = 50
	ST_NumberFormatHebrew2                      ST_NumberFormat = 51
	ST_NumberFormatArabicAlpha                  ST_NumberFormat = 52
	ST_NumberFormatArabicAbjad                  ST_NumberFormat = 53
	ST_NumberFormatHindiVowels                  ST_NumberFormat = 54
	ST_NumberFormatHindiConsonants              ST_NumberFormat = 55
	ST_NumberFormatHindiNumbers                 ST_NumberFormat = 56
	ST_NumberFormatHindiCounting                ST_NumberFormat = 57
	ST_NumberFormatThaiLetters                  ST_NumberFormat = 58
	ST_NumberFormatThaiNumbers                  ST_NumberFormat = 59
	ST_NumberFormatThaiCounting                 ST_NumberFormat = 60
	ST_NumberFormatBahtText                     ST_NumberFormat = 61
	ST_NumberFormatDollarText                   ST_NumberFormat = 62
	ST_NumberFormatCustom                       ST_NumberFormat = 63
)

func (ST_NumberFormat) MarshalXML ¶ 

func (m ST_NumberFormat) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_NumberFormat) MarshalXMLAttr ¶ 

func (e ST_NumberFormat) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_NumberFormat) String ¶ 

func (m ST_NumberFormat) String() string

func (*ST_NumberFormat) UnmarshalXML ¶ 

func (m *ST_NumberFormat) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_NumberFormat) UnmarshalXMLAttr ¶ 

func (e *ST_NumberFormat) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_NumberFormat) Validate ¶ 

func (m ST_NumberFormat) Validate() error

func (ST_NumberFormat) ValidateWithPath ¶ 

func (m ST_NumberFormat) ValidateWithPath(path string) error

type ST_ObjectDrawAspect ¶ 

type ST_ObjectDrawAspect byte
const (
	ST_ObjectDrawAspectUnset   ST_ObjectDrawAspect = 0
	ST_ObjectDrawAspectContent ST_ObjectDrawAspect = 1
	ST_ObjectDrawAspectIcon    ST_ObjectDrawAspect = 2
)

func (ST_ObjectDrawAspect) MarshalXML ¶ 

func (m ST_ObjectDrawAspect) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ObjectDrawAspect) MarshalXMLAttr ¶ 

func (e ST_ObjectDrawAspect) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ObjectDrawAspect) String ¶ 

func (m ST_ObjectDrawAspect) String() string

func (*ST_ObjectDrawAspect) UnmarshalXML ¶ 

func (m *ST_ObjectDrawAspect) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ObjectDrawAspect) UnmarshalXMLAttr ¶ 

func (e *ST_ObjectDrawAspect) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ObjectDrawAspect) Validate ¶ 

func (m ST_ObjectDrawAspect) Validate() error

func (ST_ObjectDrawAspect) ValidateWithPath ¶ 

func (m ST_ObjectDrawAspect) ValidateWithPath(path string) error

type ST_ObjectUpdateMode ¶ 

type ST_ObjectUpdateMode byte
const (
	ST_ObjectUpdateModeUnset  ST_ObjectUpdateMode = 0
	ST_ObjectUpdateModeAlways ST_ObjectUpdateMode = 1
	ST_ObjectUpdateModeOnCall ST_ObjectUpdateMode = 2
)

func (ST_ObjectUpdateMode) MarshalXML ¶ 

func (m ST_ObjectUpdateMode) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ObjectUpdateMode) MarshalXMLAttr ¶ 

func (e ST_ObjectUpdateMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ObjectUpdateMode) String ¶ 

func (m ST_ObjectUpdateMode) String() string

func (*ST_ObjectUpdateMode) UnmarshalXML ¶ 

func (m *ST_ObjectUpdateMode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ObjectUpdateMode) UnmarshalXMLAttr ¶ 

func (e *ST_ObjectUpdateMode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ObjectUpdateMode) Validate ¶ 

func (m ST_ObjectUpdateMode) Validate() error

func (ST_ObjectUpdateMode) ValidateWithPath ¶ 

func (m ST_ObjectUpdateMode) ValidateWithPath(path string) error

type ST_PTabAlignment ¶ 

type ST_PTabAlignment byte
const (
	ST_PTabAlignmentUnset  ST_PTabAlignment = 0
	ST_PTabAlignmentLeft   ST_PTabAlignment = 1
	ST_PTabAlignmentCenter ST_PTabAlignment = 2
	ST_PTabAlignmentRight  ST_PTabAlignment = 3
)

func (ST_PTabAlignment) MarshalXML ¶ 

func (m ST_PTabAlignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PTabAlignment) MarshalXMLAttr ¶ 

func (e ST_PTabAlignment) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PTabAlignment) String ¶ 

func (m ST_PTabAlignment) String() string

func (*ST_PTabAlignment) UnmarshalXML ¶ 

func (m *ST_PTabAlignment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PTabAlignment) UnmarshalXMLAttr ¶ 

func (e *ST_PTabAlignment) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PTabAlignment) Validate ¶ 

func (m ST_PTabAlignment) Validate() error

func (ST_PTabAlignment) ValidateWithPath ¶ 

func (m ST_PTabAlignment) ValidateWithPath(path string) error

type ST_PTabLeader ¶ 

type ST_PTabLeader byte
const (
	ST_PTabLeaderUnset      ST_PTabLeader = 0
	ST_PTabLeaderNone       ST_PTabLeader = 1
	ST_PTabLeaderDot        ST_PTabLeader = 2
	ST_PTabLeaderHyphen     ST_PTabLeader = 3
	ST_PTabLeaderUnderscore ST_PTabLeader = 4
	ST_PTabLeaderMiddleDot  ST_PTabLeader = 5
)

func (ST_PTabLeader) MarshalXML ¶ 

func (m ST_PTabLeader) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PTabLeader) MarshalXMLAttr ¶ 

func (e ST_PTabLeader) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PTabLeader) String ¶ 

func (m ST_PTabLeader) String() string

func (*ST_PTabLeader) UnmarshalXML ¶ 

func (m *ST_PTabLeader) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PTabLeader) UnmarshalXMLAttr ¶ 

func (e *ST_PTabLeader) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PTabLeader) Validate ¶ 

func (m ST_PTabLeader) Validate() error

func (ST_PTabLeader) ValidateWithPath ¶ 

func (m ST_PTabLeader) ValidateWithPath(path string) error

type ST_PTabRelativeTo ¶ 

type ST_PTabRelativeTo byte
const (
	ST_PTabRelativeToUnset  ST_PTabRelativeTo = 0
	ST_PTabRelativeToMargin ST_PTabRelativeTo = 1
	ST_PTabRelativeToIndent ST_PTabRelativeTo = 2
)

func (ST_PTabRelativeTo) MarshalXML ¶ 

func (m ST_PTabRelativeTo) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PTabRelativeTo) MarshalXMLAttr ¶ 

func (e ST_PTabRelativeTo) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PTabRelativeTo) String ¶ 

func (m ST_PTabRelativeTo) String() string

func (*ST_PTabRelativeTo) UnmarshalXML ¶ 

func (m *ST_PTabRelativeTo) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PTabRelativeTo) UnmarshalXMLAttr ¶ 

func (e *ST_PTabRelativeTo) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PTabRelativeTo) Validate ¶ 

func (m ST_PTabRelativeTo) Validate() error

func (ST_PTabRelativeTo) ValidateWithPath ¶ 

func (m ST_PTabRelativeTo) ValidateWithPath(path string) error

type ST_PageBorderDisplay ¶ 

type ST_PageBorderDisplay byte
const (
	ST_PageBorderDisplayUnset        ST_PageBorderDisplay = 0
	ST_PageBorderDisplayAllPages     ST_PageBorderDisplay = 1
	ST_PageBorderDisplayFirstPage    ST_PageBorderDisplay = 2
	ST_PageBorderDisplayNotFirstPage ST_PageBorderDisplay = 3
)

func (ST_PageBorderDisplay) MarshalXML ¶ 

func (m ST_PageBorderDisplay) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PageBorderDisplay) MarshalXMLAttr ¶ 

func (e ST_PageBorderDisplay) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PageBorderDisplay) String ¶ 

func (m ST_PageBorderDisplay) String() string

func (*ST_PageBorderDisplay) UnmarshalXML ¶ 

func (m *ST_PageBorderDisplay) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PageBorderDisplay) UnmarshalXMLAttr ¶ 

func (e *ST_PageBorderDisplay) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PageBorderDisplay) Validate ¶ 

func (m ST_PageBorderDisplay) Validate() error

func (ST_PageBorderDisplay) ValidateWithPath ¶ 

func (m ST_PageBorderDisplay) ValidateWithPath(path string) error

type ST_PageBorderOffset ¶ 

type ST_PageBorderOffset byte
const (
	ST_PageBorderOffsetUnset ST_PageBorderOffset = 0
	ST_PageBorderOffsetPage  ST_PageBorderOffset = 1
	ST_PageBorderOffsetText  ST_PageBorderOffset = 2
)

func (ST_PageBorderOffset) MarshalXML ¶ 

func (m ST_PageBorderOffset) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PageBorderOffset) MarshalXMLAttr ¶ 

func (e ST_PageBorderOffset) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PageBorderOffset) String ¶ 

func (m ST_PageBorderOffset) String() string

func (*ST_PageBorderOffset) UnmarshalXML ¶ 

func (m *ST_PageBorderOffset) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PageBorderOffset) UnmarshalXMLAttr ¶ 

func (e *ST_PageBorderOffset) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PageBorderOffset) Validate ¶ 

func (m ST_PageBorderOffset) Validate() error

func (ST_PageBorderOffset) ValidateWithPath ¶ 

func (m ST_PageBorderOffset) ValidateWithPath(path string) error

type ST_PageBorderZOrder ¶ 

type ST_PageBorderZOrder byte
const (
	ST_PageBorderZOrderUnset ST_PageBorderZOrder = 0
	ST_PageBorderZOrderFront ST_PageBorderZOrder = 1
	ST_PageBorderZOrderBack  ST_PageBorderZOrder = 2
)

func (ST_PageBorderZOrder) MarshalXML ¶ 

func (m ST_PageBorderZOrder) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PageBorderZOrder) MarshalXMLAttr ¶ 

func (e ST_PageBorderZOrder) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PageBorderZOrder) String ¶ 

func (m ST_PageBorderZOrder) String() string

func (*ST_PageBorderZOrder) UnmarshalXML ¶ 

func (m *ST_PageBorderZOrder) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PageBorderZOrder) UnmarshalXMLAttr ¶ 

func (e *ST_PageBorderZOrder) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PageBorderZOrder) Validate ¶ 

func (m ST_PageBorderZOrder) Validate() error

func (ST_PageBorderZOrder) ValidateWithPath ¶ 

func (m ST_PageBorderZOrder) ValidateWithPath(path string) error

type ST_PageOrientation ¶ 

type ST_PageOrientation byte
const (
	ST_PageOrientationUnset     ST_PageOrientation = 0
	ST_PageOrientationPortrait  ST_PageOrientation = 1
	ST_PageOrientationLandscape ST_PageOrientation = 2
)

func (ST_PageOrientation) MarshalXML ¶ 

func (m ST_PageOrientation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PageOrientation) MarshalXMLAttr ¶ 

func (e ST_PageOrientation) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PageOrientation) String ¶ 

func (m ST_PageOrientation) String() string

func (*ST_PageOrientation) UnmarshalXML ¶ 

func (m *ST_PageOrientation) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PageOrientation) UnmarshalXMLAttr ¶ 

func (e *ST_PageOrientation) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PageOrientation) Validate ¶ 

func (m ST_PageOrientation) Validate() error

func (ST_PageOrientation) ValidateWithPath ¶ 

func (m ST_PageOrientation) ValidateWithPath(path string) error

type ST_Pitch ¶ 

type ST_Pitch byte
const (
	ST_PitchUnset    ST_Pitch = 0
	ST_PitchFixed    ST_Pitch = 1
	ST_PitchVariable ST_Pitch = 2
	ST_PitchDefault  ST_Pitch = 3
)

func (ST_Pitch) MarshalXML ¶ 

func (m ST_Pitch) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Pitch) MarshalXMLAttr ¶ 

func (e ST_Pitch) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Pitch) String ¶ 

func (m ST_Pitch) String() string

func (*ST_Pitch) UnmarshalXML ¶ 

func (m *ST_Pitch) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Pitch) UnmarshalXMLAttr ¶ 

func (e *ST_Pitch) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Pitch) Validate ¶ 

func (m ST_Pitch) Validate() error

func (ST_Pitch) ValidateWithPath ¶ 

func (m ST_Pitch) ValidateWithPath(path string) error

type ST_Proof ¶ 

type ST_Proof byte
const (
	ST_ProofUnset ST_Proof = 0
	ST_ProofClean ST_Proof = 1
	ST_ProofDirty ST_Proof = 2
)

func (ST_Proof) MarshalXML ¶ 

func (m ST_Proof) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Proof) MarshalXMLAttr ¶ 

func (e ST_Proof) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Proof) String ¶ 

func (m ST_Proof) String() string

func (*ST_Proof) UnmarshalXML ¶ 

func (m *ST_Proof) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Proof) UnmarshalXMLAttr ¶ 

func (e *ST_Proof) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Proof) Validate ¶ 

func (m ST_Proof) Validate() error

func (ST_Proof) ValidateWithPath ¶ 

func (m ST_Proof) ValidateWithPath(path string) error

type ST_ProofErr ¶ 

type ST_ProofErr byte
const (
	ST_ProofErrUnset      ST_ProofErr = 0
	ST_ProofErrSpellStart ST_ProofErr = 1
	ST_ProofErrSpellEnd   ST_ProofErr = 2
	ST_ProofErrGramStart  ST_ProofErr = 3
	ST_ProofErrGramEnd    ST_ProofErr = 4
)

func (ST_ProofErr) MarshalXML ¶ 

func (m ST_ProofErr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ProofErr) MarshalXMLAttr ¶ 

func (e ST_ProofErr) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ProofErr) String ¶ 

func (m ST_ProofErr) String() string

func (*ST_ProofErr) UnmarshalXML ¶ 

func (m *ST_ProofErr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ProofErr) UnmarshalXMLAttr ¶ 

func (e *ST_ProofErr) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ProofErr) Validate ¶ 

func (m ST_ProofErr) Validate() error

func (ST_ProofErr) ValidateWithPath ¶ 

func (m ST_ProofErr) ValidateWithPath(path string) error

type ST_RestartNumber ¶ 

type ST_RestartNumber byte
const (
	ST_RestartNumberUnset      ST_RestartNumber = 0
	ST_RestartNumberContinuous ST_RestartNumber = 1
	ST_RestartNumberEachSect   ST_RestartNumber = 2
	ST_RestartNumberEachPage   ST_RestartNumber = 3
)

func (ST_RestartNumber) MarshalXML ¶ 

func (m ST_RestartNumber) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_RestartNumber) MarshalXMLAttr ¶ 

func (e ST_RestartNumber) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_RestartNumber) String ¶ 

func (m ST_RestartNumber) String() string

func (*ST_RestartNumber) UnmarshalXML ¶ 

func (m *ST_RestartNumber) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_RestartNumber) UnmarshalXMLAttr ¶ 

func (e *ST_RestartNumber) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_RestartNumber) Validate ¶ 

func (m ST_RestartNumber) Validate() error

func (ST_RestartNumber) ValidateWithPath ¶ 

func (m ST_RestartNumber) ValidateWithPath(path string) error

type ST_RubyAlign ¶ 

type ST_RubyAlign byte
const (
	ST_RubyAlignUnset            ST_RubyAlign = 0
	ST_RubyAlignCenter           ST_RubyAlign = 1
	ST_RubyAlignDistributeLetter ST_RubyAlign = 2
	ST_RubyAlignDistributeSpace  ST_RubyAlign = 3
	ST_RubyAlignLeft             ST_RubyAlign = 4
	ST_RubyAlignRight            ST_RubyAlign = 5
	ST_RubyAlignRightVertical    ST_RubyAlign = 6
)

func (ST_RubyAlign) MarshalXML ¶ 

func (m ST_RubyAlign) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_RubyAlign) MarshalXMLAttr ¶ 

func (e ST_RubyAlign) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_RubyAlign) String ¶ 

func (m ST_RubyAlign) String() string

func (*ST_RubyAlign) UnmarshalXML ¶ 

func (m *ST_RubyAlign) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_RubyAlign) UnmarshalXMLAttr ¶ 

func (e *ST_RubyAlign) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_RubyAlign) Validate ¶ 

func (m ST_RubyAlign) Validate() error

func (ST_RubyAlign) ValidateWithPath ¶ 

func (m ST_RubyAlign) ValidateWithPath(path string) error

type ST_SdtDateMappingType ¶ 

type ST_SdtDateMappingType byte
const (
	ST_SdtDateMappingTypeUnset    ST_SdtDateMappingType = 0
	ST_SdtDateMappingTypeText     ST_SdtDateMappingType = 1
	ST_SdtDateMappingTypeDate     ST_SdtDateMappingType = 2
	ST_SdtDateMappingTypeDateTime ST_SdtDateMappingType = 3
)

func (ST_SdtDateMappingType) MarshalXML ¶ 

func (m ST_SdtDateMappingType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SdtDateMappingType) MarshalXMLAttr ¶ 

func (e ST_SdtDateMappingType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SdtDateMappingType) String ¶ 

func (m ST_SdtDateMappingType) String() string

func (*ST_SdtDateMappingType) UnmarshalXML ¶ 

func (m *ST_SdtDateMappingType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SdtDateMappingType) UnmarshalXMLAttr ¶ 

func (e *ST_SdtDateMappingType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SdtDateMappingType) Validate ¶ 

func (m ST_SdtDateMappingType) Validate() error

func (ST_SdtDateMappingType) ValidateWithPath ¶ 

func (m ST_SdtDateMappingType) ValidateWithPath(path string) error

type ST_SectionMark ¶ 

type ST_SectionMark byte
const (
	ST_SectionMarkUnset      ST_SectionMark = 0
	ST_SectionMarkNextPage   ST_SectionMark = 1
	ST_SectionMarkNextColumn ST_SectionMark = 2
	ST_SectionMarkContinuous ST_SectionMark = 3
	ST_SectionMarkEvenPage   ST_SectionMark = 4
	ST_SectionMarkOddPage    ST_SectionMark = 5
)

func (ST_SectionMark) MarshalXML ¶ 

func (m ST_SectionMark) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SectionMark) MarshalXMLAttr ¶ 

func (e ST_SectionMark) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SectionMark) String ¶ 

func (m ST_SectionMark) String() string

func (*ST_SectionMark) UnmarshalXML ¶ 

func (m *ST_SectionMark) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SectionMark) UnmarshalXMLAttr ¶ 

func (e *ST_SectionMark) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SectionMark) Validate ¶ 

func (m ST_SectionMark) Validate() error

func (ST_SectionMark) ValidateWithPath ¶ 

func (m ST_SectionMark) ValidateWithPath(path string) error

type ST_Shd ¶ 

type ST_Shd byte
const (
	ST_ShdUnset                 ST_Shd = 0
	ST_ShdNil                   ST_Shd = 1
	ST_ShdClear                 ST_Shd = 2
	ST_ShdSolid                 ST_Shd = 3
	ST_ShdHorzStripe            ST_Shd = 4
	ST_ShdVertStripe            ST_Shd = 5
	ST_ShdReverseDiagStripe     ST_Shd = 6
	ST_ShdDiagStripe            ST_Shd = 7
	ST_ShdHorzCross             ST_Shd = 8
	ST_ShdDiagCross             ST_Shd = 9
	ST_ShdThinHorzStripe        ST_Shd = 10
	ST_ShdThinVertStripe        ST_Shd = 11
	ST_ShdThinReverseDiagStripe ST_Shd = 12
	ST_ShdThinDiagStripe        ST_Shd = 13
	ST_ShdThinHorzCross         ST_Shd = 14
	ST_ShdThinDiagCross         ST_Shd = 15
	ST_ShdPct5                  ST_Shd = 16
	ST_ShdPct10                 ST_Shd = 17
	ST_ShdPct12                 ST_Shd = 18
	ST_ShdPct15                 ST_Shd = 19
	ST_ShdPct20                 ST_Shd = 20
	ST_ShdPct25                 ST_Shd = 21
	ST_ShdPct30                 ST_Shd = 22
	ST_ShdPct35                 ST_Shd = 23
	ST_ShdPct37                 ST_Shd = 24
	ST_ShdPct40                 ST_Shd = 25
	ST_ShdPct45                 ST_Shd = 26
	ST_ShdPct50                 ST_Shd = 27
	ST_ShdPct55                 ST_Shd = 28
	ST_ShdPct60                 ST_Shd = 29
	ST_ShdPct62                 ST_Shd = 30
	ST_ShdPct65                 ST_Shd = 31
	ST_ShdPct70                 ST_Shd = 32
	ST_ShdPct75                 ST_Shd = 33
	ST_ShdPct80                 ST_Shd = 34
	ST_ShdPct85                 ST_Shd = 35
	ST_ShdPct87                 ST_Shd = 36
	ST_ShdPct90                 ST_Shd = 37
	ST_ShdPct95                 ST_Shd = 38
)

func (ST_Shd) MarshalXML ¶ 

func (m ST_Shd) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Shd) MarshalXMLAttr ¶ 

func (e ST_Shd) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Shd) String ¶ 

func (m ST_Shd) String() string

func (*ST_Shd) UnmarshalXML ¶ 

func (m *ST_Shd) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Shd) UnmarshalXMLAttr ¶ 

func (e *ST_Shd) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Shd) Validate ¶ 

func (m ST_Shd) Validate() error

func (ST_Shd) ValidateWithPath ¶ 

func (m ST_Shd) ValidateWithPath(path string) error

type ST_SignedHpsMeasure ¶ 

type ST_SignedHpsMeasure struct {
	Int64               *int64
	ST_UniversalMeasure *string
}

ST_SignedHpsMeasure is a union type

func ParseUnionST_SignedHpsMeasure ¶ 

func ParseUnionST_SignedHpsMeasure(s string) (ST_SignedHpsMeasure, error)

func (ST_SignedHpsMeasure) MarshalXML ¶ 

func (m ST_SignedHpsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SignedHpsMeasure) String ¶ 

func (m ST_SignedHpsMeasure) String() string

func (*ST_SignedHpsMeasure) Validate ¶ 

func (m *ST_SignedHpsMeasure) Validate() error

func (*ST_SignedHpsMeasure) ValidateWithPath ¶ 

func (m *ST_SignedHpsMeasure) ValidateWithPath(path string) error

type ST_SignedTwipsMeasure ¶ 

type ST_SignedTwipsMeasure struct {
	Int64               *int64
	ST_UniversalMeasure *string
}

ST_SignedTwipsMeasure is a union type

func ParseUnionST_SignedTwipsMeasure ¶ 

func ParseUnionST_SignedTwipsMeasure(s string) (ST_SignedTwipsMeasure, error)

func (ST_SignedTwipsMeasure) MarshalXML ¶ 

func (m ST_SignedTwipsMeasure) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SignedTwipsMeasure) String ¶ 

func (m ST_SignedTwipsMeasure) String() string

func (*ST_SignedTwipsMeasure) Validate ¶ 

func (m *ST_SignedTwipsMeasure) Validate() error

func (*ST_SignedTwipsMeasure) ValidateWithPath ¶ 

func (m *ST_SignedTwipsMeasure) ValidateWithPath(path string) error

type ST_StyleSort ¶ 

type ST_StyleSort byte
const (
	ST_StyleSortUnset    ST_StyleSort = 0
	ST_StyleSortName     ST_StyleSort = 1
	ST_StyleSortPriority ST_StyleSort = 2
	ST_StyleSortDefault  ST_StyleSort = 3
	ST_StyleSortFont     ST_StyleSort = 4
	ST_StyleSortBasedOn  ST_StyleSort = 5
	ST_StyleSortType     ST_StyleSort = 6
	ST_StyleSort0000     ST_StyleSort = 7
	ST_StyleSort0001     ST_StyleSort = 8
	ST_StyleSort0002     ST_StyleSort = 9
	ST_StyleSort0003     ST_StyleSort = 10
	ST_StyleSort0004     ST_StyleSort = 11
	ST_StyleSort0005     ST_StyleSort = 12
)

func (ST_StyleSort) MarshalXML ¶ 

func (m ST_StyleSort) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_StyleSort) MarshalXMLAttr ¶ 

func (e ST_StyleSort) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_StyleSort) String ¶ 

func (m ST_StyleSort) String() string

func (*ST_StyleSort) UnmarshalXML ¶ 

func (m *ST_StyleSort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_StyleSort) UnmarshalXMLAttr ¶ 

func (e *ST_StyleSort) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_StyleSort) Validate ¶ 

func (m ST_StyleSort) Validate() error

func (ST_StyleSort) ValidateWithPath ¶ 

func (m ST_StyleSort) ValidateWithPath(path string) error

type ST_StyleType ¶ 

type ST_StyleType byte
const (
	ST_StyleTypeUnset     ST_StyleType = 0
	ST_StyleTypeParagraph ST_StyleType = 1
	ST_StyleTypeCharacter ST_StyleType = 2
	ST_StyleTypeTable     ST_StyleType = 3
	ST_StyleTypeNumbering ST_StyleType = 4
)

func (ST_StyleType) MarshalXML ¶ 

func (m ST_StyleType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_StyleType) MarshalXMLAttr ¶ 

func (e ST_StyleType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_StyleType) String ¶ 

func (m ST_StyleType) String() string

func (*ST_StyleType) UnmarshalXML ¶ 

func (m *ST_StyleType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_StyleType) UnmarshalXMLAttr ¶ 

func (e *ST_StyleType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_StyleType) Validate ¶ 

func (m ST_StyleType) Validate() error

func (ST_StyleType) ValidateWithPath ¶ 

func (m ST_StyleType) ValidateWithPath(path string) error

type ST_TabJc ¶ 

type ST_TabJc byte
const (
	ST_TabJcUnset   ST_TabJc = 0
	ST_TabJcClear   ST_TabJc = 1
	ST_TabJcStart   ST_TabJc = 2
	ST_TabJcCenter  ST_TabJc = 3
	ST_TabJcEnd     ST_TabJc = 4
	ST_TabJcDecimal ST_TabJc = 5
	ST_TabJcBar     ST_TabJc = 6
	ST_TabJcNum     ST_TabJc = 7
	ST_TabJcLeft    ST_TabJc = 8
	ST_TabJcRight   ST_TabJc = 9
)

func (ST_TabJc) MarshalXML ¶ 

func (m ST_TabJc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TabJc) MarshalXMLAttr ¶ 

func (e ST_TabJc) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TabJc) String ¶ 

func (m ST_TabJc) String() string

func (*ST_TabJc) UnmarshalXML ¶ 

func (m *ST_TabJc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TabJc) UnmarshalXMLAttr ¶ 

func (e *ST_TabJc) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TabJc) Validate ¶ 

func (m ST_TabJc) Validate() error

func (ST_TabJc) ValidateWithPath ¶ 

func (m ST_TabJc) ValidateWithPath(path string) error

type ST_TabTlc ¶ 

type ST_TabTlc byte
const (
	ST_TabTlcUnset      ST_TabTlc = 0
	ST_TabTlcNone       ST_TabTlc = 1
	ST_TabTlcDot        ST_TabTlc = 2
	ST_TabTlcHyphen     ST_TabTlc = 3
	ST_TabTlcUnderscore ST_TabTlc = 4
	ST_TabTlcHeavy      ST_TabTlc = 5
	ST_TabTlcMiddleDot  ST_TabTlc = 6
)

func (ST_TabTlc) MarshalXML ¶ 

func (m ST_TabTlc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TabTlc) MarshalXMLAttr ¶ 

func (e ST_TabTlc) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TabTlc) String ¶ 

func (m ST_TabTlc) String() string

func (*ST_TabTlc) UnmarshalXML ¶ 

func (m *ST_TabTlc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TabTlc) UnmarshalXMLAttr ¶ 

func (e *ST_TabTlc) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TabTlc) Validate ¶ 

func (m ST_TabTlc) Validate() error

func (ST_TabTlc) ValidateWithPath ¶ 

func (m ST_TabTlc) ValidateWithPath(path string) error

type ST_TargetScreenSz ¶ 

type ST_TargetScreenSz byte
const (
	ST_TargetScreenSzUnset     ST_TargetScreenSz = 0
	ST_TargetScreenSz544x376   ST_TargetScreenSz = 1
	ST_TargetScreenSz640x480   ST_TargetScreenSz = 2
	ST_TargetScreenSz720x512   ST_TargetScreenSz = 3
	ST_TargetScreenSz800x600   ST_TargetScreenSz = 4
	ST_TargetScreenSz1024x768  ST_TargetScreenSz = 5
	ST_TargetScreenSz1152x882  ST_TargetScreenSz = 6
	ST_TargetScreenSz1152x900  ST_TargetScreenSz = 7
	ST_TargetScreenSz1280x1024 ST_TargetScreenSz = 8
	ST_TargetScreenSz1600x1200 ST_TargetScreenSz = 9
	ST_TargetScreenSz1800x1440 ST_TargetScreenSz = 10
	ST_TargetScreenSz1920x1200 ST_TargetScreenSz = 11
)

func (ST_TargetScreenSz) MarshalXML ¶ 

func (m ST_TargetScreenSz) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TargetScreenSz) MarshalXMLAttr ¶ 

func (e ST_TargetScreenSz) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TargetScreenSz) String ¶ 

func (m ST_TargetScreenSz) String() string

func (*ST_TargetScreenSz) UnmarshalXML ¶ 

func (m *ST_TargetScreenSz) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TargetScreenSz) UnmarshalXMLAttr ¶ 

func (e *ST_TargetScreenSz) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TargetScreenSz) Validate ¶ 

func (m ST_TargetScreenSz) Validate() error

func (ST_TargetScreenSz) ValidateWithPath ¶ 

func (m ST_TargetScreenSz) ValidateWithPath(path string) error

type ST_TblLayoutType ¶ 

type ST_TblLayoutType byte
const (
	ST_TblLayoutTypeUnset   ST_TblLayoutType = 0
	ST_TblLayoutTypeFixed   ST_TblLayoutType = 1
	ST_TblLayoutTypeAutofit ST_TblLayoutType = 2
)

func (ST_TblLayoutType) MarshalXML ¶ 

func (m ST_TblLayoutType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TblLayoutType) MarshalXMLAttr ¶ 

func (e ST_TblLayoutType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TblLayoutType) String ¶ 

func (m ST_TblLayoutType) String() string

func (*ST_TblLayoutType) UnmarshalXML ¶ 

func (m *ST_TblLayoutType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TblLayoutType) UnmarshalXMLAttr ¶ 

func (e *ST_TblLayoutType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TblLayoutType) Validate ¶ 

func (m ST_TblLayoutType) Validate() error

func (ST_TblLayoutType) ValidateWithPath ¶ 

func (m ST_TblLayoutType) ValidateWithPath(path string) error

type ST_TblOverlap ¶ 

type ST_TblOverlap byte
const (
	ST_TblOverlapUnset   ST_TblOverlap = 0
	ST_TblOverlapNever   ST_TblOverlap = 1
	ST_TblOverlapOverlap ST_TblOverlap = 2
)

func (ST_TblOverlap) MarshalXML ¶ 

func (m ST_TblOverlap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TblOverlap) MarshalXMLAttr ¶ 

func (e ST_TblOverlap) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TblOverlap) String ¶ 

func (m ST_TblOverlap) String() string

func (*ST_TblOverlap) UnmarshalXML ¶ 

func (m *ST_TblOverlap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TblOverlap) UnmarshalXMLAttr ¶ 

func (e *ST_TblOverlap) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TblOverlap) Validate ¶ 

func (m ST_TblOverlap) Validate() error

func (ST_TblOverlap) ValidateWithPath ¶ 

func (m ST_TblOverlap) ValidateWithPath(path string) error

type ST_TblStyleOverrideType ¶ 

type ST_TblStyleOverrideType byte
const (
	ST_TblStyleOverrideTypeUnset      ST_TblStyleOverrideType = 0
	ST_TblStyleOverrideTypeWholeTable ST_TblStyleOverrideType = 1
	ST_TblStyleOverrideTypeFirstRow   ST_TblStyleOverrideType = 2
	ST_TblStyleOverrideTypeLastRow    ST_TblStyleOverrideType = 3
	ST_TblStyleOverrideTypeFirstCol   ST_TblStyleOverrideType = 4
	ST_TblStyleOverrideTypeLastCol    ST_TblStyleOverrideType = 5
	ST_TblStyleOverrideTypeBand1Vert  ST_TblStyleOverrideType = 6
	ST_TblStyleOverrideTypeBand2Vert  ST_TblStyleOverrideType = 7
	ST_TblStyleOverrideTypeBand1Horz  ST_TblStyleOverrideType = 8
	ST_TblStyleOverrideTypeBand2Horz  ST_TblStyleOverrideType = 9
	ST_TblStyleOverrideTypeNeCell     ST_TblStyleOverrideType = 10
	ST_TblStyleOverrideTypeNwCell     ST_TblStyleOverrideType = 11
	ST_TblStyleOverrideTypeSeCell     ST_TblStyleOverrideType = 12
	ST_TblStyleOverrideTypeSwCell     ST_TblStyleOverrideType = 13
)

func (ST_TblStyleOverrideType) MarshalXML ¶ 

func (m ST_TblStyleOverrideType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TblStyleOverrideType) MarshalXMLAttr ¶ 

func (e ST_TblStyleOverrideType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TblStyleOverrideType) String ¶ 

func (m ST_TblStyleOverrideType) String() string

func (*ST_TblStyleOverrideType) UnmarshalXML ¶ 

func (m *ST_TblStyleOverrideType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TblStyleOverrideType) UnmarshalXMLAttr ¶ 

func (e *ST_TblStyleOverrideType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TblStyleOverrideType) Validate ¶ 

func (m ST_TblStyleOverrideType) Validate() error

func (ST_TblStyleOverrideType) ValidateWithPath ¶ 

func (m ST_TblStyleOverrideType) ValidateWithPath(path string) error

type ST_TblWidth ¶ 

type ST_TblWidth byte
const (
	ST_TblWidthUnset ST_TblWidth = 0
	ST_TblWidthNil   ST_TblWidth = 1
	ST_TblWidthPct   ST_TblWidth = 2
	ST_TblWidthDxa   ST_TblWidth = 3
	ST_TblWidthAuto  ST_TblWidth = 4
)

func (ST_TblWidth) MarshalXML ¶ 

func (m ST_TblWidth) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TblWidth) MarshalXMLAttr ¶ 

func (e ST_TblWidth) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TblWidth) String ¶ 

func (m ST_TblWidth) String() string

func (*ST_TblWidth) UnmarshalXML ¶ 

func (m *ST_TblWidth) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TblWidth) UnmarshalXMLAttr ¶ 

func (e *ST_TblWidth) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TblWidth) Validate ¶ 

func (m ST_TblWidth) Validate() error

func (ST_TblWidth) ValidateWithPath ¶ 

func (m ST_TblWidth) ValidateWithPath(path string) error

type ST_TextAlignment ¶ 

type ST_TextAlignment byte
const (
	ST_TextAlignmentUnset    ST_TextAlignment = 0
	ST_TextAlignmentTop      ST_TextAlignment = 1
	ST_TextAlignmentCenter   ST_TextAlignment = 2
	ST_TextAlignmentBaseline ST_TextAlignment = 3
	ST_TextAlignmentBottom   ST_TextAlignment = 4
	ST_TextAlignmentAuto     ST_TextAlignment = 5
)

func (ST_TextAlignment) MarshalXML ¶ 

func (m ST_TextAlignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TextAlignment) MarshalXMLAttr ¶ 

func (e ST_TextAlignment) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TextAlignment) String ¶ 

func (m ST_TextAlignment) String() string

func (*ST_TextAlignment) UnmarshalXML ¶ 

func (m *ST_TextAlignment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TextAlignment) UnmarshalXMLAttr ¶ 

func (e *ST_TextAlignment) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TextAlignment) Validate ¶ 

func (m ST_TextAlignment) Validate() error

func (ST_TextAlignment) ValidateWithPath ¶ 

func (m ST_TextAlignment) ValidateWithPath(path string) error

type ST_TextDirection ¶ 

type ST_TextDirection byte
const (
	ST_TextDirectionUnset ST_TextDirection = 0
	ST_TextDirectionTb    ST_TextDirection = 1
	ST_TextDirectionRl    ST_TextDirection = 2
	ST_TextDirectionLr    ST_TextDirection = 3
	ST_TextDirectionTbV   ST_TextDirection = 4
	ST_TextDirectionRlV   ST_TextDirection = 5
	ST_TextDirectionLrV   ST_TextDirection = 6
	ST_TextDirectionBtLr  ST_TextDirection = 7
	ST_TextDirectionLrTb  ST_TextDirection = 8
	ST_TextDirectionLrTbV ST_TextDirection = 9
	ST_TextDirectionTbLrV ST_TextDirection = 10
	ST_TextDirectionTbRl  ST_TextDirection = 11
	ST_TextDirectionTbRlV ST_TextDirection = 12
)

func (ST_TextDirection) MarshalXML ¶ 

func (m ST_TextDirection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TextDirection) MarshalXMLAttr ¶ 

func (e ST_TextDirection) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TextDirection) String ¶ 

func (m ST_TextDirection) String() string

func (*ST_TextDirection) UnmarshalXML ¶ 

func (m *ST_TextDirection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TextDirection) UnmarshalXMLAttr ¶ 

func (e *ST_TextDirection) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TextDirection) Validate ¶ 

func (m ST_TextDirection) Validate() error

func (ST_TextDirection) ValidateWithPath ¶ 

func (m ST_TextDirection) ValidateWithPath(path string) error

type ST_TextEffect ¶ 

type ST_TextEffect byte
const (
	ST_TextEffectUnset           ST_TextEffect = 0
	ST_TextEffectBlinkBackground ST_TextEffect = 1
	ST_TextEffectLights          ST_TextEffect = 2
	ST_TextEffectAntsBlack       ST_TextEffect = 3
	ST_TextEffectAntsRed         ST_TextEffect = 4
	ST_TextEffectShimmer         ST_TextEffect = 5
	ST_TextEffectSparkle         ST_TextEffect = 6
	ST_TextEffectNone            ST_TextEffect = 7
)

func (ST_TextEffect) MarshalXML ¶ 

func (m ST_TextEffect) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TextEffect) MarshalXMLAttr ¶ 

func (e ST_TextEffect) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TextEffect) String ¶ 

func (m ST_TextEffect) String() string

func (*ST_TextEffect) UnmarshalXML ¶ 

func (m *ST_TextEffect) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TextEffect) UnmarshalXMLAttr ¶ 

func (e *ST_TextEffect) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TextEffect) Validate ¶ 

func (m ST_TextEffect) Validate() error

func (ST_TextEffect) ValidateWithPath ¶ 

func (m ST_TextEffect) ValidateWithPath(path string) error

type ST_TextScale ¶ 

type ST_TextScale struct {
	ST_TextScalePercent *string
	ST_TextScaleDecimal *int64
}

ST_TextScale is a union type

func ParseUnionST_TextScale ¶ 

func ParseUnionST_TextScale(s string) (ST_TextScale, error)

func (ST_TextScale) MarshalXML ¶ 

func (m ST_TextScale) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TextScale) String ¶ 

func (m ST_TextScale) String() string

func (*ST_TextScale) Validate ¶ 

func (m *ST_TextScale) Validate() error

func (*ST_TextScale) ValidateWithPath ¶ 

func (m *ST_TextScale) ValidateWithPath(path string) error

type ST_TextboxTightWrap ¶ 

type ST_TextboxTightWrap byte
const (
	ST_TextboxTightWrapUnset            ST_TextboxTightWrap = 0
	ST_TextboxTightWrapNone             ST_TextboxTightWrap = 1
	ST_TextboxTightWrapAllLines         ST_TextboxTightWrap = 2
	ST_TextboxTightWrapFirstAndLastLine ST_TextboxTightWrap = 3
	ST_TextboxTightWrapFirstLineOnly    ST_TextboxTightWrap = 4
	ST_TextboxTightWrapLastLineOnly     ST_TextboxTightWrap = 5
)

func (ST_TextboxTightWrap) MarshalXML ¶ 

func (m ST_TextboxTightWrap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TextboxTightWrap) MarshalXMLAttr ¶ 

func (e ST_TextboxTightWrap) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TextboxTightWrap) String ¶ 

func (m ST_TextboxTightWrap) String() string

func (*ST_TextboxTightWrap) UnmarshalXML ¶ 

func (m *ST_TextboxTightWrap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TextboxTightWrap) UnmarshalXMLAttr ¶ 

func (e *ST_TextboxTightWrap) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TextboxTightWrap) Validate ¶ 

func (m ST_TextboxTightWrap) Validate() error

func (ST_TextboxTightWrap) ValidateWithPath ¶ 

func (m ST_TextboxTightWrap) ValidateWithPath(path string) error

type ST_Theme ¶ 

type ST_Theme byte
const (
	ST_ThemeUnset         ST_Theme = 0
	ST_ThemeMajorEastAsia ST_Theme = 1
	ST_ThemeMajorBidi     ST_Theme = 2
	ST_ThemeMajorAscii    ST_Theme = 3
	ST_ThemeMajorHAnsi    ST_Theme = 4
	ST_ThemeMinorEastAsia ST_Theme = 5
	ST_ThemeMinorBidi     ST_Theme = 6
	ST_ThemeMinorAscii    ST_Theme = 7
	ST_ThemeMinorHAnsi    ST_Theme = 8
)

func (ST_Theme) MarshalXML ¶ 

func (m ST_Theme) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Theme) MarshalXMLAttr ¶ 

func (e ST_Theme) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Theme) String ¶ 

func (m ST_Theme) String() string

func (*ST_Theme) UnmarshalXML ¶ 

func (m *ST_Theme) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Theme) UnmarshalXMLAttr ¶ 

func (e *ST_Theme) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Theme) Validate ¶ 

func (m ST_Theme) Validate() error

func (ST_Theme) ValidateWithPath ¶ 

func (m ST_Theme) ValidateWithPath(path string) error

type ST_ThemeColor ¶ 

type ST_ThemeColor byte
const (
	ST_ThemeColorUnset             ST_ThemeColor = 0
	ST_ThemeColorDark1             ST_ThemeColor = 1
	ST_ThemeColorLight1            ST_ThemeColor = 2
	ST_ThemeColorDark2             ST_ThemeColor = 3
	ST_ThemeColorLight2            ST_ThemeColor = 4
	ST_ThemeColorAccent1           ST_ThemeColor = 5
	ST_ThemeColorAccent2           ST_ThemeColor = 6
	ST_ThemeColorAccent3           ST_ThemeColor = 7
	ST_ThemeColorAccent4           ST_ThemeColor = 8
	ST_ThemeColorAccent5           ST_ThemeColor = 9
	ST_ThemeColorAccent6           ST_ThemeColor = 10
	ST_ThemeColorHyperlink         ST_ThemeColor = 11
	ST_ThemeColorFollowedHyperlink ST_ThemeColor = 12
	ST_ThemeColorNone              ST_ThemeColor = 13
	ST_ThemeColorBackground1       ST_ThemeColor = 14
	ST_ThemeColorText1             ST_ThemeColor = 15
	ST_ThemeColorBackground2       ST_ThemeColor = 16
	ST_ThemeColorText2             ST_ThemeColor = 17
)

func (ST_ThemeColor) MarshalXML ¶ 

func (m ST_ThemeColor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ThemeColor) MarshalXMLAttr ¶ 

func (e ST_ThemeColor) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ThemeColor) String ¶ 

func (m ST_ThemeColor) String() string

func (*ST_ThemeColor) UnmarshalXML ¶ 

func (m *ST_ThemeColor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ThemeColor) UnmarshalXMLAttr ¶ 

func (e *ST_ThemeColor) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ThemeColor) Validate ¶ 

func (m ST_ThemeColor) Validate() error

func (ST_ThemeColor) ValidateWithPath ¶ 

func (m ST_ThemeColor) ValidateWithPath(path string) error

type ST_Underline ¶ 

type ST_Underline byte
const (
	ST_UnderlineUnset           ST_Underline = 0
	ST_UnderlineSingle          ST_Underline = 1
	ST_UnderlineWords           ST_Underline = 2
	ST_UnderlineDouble          ST_Underline = 3
	ST_UnderlineThick           ST_Underline = 4
	ST_UnderlineDotted          ST_Underline = 5
	ST_UnderlineDottedHeavy     ST_Underline = 6
	ST_UnderlineDash            ST_Underline = 7
	ST_UnderlineDashedHeavy     ST_Underline = 8
	ST_UnderlineDashLong        ST_Underline = 9
	ST_UnderlineDashLongHeavy   ST_Underline = 10
	ST_UnderlineDotDash         ST_Underline = 11
	ST_UnderlineDashDotHeavy    ST_Underline = 12
	ST_UnderlineDotDotDash      ST_Underline = 13
	ST_UnderlineDashDotDotHeavy ST_Underline = 14
	ST_UnderlineWave            ST_Underline = 15
	ST_UnderlineWavyHeavy       ST_Underline = 16
	ST_UnderlineWavyDouble      ST_Underline = 17
	ST_UnderlineNone            ST_Underline = 18
)

func (ST_Underline) MarshalXML ¶ 

func (m ST_Underline) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Underline) MarshalXMLAttr ¶ 

func (e ST_Underline) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Underline) String ¶ 

func (m ST_Underline) String() string

func (*ST_Underline) UnmarshalXML ¶ 

func (m *ST_Underline) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Underline) UnmarshalXMLAttr ¶ 

func (e *ST_Underline) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Underline) Validate ¶ 

func (m ST_Underline) Validate() error

func (ST_Underline) ValidateWithPath ¶ 

func (m ST_Underline) ValidateWithPath(path string) error

type ST_VAnchor ¶ 

type ST_VAnchor byte
const (
	ST_VAnchorUnset  ST_VAnchor = 0
	ST_VAnchorText   ST_VAnchor = 1
	ST_VAnchorMargin ST_VAnchor = 2
	ST_VAnchorPage   ST_VAnchor = 3
)

func (ST_VAnchor) MarshalXML ¶ 

func (m ST_VAnchor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_VAnchor) MarshalXMLAttr ¶ 

func (e ST_VAnchor) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_VAnchor) String ¶ 

func (m ST_VAnchor) String() string

func (*ST_VAnchor) UnmarshalXML ¶ 

func (m *ST_VAnchor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_VAnchor) UnmarshalXMLAttr ¶ 

func (e *ST_VAnchor) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_VAnchor) Validate ¶ 

func (m ST_VAnchor) Validate() error

func (ST_VAnchor) ValidateWithPath ¶ 

func (m ST_VAnchor) ValidateWithPath(path string) error

type ST_VerticalJc ¶ 

type ST_VerticalJc byte
const (
	ST_VerticalJcUnset  ST_VerticalJc = 0
	ST_VerticalJcTop    ST_VerticalJc = 1
	ST_VerticalJcCenter ST_VerticalJc = 2
	ST_VerticalJcBoth   ST_VerticalJc = 3
	ST_VerticalJcBottom ST_VerticalJc = 4
)

func (ST_VerticalJc) MarshalXML ¶ 

func (m ST_VerticalJc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_VerticalJc) MarshalXMLAttr ¶ 

func (e ST_VerticalJc) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_VerticalJc) String ¶ 

func (m ST_VerticalJc) String() string

func (*ST_VerticalJc) UnmarshalXML ¶ 

func (m *ST_VerticalJc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_VerticalJc) UnmarshalXMLAttr ¶ 

func (e *ST_VerticalJc) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_VerticalJc) Validate ¶ 

func (m ST_VerticalJc) Validate() error

func (ST_VerticalJc) ValidateWithPath ¶ 

func (m ST_VerticalJc) ValidateWithPath(path string) error

type ST_View ¶ 

type ST_View byte
const (
	ST_ViewUnset       ST_View = 0
	ST_ViewNone        ST_View = 1
	ST_ViewPrint       ST_View = 2
	ST_ViewOutline     ST_View = 3
	ST_ViewMasterPages ST_View = 4
	ST_ViewNormal      ST_View = 5
	ST_ViewWeb         ST_View = 6
)

func (ST_View) MarshalXML ¶ 

func (m ST_View) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_View) MarshalXMLAttr ¶ 

func (e ST_View) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_View) String ¶ 

func (m ST_View) String() string

func (*ST_View) UnmarshalXML ¶ 

func (m *ST_View) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_View) UnmarshalXMLAttr ¶ 

func (e *ST_View) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_View) Validate ¶ 

func (m ST_View) Validate() error

func (ST_View) ValidateWithPath ¶ 

func (m ST_View) ValidateWithPath(path string) error

type ST_WmlColorSchemeIndex ¶ 

type ST_WmlColorSchemeIndex byte
const (
	ST_WmlColorSchemeIndexUnset             ST_WmlColorSchemeIndex = 0
	ST_WmlColorSchemeIndexDark1             ST_WmlColorSchemeIndex = 1
	ST_WmlColorSchemeIndexLight1            ST_WmlColorSchemeIndex = 2
	ST_WmlColorSchemeIndexDark2             ST_WmlColorSchemeIndex = 3
	ST_WmlColorSchemeIndexLight2            ST_WmlColorSchemeIndex = 4
	ST_WmlColorSchemeIndexAccent1           ST_WmlColorSchemeIndex = 5
	ST_WmlColorSchemeIndexAccent2           ST_WmlColorSchemeIndex = 6
	ST_WmlColorSchemeIndexAccent3           ST_WmlColorSchemeIndex = 7
	ST_WmlColorSchemeIndexAccent4           ST_WmlColorSchemeIndex = 8
	ST_WmlColorSchemeIndexAccent5           ST_WmlColorSchemeIndex = 9
	ST_WmlColorSchemeIndexAccent6           ST_WmlColorSchemeIndex = 10
	ST_WmlColorSchemeIndexHyperlink         ST_WmlColorSchemeIndex = 11
	ST_WmlColorSchemeIndexFollowedHyperlink ST_WmlColorSchemeIndex = 12
)

func (ST_WmlColorSchemeIndex) MarshalXML ¶ 

func (m ST_WmlColorSchemeIndex) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_WmlColorSchemeIndex) MarshalXMLAttr ¶ 

func (e ST_WmlColorSchemeIndex) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_WmlColorSchemeIndex) String ¶ 

func (m ST_WmlColorSchemeIndex) String() string

func (*ST_WmlColorSchemeIndex) UnmarshalXML ¶ 

func (m *ST_WmlColorSchemeIndex) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_WmlColorSchemeIndex) UnmarshalXMLAttr ¶ 

func (e *ST_WmlColorSchemeIndex) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_WmlColorSchemeIndex) Validate ¶ 

func (m ST_WmlColorSchemeIndex) Validate() error

func (ST_WmlColorSchemeIndex) ValidateWithPath ¶ 

func (m ST_WmlColorSchemeIndex) ValidateWithPath(path string) error

type ST_Wrap ¶ 

type ST_Wrap byte
const (
	ST_WrapUnset     ST_Wrap = 0
	ST_WrapAuto      ST_Wrap = 1
	ST_WrapNotBeside ST_Wrap = 2
	ST_WrapAround    ST_Wrap = 3
	ST_WrapTight     ST_Wrap = 4
	ST_WrapThrough   ST_Wrap = 5
	ST_WrapNone      ST_Wrap = 6
)

func (ST_Wrap) MarshalXML ¶ 

func (m ST_Wrap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Wrap) MarshalXMLAttr ¶ 

func (e ST_Wrap) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Wrap) String ¶ 

func (m ST_Wrap) String() string

func (*ST_Wrap) UnmarshalXML ¶ 

func (m *ST_Wrap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Wrap) UnmarshalXMLAttr ¶ 

func (e *ST_Wrap) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Wrap) Validate ¶ 

func (m ST_Wrap) Validate() error

func (ST_Wrap) ValidateWithPath ¶ 

func (m ST_Wrap) ValidateWithPath(path string) error

type ST_Zoom ¶ 

type ST_Zoom byte
const (
	ST_ZoomUnset    ST_Zoom = 0
	ST_ZoomNone     ST_Zoom = 1
	ST_ZoomFullPage ST_Zoom = 2
	ST_ZoomBestFit  ST_Zoom = 3
	ST_ZoomTextFit  ST_Zoom = 4
)

func (ST_Zoom) MarshalXML ¶ 

func (m ST_Zoom) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Zoom) MarshalXMLAttr ¶ 

func (e ST_Zoom) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Zoom) String ¶ 

func (m ST_Zoom) String() string

func (*ST_Zoom) UnmarshalXML ¶ 

func (m *ST_Zoom) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Zoom) UnmarshalXMLAttr ¶ 

func (e *ST_Zoom) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Zoom) Validate ¶ 

func (m ST_Zoom) Validate() error

func (ST_Zoom) ValidateWithPath ¶ 

func (m ST_Zoom) ValidateWithPath(path string) error

type Settings ¶ 

type Settings struct {
	CT_Settings
}

func NewSettings ¶ 

func NewSettings() *Settings

func (*Settings) MarshalXML ¶ 

func (m *Settings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Settings) UnmarshalXML ¶ 

func (m *Settings) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Settings) Validate ¶ 

func (m *Settings) Validate() error

Validate validates the Settings and its children

func (*Settings) ValidateWithPath ¶ 

func (m *Settings) ValidateWithPath(path string) error

ValidateWithPath validates the Settings and its children, prefixing error messages with path

type Styles ¶ 

type Styles struct {
	CT_Styles
}

func NewStyles ¶ 

func NewStyles() *Styles

func (*Styles) MarshalXML ¶ 

func (m *Styles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Styles) UnmarshalXML ¶ 

func (m *Styles) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Styles) Validate ¶ 

func (m *Styles) Validate() error

Validate validates the Styles and its children

func (*Styles) ValidateWithPath ¶ 

func (m *Styles) ValidateWithPath(path string) error

ValidateWithPath validates the Styles and its children, prefixing error messages with path

type TxbxContent ¶ 

type TxbxContent struct {
	CT_TxbxContent
}

func NewTxbxContent ¶ 

func NewTxbxContent() *TxbxContent

func (*TxbxContent) MarshalXML ¶ 

func (m *TxbxContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*TxbxContent) UnmarshalXML ¶ 

func (m *TxbxContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*TxbxContent) Validate ¶ 

func (m *TxbxContent) Validate() error

Validate validates the TxbxContent and its children

func (*TxbxContent) ValidateWithPath ¶ 

func (m *TxbxContent) ValidateWithPath(path string) error

ValidateWithPath validates the TxbxContent and its children, prefixing error messages with path

type WdAnchor ¶ 

type WdAnchor struct {
	WdCT_Anchor
}

func NewWdAnchor ¶ 

func NewWdAnchor() *WdAnchor

func (*WdAnchor) MarshalXML ¶ 

func (m *WdAnchor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdAnchor) UnmarshalXML ¶ 

func (m *WdAnchor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdAnchor) Validate ¶ 

func (m *WdAnchor) Validate() error

Validate validates the WdAnchor and its children

func (*WdAnchor) ValidateWithPath ¶ 

func (m *WdAnchor) ValidateWithPath(path string) error

ValidateWithPath validates the WdAnchor and its children, prefixing error messages with path

type WdCT_Anchor ¶ 

type WdCT_Anchor struct {
	DistTAttr          *uint32
	DistBAttr          *uint32
	DistLAttr          *uint32
	DistRAttr          *uint32
	SimplePosAttr      *bool
	RelativeHeightAttr uint32
	BehindDocAttr      bool
	LockedAttr         bool
	LayoutInCellAttr   bool
	HiddenAttr         *bool
	AllowOverlapAttr   bool
	SimplePos          *dml.CT_Point2D
	PositionH          *WdCT_PosH
	PositionV          *WdCT_PosV
	Extent             *dml.CT_PositiveSize2D
	EffectExtent       *WdCT_EffectExtent
	Choice             *WdEG_WrapTypeChoice
	DocPr              *dml.CT_NonVisualDrawingProps
	CNvGraphicFramePr  *dml.CT_NonVisualGraphicFrameProperties
	Graphic            *dml.Graphic
}

func NewWdCT_Anchor ¶ 

func NewWdCT_Anchor() *WdCT_Anchor

func (*WdCT_Anchor) MarshalXML ¶ 

func (m *WdCT_Anchor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_Anchor) UnmarshalXML ¶ 

func (m *WdCT_Anchor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_Anchor) Validate ¶ 

func (m *WdCT_Anchor) Validate() error

Validate validates the WdCT_Anchor and its children

func (*WdCT_Anchor) ValidateWithPath ¶ 

func (m *WdCT_Anchor) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_Anchor and its children, prefixing error messages with path

type WdCT_EffectExtent ¶ 

type WdCT_EffectExtent struct {
	LAttr dml.ST_Coordinate
	TAttr dml.ST_Coordinate
	RAttr dml.ST_Coordinate
	BAttr dml.ST_Coordinate
}

func NewWdCT_EffectExtent ¶ 

func NewWdCT_EffectExtent() *WdCT_EffectExtent

func (*WdCT_EffectExtent) MarshalXML ¶ 

func (m *WdCT_EffectExtent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_EffectExtent) UnmarshalXML ¶ 

func (m *WdCT_EffectExtent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_EffectExtent) Validate ¶ 

func (m *WdCT_EffectExtent) Validate() error

Validate validates the WdCT_EffectExtent and its children

func (*WdCT_EffectExtent) ValidateWithPath ¶ 

func (m *WdCT_EffectExtent) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_EffectExtent and its children, prefixing error messages with path

type WdCT_GraphicFrame ¶ 

type WdCT_GraphicFrame struct {
	CNvPr   *dml.CT_NonVisualDrawingProps
	CNvFrPr *dml.CT_NonVisualGraphicFrameProperties
	Xfrm    *dml.CT_Transform2D
	Graphic *dml.Graphic
	ExtLst  *dml.CT_OfficeArtExtensionList
}

func NewWdCT_GraphicFrame ¶ 

func NewWdCT_GraphicFrame() *WdCT_GraphicFrame

func (*WdCT_GraphicFrame) MarshalXML ¶ 

func (m *WdCT_GraphicFrame) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_GraphicFrame) UnmarshalXML ¶ 

func (m *WdCT_GraphicFrame) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_GraphicFrame) Validate ¶ 

func (m *WdCT_GraphicFrame) Validate() error

Validate validates the WdCT_GraphicFrame and its children

func (*WdCT_GraphicFrame) ValidateWithPath ¶ 

func (m *WdCT_GraphicFrame) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_GraphicFrame and its children, prefixing error messages with path

type WdCT_Inline ¶ 

type WdCT_Inline struct {
	DistTAttr         *uint32
	DistBAttr         *uint32
	DistLAttr         *uint32
	DistRAttr         *uint32
	Extent            *dml.CT_PositiveSize2D
	EffectExtent      *WdCT_EffectExtent
	DocPr             *dml.CT_NonVisualDrawingProps
	CNvGraphicFramePr *dml.CT_NonVisualGraphicFrameProperties
	Graphic           *dml.Graphic
}

func NewWdCT_Inline ¶ 

func NewWdCT_Inline() *WdCT_Inline

func (*WdCT_Inline) MarshalXML ¶ 

func (m *WdCT_Inline) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_Inline) UnmarshalXML ¶ 

func (m *WdCT_Inline) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_Inline) Validate ¶ 

func (m *WdCT_Inline) Validate() error

Validate validates the WdCT_Inline and its children

func (*WdCT_Inline) ValidateWithPath ¶ 

func (m *WdCT_Inline) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_Inline and its children, prefixing error messages with path

type WdCT_LinkedTextboxInformation ¶ 

type WdCT_LinkedTextboxInformation struct {
	IdAttr  uint16
	SeqAttr uint16
	ExtLst  *dml.CT_OfficeArtExtensionList
}

func NewWdCT_LinkedTextboxInformation ¶ 

func NewWdCT_LinkedTextboxInformation() *WdCT_LinkedTextboxInformation

func (*WdCT_LinkedTextboxInformation) MarshalXML ¶ 

func (m *WdCT_LinkedTextboxInformation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_LinkedTextboxInformation) UnmarshalXML ¶ 

func (m *WdCT_LinkedTextboxInformation) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_LinkedTextboxInformation) Validate ¶ 

func (m *WdCT_LinkedTextboxInformation) Validate() error

Validate validates the WdCT_LinkedTextboxInformation and its children

func (*WdCT_LinkedTextboxInformation) ValidateWithPath ¶ 

func (m *WdCT_LinkedTextboxInformation) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_LinkedTextboxInformation and its children, prefixing error messages with path

type WdCT_PosH ¶ 

type WdCT_PosH struct {
	RelativeFromAttr WdST_RelFromH
	Choice           *WdCT_PosHChoice
}

func NewWdCT_PosH ¶ 

func NewWdCT_PosH() *WdCT_PosH

func (*WdCT_PosH) MarshalXML ¶ 

func (m *WdCT_PosH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_PosH) UnmarshalXML ¶ 

func (m *WdCT_PosH) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_PosH) Validate ¶ 

func (m *WdCT_PosH) Validate() error

Validate validates the WdCT_PosH and its children

func (*WdCT_PosH) ValidateWithPath ¶ 

func (m *WdCT_PosH) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_PosH and its children, prefixing error messages with path

type WdCT_PosHChoice ¶ 

type WdCT_PosHChoice struct {
	Align     WdST_AlignH
	PosOffset *int32
}

func NewWdCT_PosHChoice ¶ 

func NewWdCT_PosHChoice() *WdCT_PosHChoice

func (*WdCT_PosHChoice) MarshalXML ¶ 

func (m *WdCT_PosHChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_PosHChoice) UnmarshalXML ¶ 

func (m *WdCT_PosHChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_PosHChoice) Validate ¶ 

func (m *WdCT_PosHChoice) Validate() error

Validate validates the WdCT_PosHChoice and its children

func (*WdCT_PosHChoice) ValidateWithPath ¶ 

func (m *WdCT_PosHChoice) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_PosHChoice and its children, prefixing error messages with path

type WdCT_PosV ¶ 

type WdCT_PosV struct {
	RelativeFromAttr WdST_RelFromV
	Choice           *WdCT_PosVChoice
}

func NewWdCT_PosV ¶ 

func NewWdCT_PosV() *WdCT_PosV

func (*WdCT_PosV) MarshalXML ¶ 

func (m *WdCT_PosV) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_PosV) UnmarshalXML ¶ 

func (m *WdCT_PosV) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_PosV) Validate ¶ 

func (m *WdCT_PosV) Validate() error

Validate validates the WdCT_PosV and its children

func (*WdCT_PosV) ValidateWithPath ¶ 

func (m *WdCT_PosV) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_PosV and its children, prefixing error messages with path

type WdCT_PosVChoice ¶ 

type WdCT_PosVChoice struct {
	Align     WdST_AlignV
	PosOffset *int32
}

func NewWdCT_PosVChoice ¶ 

func NewWdCT_PosVChoice() *WdCT_PosVChoice

func (*WdCT_PosVChoice) MarshalXML ¶ 

func (m *WdCT_PosVChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_PosVChoice) UnmarshalXML ¶ 

func (m *WdCT_PosVChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_PosVChoice) Validate ¶ 

func (m *WdCT_PosVChoice) Validate() error

Validate validates the WdCT_PosVChoice and its children

func (*WdCT_PosVChoice) ValidateWithPath ¶ 

func (m *WdCT_PosVChoice) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_PosVChoice and its children, prefixing error messages with path

type WdCT_TextboxInfo ¶ 

type WdCT_TextboxInfo struct {
	IdAttr      *uint16
	TxbxContent *WdCT_TxbxContent
	ExtLst      *dml.CT_OfficeArtExtensionList
}

func NewWdCT_TextboxInfo ¶ 

func NewWdCT_TextboxInfo() *WdCT_TextboxInfo

func (*WdCT_TextboxInfo) MarshalXML ¶ 

func (m *WdCT_TextboxInfo) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_TextboxInfo) UnmarshalXML ¶ 

func (m *WdCT_TextboxInfo) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_TextboxInfo) Validate ¶ 

func (m *WdCT_TextboxInfo) Validate() error

Validate validates the WdCT_TextboxInfo and its children

func (*WdCT_TextboxInfo) ValidateWithPath ¶ 

func (m *WdCT_TextboxInfo) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_TextboxInfo and its children, prefixing error messages with path

type WdCT_TxbxContent ¶ 

type WdCT_TxbxContent struct {
	// Anchor for Imported External Content
	AltChunk               []*CT_AltChunk
	EG_ContentBlockContent []*EG_ContentBlockContent
}

func NewWdCT_TxbxContent ¶ 

func NewWdCT_TxbxContent() *WdCT_TxbxContent

func (*WdCT_TxbxContent) MarshalXML ¶ 

func (m *WdCT_TxbxContent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_TxbxContent) UnmarshalXML ¶ 

func (m *WdCT_TxbxContent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_TxbxContent) Validate ¶ 

func (m *WdCT_TxbxContent) Validate() error

Validate validates the WdCT_TxbxContent and its children

func (*WdCT_TxbxContent) ValidateWithPath ¶ 

func (m *WdCT_TxbxContent) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_TxbxContent and its children, prefixing error messages with path

type WdCT_WordprocessingCanvas ¶ 

type WdCT_WordprocessingCanvas struct {
	Bg     *dml.CT_BackgroundFormatting
	Whole  *dml.CT_WholeE2oFormatting
	Choice []*WdCT_WordprocessingCanvasChoice
	ExtLst *dml.CT_OfficeArtExtensionList
}

func NewWdCT_WordprocessingCanvas ¶ 

func NewWdCT_WordprocessingCanvas() *WdCT_WordprocessingCanvas

func (*WdCT_WordprocessingCanvas) MarshalXML ¶ 

func (m *WdCT_WordprocessingCanvas) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingCanvas) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingCanvas) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingCanvas) Validate ¶ 

func (m *WdCT_WordprocessingCanvas) Validate() error

Validate validates the WdCT_WordprocessingCanvas and its children

func (*WdCT_WordprocessingCanvas) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingCanvas) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingCanvas and its children, prefixing error messages with path

type WdCT_WordprocessingCanvasChoice ¶ 

type WdCT_WordprocessingCanvasChoice struct {
	Wsp          []*WdWsp
	Pic          []*picture.Pic
	ContentPart  []*WdCT_WordprocessingContentPart
	Wgp          []*WdWgp
	GraphicFrame []*WdCT_GraphicFrame
}

func NewWdCT_WordprocessingCanvasChoice ¶ 

func NewWdCT_WordprocessingCanvasChoice() *WdCT_WordprocessingCanvasChoice

func (*WdCT_WordprocessingCanvasChoice) MarshalXML ¶ 

func (m *WdCT_WordprocessingCanvasChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingCanvasChoice) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingCanvasChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingCanvasChoice) Validate ¶ 

func (m *WdCT_WordprocessingCanvasChoice) Validate() error

Validate validates the WdCT_WordprocessingCanvasChoice and its children

func (*WdCT_WordprocessingCanvasChoice) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingCanvasChoice) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingCanvasChoice and its children, prefixing error messages with path

type WdCT_WordprocessingContentPart ¶ 

type WdCT_WordprocessingContentPart struct {
	BwModeAttr      dml.ST_BlackWhiteMode
	IdAttr          string
	NvContentPartPr *WdCT_WordprocessingContentPartNonVisual
	Xfrm            *dml.CT_Transform2D
	ExtLst          *dml.CT_OfficeArtExtensionList
}

func NewWdCT_WordprocessingContentPart ¶ 

func NewWdCT_WordprocessingContentPart() *WdCT_WordprocessingContentPart

func (*WdCT_WordprocessingContentPart) MarshalXML ¶ 

func (m *WdCT_WordprocessingContentPart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingContentPart) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingContentPart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingContentPart) Validate ¶ 

func (m *WdCT_WordprocessingContentPart) Validate() error

Validate validates the WdCT_WordprocessingContentPart and its children

func (*WdCT_WordprocessingContentPart) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingContentPart) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingContentPart and its children, prefixing error messages with path

type WdCT_WordprocessingContentPartNonVisual ¶ 

type WdCT_WordprocessingContentPartNonVisual struct {
	CNvPr            *dml.CT_NonVisualDrawingProps
	CNvContentPartPr *dml.CT_NonVisualContentPartProperties
}

func NewWdCT_WordprocessingContentPartNonVisual ¶ 

func NewWdCT_WordprocessingContentPartNonVisual() *WdCT_WordprocessingContentPartNonVisual

func (*WdCT_WordprocessingContentPartNonVisual) MarshalXML ¶ 

func (m *WdCT_WordprocessingContentPartNonVisual) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingContentPartNonVisual) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingContentPartNonVisual) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingContentPartNonVisual) Validate ¶ 

func (m *WdCT_WordprocessingContentPartNonVisual) Validate() error

Validate validates the WdCT_WordprocessingContentPartNonVisual and its children

func (*WdCT_WordprocessingContentPartNonVisual) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingContentPartNonVisual) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingContentPartNonVisual and its children, prefixing error messages with path

type WdCT_WordprocessingGroup ¶ 

type WdCT_WordprocessingGroup struct {
	CNvPr      *dml.CT_NonVisualDrawingProps
	CNvGrpSpPr *dml.CT_NonVisualGroupDrawingShapeProps
	GrpSpPr    *dml.CT_GroupShapeProperties
	Choice     []*WdCT_WordprocessingGroupChoice
	ExtLst     *dml.CT_OfficeArtExtensionList
}

func NewWdCT_WordprocessingGroup ¶ 

func NewWdCT_WordprocessingGroup() *WdCT_WordprocessingGroup

func (*WdCT_WordprocessingGroup) MarshalXML ¶ 

func (m *WdCT_WordprocessingGroup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingGroup) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingGroup) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingGroup) Validate ¶ 

func (m *WdCT_WordprocessingGroup) Validate() error

Validate validates the WdCT_WordprocessingGroup and its children

func (*WdCT_WordprocessingGroup) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingGroup) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingGroup and its children, prefixing error messages with path

type WdCT_WordprocessingGroupChoice ¶ 

type WdCT_WordprocessingGroupChoice struct {
	Wsp          []*WdWsp
	GrpSp        []*WdCT_WordprocessingGroup
	GraphicFrame []*WdCT_GraphicFrame
	Pic          []*picture.Pic
	ContentPart  []*WdCT_WordprocessingContentPart
}

func NewWdCT_WordprocessingGroupChoice ¶ 

func NewWdCT_WordprocessingGroupChoice() *WdCT_WordprocessingGroupChoice

func (*WdCT_WordprocessingGroupChoice) MarshalXML ¶ 

func (m *WdCT_WordprocessingGroupChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingGroupChoice) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingGroupChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingGroupChoice) Validate ¶ 

func (m *WdCT_WordprocessingGroupChoice) Validate() error

Validate validates the WdCT_WordprocessingGroupChoice and its children

func (*WdCT_WordprocessingGroupChoice) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingGroupChoice) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingGroupChoice and its children, prefixing error messages with path

type WdCT_WordprocessingShape ¶ 

type WdCT_WordprocessingShape struct {
	NormalEastAsianFlowAttr *bool
	CNvPr                   *dml.CT_NonVisualDrawingProps
	Choice                  *WdCT_WordprocessingShapeChoice
	SpPr                    *dml.CT_ShapeProperties
	Style                   *dml.CT_ShapeStyle
	ExtLst                  *dml.CT_OfficeArtExtensionList
	WChoice                 *WdCT_WordprocessingShapeChoice1
	BodyPr                  *dml.CT_TextBodyProperties
}

func NewWdCT_WordprocessingShape ¶ 

func NewWdCT_WordprocessingShape() *WdCT_WordprocessingShape

func (*WdCT_WordprocessingShape) MarshalXML ¶ 

func (m *WdCT_WordprocessingShape) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingShape) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingShape) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingShape) Validate ¶ 

func (m *WdCT_WordprocessingShape) Validate() error

Validate validates the WdCT_WordprocessingShape and its children

func (*WdCT_WordprocessingShape) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingShape) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingShape and its children, prefixing error messages with path

type WdCT_WordprocessingShapeChoice ¶ 

type WdCT_WordprocessingShapeChoice struct {
	CNvSpPr *dml.CT_NonVisualDrawingShapeProps
	CNvCnPr *dml.CT_NonVisualConnectorProperties
}

func NewWdCT_WordprocessingShapeChoice ¶ 

func NewWdCT_WordprocessingShapeChoice() *WdCT_WordprocessingShapeChoice

func (*WdCT_WordprocessingShapeChoice) MarshalXML ¶ 

func (m *WdCT_WordprocessingShapeChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingShapeChoice) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingShapeChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingShapeChoice) Validate ¶ 

func (m *WdCT_WordprocessingShapeChoice) Validate() error

Validate validates the WdCT_WordprocessingShapeChoice and its children

func (*WdCT_WordprocessingShapeChoice) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingShapeChoice) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingShapeChoice and its children, prefixing error messages with path

type WdCT_WordprocessingShapeChoice1 ¶ 

type WdCT_WordprocessingShapeChoice1 struct {
	Txbx       *WdCT_TextboxInfo
	LinkedTxbx *WdCT_LinkedTextboxInformation
}

func NewWdCT_WordprocessingShapeChoice1 ¶ 

func NewWdCT_WordprocessingShapeChoice1() *WdCT_WordprocessingShapeChoice1

func (*WdCT_WordprocessingShapeChoice1) MarshalXML ¶ 

func (m *WdCT_WordprocessingShapeChoice1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WordprocessingShapeChoice1) UnmarshalXML ¶ 

func (m *WdCT_WordprocessingShapeChoice1) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WordprocessingShapeChoice1) Validate ¶ 

func (m *WdCT_WordprocessingShapeChoice1) Validate() error

Validate validates the WdCT_WordprocessingShapeChoice1 and its children

func (*WdCT_WordprocessingShapeChoice1) ValidateWithPath ¶ 

func (m *WdCT_WordprocessingShapeChoice1) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WordprocessingShapeChoice1 and its children, prefixing error messages with path

type WdCT_WrapNone ¶ 

type WdCT_WrapNone struct {
}

func NewWdCT_WrapNone ¶ 

func NewWdCT_WrapNone() *WdCT_WrapNone

func (*WdCT_WrapNone) MarshalXML ¶ 

func (m *WdCT_WrapNone) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WrapNone) UnmarshalXML ¶ 

func (m *WdCT_WrapNone) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WrapNone) Validate ¶ 

func (m *WdCT_WrapNone) Validate() error

Validate validates the WdCT_WrapNone and its children

func (*WdCT_WrapNone) ValidateWithPath ¶ 

func (m *WdCT_WrapNone) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WrapNone and its children, prefixing error messages with path

type WdCT_WrapPath ¶ 

type WdCT_WrapPath struct {
	EditedAttr *bool
	Start      *dml.CT_Point2D
	LineTo     []*dml.CT_Point2D
}

func NewWdCT_WrapPath ¶ 

func NewWdCT_WrapPath() *WdCT_WrapPath

func (*WdCT_WrapPath) MarshalXML ¶ 

func (m *WdCT_WrapPath) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WrapPath) UnmarshalXML ¶ 

func (m *WdCT_WrapPath) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WrapPath) Validate ¶ 

func (m *WdCT_WrapPath) Validate() error

Validate validates the WdCT_WrapPath and its children

func (*WdCT_WrapPath) ValidateWithPath ¶ 

func (m *WdCT_WrapPath) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WrapPath and its children, prefixing error messages with path

type WdCT_WrapSquare ¶ 

type WdCT_WrapSquare struct {
	WrapTextAttr WdST_WrapText
	DistTAttr    *uint32
	DistBAttr    *uint32
	DistLAttr    *uint32
	DistRAttr    *uint32
	EffectExtent *WdCT_EffectExtent
}

func NewWdCT_WrapSquare ¶ 

func NewWdCT_WrapSquare() *WdCT_WrapSquare

func (*WdCT_WrapSquare) MarshalXML ¶ 

func (m *WdCT_WrapSquare) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WrapSquare) UnmarshalXML ¶ 

func (m *WdCT_WrapSquare) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WrapSquare) Validate ¶ 

func (m *WdCT_WrapSquare) Validate() error

Validate validates the WdCT_WrapSquare and its children

func (*WdCT_WrapSquare) ValidateWithPath ¶ 

func (m *WdCT_WrapSquare) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WrapSquare and its children, prefixing error messages with path

type WdCT_WrapThrough ¶ 

type WdCT_WrapThrough struct {
	WrapTextAttr WdST_WrapText
	DistLAttr    *uint32
	DistRAttr    *uint32
	WrapPolygon  *WdCT_WrapPath
}

func NewWdCT_WrapThrough ¶ 

func NewWdCT_WrapThrough() *WdCT_WrapThrough

func (*WdCT_WrapThrough) MarshalXML ¶ 

func (m *WdCT_WrapThrough) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WrapThrough) UnmarshalXML ¶ 

func (m *WdCT_WrapThrough) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WrapThrough) Validate ¶ 

func (m *WdCT_WrapThrough) Validate() error

Validate validates the WdCT_WrapThrough and its children

func (*WdCT_WrapThrough) ValidateWithPath ¶ 

func (m *WdCT_WrapThrough) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WrapThrough and its children, prefixing error messages with path

type WdCT_WrapTight ¶ 

type WdCT_WrapTight struct {
	WrapTextAttr WdST_WrapText
	DistLAttr    *uint32
	DistRAttr    *uint32
	WrapPolygon  *WdCT_WrapPath
}

func NewWdCT_WrapTight ¶ 

func NewWdCT_WrapTight() *WdCT_WrapTight

func (*WdCT_WrapTight) MarshalXML ¶ 

func (m *WdCT_WrapTight) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WrapTight) UnmarshalXML ¶ 

func (m *WdCT_WrapTight) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WrapTight) Validate ¶ 

func (m *WdCT_WrapTight) Validate() error

Validate validates the WdCT_WrapTight and its children

func (*WdCT_WrapTight) ValidateWithPath ¶ 

func (m *WdCT_WrapTight) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WrapTight and its children, prefixing error messages with path

type WdCT_WrapTopBottom ¶ 

type WdCT_WrapTopBottom struct {
	DistTAttr    *uint32
	DistBAttr    *uint32
	EffectExtent *WdCT_EffectExtent
}

func NewWdCT_WrapTopBottom ¶ 

func NewWdCT_WrapTopBottom() *WdCT_WrapTopBottom

func (*WdCT_WrapTopBottom) MarshalXML ¶ 

func (m *WdCT_WrapTopBottom) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdCT_WrapTopBottom) UnmarshalXML ¶ 

func (m *WdCT_WrapTopBottom) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdCT_WrapTopBottom) Validate ¶ 

func (m *WdCT_WrapTopBottom) Validate() error

Validate validates the WdCT_WrapTopBottom and its children

func (*WdCT_WrapTopBottom) ValidateWithPath ¶ 

func (m *WdCT_WrapTopBottom) ValidateWithPath(path string) error

ValidateWithPath validates the WdCT_WrapTopBottom and its children, prefixing error messages with path

type WdEG_WrapType ¶ 

type WdEG_WrapType struct {
	Choice *WdEG_WrapTypeChoice
}

func NewWdEG_WrapType ¶ 

func NewWdEG_WrapType() *WdEG_WrapType

func (*WdEG_WrapType) MarshalXML ¶ 

func (m *WdEG_WrapType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdEG_WrapType) UnmarshalXML ¶ 

func (m *WdEG_WrapType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdEG_WrapType) Validate ¶ 

func (m *WdEG_WrapType) Validate() error

Validate validates the WdEG_WrapType and its children

func (*WdEG_WrapType) ValidateWithPath ¶ 

func (m *WdEG_WrapType) ValidateWithPath(path string) error

ValidateWithPath validates the WdEG_WrapType and its children, prefixing error messages with path

type WdEG_WrapTypeChoice ¶ 

type WdEG_WrapTypeChoice struct {
	WrapNone         *WdCT_WrapNone
	WrapSquare       *WdCT_WrapSquare
	WrapTight        *WdCT_WrapTight
	WrapThrough      *WdCT_WrapThrough
	WrapTopAndBottom *WdCT_WrapTopBottom
}

func NewWdEG_WrapTypeChoice ¶ 

func NewWdEG_WrapTypeChoice() *WdEG_WrapTypeChoice

func (*WdEG_WrapTypeChoice) MarshalXML ¶ 

func (m *WdEG_WrapTypeChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdEG_WrapTypeChoice) UnmarshalXML ¶ 

func (m *WdEG_WrapTypeChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdEG_WrapTypeChoice) Validate ¶ 

func (m *WdEG_WrapTypeChoice) Validate() error

Validate validates the WdEG_WrapTypeChoice and its children

func (*WdEG_WrapTypeChoice) ValidateWithPath ¶ 

func (m *WdEG_WrapTypeChoice) ValidateWithPath(path string) error

ValidateWithPath validates the WdEG_WrapTypeChoice and its children, prefixing error messages with path

type WdInline ¶ 

type WdInline struct {
	WdCT_Inline
}

func NewWdInline ¶ 

func NewWdInline() *WdInline

func (*WdInline) MarshalXML ¶ 

func (m *WdInline) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdInline) UnmarshalXML ¶ 

func (m *WdInline) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdInline) Validate ¶ 

func (m *WdInline) Validate() error

Validate validates the WdInline and its children

func (*WdInline) ValidateWithPath ¶ 

func (m *WdInline) ValidateWithPath(path string) error

ValidateWithPath validates the WdInline and its children, prefixing error messages with path

type WdST_AlignH ¶ 

type WdST_AlignH byte
const (
	WdST_AlignHUnset   WdST_AlignH = 0
	WdST_AlignHLeft    WdST_AlignH = 1
	WdST_AlignHRight   WdST_AlignH = 2
	WdST_AlignHCenter  WdST_AlignH = 3
	WdST_AlignHInside  WdST_AlignH = 4
	WdST_AlignHOutside WdST_AlignH = 5
)

func (WdST_AlignH) MarshalXML ¶ 

func (m WdST_AlignH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (WdST_AlignH) MarshalXMLAttr ¶ 

func (e WdST_AlignH) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (WdST_AlignH) String ¶ 

func (m WdST_AlignH) String() string

func (*WdST_AlignH) UnmarshalXML ¶ 

func (m *WdST_AlignH) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdST_AlignH) UnmarshalXMLAttr ¶ 

func (e *WdST_AlignH) UnmarshalXMLAttr(attr xml.Attr) error

func (WdST_AlignH) Validate ¶ 

func (m WdST_AlignH) Validate() error

func (WdST_AlignH) ValidateWithPath ¶ 

func (m WdST_AlignH) ValidateWithPath(path string) error

type WdST_AlignV ¶ 

type WdST_AlignV byte
const (
	WdST_AlignVUnset   WdST_AlignV = 0
	WdST_AlignVTop     WdST_AlignV = 1
	WdST_AlignVBottom  WdST_AlignV = 2
	WdST_AlignVCenter  WdST_AlignV = 3
	WdST_AlignVInside  WdST_AlignV = 4
	WdST_AlignVOutside WdST_AlignV = 5
)

func (WdST_AlignV) MarshalXML ¶ 

func (m WdST_AlignV) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (WdST_AlignV) MarshalXMLAttr ¶ 

func (e WdST_AlignV) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (WdST_AlignV) String ¶ 

func (m WdST_AlignV) String() string

func (*WdST_AlignV) UnmarshalXML ¶ 

func (m *WdST_AlignV) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdST_AlignV) UnmarshalXMLAttr ¶ 

func (e *WdST_AlignV) UnmarshalXMLAttr(attr xml.Attr) error

func (WdST_AlignV) Validate ¶ 

func (m WdST_AlignV) Validate() error

func (WdST_AlignV) ValidateWithPath ¶ 

func (m WdST_AlignV) ValidateWithPath(path string) error

type WdST_RelFromH ¶ 

type WdST_RelFromH byte
const (
	WdST_RelFromHUnset         WdST_RelFromH = 0
	WdST_RelFromHMargin        WdST_RelFromH = 1
	WdST_RelFromHPage          WdST_RelFromH = 2
	WdST_RelFromHColumn        WdST_RelFromH = 3
	WdST_RelFromHCharacter     WdST_RelFromH = 4
	WdST_RelFromHLeftMargin    WdST_RelFromH = 5
	WdST_RelFromHRightMargin   WdST_RelFromH = 6
	WdST_RelFromHInsideMargin  WdST_RelFromH = 7
	WdST_RelFromHOutsideMargin WdST_RelFromH = 8
)

func (WdST_RelFromH) MarshalXML ¶ 

func (m WdST_RelFromH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (WdST_RelFromH) MarshalXMLAttr ¶ 

func (e WdST_RelFromH) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (WdST_RelFromH) String ¶ 

func (m WdST_RelFromH) String() string

func (*WdST_RelFromH) UnmarshalXML ¶ 

func (m *WdST_RelFromH) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdST_RelFromH) UnmarshalXMLAttr ¶ 

func (e *WdST_RelFromH) UnmarshalXMLAttr(attr xml.Attr) error

func (WdST_RelFromH) Validate ¶ 

func (m WdST_RelFromH) Validate() error

func (WdST_RelFromH) ValidateWithPath ¶ 

func (m WdST_RelFromH) ValidateWithPath(path string) error

type WdST_RelFromV ¶ 

type WdST_RelFromV byte
const (
	WdST_RelFromVUnset         WdST_RelFromV = 0
	WdST_RelFromVMargin        WdST_RelFromV = 1
	WdST_RelFromVPage          WdST_RelFromV = 2
	WdST_RelFromVParagraph     WdST_RelFromV = 3
	WdST_RelFromVLine          WdST_RelFromV = 4
	WdST_RelFromVTopMargin     WdST_RelFromV = 5
	WdST_RelFromVBottomMargin  WdST_RelFromV = 6
	WdST_RelFromVInsideMargin  WdST_RelFromV = 7
	WdST_RelFromVOutsideMargin WdST_RelFromV = 8
)

func (WdST_RelFromV) MarshalXML ¶ 

func (m WdST_RelFromV) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (WdST_RelFromV) MarshalXMLAttr ¶ 

func (e WdST_RelFromV) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (WdST_RelFromV) String ¶ 

func (m WdST_RelFromV) String() string

func (*WdST_RelFromV) UnmarshalXML ¶ 

func (m *WdST_RelFromV) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdST_RelFromV) UnmarshalXMLAttr ¶ 

func (e *WdST_RelFromV) UnmarshalXMLAttr(attr xml.Attr) error

func (WdST_RelFromV) Validate ¶ 

func (m WdST_RelFromV) Validate() error

func (WdST_RelFromV) ValidateWithPath ¶ 

func (m WdST_RelFromV) ValidateWithPath(path string) error

type WdST_WrapText ¶ 

type WdST_WrapText byte
const (
	WdST_WrapTextUnset     WdST_WrapText = 0
	WdST_WrapTextBothSides WdST_WrapText = 1
	WdST_WrapTextLeft      WdST_WrapText = 2
	WdST_WrapTextRight     WdST_WrapText = 3
	WdST_WrapTextLargest   WdST_WrapText = 4
)

func (WdST_WrapText) MarshalXML ¶ 

func (m WdST_WrapText) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (WdST_WrapText) MarshalXMLAttr ¶ 

func (e WdST_WrapText) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (WdST_WrapText) String ¶ 

func (m WdST_WrapText) String() string

func (*WdST_WrapText) UnmarshalXML ¶ 

func (m *WdST_WrapText) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdST_WrapText) UnmarshalXMLAttr ¶ 

func (e *WdST_WrapText) UnmarshalXMLAttr(attr xml.Attr) error

func (WdST_WrapText) Validate ¶ 

func (m WdST_WrapText) Validate() error

func (WdST_WrapText) ValidateWithPath ¶ 

func (m WdST_WrapText) ValidateWithPath(path string) error

type WdWgp ¶ 

type WdWgp struct {
	WdCT_WordprocessingGroup
}

func NewWdWgp ¶ 

func NewWdWgp() *WdWgp

func (*WdWgp) MarshalXML ¶ 

func (m *WdWgp) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdWgp) UnmarshalXML ¶ 

func (m *WdWgp) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdWgp) Validate ¶ 

func (m *WdWgp) Validate() error

Validate validates the WdWgp and its children

func (*WdWgp) ValidateWithPath ¶ 

func (m *WdWgp) ValidateWithPath(path string) error

ValidateWithPath validates the WdWgp and its children, prefixing error messages with path

type WdWpc ¶ 

type WdWpc struct {
	WdCT_WordprocessingCanvas
}

func NewWdWpc ¶ 

func NewWdWpc() *WdWpc

func (*WdWpc) MarshalXML ¶ 

func (m *WdWpc) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdWpc) UnmarshalXML ¶ 

func (m *WdWpc) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdWpc) Validate ¶ 

func (m *WdWpc) Validate() error

Validate validates the WdWpc and its children

func (*WdWpc) ValidateWithPath ¶ 

func (m *WdWpc) ValidateWithPath(path string) error

ValidateWithPath validates the WdWpc and its children, prefixing error messages with path

type WdWsp ¶ 

type WdWsp struct {
	WdCT_WordprocessingShape
}

func NewWdWsp ¶ 

func NewWdWsp() *WdWsp

func (*WdWsp) MarshalXML ¶ 

func (m *WdWsp) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WdWsp) UnmarshalXML ¶ 

func (m *WdWsp) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WdWsp) Validate ¶ 

func (m *WdWsp) Validate() error

Validate validates the WdWsp and its children

func (*WdWsp) ValidateWithPath ¶ 

func (m *WdWsp) ValidateWithPath(path string) error

ValidateWithPath validates the WdWsp and its children, prefixing error messages with path

type WebSettings ¶ 

type WebSettings struct {
	CT_WebSettings
}

func NewWebSettings ¶ 

func NewWebSettings() *WebSettings

func (*WebSettings) MarshalXML ¶ 

func (m *WebSettings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*WebSettings) UnmarshalXML ¶ 

func (m *WebSettings) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*WebSettings) Validate ¶ 

func (m *WebSettings) Validate() error

Validate validates the WebSettings and its children

func (*WebSettings) ValidateWithPath ¶ 

func (m *WebSettings) ValidateWithPath(path string) error

ValidateWithPath validates the WebSettings and its children, prefixing error messages with path

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.