pml

package
v1.1.1 Latest Latest
Warning

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

 Go to latest Published: Jun 6, 2019 License: AGPL-3.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ParseStdlibTime 

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

func ParseUnionST_Coordinate32 

func ParseUnionST_Coordinate32(s string) (dml.ST_Coordinate32, error)

func ParseUnionST_FixedPercentage 

func ParseUnionST_FixedPercentage(s string) (dml.ST_FixedPercentage, error)

func ParseUnionST_Percentage 

func ParseUnionST_Percentage(s string) (dml.ST_Percentage, error)

func ParseUnionST_PositiveFixedPercentage 

func ParseUnionST_PositiveFixedPercentage(s string) (dml.ST_PositiveFixedPercentage, error)

func ParseUnionST_PositivePercentage 

func ParseUnionST_PositivePercentage(s string) (dml.ST_PositivePercentage, error)

Types

type AG_ChildSlide 

type AG_ChildSlide struct {
	ShowMasterSpAttr     *bool
	ShowMasterPhAnimAttr *bool
}

func NewAG_ChildSlide 

func NewAG_ChildSlide() *AG_ChildSlide

func (*AG_ChildSlide) MarshalXML 

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

func (*AG_ChildSlide) UnmarshalXML 

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

func (*AG_ChildSlide) Validate 

func (m *AG_ChildSlide) Validate() error

Validate validates the AG_ChildSlide and its children

func (*AG_ChildSlide) ValidateWithPath 

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

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

type AG_Ole 

type AG_Ole struct {
	SpidAttr       *string
	NameAttr       *string
	ShowAsIconAttr *bool
	IdAttr         *string
	ImgWAttr       *int32
	ImgHAttr       *int32
}

func NewAG_Ole 

func NewAG_Ole() *AG_Ole

func (*AG_Ole) MarshalXML 

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

func (*AG_Ole) UnmarshalXML 

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

func (*AG_Ole) Validate 

func (m *AG_Ole) Validate() error

Validate validates the AG_Ole and its children

func (*AG_Ole) ValidateWithPath 

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

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

type AG_TLBuild 

type AG_TLBuild struct {
	SpidAttr     *uint32
	GrpIdAttr    *uint32
	UiExpandAttr *bool
}

func NewAG_TLBuild 

func NewAG_TLBuild() *AG_TLBuild

func (*AG_TLBuild) MarshalXML 

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

func (*AG_TLBuild) UnmarshalXML 

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

func (*AG_TLBuild) Validate 

func (m *AG_TLBuild) Validate() error

Validate validates the AG_TLBuild and its children

func (*AG_TLBuild) ValidateWithPath 

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

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

type CT_ApplicationNonVisualDrawingProps 

type CT_ApplicationNonVisualDrawingProps struct {
	// Is a Photo Album
	IsPhotoAttr *bool
	// Is User Drawn
	UserDrawnAttr *bool
	// Placeholder Shape
	Ph            *CT_Placeholder
	AudioCd       *dml.CT_AudioCD
	WavAudioFile  *dml.CT_EmbeddedWAVAudioFile
	AudioFile     *dml.CT_AudioFile
	VideoFile     *dml.CT_VideoFile
	QuickTimeFile *dml.CT_QuickTimeFile
	// Customer Data List
	CustDataLst *CT_CustomerDataList
	ExtLst      *CT_ExtensionList
}

func NewCT_ApplicationNonVisualDrawingProps 

func NewCT_ApplicationNonVisualDrawingProps() *CT_ApplicationNonVisualDrawingProps

func (*CT_ApplicationNonVisualDrawingProps) MarshalXML 

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

func (*CT_ApplicationNonVisualDrawingProps) UnmarshalXML 

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

func (*CT_ApplicationNonVisualDrawingProps) Validate 

func (m *CT_ApplicationNonVisualDrawingProps) Validate() error

Validate validates the CT_ApplicationNonVisualDrawingProps and its children

func (*CT_ApplicationNonVisualDrawingProps) ValidateWithPath 

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

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

type CT_Background 

type CT_Background struct {
	// Black and White Mode
	BwModeAttr dml.ST_BlackWhiteMode
	// Background Properties
	BgPr *CT_BackgroundProperties
	// Background Style Reference
	BgRef *dml.CT_StyleMatrixReference
}

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_BackgroundProperties 

type CT_BackgroundProperties struct {
	// Shade to Title
	ShadeToTitleAttr *bool
	NoFill           *dml.CT_NoFillProperties
	SolidFill        *dml.CT_SolidColorFillProperties
	GradFill         *dml.CT_GradientFillProperties
	BlipFill         *dml.CT_BlipFillProperties
	PattFill         *dml.CT_PatternFillProperties
	GrpFill          *dml.CT_GroupFillProperties
	EffectLst        *dml.CT_EffectList
	EffectDag        *dml.CT_EffectContainer
	ExtLst           *CT_ExtensionList
}

func NewCT_BackgroundProperties 

func NewCT_BackgroundProperties() *CT_BackgroundProperties

func (*CT_BackgroundProperties) MarshalXML 

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

func (*CT_BackgroundProperties) UnmarshalXML 

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

func (*CT_BackgroundProperties) Validate 

func (m *CT_BackgroundProperties) Validate() error

Validate validates the CT_BackgroundProperties and its children

func (*CT_BackgroundProperties) ValidateWithPath 

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

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

type CT_BuildList 

type CT_BuildList struct {
	// Build Paragraph
	BldP []*CT_TLBuildParagraph
	// Build Diagram
	BldDgm []*CT_TLBuildDiagram
	// Build Embedded Chart
	BldOleChart []*CT_TLOleBuildChart
	// Build Graphics
	BldGraphic []*CT_TLGraphicalObjectBuild
}

func NewCT_BuildList 

func NewCT_BuildList() *CT_BuildList

func (*CT_BuildList) MarshalXML 

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

func (*CT_BuildList) UnmarshalXML 

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

func (*CT_BuildList) Validate 

func (m *CT_BuildList) Validate() error

Validate validates the CT_BuildList and its children

func (*CT_BuildList) ValidateWithPath 

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

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

type CT_Comment 

type CT_Comment struct {
	// Comment Author ID
	AuthorIdAttr uint32
	// Comment Date/Time
	DtAttr *time.Time
	// Comment Index
	IdxAttr uint32
	// Comment Position
	Pos *dml.CT_Point2D
	// Comment's Text Content
	Text   string
	ExtLst *CT_ExtensionListModify
}

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_CommentAuthor 

type CT_CommentAuthor struct {
	// Comment Author ID
	IdAttr uint32
	// Comment Author Name
	NameAttr string
	// Comment Author Initials
	InitialsAttr string
	// Index of Comment Author's last comment
	LastIdxAttr uint32
	// Comment Author Color Index
	ClrIdxAttr uint32
	ExtLst     *CT_ExtensionList
}

func NewCT_CommentAuthor 

func NewCT_CommentAuthor() *CT_CommentAuthor

func (*CT_CommentAuthor) MarshalXML 

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

func (*CT_CommentAuthor) UnmarshalXML 

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

func (*CT_CommentAuthor) Validate 

func (m *CT_CommentAuthor) Validate() error

Validate validates the CT_CommentAuthor and its children

func (*CT_CommentAuthor) ValidateWithPath 

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

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

type CT_CommentAuthorList 

type CT_CommentAuthorList struct {
	// Comment Author
	CmAuthor []*CT_CommentAuthor
}

func NewCT_CommentAuthorList 

func NewCT_CommentAuthorList() *CT_CommentAuthorList

func (*CT_CommentAuthorList) MarshalXML 

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

func (*CT_CommentAuthorList) UnmarshalXML 

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

func (*CT_CommentAuthorList) Validate 

func (m *CT_CommentAuthorList) Validate() error

Validate validates the CT_CommentAuthorList and its children

func (*CT_CommentAuthorList) ValidateWithPath 

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

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

type CT_CommentList 

type CT_CommentList struct {
	// Comment
	Cm []*CT_Comment
}

func NewCT_CommentList 

func NewCT_CommentList() *CT_CommentList

func (*CT_CommentList) MarshalXML 

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

func (*CT_CommentList) UnmarshalXML 

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

func (*CT_CommentList) Validate 

func (m *CT_CommentList) Validate() error

Validate validates the CT_CommentList and its children

func (*CT_CommentList) ValidateWithPath 

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

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

type CT_CommonSlideData 

type CT_CommonSlideData struct {
	// Name
	NameAttr *string
	// Slide Background
	Bg *CT_Background
	// Shape Tree
	SpTree *CT_GroupShape
	// Customer Data List
	CustDataLst *CT_CustomerDataList
	// List of controls
	Controls *CT_ControlList
	ExtLst   *CT_ExtensionList
}

func NewCT_CommonSlideData 

func NewCT_CommonSlideData() *CT_CommonSlideData

func (*CT_CommonSlideData) MarshalXML 

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

func (*CT_CommonSlideData) UnmarshalXML 

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

func (*CT_CommonSlideData) Validate 

func (m *CT_CommonSlideData) Validate() error

Validate validates the CT_CommonSlideData and its children

func (*CT_CommonSlideData) ValidateWithPath 

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

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

type CT_CommonSlideViewProperties 

type CT_CommonSlideViewProperties struct {
	// Snap Objects to Grid
	SnapToGridAttr *bool
	// Snap Objects to Objects
	SnapToObjectsAttr *bool
	// Show Guides in View
	ShowGuidesAttr *bool
	// Base properties for Slide View
	CViewPr *CT_CommonViewProperties
	// List of Guides
	GuideLst *CT_GuideList
}

func NewCT_CommonSlideViewProperties 

func NewCT_CommonSlideViewProperties() *CT_CommonSlideViewProperties

func (*CT_CommonSlideViewProperties) MarshalXML 

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

func (*CT_CommonSlideViewProperties) UnmarshalXML 

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

func (*CT_CommonSlideViewProperties) Validate 

func (m *CT_CommonSlideViewProperties) Validate() error

Validate validates the CT_CommonSlideViewProperties and its children

func (*CT_CommonSlideViewProperties) ValidateWithPath 

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

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

type CT_CommonViewProperties 

type CT_CommonViewProperties struct {
	// Variable Scale
	VarScaleAttr *bool
	// View Scale
	Scale *dml.CT_Scale2D
	// View Origin
	Origin *dml.CT_Point2D
}

func NewCT_CommonViewProperties 

func NewCT_CommonViewProperties() *CT_CommonViewProperties

func (*CT_CommonViewProperties) MarshalXML 

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

func (*CT_CommonViewProperties) UnmarshalXML 

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

func (*CT_CommonViewProperties) Validate 

func (m *CT_CommonViewProperties) Validate() error

Validate validates the CT_CommonViewProperties and its children

func (*CT_CommonViewProperties) ValidateWithPath 

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

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

type CT_Connector 

type CT_Connector struct {
	// Non-Visual Properties for a Connection Shape
	NvCxnSpPr *CT_ConnectorNonVisual
	// Shape Properties
	SpPr *dml.CT_ShapeProperties
	// Connector Shape Style
	Style  *dml.CT_ShapeStyle
	ExtLst *CT_ExtensionListModify
}

func NewCT_Connector 

func NewCT_Connector() *CT_Connector

func (*CT_Connector) MarshalXML 

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

func (*CT_Connector) UnmarshalXML 

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

func (*CT_Connector) Validate 

func (m *CT_Connector) Validate() error

Validate validates the CT_Connector and its children

func (*CT_Connector) ValidateWithPath 

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

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

type CT_ConnectorNonVisual 

type CT_ConnectorNonVisual struct {
	// Non-Visual Drawing Properties
	CNvPr *dml.CT_NonVisualDrawingProps
	// Non-Visual Connector Shape Drawing Properties
	CNvCxnSpPr *dml.CT_NonVisualConnectorProperties
	// Application Non-Visual Drawing Properties
	NvPr *CT_ApplicationNonVisualDrawingProps
}

func NewCT_ConnectorNonVisual 

func NewCT_ConnectorNonVisual() *CT_ConnectorNonVisual

func (*CT_ConnectorNonVisual) MarshalXML 

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

func (*CT_ConnectorNonVisual) UnmarshalXML 

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

func (*CT_ConnectorNonVisual) Validate 

func (m *CT_ConnectorNonVisual) Validate() error

Validate validates the CT_ConnectorNonVisual and its children

func (*CT_ConnectorNonVisual) ValidateWithPath 

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

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

type CT_Control 

type CT_Control struct {
	ExtLst         *CT_ExtensionList
	Pic            *CT_Picture
	SpidAttr       *string
	NameAttr       *string
	ShowAsIconAttr *bool
	IdAttr         *string
	ImgWAttr       *int32
	ImgHAttr       *int32
}

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_ControlList 

type CT_ControlList struct {
	// Embedded Control
	Control []*CT_Control
}

func NewCT_ControlList 

func NewCT_ControlList() *CT_ControlList

func (*CT_ControlList) MarshalXML 

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

func (*CT_ControlList) UnmarshalXML 

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

func (*CT_ControlList) Validate 

func (m *CT_ControlList) Validate() error

Validate validates the CT_ControlList and its children

func (*CT_ControlList) ValidateWithPath 

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

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

type CT_CornerDirectionTransition 

type CT_CornerDirectionTransition struct {
	// Direction
	DirAttr ST_TransitionCornerDirectionType
}

func NewCT_CornerDirectionTransition 

func NewCT_CornerDirectionTransition() *CT_CornerDirectionTransition

func (*CT_CornerDirectionTransition) MarshalXML 

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

func (*CT_CornerDirectionTransition) UnmarshalXML 

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

func (*CT_CornerDirectionTransition) Validate 

func (m *CT_CornerDirectionTransition) Validate() error

Validate validates the CT_CornerDirectionTransition and its children

func (*CT_CornerDirectionTransition) ValidateWithPath 

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

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

type CT_CustomShow 

type CT_CustomShow struct {
	// Custom Show Name
	NameAttr string
	// Custom Show ID
	IdAttr uint32
	// List of Presentation Slides
	SldLst *CT_SlideRelationshipList
	ExtLst *CT_ExtensionList
}

func NewCT_CustomShow 

func NewCT_CustomShow() *CT_CustomShow

func (*CT_CustomShow) MarshalXML 

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

func (*CT_CustomShow) UnmarshalXML 

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

func (*CT_CustomShow) Validate 

func (m *CT_CustomShow) Validate() error

Validate validates the CT_CustomShow and its children

func (*CT_CustomShow) ValidateWithPath 

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

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

type CT_CustomShowId 

type CT_CustomShowId struct {
	// Custom Show Identifier
	IdAttr uint32
}

func NewCT_CustomShowId 

func NewCT_CustomShowId() *CT_CustomShowId

func (*CT_CustomShowId) MarshalXML 

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

func (*CT_CustomShowId) UnmarshalXML 

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

func (*CT_CustomShowId) Validate 

func (m *CT_CustomShowId) Validate() error

Validate validates the CT_CustomShowId and its children

func (*CT_CustomShowId) ValidateWithPath 

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

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

type CT_CustomShowList 

type CT_CustomShowList struct {
	// Custom Show
	CustShow []*CT_CustomShow
}

func NewCT_CustomShowList 

func NewCT_CustomShowList() *CT_CustomShowList

func (*CT_CustomShowList) MarshalXML 

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

func (*CT_CustomShowList) UnmarshalXML 

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

func (*CT_CustomShowList) Validate 

func (m *CT_CustomShowList) Validate() error

Validate validates the CT_CustomShowList and its children

func (*CT_CustomShowList) ValidateWithPath 

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

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

type CT_CustomerData 

type CT_CustomerData struct {
	IdAttr string
}

func NewCT_CustomerData 

func NewCT_CustomerData() *CT_CustomerData

func (*CT_CustomerData) MarshalXML 

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

func (*CT_CustomerData) UnmarshalXML 

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

func (*CT_CustomerData) Validate 

func (m *CT_CustomerData) Validate() error

Validate validates the CT_CustomerData and its children

func (*CT_CustomerData) ValidateWithPath 

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

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

type CT_CustomerDataList 

type CT_CustomerDataList struct {
	// Customer Data
	CustData []*CT_CustomerData
	// Customer Data Tags
	Tags *CT_TagsData
}

func NewCT_CustomerDataList 

func NewCT_CustomerDataList() *CT_CustomerDataList

func (*CT_CustomerDataList) MarshalXML 

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

func (*CT_CustomerDataList) UnmarshalXML 

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

func (*CT_CustomerDataList) Validate 

func (m *CT_CustomerDataList) Validate() error

Validate validates the CT_CustomerDataList and its children

func (*CT_CustomerDataList) ValidateWithPath 

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

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

type CT_EightDirectionTransition 

type CT_EightDirectionTransition struct {
	// Direction
	DirAttr *ST_TransitionEightDirectionType
}

func NewCT_EightDirectionTransition 

func NewCT_EightDirectionTransition() *CT_EightDirectionTransition

func (*CT_EightDirectionTransition) MarshalXML 

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

func (*CT_EightDirectionTransition) UnmarshalXML 

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

func (*CT_EightDirectionTransition) Validate 

func (m *CT_EightDirectionTransition) Validate() error

Validate validates the CT_EightDirectionTransition and its children

func (*CT_EightDirectionTransition) ValidateWithPath 

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

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

type CT_EmbeddedFontDataId 

type CT_EmbeddedFontDataId struct {
	IdAttr string
}

func NewCT_EmbeddedFontDataId 

func NewCT_EmbeddedFontDataId() *CT_EmbeddedFontDataId

func (*CT_EmbeddedFontDataId) MarshalXML 

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

func (*CT_EmbeddedFontDataId) UnmarshalXML 

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

func (*CT_EmbeddedFontDataId) Validate 

func (m *CT_EmbeddedFontDataId) Validate() error

Validate validates the CT_EmbeddedFontDataId and its children

func (*CT_EmbeddedFontDataId) ValidateWithPath 

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

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

type CT_EmbeddedFontList 

type CT_EmbeddedFontList struct {
	// Embedded Font
	EmbeddedFont []*CT_EmbeddedFontListEntry
}

func NewCT_EmbeddedFontList 

func NewCT_EmbeddedFontList() *CT_EmbeddedFontList

func (*CT_EmbeddedFontList) MarshalXML 

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

func (*CT_EmbeddedFontList) UnmarshalXML 

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

func (*CT_EmbeddedFontList) Validate 

func (m *CT_EmbeddedFontList) Validate() error

Validate validates the CT_EmbeddedFontList and its children

func (*CT_EmbeddedFontList) ValidateWithPath 

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

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

type CT_EmbeddedFontListEntry 

type CT_EmbeddedFontListEntry struct {
	// Embedded Font Name
	Font *dml.CT_TextFont
	// Regular Embedded Font
	Regular *CT_EmbeddedFontDataId
	// Bold Embedded Font
	Bold *CT_EmbeddedFontDataId
	// Italic Embedded Font
	Italic *CT_EmbeddedFontDataId
	// Bold Italic Embedded Font
	BoldItalic *CT_EmbeddedFontDataId
}

func NewCT_EmbeddedFontListEntry 

func NewCT_EmbeddedFontListEntry() *CT_EmbeddedFontListEntry

func (*CT_EmbeddedFontListEntry) MarshalXML 

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

func (*CT_EmbeddedFontListEntry) UnmarshalXML 

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

func (*CT_EmbeddedFontListEntry) Validate 

func (m *CT_EmbeddedFontListEntry) Validate() error

Validate validates the CT_EmbeddedFontListEntry and its children

func (*CT_EmbeddedFontListEntry) ValidateWithPath 

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

ValidateWithPath validates the CT_EmbeddedFontListEntry 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_Extension 

type CT_Extension struct {
	// Uniform Resource Identifier
	UriAttr string
	Any     []unioffice.Any
}

func NewCT_Extension 

func NewCT_Extension() *CT_Extension

func (*CT_Extension) MarshalXML 

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

func (*CT_Extension) UnmarshalXML 

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

func (*CT_Extension) Validate 

func (m *CT_Extension) Validate() error

Validate validates the CT_Extension and its children

func (*CT_Extension) ValidateWithPath 

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

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

type CT_ExtensionList 

type CT_ExtensionList struct {
	// Extension
	Ext []*CT_Extension
}

func NewCT_ExtensionList 

func NewCT_ExtensionList() *CT_ExtensionList

func (*CT_ExtensionList) MarshalXML 

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

func (*CT_ExtensionList) UnmarshalXML 

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

func (*CT_ExtensionList) Validate 

func (m *CT_ExtensionList) Validate() error

Validate validates the CT_ExtensionList and its children

func (*CT_ExtensionList) ValidateWithPath 

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

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

type CT_ExtensionListModify 

type CT_ExtensionListModify struct {
	// Modify
	ModAttr *bool
	// Extension
	Ext []*CT_Extension
}

func NewCT_ExtensionListModify 

func NewCT_ExtensionListModify() *CT_ExtensionListModify

func (*CT_ExtensionListModify) MarshalXML 

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

func (*CT_ExtensionListModify) UnmarshalXML 

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

func (*CT_ExtensionListModify) Validate 

func (m *CT_ExtensionListModify) Validate() error

Validate validates the CT_ExtensionListModify and its children

func (*CT_ExtensionListModify) ValidateWithPath 

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

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

type CT_GraphicalObjectFrame 

type CT_GraphicalObjectFrame struct {
	BwModeAttr dml.ST_BlackWhiteMode
	// Non-Visual Properties for a Graphic Frame
	NvGraphicFramePr *CT_GraphicalObjectFrameNonVisual
	// 2D Transform for Graphic Frame
	Xfrm    *dml.CT_Transform2D
	Graphic *dml.Graphic
	// Extension List with Modification Flag
	ExtLst *CT_ExtensionListModify
}

func NewCT_GraphicalObjectFrame 

func NewCT_GraphicalObjectFrame() *CT_GraphicalObjectFrame

func (*CT_GraphicalObjectFrame) MarshalXML 

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

func (*CT_GraphicalObjectFrame) UnmarshalXML 

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

func (*CT_GraphicalObjectFrame) Validate 

func (m *CT_GraphicalObjectFrame) Validate() error

Validate validates the CT_GraphicalObjectFrame and its children

func (*CT_GraphicalObjectFrame) ValidateWithPath 

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

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

type CT_GraphicalObjectFrameNonVisual 

type CT_GraphicalObjectFrameNonVisual struct {
	// Non-Visual Drawing Properties
	CNvPr *dml.CT_NonVisualDrawingProps
	// Non-Visual Graphic Frame Drawing Properties
	CNvGraphicFramePr *dml.CT_NonVisualGraphicFrameProperties
	// Application Non-Visual Drawing Properties
	NvPr *CT_ApplicationNonVisualDrawingProps
}

func NewCT_GraphicalObjectFrameNonVisual 

func NewCT_GraphicalObjectFrameNonVisual() *CT_GraphicalObjectFrameNonVisual

func (*CT_GraphicalObjectFrameNonVisual) MarshalXML 

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

func (*CT_GraphicalObjectFrameNonVisual) UnmarshalXML 

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

func (*CT_GraphicalObjectFrameNonVisual) Validate 

func (m *CT_GraphicalObjectFrameNonVisual) Validate() error

Validate validates the CT_GraphicalObjectFrameNonVisual and its children

func (*CT_GraphicalObjectFrameNonVisual) ValidateWithPath 

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

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

type CT_GroupShape 

type CT_GroupShape struct {
	// Non-Visual Properties for a Group Shape
	NvGrpSpPr *CT_GroupShapeNonVisual
	// Group Shape Properties
	GrpSpPr *dml.CT_GroupShapeProperties
	Choice  []*CT_GroupShapeChoice
	ExtLst  *CT_ExtensionListModify
}

func NewCT_GroupShape 

func NewCT_GroupShape() *CT_GroupShape

func (*CT_GroupShape) MarshalXML 

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

func (*CT_GroupShape) UnmarshalXML 

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

func (*CT_GroupShape) Validate 

func (m *CT_GroupShape) Validate() error

Validate validates the CT_GroupShape and its children

func (*CT_GroupShape) ValidateWithPath 

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

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

type CT_GroupShapeChoice 

type CT_GroupShapeChoice struct {
	Sp           []*CT_Shape
	GrpSp        []*CT_GroupShape
	GraphicFrame []*CT_GraphicalObjectFrame
	CxnSp        []*CT_Connector
	Pic          []*CT_Picture
	ContentPart  []*CT_Rel
}

func NewCT_GroupShapeChoice 

func NewCT_GroupShapeChoice() *CT_GroupShapeChoice

func (*CT_GroupShapeChoice) MarshalXML 

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

func (*CT_GroupShapeChoice) UnmarshalXML 

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

func (*CT_GroupShapeChoice) Validate 

func (m *CT_GroupShapeChoice) Validate() error

Validate validates the CT_GroupShapeChoice and its children

func (*CT_GroupShapeChoice) ValidateWithPath 

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

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

type CT_GroupShapeNonVisual 

type CT_GroupShapeNonVisual struct {
	// Non-visual Drawing Properties
	CNvPr *dml.CT_NonVisualDrawingProps
	// Non-Visual Group Shape Drawing Properties
	CNvGrpSpPr *dml.CT_NonVisualGroupDrawingShapeProps
	// Non-Visual Properties
	NvPr *CT_ApplicationNonVisualDrawingProps
}

func NewCT_GroupShapeNonVisual 

func NewCT_GroupShapeNonVisual() *CT_GroupShapeNonVisual

func (*CT_GroupShapeNonVisual) MarshalXML 

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

func (*CT_GroupShapeNonVisual) UnmarshalXML 

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

func (*CT_GroupShapeNonVisual) Validate 

func (m *CT_GroupShapeNonVisual) Validate() error

Validate validates the CT_GroupShapeNonVisual and its children

func (*CT_GroupShapeNonVisual) ValidateWithPath 

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

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

type CT_Guide 

type CT_Guide struct {
	// Guide Orientation
	OrientAttr ST_Direction
	// Guide Position
	PosAttr *dml.ST_Coordinate32
}

func NewCT_Guide 

func NewCT_Guide() *CT_Guide

func (*CT_Guide) MarshalXML 

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

func (*CT_Guide) UnmarshalXML 

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

func (*CT_Guide) Validate 

func (m *CT_Guide) Validate() error

Validate validates the CT_Guide and its children

func (*CT_Guide) ValidateWithPath 

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

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

type CT_GuideList 

type CT_GuideList struct {
	// A Guide
	Guide []*CT_Guide
}

func NewCT_GuideList 

func NewCT_GuideList() *CT_GuideList

func (*CT_GuideList) MarshalXML 

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

func (*CT_GuideList) UnmarshalXML 

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

func (*CT_GuideList) Validate 

func (m *CT_GuideList) Validate() error

Validate validates the CT_GuideList and its children

func (*CT_GuideList) ValidateWithPath 

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

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

type CT_HandoutMaster 

type CT_HandoutMaster struct {
	// Common slide data for handout master
	CSld *CT_CommonSlideData
	// Color Scheme Map
	ClrMap *dml.CT_ColorMapping
	// Header/Footer information for a handout master
	Hf     *CT_HeaderFooter
	ExtLst *CT_ExtensionListModify
}

func NewCT_HandoutMaster 

func NewCT_HandoutMaster() *CT_HandoutMaster

func (*CT_HandoutMaster) MarshalXML 

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

func (*CT_HandoutMaster) UnmarshalXML 

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

func (*CT_HandoutMaster) Validate 

func (m *CT_HandoutMaster) Validate() error

Validate validates the CT_HandoutMaster and its children

func (*CT_HandoutMaster) ValidateWithPath 

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

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

type CT_HandoutMasterIdList 

type CT_HandoutMasterIdList struct {
	// Handout Master ID
	HandoutMasterId *CT_HandoutMasterIdListEntry
}

func NewCT_HandoutMasterIdList 

func NewCT_HandoutMasterIdList() *CT_HandoutMasterIdList

func (*CT_HandoutMasterIdList) MarshalXML 

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

func (*CT_HandoutMasterIdList) UnmarshalXML 

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

func (*CT_HandoutMasterIdList) Validate 

func (m *CT_HandoutMasterIdList) Validate() error

Validate validates the CT_HandoutMasterIdList and its children

func (*CT_HandoutMasterIdList) ValidateWithPath 

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

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

type CT_HandoutMasterIdListEntry 

type CT_HandoutMasterIdListEntry struct {
	IdAttr string
	ExtLst *CT_ExtensionList
}

func NewCT_HandoutMasterIdListEntry 

func NewCT_HandoutMasterIdListEntry() *CT_HandoutMasterIdListEntry

func (*CT_HandoutMasterIdListEntry) MarshalXML 

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

func (*CT_HandoutMasterIdListEntry) UnmarshalXML 

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

func (*CT_HandoutMasterIdListEntry) Validate 

func (m *CT_HandoutMasterIdListEntry) Validate() error

Validate validates the CT_HandoutMasterIdListEntry and its children

func (*CT_HandoutMasterIdListEntry) ValidateWithPath 

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

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

type CT_HeaderFooter 

type CT_HeaderFooter struct {
	// Slide Number Placeholder
	SldNumAttr *bool
	// Header Placeholder
	HdrAttr *bool
	// Footer Placeholder
	FtrAttr *bool
	// Date/Time Placeholder
	DtAttr *bool
	ExtLst *CT_ExtensionListModify
}

func NewCT_HeaderFooter 

func NewCT_HeaderFooter() *CT_HeaderFooter

func (*CT_HeaderFooter) MarshalXML 

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

func (*CT_HeaderFooter) UnmarshalXML 

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

func (*CT_HeaderFooter) Validate 

func (m *CT_HeaderFooter) Validate() error

Validate validates the CT_HeaderFooter and its children

func (*CT_HeaderFooter) ValidateWithPath 

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

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

type CT_HtmlPublishProperties 

type CT_HtmlPublishProperties struct {
	// Show Speaker Notes
	ShowSpeakerNotesAttr *bool
	// Target Output Profile
	TargetAttr *string
	// HTML Output Title
	TitleAttr *string
	IdAttr    string
	// All Slides
	SldAll *CT_Empty
	// Slide Range
	SldRg *CT_IndexRange
	// Custom Show
	CustShow *CT_CustomShowId
	ExtLst   *CT_ExtensionList
}

func NewCT_HtmlPublishProperties 

func NewCT_HtmlPublishProperties() *CT_HtmlPublishProperties

func (*CT_HtmlPublishProperties) MarshalXML 

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

func (*CT_HtmlPublishProperties) UnmarshalXML 

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

func (*CT_HtmlPublishProperties) Validate 

func (m *CT_HtmlPublishProperties) Validate() error

Validate validates the CT_HtmlPublishProperties and its children

func (*CT_HtmlPublishProperties) ValidateWithPath 

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

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

type CT_InOutTransition 

type CT_InOutTransition struct {
	// Direction
	DirAttr ST_TransitionInOutDirectionType
}

func NewCT_InOutTransition 

func NewCT_InOutTransition() *CT_InOutTransition

func (*CT_InOutTransition) MarshalXML 

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

func (*CT_InOutTransition) UnmarshalXML 

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

func (*CT_InOutTransition) Validate 

func (m *CT_InOutTransition) Validate() error

Validate validates the CT_InOutTransition and its children

func (*CT_InOutTransition) ValidateWithPath 

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

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

type CT_IndexRange 

type CT_IndexRange struct {
	// Start
	StAttr uint32
	// End
	EndAttr uint32
}

func NewCT_IndexRange 

func NewCT_IndexRange() *CT_IndexRange

func (*CT_IndexRange) MarshalXML 

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

func (*CT_IndexRange) UnmarshalXML 

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

func (*CT_IndexRange) Validate 

func (m *CT_IndexRange) Validate() error

Validate validates the CT_IndexRange and its children

func (*CT_IndexRange) ValidateWithPath 

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

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

type CT_Kinsoku 

type CT_Kinsoku struct {
	// Language
	LangAttr *string
	// Invalid Kinsoku Start Characters
	InvalStCharsAttr string
	// Invalid Kinsoku End Characters
	InvalEndCharsAttr 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_ModifyVerifier 

type CT_ModifyVerifier struct {
	// Cryptographic Algorithm Name
	AlgorithmNameAttr *string
	// Password Hash Value
	HashValueAttr *string
	// Salt Value for Password Verifier
	SaltValueAttr *string
	// Iterations to Run Hashing Algorithm
	SpinValueAttr *uint32
	// Cryptographic Provider Type
	CryptProviderTypeAttr sharedTypes.ST_CryptProv
	// Cryptographic Algorithm Class
	CryptAlgorithmClassAttr sharedTypes.ST_AlgClass
	// Cryptographic Algorithm Type
	CryptAlgorithmTypeAttr sharedTypes.ST_AlgType
	// Cryptographic Hashing Algorithm
	CryptAlgorithmSidAttr *uint32
	// Iterations to Run Hashing Algorithm
	SpinCountAttr *uint32
	// Salt for Password Verifier
	SaltDataAttr *string
	// Password Hash
	HashDataAttr *string
	// Cryptographic Provider
	CryptProviderAttr *string
	// Cryptographic Algorithm Extensibility
	AlgIdExtAttr *uint32
	// Algorithm Extensibility Source
	AlgIdExtSourceAttr *string
	// Cryptographic Provider Type Extensibility
	CryptProviderTypeExtAttr *uint32
	// Provider Type Extensibility Source
	CryptProviderTypeExtSourceAttr *string
}

func NewCT_ModifyVerifier 

func NewCT_ModifyVerifier() *CT_ModifyVerifier

func (*CT_ModifyVerifier) MarshalXML 

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

func (*CT_ModifyVerifier) UnmarshalXML 

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

func (*CT_ModifyVerifier) Validate 

func (m *CT_ModifyVerifier) Validate() error

Validate validates the CT_ModifyVerifier and its children

func (*CT_ModifyVerifier) ValidateWithPath 

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

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

type CT_NormalViewPortion 

type CT_NormalViewPortion struct {
	// Normal View Dimension Size
	SzAttr dml.ST_PositiveFixedPercentage
	// Auto Adjust Normal View
	AutoAdjustAttr *bool
}

func NewCT_NormalViewPortion 

func NewCT_NormalViewPortion() *CT_NormalViewPortion

func (*CT_NormalViewPortion) MarshalXML 

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

func (*CT_NormalViewPortion) UnmarshalXML 

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

func (*CT_NormalViewPortion) Validate 

func (m *CT_NormalViewPortion) Validate() error

Validate validates the CT_NormalViewPortion and its children

func (*CT_NormalViewPortion) ValidateWithPath 

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

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

type CT_NormalViewProperties 

type CT_NormalViewProperties struct {
	// Show Outline Icons in Normal View
	ShowOutlineIconsAttr *bool
	// Snap Vertical Splitter
	SnapVertSplitterAttr *bool
	// State of the Vertical Splitter Bar
	VertBarStateAttr ST_SplitterBarState
	// State of the Horizontal Splitter Bar
	HorzBarStateAttr ST_SplitterBarState
	// Prefer Single View
	PreferSingleViewAttr *bool
	// Normal View Restored Left Properties
	RestoredLeft *CT_NormalViewPortion
	// Normal View Restored Top Properties
	RestoredTop *CT_NormalViewPortion
	ExtLst      *CT_ExtensionList
}

func NewCT_NormalViewProperties 

func NewCT_NormalViewProperties() *CT_NormalViewProperties

func (*CT_NormalViewProperties) MarshalXML 

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

func (*CT_NormalViewProperties) UnmarshalXML 

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

func (*CT_NormalViewProperties) Validate 

func (m *CT_NormalViewProperties) Validate() error

Validate validates the CT_NormalViewProperties and its children

func (*CT_NormalViewProperties) ValidateWithPath 

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

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

type CT_NotesMaster 

type CT_NotesMaster struct {
	// Common Slide Data
	CSld *CT_CommonSlideData
	// Color Scheme Map
	ClrMap *dml.CT_ColorMapping
	// Header/Footer Information for a Notes Master
	Hf *CT_HeaderFooter
	// Notes Text Style
	NotesStyle *dml.CT_TextListStyle
	ExtLst     *CT_ExtensionListModify
}

func NewCT_NotesMaster 

func NewCT_NotesMaster() *CT_NotesMaster

func (*CT_NotesMaster) MarshalXML 

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

func (*CT_NotesMaster) UnmarshalXML 

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

func (*CT_NotesMaster) Validate 

func (m *CT_NotesMaster) Validate() error

Validate validates the CT_NotesMaster and its children

func (*CT_NotesMaster) ValidateWithPath 

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

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

type CT_NotesMasterIdList 

type CT_NotesMasterIdList struct {
	// Notes Master ID
	NotesMasterId *CT_NotesMasterIdListEntry
}

func NewCT_NotesMasterIdList 

func NewCT_NotesMasterIdList() *CT_NotesMasterIdList

func (*CT_NotesMasterIdList) MarshalXML 

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

func (*CT_NotesMasterIdList) UnmarshalXML 

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

func (*CT_NotesMasterIdList) Validate 

func (m *CT_NotesMasterIdList) Validate() error

Validate validates the CT_NotesMasterIdList and its children

func (*CT_NotesMasterIdList) ValidateWithPath 

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

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

type CT_NotesMasterIdListEntry 

type CT_NotesMasterIdListEntry struct {
	IdAttr string
	ExtLst *CT_ExtensionList
}

func NewCT_NotesMasterIdListEntry 

func NewCT_NotesMasterIdListEntry() *CT_NotesMasterIdListEntry

func (*CT_NotesMasterIdListEntry) MarshalXML 

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

func (*CT_NotesMasterIdListEntry) UnmarshalXML 

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

func (*CT_NotesMasterIdListEntry) Validate 

func (m *CT_NotesMasterIdListEntry) Validate() error

Validate validates the CT_NotesMasterIdListEntry and its children

func (*CT_NotesMasterIdListEntry) ValidateWithPath 

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

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

type CT_NotesSlide 

type CT_NotesSlide struct {
	// Common slide data for notes slides
	CSld *CT_CommonSlideData
	// Color Scheme Map Override
	ClrMapOvr            *dml.CT_ColorMappingOverride
	ExtLst               *CT_ExtensionListModify
	ShowMasterSpAttr     *bool
	ShowMasterPhAnimAttr *bool
}

func NewCT_NotesSlide 

func NewCT_NotesSlide() *CT_NotesSlide

func (*CT_NotesSlide) MarshalXML 

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

func (*CT_NotesSlide) UnmarshalXML 

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

func (*CT_NotesSlide) Validate 

func (m *CT_NotesSlide) Validate() error

Validate validates the CT_NotesSlide and its children

func (*CT_NotesSlide) ValidateWithPath 

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

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

type CT_NotesTextViewProperties 

type CT_NotesTextViewProperties struct {
	// Base properties for Notes View
	CViewPr *CT_CommonViewProperties
	ExtLst  *CT_ExtensionList
}

func NewCT_NotesTextViewProperties 

func NewCT_NotesTextViewProperties() *CT_NotesTextViewProperties

func (*CT_NotesTextViewProperties) MarshalXML 

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

func (*CT_NotesTextViewProperties) UnmarshalXML 

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

func (*CT_NotesTextViewProperties) Validate 

func (m *CT_NotesTextViewProperties) Validate() error

Validate validates the CT_NotesTextViewProperties and its children

func (*CT_NotesTextViewProperties) ValidateWithPath 

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

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

type CT_NotesViewProperties 

type CT_NotesViewProperties struct {
	// Common Slide View Properties
	CSldViewPr *CT_CommonSlideViewProperties
	ExtLst     *CT_ExtensionList
}

func NewCT_NotesViewProperties 

func NewCT_NotesViewProperties() *CT_NotesViewProperties

func (*CT_NotesViewProperties) MarshalXML 

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

func (*CT_NotesViewProperties) UnmarshalXML 

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

func (*CT_NotesViewProperties) Validate 

func (m *CT_NotesViewProperties) Validate() error

Validate validates the CT_NotesViewProperties and its children

func (*CT_NotesViewProperties) ValidateWithPath 

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

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

type CT_OleObject 

type CT_OleObject struct {
	// Embedded Object ProgID
	ProgIdAttr     *string
	Choice         *CT_OleObjectChoice
	Pic            *CT_Picture
	SpidAttr       *string
	NameAttr       *string
	ShowAsIconAttr *bool
	IdAttr         *string
	ImgWAttr       *int32
	ImgHAttr       *int32
}

func NewCT_OleObject 

func NewCT_OleObject() *CT_OleObject

func (*CT_OleObject) MarshalXML 

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

func (*CT_OleObject) UnmarshalXML 

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

func (*CT_OleObject) Validate 

func (m *CT_OleObject) Validate() error

Validate validates the CT_OleObject and its children

func (*CT_OleObject) ValidateWithPath 

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

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

type CT_OleObjectChoice 

type CT_OleObjectChoice struct {
	Embed *CT_OleObjectEmbed
	Link  *CT_OleObjectLink
}

func NewCT_OleObjectChoice 

func NewCT_OleObjectChoice() *CT_OleObjectChoice

func (*CT_OleObjectChoice) MarshalXML 

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

func (*CT_OleObjectChoice) UnmarshalXML 

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

func (*CT_OleObjectChoice) Validate 

func (m *CT_OleObjectChoice) Validate() error

Validate validates the CT_OleObjectChoice and its children

func (*CT_OleObjectChoice) ValidateWithPath 

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

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

type CT_OleObjectEmbed 

type CT_OleObjectEmbed struct {
	// Color Scheme Properties for Embedded object
	FollowColorSchemeAttr ST_OleObjectFollowColorScheme
	ExtLst                *CT_ExtensionList
}

func NewCT_OleObjectEmbed 

func NewCT_OleObjectEmbed() *CT_OleObjectEmbed

func (*CT_OleObjectEmbed) MarshalXML 

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

func (*CT_OleObjectEmbed) UnmarshalXML 

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

func (*CT_OleObjectEmbed) Validate 

func (m *CT_OleObjectEmbed) Validate() error

Validate validates the CT_OleObjectEmbed and its children

func (*CT_OleObjectEmbed) ValidateWithPath 

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

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

type CT_OleObjectLink struct {
	// Update Linked Embedded Objects Automatically
	UpdateAutomaticAttr *bool
	ExtLst              *CT_ExtensionList
}
func NewCT_OleObjectLink() *CT_OleObjectLink

func (*CT_OleObjectLink) MarshalXML 

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

func (*CT_OleObjectLink) UnmarshalXML 

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

func (*CT_OleObjectLink) Validate 

func (m *CT_OleObjectLink) Validate() error

Validate validates the CT_OleObjectLink and its children

func (*CT_OleObjectLink) ValidateWithPath 

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

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

type CT_OptionalBlackTransition 

type CT_OptionalBlackTransition struct {
	// Transition Through Black
	ThruBlkAttr *bool
}

func NewCT_OptionalBlackTransition 

func NewCT_OptionalBlackTransition() *CT_OptionalBlackTransition

func (*CT_OptionalBlackTransition) MarshalXML 

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

func (*CT_OptionalBlackTransition) UnmarshalXML 

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

func (*CT_OptionalBlackTransition) Validate 

func (m *CT_OptionalBlackTransition) Validate() error

Validate validates the CT_OptionalBlackTransition and its children

func (*CT_OptionalBlackTransition) ValidateWithPath 

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

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

type CT_OrientationTransition 

type CT_OrientationTransition struct {
	// Transition Direction
	DirAttr ST_Direction
}

func NewCT_OrientationTransition 

func NewCT_OrientationTransition() *CT_OrientationTransition

func (*CT_OrientationTransition) MarshalXML 

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

func (*CT_OrientationTransition) UnmarshalXML 

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

func (*CT_OrientationTransition) Validate 

func (m *CT_OrientationTransition) Validate() error

Validate validates the CT_OrientationTransition and its children

func (*CT_OrientationTransition) ValidateWithPath 

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

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

type CT_OutlineViewProperties 

type CT_OutlineViewProperties struct {
	// Common View Properties
	CViewPr *CT_CommonViewProperties
	// List of Presentation Slides
	SldLst *CT_OutlineViewSlideList
	ExtLst *CT_ExtensionList
}

func NewCT_OutlineViewProperties 

func NewCT_OutlineViewProperties() *CT_OutlineViewProperties

func (*CT_OutlineViewProperties) MarshalXML 

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

func (*CT_OutlineViewProperties) UnmarshalXML 

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

func (*CT_OutlineViewProperties) Validate 

func (m *CT_OutlineViewProperties) Validate() error

Validate validates the CT_OutlineViewProperties and its children

func (*CT_OutlineViewProperties) ValidateWithPath 

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

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

type CT_OutlineViewSlideEntry 

type CT_OutlineViewSlideEntry struct {
	IdAttr string
	// Collapsed
	CollapseAttr *bool
}

func NewCT_OutlineViewSlideEntry 

func NewCT_OutlineViewSlideEntry() *CT_OutlineViewSlideEntry

func (*CT_OutlineViewSlideEntry) MarshalXML 

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

func (*CT_OutlineViewSlideEntry) UnmarshalXML 

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

func (*CT_OutlineViewSlideEntry) Validate 

func (m *CT_OutlineViewSlideEntry) Validate() error

Validate validates the CT_OutlineViewSlideEntry and its children

func (*CT_OutlineViewSlideEntry) ValidateWithPath 

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

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

type CT_OutlineViewSlideList 

type CT_OutlineViewSlideList struct {
	// Presentation Slide
	Sld []*CT_OutlineViewSlideEntry
}

func NewCT_OutlineViewSlideList 

func NewCT_OutlineViewSlideList() *CT_OutlineViewSlideList

func (*CT_OutlineViewSlideList) MarshalXML 

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

func (*CT_OutlineViewSlideList) UnmarshalXML 

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

func (*CT_OutlineViewSlideList) Validate 

func (m *CT_OutlineViewSlideList) Validate() error

Validate validates the CT_OutlineViewSlideList and its children

func (*CT_OutlineViewSlideList) ValidateWithPath 

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

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

type CT_PhotoAlbum 

type CT_PhotoAlbum struct {
	// Black and White
	BwAttr *bool
	// Show/Hide Captions
	ShowCaptionsAttr *bool
	// Photo Album Layout
	LayoutAttr ST_PhotoAlbumLayout
	// Frame Type
	FrameAttr ST_PhotoAlbumFrameShape
	ExtLst    *CT_ExtensionList
}

func NewCT_PhotoAlbum 

func NewCT_PhotoAlbum() *CT_PhotoAlbum

func (*CT_PhotoAlbum) MarshalXML 

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

func (*CT_PhotoAlbum) UnmarshalXML 

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

func (*CT_PhotoAlbum) Validate 

func (m *CT_PhotoAlbum) Validate() error

Validate validates the CT_PhotoAlbum and its children

func (*CT_PhotoAlbum) ValidateWithPath 

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

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

type CT_Picture 

type CT_Picture struct {
	// Non-Visual Properties for a Picture
	NvPicPr *CT_PictureNonVisual
	// Picture Fill
	BlipFill *dml.CT_BlipFillProperties
	SpPr     *dml.CT_ShapeProperties
	Style    *dml.CT_ShapeStyle
	ExtLst   *CT_ExtensionListModify
}

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_PictureNonVisual 

type CT_PictureNonVisual struct {
	CNvPr *dml.CT_NonVisualDrawingProps
	// Non-Visual Picture Drawing Properties
	CNvPicPr *dml.CT_NonVisualPictureProperties
	NvPr     *CT_ApplicationNonVisualDrawingProps
}

func NewCT_PictureNonVisual 

func NewCT_PictureNonVisual() *CT_PictureNonVisual

func (*CT_PictureNonVisual) MarshalXML 

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

func (*CT_PictureNonVisual) UnmarshalXML 

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

func (*CT_PictureNonVisual) Validate 

func (m *CT_PictureNonVisual) Validate() error

Validate validates the CT_PictureNonVisual and its children

func (*CT_PictureNonVisual) ValidateWithPath 

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

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

type CT_Placeholder 

type CT_Placeholder struct {
	// Placeholder Type
	TypeAttr ST_PlaceholderType
	// Placeholder Orientation
	OrientAttr ST_Direction
	// Placeholder Size
	SzAttr ST_PlaceholderSize
	// Placeholder Index
	IdxAttr *uint32
	// Placeholder has custom prompt
	HasCustomPromptAttr *bool
	ExtLst              *CT_ExtensionListModify
}

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_Presentation 

type CT_Presentation struct {
	// Server Zoom
	ServerZoomAttr *dml.ST_Percentage
	// First Slide Number
	FirstSlideNumAttr *int32
	// Show Header and Footer Placeholders on Titles
	ShowSpecialPlsOnTitleSldAttr *bool
	// Right-To-Left Views
	RtlAttr *bool
	// Remove Personal Information on Save
	RemovePersonalInfoOnSaveAttr *bool
	// Compatibility Mode
	CompatModeAttr *bool
	// Strict First and Last Characters
	StrictFirstAndLastCharsAttr *bool
	// Embed True Type Fonts
	EmbedTrueTypeFontsAttr *bool
	// Save Subset Fonts
	SaveSubsetFontsAttr *bool
	// Automatically Compress Pictures
	AutoCompressPicturesAttr *bool
	// Bookmark ID Seed
	BookmarkIdSeedAttr *uint32
	// Document Conformance Class
	ConformanceAttr sharedTypes.ST_ConformanceClass
	// List of Slide Master IDs
	SldMasterIdLst *CT_SlideMasterIdList
	// List of Notes Master IDs
	NotesMasterIdLst *CT_NotesMasterIdList
	// List of Handout Master IDs
	HandoutMasterIdLst *CT_HandoutMasterIdList
	// List of Slide IDs
	SldIdLst *CT_SlideIdList
	// Presentation Slide Size
	SldSz *CT_SlideSize
	// Notes Slide Size
	NotesSz *dml.CT_PositiveSize2D
	// Smart Tags
	SmartTags *CT_SmartTags
	// Embedded Font List
	EmbeddedFontLst *CT_EmbeddedFontList
	// List of Custom Shows
	CustShowLst *CT_CustomShowList
	// Photo Album Information
	PhotoAlbum *CT_PhotoAlbum
	// List of Customer Data Buckets
	CustDataLst *CT_CustomerDataList
	// Kinsoku Settings
	Kinsoku *CT_Kinsoku
	// Presentation Default Text Style
	DefaultTextStyle *dml.CT_TextListStyle
	// Modification Verifier
	ModifyVerifier *CT_ModifyVerifier
	// Extension List
	ExtLst *CT_ExtensionList
}

func NewCT_Presentation 

func NewCT_Presentation() *CT_Presentation

func (*CT_Presentation) MarshalXML 

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

func (*CT_Presentation) UnmarshalXML 

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

func (*CT_Presentation) Validate 

func (m *CT_Presentation) Validate() error

Validate validates the CT_Presentation and its children

func (*CT_Presentation) ValidateWithPath 

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

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

type CT_PresentationProperties 

type CT_PresentationProperties struct {
	// HTML Publishing Properties
	HtmlPubPr *CT_HtmlPublishProperties
	// Web Properties
	WebPr *CT_WebProperties
	// Printing Properties
	PrnPr *CT_PrintProperties
	// Presentation-wide Show Properties
	ShowPr *CT_ShowProperties
	// Color MRU
	ClrMru *dml.CT_ColorMRU
	ExtLst *CT_ExtensionList
}

func NewCT_PresentationProperties 

func NewCT_PresentationProperties() *CT_PresentationProperties

func (*CT_PresentationProperties) MarshalXML 

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

func (*CT_PresentationProperties) UnmarshalXML 

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

func (*CT_PresentationProperties) Validate 

func (m *CT_PresentationProperties) Validate() error

Validate validates the CT_PresentationProperties and its children

func (*CT_PresentationProperties) ValidateWithPath 

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

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

type CT_PrintProperties 

type CT_PrintProperties struct {
	// Print Output
	PrnWhatAttr ST_PrintWhat
	// Print Color Mode
	ClrModeAttr ST_PrintColorMode
	// Print Hidden Slides
	HiddenSlidesAttr *bool
	// Scale to Fit Paper when printing
	ScaleToFitPaperAttr *bool
	// Frame slides when printing
	FrameSlidesAttr *bool
	ExtLst          *CT_ExtensionList
}

func NewCT_PrintProperties 

func NewCT_PrintProperties() *CT_PrintProperties

func (*CT_PrintProperties) MarshalXML 

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

func (*CT_PrintProperties) UnmarshalXML 

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

func (*CT_PrintProperties) Validate 

func (m *CT_PrintProperties) Validate() error

Validate validates the CT_PrintProperties and its children

func (*CT_PrintProperties) ValidateWithPath 

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

ValidateWithPath validates the CT_PrintProperties 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_Shape 

type CT_Shape struct {
	// Use Background Fill
	UseBgFillAttr *bool
	// Non-Visual Properties for a Shape
	NvSpPr *CT_ShapeNonVisual
	SpPr   *dml.CT_ShapeProperties
	// Shape Style
	Style *dml.CT_ShapeStyle
	// Shape Text Body
	TxBody *dml.CT_TextBody
	ExtLst *CT_ExtensionListModify
}

func NewCT_Shape 

func NewCT_Shape() *CT_Shape

func (*CT_Shape) MarshalXML 

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

func (*CT_Shape) UnmarshalXML 

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

func (*CT_Shape) Validate 

func (m *CT_Shape) Validate() error

Validate validates the CT_Shape and its children

func (*CT_Shape) ValidateWithPath 

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

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

type CT_ShapeNonVisual 

type CT_ShapeNonVisual struct {
	// Non-Visual Drawing Properties
	CNvPr *dml.CT_NonVisualDrawingProps
	// Non-Visual Drawing Properties for a Shape
	CNvSpPr *dml.CT_NonVisualDrawingShapeProps
	// Application Non-Visual Drawing Properties
	NvPr *CT_ApplicationNonVisualDrawingProps
}

func NewCT_ShapeNonVisual 

func NewCT_ShapeNonVisual() *CT_ShapeNonVisual

func (*CT_ShapeNonVisual) MarshalXML 

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

func (*CT_ShapeNonVisual) UnmarshalXML 

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

func (*CT_ShapeNonVisual) Validate 

func (m *CT_ShapeNonVisual) Validate() error

Validate validates the CT_ShapeNonVisual and its children

func (*CT_ShapeNonVisual) ValidateWithPath 

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

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

type CT_ShowInfoBrowse 

type CT_ShowInfoBrowse struct {
	// Show Scroll Bar in Window
	ShowScrollbarAttr *bool
}

func NewCT_ShowInfoBrowse 

func NewCT_ShowInfoBrowse() *CT_ShowInfoBrowse

func (*CT_ShowInfoBrowse) MarshalXML 

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

func (*CT_ShowInfoBrowse) UnmarshalXML 

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

func (*CT_ShowInfoBrowse) Validate 

func (m *CT_ShowInfoBrowse) Validate() error

Validate validates the CT_ShowInfoBrowse and its children

func (*CT_ShowInfoBrowse) ValidateWithPath 

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

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

type CT_ShowInfoKiosk 

type CT_ShowInfoKiosk struct {
	// Restart Show
	RestartAttr *uint32
}

func NewCT_ShowInfoKiosk 

func NewCT_ShowInfoKiosk() *CT_ShowInfoKiosk

func (*CT_ShowInfoKiosk) MarshalXML 

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

func (*CT_ShowInfoKiosk) UnmarshalXML 

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

func (*CT_ShowInfoKiosk) Validate 

func (m *CT_ShowInfoKiosk) Validate() error

Validate validates the CT_ShowInfoKiosk and its children

func (*CT_ShowInfoKiosk) ValidateWithPath 

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

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

type CT_ShowProperties 

type CT_ShowProperties struct {
	// Loop Slide Show
	LoopAttr *bool
	// Show Narration in Slide Show
	ShowNarrationAttr *bool
	// Show Animation in Slide Show
	ShowAnimationAttr *bool
	// Use Timings in Slide Show
	UseTimingsAttr *bool
	// Presenter Slide Show Mode
	Present *CT_Empty
	// Browse Slide Show Mode
	Browse *CT_ShowInfoBrowse
	// Kiosk Slide Show Mode
	Kiosk *CT_ShowInfoKiosk
	// All Slides
	SldAll *CT_Empty
	// Slide Range
	SldRg *CT_IndexRange
	// Custom Show
	CustShow *CT_CustomShowId
	// Pen Color for Slide Show
	PenClr *dml.CT_Color
	ExtLst *CT_ExtensionList
}

func NewCT_ShowProperties 

func NewCT_ShowProperties() *CT_ShowProperties

func (*CT_ShowProperties) MarshalXML 

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

func (*CT_ShowProperties) UnmarshalXML 

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

func (*CT_ShowProperties) Validate 

func (m *CT_ShowProperties) Validate() error

Validate validates the CT_ShowProperties and its children

func (*CT_ShowProperties) ValidateWithPath 

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

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

type CT_SideDirectionTransition 

type CT_SideDirectionTransition struct {
	// Direction
	DirAttr ST_TransitionSideDirectionType
}

func NewCT_SideDirectionTransition 

func NewCT_SideDirectionTransition() *CT_SideDirectionTransition

func (*CT_SideDirectionTransition) MarshalXML 

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

func (*CT_SideDirectionTransition) UnmarshalXML 

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

func (*CT_SideDirectionTransition) Validate 

func (m *CT_SideDirectionTransition) Validate() error

Validate validates the CT_SideDirectionTransition and its children

func (*CT_SideDirectionTransition) ValidateWithPath 

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

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

type CT_Slide 

type CT_Slide struct {
	// Show Slide in Slide Show
	ShowAttr *bool
	// Common slide data for slides
	CSld *CT_CommonSlideData
	// Color Scheme Map Override
	ClrMapOvr *dml.CT_ColorMappingOverride
	// Slide Transition
	Transition *CT_SlideTransition
	// Slide Timing Information for a Slide
	Timing               *CT_SlideTiming
	ExtLst               *CT_ExtensionListModify
	ShowMasterSpAttr     *bool
	ShowMasterPhAnimAttr *bool
}

func NewCT_Slide 

func NewCT_Slide() *CT_Slide

func (*CT_Slide) MarshalXML 

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

func (*CT_Slide) UnmarshalXML 

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

func (*CT_Slide) Validate 

func (m *CT_Slide) Validate() error

Validate validates the CT_Slide and its children

func (*CT_Slide) ValidateWithPath 

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

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

type CT_SlideIdList 

type CT_SlideIdList struct {
	// Slide ID
	SldId []*CT_SlideIdListEntry
}

func NewCT_SlideIdList 

func NewCT_SlideIdList() *CT_SlideIdList

func (*CT_SlideIdList) MarshalXML 

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

func (*CT_SlideIdList) UnmarshalXML 

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

func (*CT_SlideIdList) Validate 

func (m *CT_SlideIdList) Validate() error

Validate validates the CT_SlideIdList and its children

func (*CT_SlideIdList) ValidateWithPath 

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

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

type CT_SlideIdListEntry 

type CT_SlideIdListEntry struct {
	// Slide Identifier
	IdAttr  uint32
	RIdAttr string
	ExtLst  *CT_ExtensionList
}

func NewCT_SlideIdListEntry 

func NewCT_SlideIdListEntry() *CT_SlideIdListEntry

func (*CT_SlideIdListEntry) MarshalXML 

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

func (*CT_SlideIdListEntry) UnmarshalXML 

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

func (*CT_SlideIdListEntry) Validate 

func (m *CT_SlideIdListEntry) Validate() error

Validate validates the CT_SlideIdListEntry and its children

func (*CT_SlideIdListEntry) ValidateWithPath 

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

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

type CT_SlideLayout 

type CT_SlideLayout struct {
	// Matching Name
	MatchingNameAttr *string
	// Slide Layout Type
	TypeAttr ST_SlideLayoutType
	// Preserve Slide Layout
	PreserveAttr *bool
	// Is User Drawn
	UserDrawnAttr *bool
	// Common slide data for slide layouts
	CSld *CT_CommonSlideData
	// Color Scheme Map Override
	ClrMapOvr *dml.CT_ColorMappingOverride
	// Slide Transition for a Slide Layout
	Transition *CT_SlideTransition
	// Slide Timing Information for a Slide Layout
	Timing *CT_SlideTiming
	// Header/Footer information for a slide layout
	Hf                   *CT_HeaderFooter
	ExtLst               *CT_ExtensionListModify
	ShowMasterSpAttr     *bool
	ShowMasterPhAnimAttr *bool
}

func NewCT_SlideLayout 

func NewCT_SlideLayout() *CT_SlideLayout

func (*CT_SlideLayout) MarshalXML 

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

func (*CT_SlideLayout) UnmarshalXML 

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

func (*CT_SlideLayout) Validate 

func (m *CT_SlideLayout) Validate() error

Validate validates the CT_SlideLayout and its children

func (*CT_SlideLayout) ValidateWithPath 

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

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

type CT_SlideLayoutIdList 

type CT_SlideLayoutIdList struct {
	// Slide Layout Id
	SldLayoutId []*CT_SlideLayoutIdListEntry
}

func NewCT_SlideLayoutIdList 

func NewCT_SlideLayoutIdList() *CT_SlideLayoutIdList

func (*CT_SlideLayoutIdList) MarshalXML 

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

func (*CT_SlideLayoutIdList) UnmarshalXML 

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

func (*CT_SlideLayoutIdList) Validate 

func (m *CT_SlideLayoutIdList) Validate() error

Validate validates the CT_SlideLayoutIdList and its children

func (*CT_SlideLayoutIdList) ValidateWithPath 

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

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

type CT_SlideLayoutIdListEntry 

type CT_SlideLayoutIdListEntry struct {
	// ID Tag
	IdAttr  *uint32
	RIdAttr string
	ExtLst  *CT_ExtensionList
}

func NewCT_SlideLayoutIdListEntry 

func NewCT_SlideLayoutIdListEntry() *CT_SlideLayoutIdListEntry

func (*CT_SlideLayoutIdListEntry) MarshalXML 

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

func (*CT_SlideLayoutIdListEntry) UnmarshalXML 

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

func (*CT_SlideLayoutIdListEntry) Validate 

func (m *CT_SlideLayoutIdListEntry) Validate() error

Validate validates the CT_SlideLayoutIdListEntry and its children

func (*CT_SlideLayoutIdListEntry) ValidateWithPath 

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

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

type CT_SlideMaster 

type CT_SlideMaster struct {
	// Preserve Slide Master
	PreserveAttr *bool
	// Common slide data for slide masters
	CSld *CT_CommonSlideData
	// Color Scheme Map
	ClrMap *dml.CT_ColorMapping
	// List of Slide Layouts
	SldLayoutIdLst *CT_SlideLayoutIdList
	// Slide Transition for a Slide Master
	Transition *CT_SlideTransition
	// Slide Timing Information for Slide Masters
	Timing *CT_SlideTiming
	// Header/Footer information for a slide master
	Hf *CT_HeaderFooter
	// Slide Master Text Styles
	TxStyles *CT_SlideMasterTextStyles
	ExtLst   *CT_ExtensionListModify
}

func NewCT_SlideMaster 

func NewCT_SlideMaster() *CT_SlideMaster

func (*CT_SlideMaster) MarshalXML 

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

func (*CT_SlideMaster) UnmarshalXML 

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

func (*CT_SlideMaster) Validate 

func (m *CT_SlideMaster) Validate() error

Validate validates the CT_SlideMaster and its children

func (*CT_SlideMaster) ValidateWithPath 

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

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

type CT_SlideMasterIdList 

type CT_SlideMasterIdList struct {
	// Slide Master ID
	SldMasterId []*CT_SlideMasterIdListEntry
}

func NewCT_SlideMasterIdList 

func NewCT_SlideMasterIdList() *CT_SlideMasterIdList

func (*CT_SlideMasterIdList) MarshalXML 

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

func (*CT_SlideMasterIdList) UnmarshalXML 

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

func (*CT_SlideMasterIdList) Validate 

func (m *CT_SlideMasterIdList) Validate() error

Validate validates the CT_SlideMasterIdList and its children

func (*CT_SlideMasterIdList) ValidateWithPath 

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

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

type CT_SlideMasterIdListEntry 

type CT_SlideMasterIdListEntry struct {
	// Slide Master Identifier
	IdAttr  *uint32
	RIdAttr string
	ExtLst  *CT_ExtensionList
}

func NewCT_SlideMasterIdListEntry 

func NewCT_SlideMasterIdListEntry() *CT_SlideMasterIdListEntry

func (*CT_SlideMasterIdListEntry) MarshalXML 

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

func (*CT_SlideMasterIdListEntry) UnmarshalXML 

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

func (*CT_SlideMasterIdListEntry) Validate 

func (m *CT_SlideMasterIdListEntry) Validate() error

Validate validates the CT_SlideMasterIdListEntry and its children

func (*CT_SlideMasterIdListEntry) ValidateWithPath 

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

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

type CT_SlideMasterTextStyles 

type CT_SlideMasterTextStyles struct {
	// Slide Master Title Text Style
	TitleStyle *dml.CT_TextListStyle
	// Slide Master Body Text Style
	BodyStyle *dml.CT_TextListStyle
	// Slide Master Other Text Style
	OtherStyle *dml.CT_TextListStyle
	ExtLst     *CT_ExtensionList
}

func NewCT_SlideMasterTextStyles 

func NewCT_SlideMasterTextStyles() *CT_SlideMasterTextStyles

func (*CT_SlideMasterTextStyles) MarshalXML 

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

func (*CT_SlideMasterTextStyles) UnmarshalXML 

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

func (*CT_SlideMasterTextStyles) Validate 

func (m *CT_SlideMasterTextStyles) Validate() error

Validate validates the CT_SlideMasterTextStyles and its children

func (*CT_SlideMasterTextStyles) ValidateWithPath 

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

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

type CT_SlideRelationshipList 

type CT_SlideRelationshipList struct {
	// Presentation Slide
	Sld []*CT_SlideRelationshipListEntry
}

func NewCT_SlideRelationshipList 

func NewCT_SlideRelationshipList() *CT_SlideRelationshipList

func (*CT_SlideRelationshipList) MarshalXML 

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

func (*CT_SlideRelationshipList) UnmarshalXML 

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

func (*CT_SlideRelationshipList) Validate 

func (m *CT_SlideRelationshipList) Validate() error

Validate validates the CT_SlideRelationshipList and its children

func (*CT_SlideRelationshipList) ValidateWithPath 

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

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

type CT_SlideRelationshipListEntry 

type CT_SlideRelationshipListEntry struct {
	IdAttr string
}

func NewCT_SlideRelationshipListEntry 

func NewCT_SlideRelationshipListEntry() *CT_SlideRelationshipListEntry

func (*CT_SlideRelationshipListEntry) MarshalXML 

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

func (*CT_SlideRelationshipListEntry) UnmarshalXML 

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

func (*CT_SlideRelationshipListEntry) Validate 

func (m *CT_SlideRelationshipListEntry) Validate() error

Validate validates the CT_SlideRelationshipListEntry and its children

func (*CT_SlideRelationshipListEntry) ValidateWithPath 

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

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

type CT_SlideSize 

type CT_SlideSize struct {
	// Extent Length
	CxAttr int32
	// Extent Width
	CyAttr int32
	// Type of Size
	TypeAttr ST_SlideSizeType
}

func NewCT_SlideSize 

func NewCT_SlideSize() *CT_SlideSize

func (*CT_SlideSize) MarshalXML 

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

func (*CT_SlideSize) UnmarshalXML 

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

func (*CT_SlideSize) Validate 

func (m *CT_SlideSize) Validate() error

Validate validates the CT_SlideSize and its children

func (*CT_SlideSize) ValidateWithPath 

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

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

type CT_SlideSorterViewProperties 

type CT_SlideSorterViewProperties struct {
	// Show Formatting
	ShowFormattingAttr *bool
	// Base properties for Slide Sorter View
	CViewPr *CT_CommonViewProperties
	ExtLst  *CT_ExtensionList
}

func NewCT_SlideSorterViewProperties 

func NewCT_SlideSorterViewProperties() *CT_SlideSorterViewProperties

func (*CT_SlideSorterViewProperties) MarshalXML 

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

func (*CT_SlideSorterViewProperties) UnmarshalXML 

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

func (*CT_SlideSorterViewProperties) Validate 

func (m *CT_SlideSorterViewProperties) Validate() error

Validate validates the CT_SlideSorterViewProperties and its children

func (*CT_SlideSorterViewProperties) ValidateWithPath 

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

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

type CT_SlideSyncProperties 

type CT_SlideSyncProperties struct {
	// Server's Slide File ID
	ServerSldIdAttr string
	// Server's Slide File's modification date/time
	ServerSldModifiedTimeAttr time.Time
	// Client Slide Insertion date/time
	ClientInsertedTimeAttr time.Time
	ExtLst                 *CT_ExtensionList
}

func NewCT_SlideSyncProperties 

func NewCT_SlideSyncProperties() *CT_SlideSyncProperties

func (*CT_SlideSyncProperties) MarshalXML 

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

func (*CT_SlideSyncProperties) UnmarshalXML 

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

func (*CT_SlideSyncProperties) Validate 

func (m *CT_SlideSyncProperties) Validate() error

Validate validates the CT_SlideSyncProperties and its children

func (*CT_SlideSyncProperties) ValidateWithPath 

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

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

type CT_SlideTiming 

type CT_SlideTiming struct {
	TnLst *CT_TimeNodeList
	// Build List
	BldLst *CT_BuildList
	ExtLst *CT_ExtensionListModify
}

func NewCT_SlideTiming 

func NewCT_SlideTiming() *CT_SlideTiming

func (*CT_SlideTiming) MarshalXML 

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

func (*CT_SlideTiming) UnmarshalXML 

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

func (*CT_SlideTiming) Validate 

func (m *CT_SlideTiming) Validate() error

Validate validates the CT_SlideTiming and its children

func (*CT_SlideTiming) ValidateWithPath 

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

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

type CT_SlideTransition 

type CT_SlideTransition struct {
	// Transition Speed
	SpdAttr ST_TransitionSpeed
	// Advance on Click
	AdvClickAttr *bool
	// Advance after time
	AdvTmAttr *uint32
	Choice    *CT_SlideTransitionChoice
	// Sound Action
	SndAc  *CT_TransitionSoundAction
	ExtLst *CT_ExtensionListModify
}

func NewCT_SlideTransition 

func NewCT_SlideTransition() *CT_SlideTransition

func (*CT_SlideTransition) MarshalXML 

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

func (*CT_SlideTransition) UnmarshalXML 

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

func (*CT_SlideTransition) Validate 

func (m *CT_SlideTransition) Validate() error

Validate validates the CT_SlideTransition and its children

func (*CT_SlideTransition) ValidateWithPath 

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

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

type CT_SlideTransitionChoice 

type CT_SlideTransitionChoice struct {
	Blinds    *CT_OrientationTransition
	Checker   *CT_OrientationTransition
	Circle    *CT_Empty
	Dissolve  *CT_Empty
	Comb      *CT_OrientationTransition
	Cover     *CT_EightDirectionTransition
	Cut       *CT_OptionalBlackTransition
	Diamond   *CT_Empty
	Fade      *CT_OptionalBlackTransition
	Newsflash *CT_Empty
	Plus      *CT_Empty
	Pull      *CT_EightDirectionTransition
	Push      *CT_SideDirectionTransition
	Random    *CT_Empty
	RandomBar *CT_OrientationTransition
	Split     *CT_SplitTransition
	Strips    *CT_CornerDirectionTransition
	Wedge     *CT_Empty
	Wheel     *CT_WheelTransition
	Wipe      *CT_SideDirectionTransition
	Zoom      *CT_InOutTransition
}

func NewCT_SlideTransitionChoice 

func NewCT_SlideTransitionChoice() *CT_SlideTransitionChoice

func (*CT_SlideTransitionChoice) MarshalXML 

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

func (*CT_SlideTransitionChoice) UnmarshalXML 

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

func (*CT_SlideTransitionChoice) Validate 

func (m *CT_SlideTransitionChoice) Validate() error

Validate validates the CT_SlideTransitionChoice and its children

func (*CT_SlideTransitionChoice) ValidateWithPath 

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

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

type CT_SlideViewProperties 

type CT_SlideViewProperties struct {
	CSldViewPr *CT_CommonSlideViewProperties
	ExtLst     *CT_ExtensionList
}

func NewCT_SlideViewProperties 

func NewCT_SlideViewProperties() *CT_SlideViewProperties

func (*CT_SlideViewProperties) MarshalXML 

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

func (*CT_SlideViewProperties) UnmarshalXML 

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

func (*CT_SlideViewProperties) Validate 

func (m *CT_SlideViewProperties) Validate() error

Validate validates the CT_SlideViewProperties and its children

func (*CT_SlideViewProperties) ValidateWithPath 

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

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

type CT_SmartTags 

type CT_SmartTags struct {
	IdAttr string
}

func NewCT_SmartTags 

func NewCT_SmartTags() *CT_SmartTags

func (*CT_SmartTags) MarshalXML 

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

func (*CT_SmartTags) UnmarshalXML 

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

func (*CT_SmartTags) Validate 

func (m *CT_SmartTags) Validate() error

Validate validates the CT_SmartTags and its children

func (*CT_SmartTags) ValidateWithPath 

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

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

type CT_SplitTransition 

type CT_SplitTransition struct {
	// Orientation
	OrientAttr ST_Direction
	// Direction
	DirAttr ST_TransitionInOutDirectionType
}

func NewCT_SplitTransition 

func NewCT_SplitTransition() *CT_SplitTransition

func (*CT_SplitTransition) MarshalXML 

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

func (*CT_SplitTransition) UnmarshalXML 

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

func (*CT_SplitTransition) Validate 

func (m *CT_SplitTransition) Validate() error

Validate validates the CT_SplitTransition and its children

func (*CT_SplitTransition) ValidateWithPath 

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

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

type CT_StringTag 

type CT_StringTag struct {
	// Name
	NameAttr string
	// Value
	ValAttr string
}

func NewCT_StringTag 

func NewCT_StringTag() *CT_StringTag

func (*CT_StringTag) MarshalXML 

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

func (*CT_StringTag) UnmarshalXML 

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

func (*CT_StringTag) Validate 

func (m *CT_StringTag) Validate() error

Validate validates the CT_StringTag and its children

func (*CT_StringTag) ValidateWithPath 

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

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

type CT_TLAnimVariant 

type CT_TLAnimVariant struct {
	// Boolean Variant
	BoolVal *CT_TLAnimVariantBooleanVal
	// Integer
	IntVal *CT_TLAnimVariantIntegerVal
	// Float Value
	FltVal *CT_TLAnimVariantFloatVal
	// String Value
	StrVal *CT_TLAnimVariantStringVal
	// Color Value
	ClrVal *dml.CT_Color
}

func NewCT_TLAnimVariant 

func NewCT_TLAnimVariant() *CT_TLAnimVariant

func (*CT_TLAnimVariant) MarshalXML 

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

func (*CT_TLAnimVariant) UnmarshalXML 

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

func (*CT_TLAnimVariant) Validate 

func (m *CT_TLAnimVariant) Validate() error

Validate validates the CT_TLAnimVariant and its children

func (*CT_TLAnimVariant) ValidateWithPath 

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

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

type CT_TLAnimVariantBooleanVal 

type CT_TLAnimVariantBooleanVal struct {
	// Value
	ValAttr bool
}

func NewCT_TLAnimVariantBooleanVal 

func NewCT_TLAnimVariantBooleanVal() *CT_TLAnimVariantBooleanVal

func (*CT_TLAnimVariantBooleanVal) MarshalXML 

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

func (*CT_TLAnimVariantBooleanVal) UnmarshalXML 

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

func (*CT_TLAnimVariantBooleanVal) Validate 

func (m *CT_TLAnimVariantBooleanVal) Validate() error

Validate validates the CT_TLAnimVariantBooleanVal and its children

func (*CT_TLAnimVariantBooleanVal) ValidateWithPath 

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

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

type CT_TLAnimVariantFloatVal 

type CT_TLAnimVariantFloatVal struct {
	// Value
	ValAttr float32
}

func NewCT_TLAnimVariantFloatVal 

func NewCT_TLAnimVariantFloatVal() *CT_TLAnimVariantFloatVal

func (*CT_TLAnimVariantFloatVal) MarshalXML 

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

func (*CT_TLAnimVariantFloatVal) UnmarshalXML 

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

func (*CT_TLAnimVariantFloatVal) Validate 

func (m *CT_TLAnimVariantFloatVal) Validate() error

Validate validates the CT_TLAnimVariantFloatVal and its children

func (*CT_TLAnimVariantFloatVal) ValidateWithPath 

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

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

type CT_TLAnimVariantIntegerVal 

type CT_TLAnimVariantIntegerVal struct {
	// Value
	ValAttr int32
}

func NewCT_TLAnimVariantIntegerVal 

func NewCT_TLAnimVariantIntegerVal() *CT_TLAnimVariantIntegerVal

func (*CT_TLAnimVariantIntegerVal) MarshalXML 

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

func (*CT_TLAnimVariantIntegerVal) UnmarshalXML 

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

func (*CT_TLAnimVariantIntegerVal) Validate 

func (m *CT_TLAnimVariantIntegerVal) Validate() error

Validate validates the CT_TLAnimVariantIntegerVal and its children

func (*CT_TLAnimVariantIntegerVal) ValidateWithPath 

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

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

type CT_TLAnimVariantStringVal 

type CT_TLAnimVariantStringVal struct {
	// Value
	ValAttr string
}

func NewCT_TLAnimVariantStringVal 

func NewCT_TLAnimVariantStringVal() *CT_TLAnimVariantStringVal

func (*CT_TLAnimVariantStringVal) MarshalXML 

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

func (*CT_TLAnimVariantStringVal) UnmarshalXML 

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

func (*CT_TLAnimVariantStringVal) Validate 

func (m *CT_TLAnimVariantStringVal) Validate() error

Validate validates the CT_TLAnimVariantStringVal and its children

func (*CT_TLAnimVariantStringVal) ValidateWithPath 

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

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

type CT_TLAnimateBehavior 

type CT_TLAnimateBehavior struct {
	// By
	ByAttr *string
	// From
	FromAttr *string
	// To
	ToAttr *string
	// Calculation Mode
	CalcmodeAttr ST_TLAnimateBehaviorCalcMode
	// Value Type
	ValueTypeAttr ST_TLAnimateBehaviorValueType
	CBhvr         *CT_TLCommonBehaviorData
	// Time Animated Value List
	TavLst *CT_TLTimeAnimateValueList
}

func NewCT_TLAnimateBehavior 

func NewCT_TLAnimateBehavior() *CT_TLAnimateBehavior

func (*CT_TLAnimateBehavior) MarshalXML 

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

func (*CT_TLAnimateBehavior) UnmarshalXML 

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

func (*CT_TLAnimateBehavior) Validate 

func (m *CT_TLAnimateBehavior) Validate() error

Validate validates the CT_TLAnimateBehavior and its children

func (*CT_TLAnimateBehavior) ValidateWithPath 

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

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

type CT_TLAnimateColorBehavior 

type CT_TLAnimateColorBehavior struct {
	// Color Space
	ClrSpcAttr ST_TLAnimateColorSpace
	// Direction
	DirAttr ST_TLAnimateColorDirection
	CBhvr   *CT_TLCommonBehaviorData
	// By
	By *CT_TLByAnimateColorTransform
	// From
	From *dml.CT_Color
	// To
	To *dml.CT_Color
}

func NewCT_TLAnimateColorBehavior 

func NewCT_TLAnimateColorBehavior() *CT_TLAnimateColorBehavior

func (*CT_TLAnimateColorBehavior) MarshalXML 

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

func (*CT_TLAnimateColorBehavior) UnmarshalXML 

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

func (*CT_TLAnimateColorBehavior) Validate 

func (m *CT_TLAnimateColorBehavior) Validate() error

Validate validates the CT_TLAnimateColorBehavior and its children

func (*CT_TLAnimateColorBehavior) ValidateWithPath 

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

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

type CT_TLAnimateEffectBehavior 

type CT_TLAnimateEffectBehavior struct {
	// Transition
	TransitionAttr ST_TLAnimateEffectTransition
	// Filter
	FilterAttr *string
	// Property List
	PrLstAttr *string
	CBhvr     *CT_TLCommonBehaviorData
	// Progress
	Progress *CT_TLAnimVariant
}

func NewCT_TLAnimateEffectBehavior 

func NewCT_TLAnimateEffectBehavior() *CT_TLAnimateEffectBehavior

func (*CT_TLAnimateEffectBehavior) MarshalXML 

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

func (*CT_TLAnimateEffectBehavior) UnmarshalXML 

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

func (*CT_TLAnimateEffectBehavior) Validate 

func (m *CT_TLAnimateEffectBehavior) Validate() error

Validate validates the CT_TLAnimateEffectBehavior and its children

func (*CT_TLAnimateEffectBehavior) ValidateWithPath 

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

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

type CT_TLAnimateMotionBehavior 

type CT_TLAnimateMotionBehavior struct {
	// Origin
	OriginAttr ST_TLAnimateMotionBehaviorOrigin
	// Path
	PathAttr *string
	// Path Edit Mode
	PathEditModeAttr ST_TLAnimateMotionPathEditMode
	// Relative Angle
	RAngAttr *int32
	// Points Types
	PtsTypesAttr *string
	CBhvr        *CT_TLCommonBehaviorData
	By           *CT_TLPoint
	// From
	From *CT_TLPoint
	To   *CT_TLPoint
	// Rotation Center
	RCtr *CT_TLPoint
}

func NewCT_TLAnimateMotionBehavior 

func NewCT_TLAnimateMotionBehavior() *CT_TLAnimateMotionBehavior

func (*CT_TLAnimateMotionBehavior) MarshalXML 

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

func (*CT_TLAnimateMotionBehavior) UnmarshalXML 

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

func (*CT_TLAnimateMotionBehavior) Validate 

func (m *CT_TLAnimateMotionBehavior) Validate() error

Validate validates the CT_TLAnimateMotionBehavior and its children

func (*CT_TLAnimateMotionBehavior) ValidateWithPath 

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

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

type CT_TLAnimateRotationBehavior 

type CT_TLAnimateRotationBehavior struct {
	// By
	ByAttr *int32
	// From
	FromAttr *int32
	// To
	ToAttr *int32
	CBhvr  *CT_TLCommonBehaviorData
}

func NewCT_TLAnimateRotationBehavior 

func NewCT_TLAnimateRotationBehavior() *CT_TLAnimateRotationBehavior

func (*CT_TLAnimateRotationBehavior) MarshalXML 

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

func (*CT_TLAnimateRotationBehavior) UnmarshalXML 

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

func (*CT_TLAnimateRotationBehavior) Validate 

func (m *CT_TLAnimateRotationBehavior) Validate() error

Validate validates the CT_TLAnimateRotationBehavior and its children

func (*CT_TLAnimateRotationBehavior) ValidateWithPath 

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

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

type CT_TLAnimateScaleBehavior 

type CT_TLAnimateScaleBehavior struct {
	// Zoom Content
	ZoomContentsAttr *bool
	CBhvr            *CT_TLCommonBehaviorData
	// By
	By   *CT_TLPoint
	From *CT_TLPoint
	// To
	To *CT_TLPoint
}

func NewCT_TLAnimateScaleBehavior 

func NewCT_TLAnimateScaleBehavior() *CT_TLAnimateScaleBehavior

func (*CT_TLAnimateScaleBehavior) MarshalXML 

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

func (*CT_TLAnimateScaleBehavior) UnmarshalXML 

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

func (*CT_TLAnimateScaleBehavior) Validate 

func (m *CT_TLAnimateScaleBehavior) Validate() error

Validate validates the CT_TLAnimateScaleBehavior and its children

func (*CT_TLAnimateScaleBehavior) ValidateWithPath 

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

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

type CT_TLBehaviorAttributeNameList 

type CT_TLBehaviorAttributeNameList struct {
	// Attribute Name
	AttrName []string
}

func NewCT_TLBehaviorAttributeNameList 

func NewCT_TLBehaviorAttributeNameList() *CT_TLBehaviorAttributeNameList

func (*CT_TLBehaviorAttributeNameList) MarshalXML 

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

func (*CT_TLBehaviorAttributeNameList) UnmarshalXML 

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

func (*CT_TLBehaviorAttributeNameList) Validate 

func (m *CT_TLBehaviorAttributeNameList) Validate() error

Validate validates the CT_TLBehaviorAttributeNameList and its children

func (*CT_TLBehaviorAttributeNameList) ValidateWithPath 

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

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

type CT_TLBuildDiagram 

type CT_TLBuildDiagram struct {
	// Diagram Build Types
	BldAttr      ST_TLDiagramBuildType
	SpidAttr     *uint32
	GrpIdAttr    *uint32
	UiExpandAttr *bool
}

func NewCT_TLBuildDiagram 

func NewCT_TLBuildDiagram() *CT_TLBuildDiagram

func (*CT_TLBuildDiagram) MarshalXML 

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

func (*CT_TLBuildDiagram) UnmarshalXML 

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

func (*CT_TLBuildDiagram) Validate 

func (m *CT_TLBuildDiagram) Validate() error

Validate validates the CT_TLBuildDiagram and its children

func (*CT_TLBuildDiagram) ValidateWithPath 

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

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

type CT_TLBuildParagraph 

type CT_TLBuildParagraph struct {
	// Build Types
	BuildAttr ST_TLParaBuildType
	// Build Level
	BldLvlAttr *uint32
	// Animate Background
	AnimBgAttr *bool
	// Auto Update Animation Background
	AutoUpdateAnimBgAttr *bool
	// Reverse
	RevAttr *bool
	// Auto Advance Time
	AdvAutoAttr *ST_TLTime
	// Template effects
	TmplLst      *CT_TLTemplateList
	SpidAttr     *uint32
	GrpIdAttr    *uint32
	UiExpandAttr *bool
}

func NewCT_TLBuildParagraph 

func NewCT_TLBuildParagraph() *CT_TLBuildParagraph

func (*CT_TLBuildParagraph) MarshalXML 

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

func (*CT_TLBuildParagraph) UnmarshalXML 

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

func (*CT_TLBuildParagraph) Validate 

func (m *CT_TLBuildParagraph) Validate() error

Validate validates the CT_TLBuildParagraph and its children

func (*CT_TLBuildParagraph) ValidateWithPath 

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

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

type CT_TLByAnimateColorTransform 

type CT_TLByAnimateColorTransform struct {
	// RGB
	Rgb *CT_TLByRgbColorTransform
	// HSL
	Hsl *CT_TLByHslColorTransform
}

func NewCT_TLByAnimateColorTransform 

func NewCT_TLByAnimateColorTransform() *CT_TLByAnimateColorTransform

func (*CT_TLByAnimateColorTransform) MarshalXML 

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

func (*CT_TLByAnimateColorTransform) UnmarshalXML 

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

func (*CT_TLByAnimateColorTransform) Validate 

func (m *CT_TLByAnimateColorTransform) Validate() error

Validate validates the CT_TLByAnimateColorTransform and its children

func (*CT_TLByAnimateColorTransform) ValidateWithPath 

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

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

type CT_TLByHslColorTransform 

type CT_TLByHslColorTransform struct {
	// Hue
	HAttr int32
	// Saturation
	SAttr dml.ST_FixedPercentage
	// Lightness
	LAttr dml.ST_FixedPercentage
}

func NewCT_TLByHslColorTransform 

func NewCT_TLByHslColorTransform() *CT_TLByHslColorTransform

func (*CT_TLByHslColorTransform) MarshalXML 

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

func (*CT_TLByHslColorTransform) UnmarshalXML 

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

func (*CT_TLByHslColorTransform) Validate 

func (m *CT_TLByHslColorTransform) Validate() error

Validate validates the CT_TLByHslColorTransform and its children

func (*CT_TLByHslColorTransform) ValidateWithPath 

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

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

type CT_TLByRgbColorTransform 

type CT_TLByRgbColorTransform struct {
	// Red
	RAttr dml.ST_FixedPercentage
	// Green
	GAttr dml.ST_FixedPercentage
	// Blue
	BAttr dml.ST_FixedPercentage
}

func NewCT_TLByRgbColorTransform 

func NewCT_TLByRgbColorTransform() *CT_TLByRgbColorTransform

func (*CT_TLByRgbColorTransform) MarshalXML 

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

func (*CT_TLByRgbColorTransform) UnmarshalXML 

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

func (*CT_TLByRgbColorTransform) Validate 

func (m *CT_TLByRgbColorTransform) Validate() error

Validate validates the CT_TLByRgbColorTransform and its children

func (*CT_TLByRgbColorTransform) ValidateWithPath 

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

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

type CT_TLCommandBehavior 

type CT_TLCommandBehavior struct {
	// Command Type
	TypeAttr ST_TLCommandType
	// Command
	CmdAttr *string
	CBhvr   *CT_TLCommonBehaviorData
}

func NewCT_TLCommandBehavior 

func NewCT_TLCommandBehavior() *CT_TLCommandBehavior

func (*CT_TLCommandBehavior) MarshalXML 

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

func (*CT_TLCommandBehavior) UnmarshalXML 

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

func (*CT_TLCommandBehavior) Validate 

func (m *CT_TLCommandBehavior) Validate() error

Validate validates the CT_TLCommandBehavior and its children

func (*CT_TLCommandBehavior) ValidateWithPath 

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

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

type CT_TLCommonBehaviorData 

type CT_TLCommonBehaviorData struct {
	// Additive
	AdditiveAttr ST_TLBehaviorAdditiveType
	// Accumulate
	AccumulateAttr ST_TLBehaviorAccumulateType
	// Transform Type
	XfrmTypeAttr ST_TLBehaviorTransformType
	// From
	FromAttr *string
	// To
	ToAttr *string
	// By
	ByAttr *string
	// Runtime Context
	RctxAttr *string
	// Override
	OverrideAttr ST_TLBehaviorOverrideType
	CTn          *CT_TLCommonTimeNodeData
	// Target Element
	TgtEl *CT_TLTimeTargetElement
	// Attribute Name List
	AttrNameLst *CT_TLBehaviorAttributeNameList
}

func NewCT_TLCommonBehaviorData 

func NewCT_TLCommonBehaviorData() *CT_TLCommonBehaviorData

func (*CT_TLCommonBehaviorData) MarshalXML 

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

func (*CT_TLCommonBehaviorData) UnmarshalXML 

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

func (*CT_TLCommonBehaviorData) Validate 

func (m *CT_TLCommonBehaviorData) Validate() error

Validate validates the CT_TLCommonBehaviorData and its children

func (*CT_TLCommonBehaviorData) ValidateWithPath 

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

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

type CT_TLCommonMediaNodeData 

type CT_TLCommonMediaNodeData struct {
	// Volume
	VolAttr *dml.ST_PositiveFixedPercentage
	// Mute
	MuteAttr *bool
	// Number of Slides
	NumSldAttr *uint32
	// Show When Stopped
	ShowWhenStoppedAttr *bool
	// Common Time Node Properties
	CTn   *CT_TLCommonTimeNodeData
	TgtEl *CT_TLTimeTargetElement
}

func NewCT_TLCommonMediaNodeData 

func NewCT_TLCommonMediaNodeData() *CT_TLCommonMediaNodeData

func (*CT_TLCommonMediaNodeData) MarshalXML 

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

func (*CT_TLCommonMediaNodeData) UnmarshalXML 

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

func (*CT_TLCommonMediaNodeData) Validate 

func (m *CT_TLCommonMediaNodeData) Validate() error

Validate validates the CT_TLCommonMediaNodeData and its children

func (*CT_TLCommonMediaNodeData) ValidateWithPath 

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

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

type CT_TLCommonTimeNodeData 

type CT_TLCommonTimeNodeData struct {
	// ID
	IdAttr *uint32
	// Preset ID
	PresetIDAttr *int32
	// Preset Types
	PresetClassAttr ST_TLTimeNodePresetClassType
	// Preset SubType
	PresetSubtypeAttr *int32
	// Duration
	DurAttr *ST_TLTime
	// Repeat Count
	RepeatCountAttr *ST_TLTime
	// Repeat Duration
	RepeatDurAttr *ST_TLTime
	// Speed
	SpdAttr *dml.ST_Percentage
	// Acceleration
	AccelAttr *dml.ST_PositiveFixedPercentage
	// Deceleration
	DecelAttr *dml.ST_PositiveFixedPercentage
	// Auto Reverse
	AutoRevAttr *bool
	// Restart
	RestartAttr ST_TLTimeNodeRestartType
	// Fill
	FillAttr ST_TLTimeNodeFillType
	// Synchronization Behavior
	SyncBehaviorAttr ST_TLTimeNodeSyncType
	// Time Filter
	TmFilterAttr *string
	// Event Filter
	EvtFilterAttr *string
	// Display
	DisplayAttr *bool
	// Master Relation
	MasterRelAttr ST_TLTimeNodeMasterRelation
	// Build level
	BldLvlAttr *int32
	// Group ID
	GrpIdAttr *uint32
	// After Effect
	AfterEffectAttr *bool
	// Node Type
	NodeTypeAttr ST_TLTimeNodeType
	// Node Placeholder
	NodePhAttr *bool
	// Start Conditions List
	StCondLst *CT_TLTimeConditionList
	// End Conditions List
	EndCondLst *CT_TLTimeConditionList
	// EndSync
	EndSync *CT_TLTimeCondition
	// Iterate
	Iterate *CT_TLIterateData
	// Children Time Node List
	ChildTnLst *CT_TimeNodeList
	// Sub-TimeNodes List
	SubTnLst *CT_TimeNodeList
}

func NewCT_TLCommonTimeNodeData 

func NewCT_TLCommonTimeNodeData() *CT_TLCommonTimeNodeData

func (*CT_TLCommonTimeNodeData) MarshalXML 

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

func (*CT_TLCommonTimeNodeData) UnmarshalXML 

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

func (*CT_TLCommonTimeNodeData) Validate 

func (m *CT_TLCommonTimeNodeData) Validate() error

Validate validates the CT_TLCommonTimeNodeData and its children

func (*CT_TLCommonTimeNodeData) ValidateWithPath 

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

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

type CT_TLGraphicalObjectBuild 

type CT_TLGraphicalObjectBuild struct {
	// Build As One
	BldAsOne *CT_Empty
	// Build Sub Elements
	BldSub       *dml.CT_AnimationGraphicalObjectBuildProperties
	SpidAttr     *uint32
	GrpIdAttr    *uint32
	UiExpandAttr *bool
}

func NewCT_TLGraphicalObjectBuild 

func NewCT_TLGraphicalObjectBuild() *CT_TLGraphicalObjectBuild

func (*CT_TLGraphicalObjectBuild) MarshalXML 

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

func (*CT_TLGraphicalObjectBuild) UnmarshalXML 

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

func (*CT_TLGraphicalObjectBuild) Validate 

func (m *CT_TLGraphicalObjectBuild) Validate() error

Validate validates the CT_TLGraphicalObjectBuild and its children

func (*CT_TLGraphicalObjectBuild) ValidateWithPath 

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

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

type CT_TLIterateData 

type CT_TLIterateData struct {
	// Iterate Type
	TypeAttr ST_IterateType
	// Backwards
	BackwardsAttr *bool
	// Time Absolute
	TmAbs *CT_TLIterateIntervalTime
	// Time Percentage
	TmPct *CT_TLIterateIntervalPercentage
}

func NewCT_TLIterateData 

func NewCT_TLIterateData() *CT_TLIterateData

func (*CT_TLIterateData) MarshalXML 

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

func (*CT_TLIterateData) UnmarshalXML 

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

func (*CT_TLIterateData) Validate 

func (m *CT_TLIterateData) Validate() error

Validate validates the CT_TLIterateData and its children

func (*CT_TLIterateData) ValidateWithPath 

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

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

type CT_TLIterateIntervalPercentage 

type CT_TLIterateIntervalPercentage struct {
	// Value
	ValAttr dml.ST_PositivePercentage
}

func NewCT_TLIterateIntervalPercentage 

func NewCT_TLIterateIntervalPercentage() *CT_TLIterateIntervalPercentage

func (*CT_TLIterateIntervalPercentage) MarshalXML 

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

func (*CT_TLIterateIntervalPercentage) UnmarshalXML 

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

func (*CT_TLIterateIntervalPercentage) Validate 

func (m *CT_TLIterateIntervalPercentage) Validate() error

Validate validates the CT_TLIterateIntervalPercentage and its children

func (*CT_TLIterateIntervalPercentage) ValidateWithPath 

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

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

type CT_TLIterateIntervalTime 

type CT_TLIterateIntervalTime struct {
	// Time
	ValAttr ST_TLTime
}

func NewCT_TLIterateIntervalTime 

func NewCT_TLIterateIntervalTime() *CT_TLIterateIntervalTime

func (*CT_TLIterateIntervalTime) MarshalXML 

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

func (*CT_TLIterateIntervalTime) UnmarshalXML 

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

func (*CT_TLIterateIntervalTime) Validate 

func (m *CT_TLIterateIntervalTime) Validate() error

Validate validates the CT_TLIterateIntervalTime and its children

func (*CT_TLIterateIntervalTime) ValidateWithPath 

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

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

type CT_TLMediaNodeAudio 

type CT_TLMediaNodeAudio struct {
	// Is Narration
	IsNarrationAttr *bool
	// Common Media Node Properties
	CMediaNode *CT_TLCommonMediaNodeData
}

func NewCT_TLMediaNodeAudio 

func NewCT_TLMediaNodeAudio() *CT_TLMediaNodeAudio

func (*CT_TLMediaNodeAudio) MarshalXML 

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

func (*CT_TLMediaNodeAudio) UnmarshalXML 

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

func (*CT_TLMediaNodeAudio) Validate 

func (m *CT_TLMediaNodeAudio) Validate() error

Validate validates the CT_TLMediaNodeAudio and its children

func (*CT_TLMediaNodeAudio) ValidateWithPath 

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

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

type CT_TLMediaNodeVideo 

type CT_TLMediaNodeVideo struct {
	// Full Screen
	FullScrnAttr *bool
	// Common Media Node Properties
	CMediaNode *CT_TLCommonMediaNodeData
}

func NewCT_TLMediaNodeVideo 

func NewCT_TLMediaNodeVideo() *CT_TLMediaNodeVideo

func (*CT_TLMediaNodeVideo) MarshalXML 

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

func (*CT_TLMediaNodeVideo) UnmarshalXML 

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

func (*CT_TLMediaNodeVideo) Validate 

func (m *CT_TLMediaNodeVideo) Validate() error

Validate validates the CT_TLMediaNodeVideo and its children

func (*CT_TLMediaNodeVideo) ValidateWithPath 

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

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

type CT_TLOleBuildChart 

type CT_TLOleBuildChart struct {
	// Build
	BldAttr ST_TLOleChartBuildType
	// Animate Background
	AnimBgAttr   *bool
	SpidAttr     *uint32
	GrpIdAttr    *uint32
	UiExpandAttr *bool
}

func NewCT_TLOleBuildChart 

func NewCT_TLOleBuildChart() *CT_TLOleBuildChart

func (*CT_TLOleBuildChart) MarshalXML 

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

func (*CT_TLOleBuildChart) UnmarshalXML 

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

func (*CT_TLOleBuildChart) Validate 

func (m *CT_TLOleBuildChart) Validate() error

Validate validates the CT_TLOleBuildChart and its children

func (*CT_TLOleBuildChart) ValidateWithPath 

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

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

type CT_TLOleChartTargetElement 

type CT_TLOleChartTargetElement struct {
	// Type
	TypeAttr ST_TLChartSubelementType
	// Level
	LvlAttr *uint32
}

func NewCT_TLOleChartTargetElement 

func NewCT_TLOleChartTargetElement() *CT_TLOleChartTargetElement

func (*CT_TLOleChartTargetElement) MarshalXML 

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

func (*CT_TLOleChartTargetElement) UnmarshalXML 

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

func (*CT_TLOleChartTargetElement) Validate 

func (m *CT_TLOleChartTargetElement) Validate() error

Validate validates the CT_TLOleChartTargetElement and its children

func (*CT_TLOleChartTargetElement) ValidateWithPath 

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

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

type CT_TLPoint 

type CT_TLPoint struct {
	// X coordinate
	XAttr dml.ST_Percentage
	// Y coordinate
	YAttr dml.ST_Percentage
}

func NewCT_TLPoint 

func NewCT_TLPoint() *CT_TLPoint

func (*CT_TLPoint) MarshalXML 

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

func (*CT_TLPoint) UnmarshalXML 

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

func (*CT_TLPoint) Validate 

func (m *CT_TLPoint) Validate() error

Validate validates the CT_TLPoint and its children

func (*CT_TLPoint) ValidateWithPath 

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

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

type CT_TLSetBehavior 

type CT_TLSetBehavior struct {
	// Common Behavior
	CBhvr *CT_TLCommonBehaviorData
	// To
	To *CT_TLAnimVariant
}

func NewCT_TLSetBehavior 

func NewCT_TLSetBehavior() *CT_TLSetBehavior

func (*CT_TLSetBehavior) MarshalXML 

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

func (*CT_TLSetBehavior) UnmarshalXML 

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

func (*CT_TLSetBehavior) Validate 

func (m *CT_TLSetBehavior) Validate() error

Validate validates the CT_TLSetBehavior and its children

func (*CT_TLSetBehavior) ValidateWithPath 

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

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

type CT_TLShapeTargetElement 

type CT_TLShapeTargetElement struct {
	// Shape ID
	SpidAttr uint32
	// Background
	Bg *CT_Empty
	// Subshape
	SubSp *CT_TLSubShapeId
	// Embedded Chart Element
	OleChartEl *CT_TLOleChartTargetElement
	// Text Element
	TxEl *CT_TLTextTargetElement
	// Graphic Element
	GraphicEl *dml.CT_AnimationElementChoice
}

func NewCT_TLShapeTargetElement 

func NewCT_TLShapeTargetElement() *CT_TLShapeTargetElement

func (*CT_TLShapeTargetElement) MarshalXML 

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

func (*CT_TLShapeTargetElement) UnmarshalXML 

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

func (*CT_TLShapeTargetElement) Validate 

func (m *CT_TLShapeTargetElement) Validate() error

Validate validates the CT_TLShapeTargetElement and its children

func (*CT_TLShapeTargetElement) ValidateWithPath 

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

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

type CT_TLSubShapeId 

type CT_TLSubShapeId struct {
	// Shape ID
	SpidAttr string
}

func NewCT_TLSubShapeId 

func NewCT_TLSubShapeId() *CT_TLSubShapeId

func (*CT_TLSubShapeId) MarshalXML 

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

func (*CT_TLSubShapeId) UnmarshalXML 

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

func (*CT_TLSubShapeId) Validate 

func (m *CT_TLSubShapeId) Validate() error

Validate validates the CT_TLSubShapeId and its children

func (*CT_TLSubShapeId) ValidateWithPath 

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

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

type CT_TLTemplate 

type CT_TLTemplate struct {
	// Level
	LvlAttr *uint32
	// Time Node List
	TnLst *CT_TimeNodeList
}

func NewCT_TLTemplate 

func NewCT_TLTemplate() *CT_TLTemplate

func (*CT_TLTemplate) MarshalXML 

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

func (*CT_TLTemplate) UnmarshalXML 

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

func (*CT_TLTemplate) Validate 

func (m *CT_TLTemplate) Validate() error

Validate validates the CT_TLTemplate and its children

func (*CT_TLTemplate) ValidateWithPath 

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

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

type CT_TLTemplateList 

type CT_TLTemplateList struct {
	// Template Effects
	Tmpl []*CT_TLTemplate
}

func NewCT_TLTemplateList 

func NewCT_TLTemplateList() *CT_TLTemplateList

func (*CT_TLTemplateList) MarshalXML 

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

func (*CT_TLTemplateList) UnmarshalXML 

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

func (*CT_TLTemplateList) Validate 

func (m *CT_TLTemplateList) Validate() error

Validate validates the CT_TLTemplateList and its children

func (*CT_TLTemplateList) ValidateWithPath 

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

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

type CT_TLTextTargetElement 

type CT_TLTextTargetElement struct {
	// Character Range
	CharRg *CT_IndexRange
	// Paragraph Text Range
	PRg *CT_IndexRange
}

func NewCT_TLTextTargetElement 

func NewCT_TLTextTargetElement() *CT_TLTextTargetElement

func (*CT_TLTextTargetElement) MarshalXML 

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

func (*CT_TLTextTargetElement) UnmarshalXML 

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

func (*CT_TLTextTargetElement) Validate 

func (m *CT_TLTextTargetElement) Validate() error

Validate validates the CT_TLTextTargetElement and its children

func (*CT_TLTextTargetElement) ValidateWithPath 

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

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

type CT_TLTimeAnimateValue 

type CT_TLTimeAnimateValue struct {
	// Time
	TmAttr *ST_TLTimeAnimateValueTime
	// Formula
	FmlaAttr *string
	// Value
	Val *CT_TLAnimVariant
}

func NewCT_TLTimeAnimateValue 

func NewCT_TLTimeAnimateValue() *CT_TLTimeAnimateValue

func (*CT_TLTimeAnimateValue) MarshalXML 

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

func (*CT_TLTimeAnimateValue) UnmarshalXML 

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

func (*CT_TLTimeAnimateValue) Validate 

func (m *CT_TLTimeAnimateValue) Validate() error

Validate validates the CT_TLTimeAnimateValue and its children

func (*CT_TLTimeAnimateValue) ValidateWithPath 

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

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

type CT_TLTimeAnimateValueList 

type CT_TLTimeAnimateValueList struct {
	// Time Animate Value
	Tav []*CT_TLTimeAnimateValue
}

func NewCT_TLTimeAnimateValueList 

func NewCT_TLTimeAnimateValueList() *CT_TLTimeAnimateValueList

func (*CT_TLTimeAnimateValueList) MarshalXML 

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

func (*CT_TLTimeAnimateValueList) UnmarshalXML 

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

func (*CT_TLTimeAnimateValueList) Validate 

func (m *CT_TLTimeAnimateValueList) Validate() error

Validate validates the CT_TLTimeAnimateValueList and its children

func (*CT_TLTimeAnimateValueList) ValidateWithPath 

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

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

type CT_TLTimeCondition 

type CT_TLTimeCondition struct {
	// Trigger Event
	EvtAttr ST_TLTriggerEvent
	// Trigger Delay
	DelayAttr *ST_TLTime
	// Target Element Trigger Choice
	TgtEl *CT_TLTimeTargetElement
	// Time Node
	Tn *CT_TLTriggerTimeNodeID
	// Runtime Node Trigger Choice
	Rtn *CT_TLTriggerRuntimeNode
}

func NewCT_TLTimeCondition 

func NewCT_TLTimeCondition() *CT_TLTimeCondition

func (*CT_TLTimeCondition) MarshalXML 

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

func (*CT_TLTimeCondition) UnmarshalXML 

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

func (*CT_TLTimeCondition) Validate 

func (m *CT_TLTimeCondition) Validate() error

Validate validates the CT_TLTimeCondition and its children

func (*CT_TLTimeCondition) ValidateWithPath 

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

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

type CT_TLTimeConditionList 

type CT_TLTimeConditionList struct {
	// Condition
	Cond []*CT_TLTimeCondition
}

func NewCT_TLTimeConditionList 

func NewCT_TLTimeConditionList() *CT_TLTimeConditionList

func (*CT_TLTimeConditionList) MarshalXML 

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

func (*CT_TLTimeConditionList) UnmarshalXML 

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

func (*CT_TLTimeConditionList) Validate 

func (m *CT_TLTimeConditionList) Validate() error

Validate validates the CT_TLTimeConditionList and its children

func (*CT_TLTimeConditionList) ValidateWithPath 

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

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

type CT_TLTimeNodeExclusive 

type CT_TLTimeNodeExclusive struct {
	// Common TimeNode Properties
	CTn *CT_TLCommonTimeNodeData
}

func NewCT_TLTimeNodeExclusive 

func NewCT_TLTimeNodeExclusive() *CT_TLTimeNodeExclusive

func (*CT_TLTimeNodeExclusive) MarshalXML 

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

func (*CT_TLTimeNodeExclusive) UnmarshalXML 

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

func (*CT_TLTimeNodeExclusive) Validate 

func (m *CT_TLTimeNodeExclusive) Validate() error

Validate validates the CT_TLTimeNodeExclusive and its children

func (*CT_TLTimeNodeExclusive) ValidateWithPath 

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

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

type CT_TLTimeNodeParallel 

type CT_TLTimeNodeParallel struct {
	// Parallel TimeNode
	CTn *CT_TLCommonTimeNodeData
}

func NewCT_TLTimeNodeParallel 

func NewCT_TLTimeNodeParallel() *CT_TLTimeNodeParallel

func (*CT_TLTimeNodeParallel) MarshalXML 

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

func (*CT_TLTimeNodeParallel) UnmarshalXML 

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

func (*CT_TLTimeNodeParallel) Validate 

func (m *CT_TLTimeNodeParallel) Validate() error

Validate validates the CT_TLTimeNodeParallel and its children

func (*CT_TLTimeNodeParallel) ValidateWithPath 

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

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

type CT_TLTimeNodeSequence 

type CT_TLTimeNodeSequence struct {
	// Concurrent
	ConcurrentAttr *bool
	// Previous Action
	PrevAcAttr ST_TLPreviousActionType
	// Next Action
	NextAcAttr ST_TLNextActionType
	// Common TimeNode Properties
	CTn *CT_TLCommonTimeNodeData
	// Previous Conditions List
	PrevCondLst *CT_TLTimeConditionList
	// Next Conditions List
	NextCondLst *CT_TLTimeConditionList
}

func NewCT_TLTimeNodeSequence 

func NewCT_TLTimeNodeSequence() *CT_TLTimeNodeSequence

func (*CT_TLTimeNodeSequence) MarshalXML 

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

func (*CT_TLTimeNodeSequence) UnmarshalXML 

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

func (*CT_TLTimeNodeSequence) Validate 

func (m *CT_TLTimeNodeSequence) Validate() error

Validate validates the CT_TLTimeNodeSequence and its children

func (*CT_TLTimeNodeSequence) ValidateWithPath 

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

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

type CT_TLTimeTargetElement 

type CT_TLTimeTargetElement struct {
	// Slide Target
	SldTgt *CT_Empty
	// Sound Target
	SndTgt *dml.CT_EmbeddedWAVAudioFile
	// Shape Target
	SpTgt *CT_TLShapeTargetElement
	// Ink Target
	InkTgt *CT_TLSubShapeId
}

func NewCT_TLTimeTargetElement 

func NewCT_TLTimeTargetElement() *CT_TLTimeTargetElement

func (*CT_TLTimeTargetElement) MarshalXML 

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

func (*CT_TLTimeTargetElement) UnmarshalXML 

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

func (*CT_TLTimeTargetElement) Validate 

func (m *CT_TLTimeTargetElement) Validate() error

Validate validates the CT_TLTimeTargetElement and its children

func (*CT_TLTimeTargetElement) ValidateWithPath 

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

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

type CT_TLTriggerRuntimeNode 

type CT_TLTriggerRuntimeNode struct {
	// Value
	ValAttr ST_TLTriggerRuntimeNode
}

func NewCT_TLTriggerRuntimeNode 

func NewCT_TLTriggerRuntimeNode() *CT_TLTriggerRuntimeNode

func (*CT_TLTriggerRuntimeNode) MarshalXML 

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

func (*CT_TLTriggerRuntimeNode) UnmarshalXML 

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

func (*CT_TLTriggerRuntimeNode) Validate 

func (m *CT_TLTriggerRuntimeNode) Validate() error

Validate validates the CT_TLTriggerRuntimeNode and its children

func (*CT_TLTriggerRuntimeNode) ValidateWithPath 

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

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

type CT_TLTriggerTimeNodeID 

type CT_TLTriggerTimeNodeID struct {
	// Value
	ValAttr uint32
}

func NewCT_TLTriggerTimeNodeID 

func NewCT_TLTriggerTimeNodeID() *CT_TLTriggerTimeNodeID

func (*CT_TLTriggerTimeNodeID) MarshalXML 

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

func (*CT_TLTriggerTimeNodeID) UnmarshalXML 

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

func (*CT_TLTriggerTimeNodeID) Validate 

func (m *CT_TLTriggerTimeNodeID) Validate() error

Validate validates the CT_TLTriggerTimeNodeID and its children

func (*CT_TLTriggerTimeNodeID) ValidateWithPath 

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

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

type CT_TagList 

type CT_TagList struct {
	// Programmable Extensibility Tag
	Tag []*CT_StringTag
}

func NewCT_TagList 

func NewCT_TagList() *CT_TagList

func (*CT_TagList) MarshalXML 

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

func (*CT_TagList) UnmarshalXML 

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

func (*CT_TagList) Validate 

func (m *CT_TagList) Validate() error

Validate validates the CT_TagList and its children

func (*CT_TagList) ValidateWithPath 

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

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

type CT_TagsData 

type CT_TagsData struct {
	IdAttr string
}

func NewCT_TagsData 

func NewCT_TagsData() *CT_TagsData

func (*CT_TagsData) MarshalXML 

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

func (*CT_TagsData) UnmarshalXML 

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

func (*CT_TagsData) Validate 

func (m *CT_TagsData) Validate() error

Validate validates the CT_TagsData and its children

func (*CT_TagsData) ValidateWithPath 

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

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

type CT_TimeNodeList 

type CT_TimeNodeList struct {
	// Parallel Time Node
	Par []*CT_TLTimeNodeParallel
	// Sequence Time Node
	Seq []*CT_TLTimeNodeSequence
	// Exclusive
	Excl []*CT_TLTimeNodeExclusive
	// Animate
	Anim []*CT_TLAnimateBehavior
	// Animate Color Behavior
	AnimClr []*CT_TLAnimateColorBehavior
	// Animate Effect
	AnimEffect []*CT_TLAnimateEffectBehavior
	// Animate Motion
	AnimMotion []*CT_TLAnimateMotionBehavior
	// Animate Rotation
	AnimRot []*CT_TLAnimateRotationBehavior
	// Animate Scale
	AnimScale []*CT_TLAnimateScaleBehavior
	// Command
	Cmd []*CT_TLCommandBehavior
	// Set Time Node Behavior
	Set []*CT_TLSetBehavior
	// Audio
	Audio []*CT_TLMediaNodeAudio
	// Video
	Video []*CT_TLMediaNodeVideo
}

func NewCT_TimeNodeList 

func NewCT_TimeNodeList() *CT_TimeNodeList

func (*CT_TimeNodeList) MarshalXML 

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

func (*CT_TimeNodeList) UnmarshalXML 

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

func (*CT_TimeNodeList) Validate 

func (m *CT_TimeNodeList) Validate() error

Validate validates the CT_TimeNodeList and its children

func (*CT_TimeNodeList) ValidateWithPath 

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

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

type CT_TransitionSoundAction 

type CT_TransitionSoundAction struct {
	// Start Sound Action
	StSnd *CT_TransitionStartSoundAction
	// Stop Sound Action
	EndSnd *CT_Empty
}

func NewCT_TransitionSoundAction 

func NewCT_TransitionSoundAction() *CT_TransitionSoundAction

func (*CT_TransitionSoundAction) MarshalXML 

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

func (*CT_TransitionSoundAction) UnmarshalXML 

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

func (*CT_TransitionSoundAction) Validate 

func (m *CT_TransitionSoundAction) Validate() error

Validate validates the CT_TransitionSoundAction and its children

func (*CT_TransitionSoundAction) ValidateWithPath 

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

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

type CT_TransitionStartSoundAction 

type CT_TransitionStartSoundAction struct {
	// Loop Sound
	LoopAttr *bool
	// Sound
	Snd *dml.CT_EmbeddedWAVAudioFile
}

func NewCT_TransitionStartSoundAction 

func NewCT_TransitionStartSoundAction() *CT_TransitionStartSoundAction

func (*CT_TransitionStartSoundAction) MarshalXML 

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

func (*CT_TransitionStartSoundAction) UnmarshalXML 

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

func (*CT_TransitionStartSoundAction) Validate 

func (m *CT_TransitionStartSoundAction) Validate() error

Validate validates the CT_TransitionStartSoundAction and its children

func (*CT_TransitionStartSoundAction) ValidateWithPath 

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

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

type CT_ViewProperties 

type CT_ViewProperties struct {
	// Last View
	LastViewAttr ST_ViewType
	// Show Comments
	ShowCommentsAttr *bool
	// Normal View Properties
	NormalViewPr *CT_NormalViewProperties
	// Slide View Properties
	SlideViewPr *CT_SlideViewProperties
	// Outline View Properties
	OutlineViewPr *CT_OutlineViewProperties
	// Notes Text View Properties
	NotesTextViewPr *CT_NotesTextViewProperties
	// Slide Sorter View Properties
	SorterViewPr *CT_SlideSorterViewProperties
	// Notes View Properties
	NotesViewPr *CT_NotesViewProperties
	// Grid Spacing
	GridSpacing *dml.CT_PositiveSize2D
	ExtLst      *CT_ExtensionList
}

func NewCT_ViewProperties 

func NewCT_ViewProperties() *CT_ViewProperties

func (*CT_ViewProperties) MarshalXML 

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

func (*CT_ViewProperties) UnmarshalXML 

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

func (*CT_ViewProperties) Validate 

func (m *CT_ViewProperties) Validate() error

Validate validates the CT_ViewProperties and its children

func (*CT_ViewProperties) ValidateWithPath 

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

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

type CT_WebProperties 

type CT_WebProperties struct {
	// Show animation in HTML output
	ShowAnimationAttr *bool
	// Resize graphics in HTML output
	ResizeGraphicsAttr *bool
	// Allow PNG in HTML output
	AllowPngAttr *bool
	// Rely on VML for HTML output
	RelyOnVmlAttr *bool
	// Organize HTML output in folders
	OrganizeInFoldersAttr *bool
	// Use long file names in HTML output
	UseLongFilenamesAttr *bool
	// Image size for HTML output
	ImgSzAttr ST_WebScreenSize
	// Encoding for HTML output
	EncodingAttr *string
	// Slide Navigation Colors for HTML output
	ClrAttr ST_WebColorType
	ExtLst  *CT_ExtensionList
}

func NewCT_WebProperties 

func NewCT_WebProperties() *CT_WebProperties

func (*CT_WebProperties) MarshalXML 

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

func (*CT_WebProperties) UnmarshalXML 

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

func (*CT_WebProperties) Validate 

func (m *CT_WebProperties) Validate() error

Validate validates the CT_WebProperties and its children

func (*CT_WebProperties) ValidateWithPath 

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

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

type CT_WheelTransition 

type CT_WheelTransition struct {
	// Spokes
	SpokesAttr *uint32
}

func NewCT_WheelTransition 

func NewCT_WheelTransition() *CT_WheelTransition

func (*CT_WheelTransition) MarshalXML 

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

func (*CT_WheelTransition) UnmarshalXML 

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

func (*CT_WheelTransition) Validate 

func (m *CT_WheelTransition) Validate() error

Validate validates the CT_WheelTransition and its children

func (*CT_WheelTransition) ValidateWithPath 

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

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

type CmAuthorLst 

type CmAuthorLst struct {
	CT_CommentAuthorList
}

func NewCmAuthorLst 

func NewCmAuthorLst() *CmAuthorLst

func (*CmAuthorLst) MarshalXML 

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

func (*CmAuthorLst) UnmarshalXML 

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

func (*CmAuthorLst) Validate 

func (m *CmAuthorLst) Validate() error

Validate validates the CmAuthorLst and its children

func (*CmAuthorLst) ValidateWithPath 

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

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

type CmLst 

type CmLst struct {
	CT_CommentList
}

func NewCmLst 

func NewCmLst() *CmLst

func (*CmLst) MarshalXML 

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

func (*CmLst) UnmarshalXML 

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

func (*CmLst) Validate 

func (m *CmLst) Validate() error

Validate validates the CmLst and its children

func (*CmLst) ValidateWithPath 

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

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

type EG_Background 

type EG_Background struct {
	// Background Properties
	BgPr *CT_BackgroundProperties
	// Background Style Reference
	BgRef *dml.CT_StyleMatrixReference
}

func NewEG_Background 

func NewEG_Background() *EG_Background

func (*EG_Background) MarshalXML 

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

func (*EG_Background) UnmarshalXML 

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

func (*EG_Background) Validate 

func (m *EG_Background) Validate() error

Validate validates the EG_Background and its children

func (*EG_Background) ValidateWithPath 

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

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

type EG_ChildSlide 

type EG_ChildSlide struct {
	// Color Scheme Map Override
	ClrMapOvr *dml.CT_ColorMappingOverride
}

func NewEG_ChildSlide 

func NewEG_ChildSlide() *EG_ChildSlide

func (*EG_ChildSlide) MarshalXML 

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

func (*EG_ChildSlide) UnmarshalXML 

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

func (*EG_ChildSlide) Validate 

func (m *EG_ChildSlide) Validate() error

Validate validates the EG_ChildSlide and its children

func (*EG_ChildSlide) ValidateWithPath 

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

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

type EG_ExtensionList 

type EG_ExtensionList struct {
	// Extension
	Ext []*CT_Extension
}

func NewEG_ExtensionList 

func NewEG_ExtensionList() *EG_ExtensionList

func (*EG_ExtensionList) MarshalXML 

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

func (*EG_ExtensionList) UnmarshalXML 

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

func (*EG_ExtensionList) Validate 

func (m *EG_ExtensionList) Validate() error

Validate validates the EG_ExtensionList and its children

func (*EG_ExtensionList) ValidateWithPath 

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

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

type EG_ShowType 

type EG_ShowType struct {
	// Presenter Slide Show Mode
	Present *CT_Empty
	// Browse Slide Show Mode
	Browse *CT_ShowInfoBrowse
	// Kiosk Slide Show Mode
	Kiosk *CT_ShowInfoKiosk
}

func NewEG_ShowType 

func NewEG_ShowType() *EG_ShowType

func (*EG_ShowType) MarshalXML 

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

func (*EG_ShowType) UnmarshalXML 

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

func (*EG_ShowType) Validate 

func (m *EG_ShowType) Validate() error

Validate validates the EG_ShowType and its children

func (*EG_ShowType) ValidateWithPath 

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

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

type EG_SlideListChoice 

type EG_SlideListChoice struct {
	// All Slides
	SldAll *CT_Empty
	// Slide Range
	SldRg *CT_IndexRange
	// Custom Show
	CustShow *CT_CustomShowId
}

func NewEG_SlideListChoice 

func NewEG_SlideListChoice() *EG_SlideListChoice

func (*EG_SlideListChoice) MarshalXML 

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

func (*EG_SlideListChoice) UnmarshalXML 

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

func (*EG_SlideListChoice) Validate 

func (m *EG_SlideListChoice) Validate() error

Validate validates the EG_SlideListChoice and its children

func (*EG_SlideListChoice) ValidateWithPath 

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

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

type EG_TopLevelSlide 

type EG_TopLevelSlide struct {
	// Color Scheme Map
	ClrMap *dml.CT_ColorMapping
}

func NewEG_TopLevelSlide 

func NewEG_TopLevelSlide() *EG_TopLevelSlide

func (*EG_TopLevelSlide) MarshalXML 

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

func (*EG_TopLevelSlide) UnmarshalXML 

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

func (*EG_TopLevelSlide) Validate 

func (m *EG_TopLevelSlide) Validate() error

Validate validates the EG_TopLevelSlide and its children

func (*EG_TopLevelSlide) ValidateWithPath 

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

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

type HandoutMaster 

type HandoutMaster struct {
	CT_HandoutMaster
}

func NewHandoutMaster 

func NewHandoutMaster() *HandoutMaster

func (*HandoutMaster) MarshalXML 

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

func (*HandoutMaster) UnmarshalXML 

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

func (*HandoutMaster) Validate 

func (m *HandoutMaster) Validate() error

Validate validates the HandoutMaster and its children

func (*HandoutMaster) ValidateWithPath 

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

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

type Notes 

type Notes struct {
	CT_NotesSlide
}

func NewNotes 

func NewNotes() *Notes

func (*Notes) MarshalXML 

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

func (*Notes) UnmarshalXML 

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

func (*Notes) Validate 

func (m *Notes) Validate() error

Validate validates the Notes and its children

func (*Notes) ValidateWithPath 

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

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

type NotesMaster 

type NotesMaster struct {
	CT_NotesMaster
}

func NewNotesMaster 

func NewNotesMaster() *NotesMaster

func (*NotesMaster) MarshalXML 

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

func (*NotesMaster) UnmarshalXML 

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

func (*NotesMaster) Validate 

func (m *NotesMaster) Validate() error

Validate validates the NotesMaster and its children

func (*NotesMaster) ValidateWithPath 

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

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

type OleObj 

type OleObj struct {
	CT_OleObject
}

func NewOleObj 

func NewOleObj() *OleObj

func (*OleObj) MarshalXML 

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

func (*OleObj) UnmarshalXML 

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

func (*OleObj) Validate 

func (m *OleObj) Validate() error

Validate validates the OleObj and its children

func (*OleObj) ValidateWithPath 

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

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

type Presentation 

type Presentation struct {
	CT_Presentation
}

func NewPresentation 

func NewPresentation() *Presentation

func (*Presentation) MarshalXML 

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

func (*Presentation) UnmarshalXML 

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

func (*Presentation) Validate 

func (m *Presentation) Validate() error

Validate validates the Presentation and its children

func (*Presentation) ValidateWithPath 

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

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

type PresentationPr 

type PresentationPr struct {
	CT_PresentationProperties
}

func NewPresentationPr 

func NewPresentationPr() *PresentationPr

func (*PresentationPr) MarshalXML 

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

func (*PresentationPr) UnmarshalXML 

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

func (*PresentationPr) Validate 

func (m *PresentationPr) Validate() error

Validate validates the PresentationPr and its children

func (*PresentationPr) ValidateWithPath 

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

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

type ST_Direction 

type ST_Direction byte
const (
	ST_DirectionUnset ST_Direction = 0
	ST_DirectionHorz  ST_Direction = 1
	ST_DirectionVert  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_IterateType 

type ST_IterateType byte
const (
	ST_IterateTypeUnset ST_IterateType = 0
	ST_IterateTypeEl    ST_IterateType = 1
	ST_IterateTypeWd    ST_IterateType = 2
	ST_IterateTypeLt    ST_IterateType = 3
)

func (ST_IterateType) MarshalXML 

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

func (ST_IterateType) MarshalXMLAttr 

func (e ST_IterateType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_IterateType) String 

func (m ST_IterateType) String() string

func (*ST_IterateType) UnmarshalXML 

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

func (*ST_IterateType) UnmarshalXMLAttr 

func (e *ST_IterateType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_IterateType) Validate 

func (m ST_IterateType) Validate() error

func (ST_IterateType) ValidateWithPath 

func (m ST_IterateType) ValidateWithPath(path string) error

type ST_OleObjectFollowColorScheme 

type ST_OleObjectFollowColorScheme byte
const (
	ST_OleObjectFollowColorSchemeUnset             ST_OleObjectFollowColorScheme = 0
	ST_OleObjectFollowColorSchemeNone              ST_OleObjectFollowColorScheme = 1
	ST_OleObjectFollowColorSchemeFull              ST_OleObjectFollowColorScheme = 2
	ST_OleObjectFollowColorSchemeTextAndBackground ST_OleObjectFollowColorScheme = 3
)

func (ST_OleObjectFollowColorScheme) MarshalXML 

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

func (ST_OleObjectFollowColorScheme) MarshalXMLAttr 

func (e ST_OleObjectFollowColorScheme) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_OleObjectFollowColorScheme) String 

func (m ST_OleObjectFollowColorScheme) String() string

func (*ST_OleObjectFollowColorScheme) UnmarshalXML 

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

func (*ST_OleObjectFollowColorScheme) UnmarshalXMLAttr 

func (e *ST_OleObjectFollowColorScheme) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_OleObjectFollowColorScheme) Validate 

func (m ST_OleObjectFollowColorScheme) Validate() error

func (ST_OleObjectFollowColorScheme) ValidateWithPath 

func (m ST_OleObjectFollowColorScheme) ValidateWithPath(path string) error

type ST_PhotoAlbumFrameShape 

type ST_PhotoAlbumFrameShape byte
const (
	ST_PhotoAlbumFrameShapeUnset       ST_PhotoAlbumFrameShape = 0
	ST_PhotoAlbumFrameShapeFrameStyle1 ST_PhotoAlbumFrameShape = 1
	ST_PhotoAlbumFrameShapeFrameStyle2 ST_PhotoAlbumFrameShape = 2
	ST_PhotoAlbumFrameShapeFrameStyle3 ST_PhotoAlbumFrameShape = 3
	ST_PhotoAlbumFrameShapeFrameStyle4 ST_PhotoAlbumFrameShape = 4
	ST_PhotoAlbumFrameShapeFrameStyle5 ST_PhotoAlbumFrameShape = 5
	ST_PhotoAlbumFrameShapeFrameStyle6 ST_PhotoAlbumFrameShape = 6
	ST_PhotoAlbumFrameShapeFrameStyle7 ST_PhotoAlbumFrameShape = 7
)

func (ST_PhotoAlbumFrameShape) MarshalXML 

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

func (ST_PhotoAlbumFrameShape) MarshalXMLAttr 

func (e ST_PhotoAlbumFrameShape) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PhotoAlbumFrameShape) String 

func (m ST_PhotoAlbumFrameShape) String() string

func (*ST_PhotoAlbumFrameShape) UnmarshalXML 

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

func (*ST_PhotoAlbumFrameShape) UnmarshalXMLAttr 

func (e *ST_PhotoAlbumFrameShape) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PhotoAlbumFrameShape) Validate 

func (m ST_PhotoAlbumFrameShape) Validate() error

func (ST_PhotoAlbumFrameShape) ValidateWithPath 

func (m ST_PhotoAlbumFrameShape) ValidateWithPath(path string) error

type ST_PhotoAlbumLayout 

type ST_PhotoAlbumLayout byte
const (
	ST_PhotoAlbumLayoutUnset      ST_PhotoAlbumLayout = 0
	ST_PhotoAlbumLayoutFitToSlide ST_PhotoAlbumLayout = 1
	ST_PhotoAlbumLayout1pic       ST_PhotoAlbumLayout = 2
	ST_PhotoAlbumLayout2pic       ST_PhotoAlbumLayout = 3
	ST_PhotoAlbumLayout4pic       ST_PhotoAlbumLayout = 4
	ST_PhotoAlbumLayout1picTitle  ST_PhotoAlbumLayout = 5
	ST_PhotoAlbumLayout2picTitle  ST_PhotoAlbumLayout = 6
	ST_PhotoAlbumLayout4picTitle  ST_PhotoAlbumLayout = 7
)

func (ST_PhotoAlbumLayout) MarshalXML 

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

func (ST_PhotoAlbumLayout) MarshalXMLAttr 

func (e ST_PhotoAlbumLayout) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PhotoAlbumLayout) String 

func (m ST_PhotoAlbumLayout) String() string

func (*ST_PhotoAlbumLayout) UnmarshalXML 

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

func (*ST_PhotoAlbumLayout) UnmarshalXMLAttr 

func (e *ST_PhotoAlbumLayout) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PhotoAlbumLayout) Validate 

func (m ST_PhotoAlbumLayout) Validate() error

func (ST_PhotoAlbumLayout) ValidateWithPath 

func (m ST_PhotoAlbumLayout) ValidateWithPath(path string) error

type ST_PlaceholderSize 

type ST_PlaceholderSize byte
const (
	ST_PlaceholderSizeUnset   ST_PlaceholderSize = 0
	ST_PlaceholderSizeFull    ST_PlaceholderSize = 1
	ST_PlaceholderSizeHalf    ST_PlaceholderSize = 2
	ST_PlaceholderSizeQuarter ST_PlaceholderSize = 3
)

func (ST_PlaceholderSize) MarshalXML 

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

func (ST_PlaceholderSize) MarshalXMLAttr 

func (e ST_PlaceholderSize) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PlaceholderSize) String 

func (m ST_PlaceholderSize) String() string

func (*ST_PlaceholderSize) UnmarshalXML 

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

func (*ST_PlaceholderSize) UnmarshalXMLAttr 

func (e *ST_PlaceholderSize) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PlaceholderSize) Validate 

func (m ST_PlaceholderSize) Validate() error

func (ST_PlaceholderSize) ValidateWithPath 

func (m ST_PlaceholderSize) ValidateWithPath(path string) error

type ST_PlaceholderType 

type ST_PlaceholderType byte
const (
	ST_PlaceholderTypeUnset    ST_PlaceholderType = 0
	ST_PlaceholderTypeTitle    ST_PlaceholderType = 1
	ST_PlaceholderTypeBody     ST_PlaceholderType = 2
	ST_PlaceholderTypeCtrTitle ST_PlaceholderType = 3
	ST_PlaceholderTypeSubTitle ST_PlaceholderType = 4
	ST_PlaceholderTypeDt       ST_PlaceholderType = 5
	ST_PlaceholderTypeSldNum   ST_PlaceholderType = 6
	ST_PlaceholderTypeFtr      ST_PlaceholderType = 7
	ST_PlaceholderTypeHdr      ST_PlaceholderType = 8
	ST_PlaceholderTypeObj      ST_PlaceholderType = 9
	ST_PlaceholderTypeChart    ST_PlaceholderType = 10
	ST_PlaceholderTypeTbl      ST_PlaceholderType = 11
	ST_PlaceholderTypeClipArt  ST_PlaceholderType = 12
	ST_PlaceholderTypeDgm      ST_PlaceholderType = 13
	ST_PlaceholderTypeMedia    ST_PlaceholderType = 14
	ST_PlaceholderTypeSldImg   ST_PlaceholderType = 15
	ST_PlaceholderTypePic      ST_PlaceholderType = 16
)

func (ST_PlaceholderType) MarshalXML 

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

func (ST_PlaceholderType) MarshalXMLAttr 

func (e ST_PlaceholderType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PlaceholderType) String 

func (m ST_PlaceholderType) String() string

func (*ST_PlaceholderType) UnmarshalXML 

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

func (*ST_PlaceholderType) UnmarshalXMLAttr 

func (e *ST_PlaceholderType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PlaceholderType) Validate 

func (m ST_PlaceholderType) Validate() error

func (ST_PlaceholderType) ValidateWithPath 

func (m ST_PlaceholderType) ValidateWithPath(path string) error

type ST_PrintColorMode 

type ST_PrintColorMode byte
const (
	ST_PrintColorModeUnset ST_PrintColorMode = 0
	ST_PrintColorModeBw    ST_PrintColorMode = 1
	ST_PrintColorModeGray  ST_PrintColorMode = 2
	ST_PrintColorModeClr   ST_PrintColorMode = 3
)

func (ST_PrintColorMode) MarshalXML 

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

func (ST_PrintColorMode) MarshalXMLAttr 

func (e ST_PrintColorMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PrintColorMode) String 

func (m ST_PrintColorMode) String() string

func (*ST_PrintColorMode) UnmarshalXML 

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

func (*ST_PrintColorMode) UnmarshalXMLAttr 

func (e *ST_PrintColorMode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PrintColorMode) Validate 

func (m ST_PrintColorMode) Validate() error

func (ST_PrintColorMode) ValidateWithPath 

func (m ST_PrintColorMode) ValidateWithPath(path string) error

type ST_PrintWhat 

type ST_PrintWhat byte
const (
	ST_PrintWhatUnset     ST_PrintWhat = 0
	ST_PrintWhatSlides    ST_PrintWhat = 1
	ST_PrintWhatHandouts1 ST_PrintWhat = 2
	ST_PrintWhatHandouts2 ST_PrintWhat = 3
	ST_PrintWhatHandouts3 ST_PrintWhat = 4
	ST_PrintWhatHandouts4 ST_PrintWhat = 5
	ST_PrintWhatHandouts6 ST_PrintWhat = 6
	ST_PrintWhatHandouts9 ST_PrintWhat = 7
	ST_PrintWhatNotes     ST_PrintWhat = 8
	ST_PrintWhatOutline   ST_PrintWhat = 9
)

func (ST_PrintWhat) MarshalXML 

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

func (ST_PrintWhat) MarshalXMLAttr 

func (e ST_PrintWhat) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PrintWhat) String 

func (m ST_PrintWhat) String() string

func (*ST_PrintWhat) UnmarshalXML 

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

func (*ST_PrintWhat) UnmarshalXMLAttr 

func (e *ST_PrintWhat) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PrintWhat) Validate 

func (m ST_PrintWhat) Validate() error

func (ST_PrintWhat) ValidateWithPath 

func (m ST_PrintWhat) ValidateWithPath(path string) error

type ST_SlideLayoutType 

type ST_SlideLayoutType byte
const (
	ST_SlideLayoutTypeUnset                   ST_SlideLayoutType = 0
	ST_SlideLayoutTypeTitle                   ST_SlideLayoutType = 1
	ST_SlideLayoutTypeTx                      ST_SlideLayoutType = 2
	ST_SlideLayoutTypeTwoColTx                ST_SlideLayoutType = 3
	ST_SlideLayoutTypeTbl                     ST_SlideLayoutType = 4
	ST_SlideLayoutTypeTxAndChart              ST_SlideLayoutType = 5
	ST_SlideLayoutTypeChartAndTx              ST_SlideLayoutType = 6
	ST_SlideLayoutTypeDgm                     ST_SlideLayoutType = 7
	ST_SlideLayoutTypeChart                   ST_SlideLayoutType = 8
	ST_SlideLayoutTypeTxAndClipArt            ST_SlideLayoutType = 9
	ST_SlideLayoutTypeClipArtAndTx            ST_SlideLayoutType = 10
	ST_SlideLayoutTypeTitleOnly               ST_SlideLayoutType = 11
	ST_SlideLayoutTypeBlank                   ST_SlideLayoutType = 12
	ST_SlideLayoutTypeTxAndObj                ST_SlideLayoutType = 13
	ST_SlideLayoutTypeObjAndTx                ST_SlideLayoutType = 14
	ST_SlideLayoutTypeObjOnly                 ST_SlideLayoutType = 15
	ST_SlideLayoutTypeObj                     ST_SlideLayoutType = 16
	ST_SlideLayoutTypeTxAndMedia              ST_SlideLayoutType = 17
	ST_SlideLayoutTypeMediaAndTx              ST_SlideLayoutType = 18
	ST_SlideLayoutTypeObjOverTx               ST_SlideLayoutType = 19
	ST_SlideLayoutTypeTxOverObj               ST_SlideLayoutType = 20
	ST_SlideLayoutTypeTxAndTwoObj             ST_SlideLayoutType = 21
	ST_SlideLayoutTypeTwoObjAndTx             ST_SlideLayoutType = 22
	ST_SlideLayoutTypeTwoObjOverTx            ST_SlideLayoutType = 23
	ST_SlideLayoutTypeFourObj                 ST_SlideLayoutType = 24
	ST_SlideLayoutTypeVertTx                  ST_SlideLayoutType = 25
	ST_SlideLayoutTypeClipArtAndVertTx        ST_SlideLayoutType = 26
	ST_SlideLayoutTypeVertTitleAndTx          ST_SlideLayoutType = 27
	ST_SlideLayoutTypeVertTitleAndTxOverChart ST_SlideLayoutType = 28
	ST_SlideLayoutTypeTwoObj                  ST_SlideLayoutType = 29
	ST_SlideLayoutTypeObjAndTwoObj            ST_SlideLayoutType = 30
	ST_SlideLayoutTypeTwoObjAndObj            ST_SlideLayoutType = 31
	ST_SlideLayoutTypeCust                    ST_SlideLayoutType = 32
	ST_SlideLayoutTypeSecHead                 ST_SlideLayoutType = 33
	ST_SlideLayoutTypeTwoTxTwoObj             ST_SlideLayoutType = 34
	ST_SlideLayoutTypeObjTx                   ST_SlideLayoutType = 35
	ST_SlideLayoutTypePicTx                   ST_SlideLayoutType = 36
)

func (ST_SlideLayoutType) MarshalXML 

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

func (ST_SlideLayoutType) MarshalXMLAttr 

func (e ST_SlideLayoutType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SlideLayoutType) String 

func (m ST_SlideLayoutType) String() string

func (*ST_SlideLayoutType) UnmarshalXML 

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

func (*ST_SlideLayoutType) UnmarshalXMLAttr 

func (e *ST_SlideLayoutType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SlideLayoutType) Validate 

func (m ST_SlideLayoutType) Validate() error

func (ST_SlideLayoutType) ValidateWithPath 

func (m ST_SlideLayoutType) ValidateWithPath(path string) error

type ST_SlideSizeType 

type ST_SlideSizeType byte
const (
	ST_SlideSizeTypeUnset       ST_SlideSizeType = 0
	ST_SlideSizeTypeScreen4x3   ST_SlideSizeType = 1
	ST_SlideSizeTypeLetter      ST_SlideSizeType = 2
	ST_SlideSizeTypeA4          ST_SlideSizeType = 3
	ST_SlideSizeType35mm        ST_SlideSizeType = 4
	ST_SlideSizeTypeOverhead    ST_SlideSizeType = 5
	ST_SlideSizeTypeBanner      ST_SlideSizeType = 6
	ST_SlideSizeTypeCustom      ST_SlideSizeType = 7
	ST_SlideSizeTypeLedger      ST_SlideSizeType = 8
	ST_SlideSizeTypeA3          ST_SlideSizeType = 9
	ST_SlideSizeTypeB4ISO       ST_SlideSizeType = 10
	ST_SlideSizeTypeB5ISO       ST_SlideSizeType = 11
	ST_SlideSizeTypeB4JIS       ST_SlideSizeType = 12
	ST_SlideSizeTypeB5JIS       ST_SlideSizeType = 13
	ST_SlideSizeTypeHagakiCard  ST_SlideSizeType = 14
	ST_SlideSizeTypeScreen16x9  ST_SlideSizeType = 15
	ST_SlideSizeTypeScreen16x10 ST_SlideSizeType = 16
)

func (ST_SlideSizeType) MarshalXML 

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

func (ST_SlideSizeType) MarshalXMLAttr 

func (e ST_SlideSizeType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SlideSizeType) String 

func (m ST_SlideSizeType) String() string

func (*ST_SlideSizeType) UnmarshalXML 

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

func (*ST_SlideSizeType) UnmarshalXMLAttr 

func (e *ST_SlideSizeType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SlideSizeType) Validate 

func (m ST_SlideSizeType) Validate() error

func (ST_SlideSizeType) ValidateWithPath 

func (m ST_SlideSizeType) ValidateWithPath(path string) error

type ST_SplitterBarState 

type ST_SplitterBarState byte
const (
	ST_SplitterBarStateUnset     ST_SplitterBarState = 0
	ST_SplitterBarStateMinimized ST_SplitterBarState = 1
	ST_SplitterBarStateRestored  ST_SplitterBarState = 2
	ST_SplitterBarStateMaximized ST_SplitterBarState = 3
)

func (ST_SplitterBarState) MarshalXML 

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

func (ST_SplitterBarState) MarshalXMLAttr 

func (e ST_SplitterBarState) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SplitterBarState) String 

func (m ST_SplitterBarState) String() string

func (*ST_SplitterBarState) UnmarshalXML 

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

func (*ST_SplitterBarState) UnmarshalXMLAttr 

func (e *ST_SplitterBarState) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SplitterBarState) Validate 

func (m ST_SplitterBarState) Validate() error

func (ST_SplitterBarState) ValidateWithPath 

func (m ST_SplitterBarState) ValidateWithPath(path string) error

type ST_TLAnimateBehaviorCalcMode 

type ST_TLAnimateBehaviorCalcMode byte
const (
	ST_TLAnimateBehaviorCalcModeUnset    ST_TLAnimateBehaviorCalcMode = 0
	ST_TLAnimateBehaviorCalcModeDiscrete ST_TLAnimateBehaviorCalcMode = 1
	ST_TLAnimateBehaviorCalcModeLin      ST_TLAnimateBehaviorCalcMode = 2
	ST_TLAnimateBehaviorCalcModeFmla     ST_TLAnimateBehaviorCalcMode = 3
)

func (ST_TLAnimateBehaviorCalcMode) MarshalXML 

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

func (ST_TLAnimateBehaviorCalcMode) MarshalXMLAttr 

func (e ST_TLAnimateBehaviorCalcMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLAnimateBehaviorCalcMode) String 

func (m ST_TLAnimateBehaviorCalcMode) String() string

func (*ST_TLAnimateBehaviorCalcMode) UnmarshalXML 

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

func (*ST_TLAnimateBehaviorCalcMode) UnmarshalXMLAttr 

func (e *ST_TLAnimateBehaviorCalcMode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLAnimateBehaviorCalcMode) Validate 

func (m ST_TLAnimateBehaviorCalcMode) Validate() error

func (ST_TLAnimateBehaviorCalcMode) ValidateWithPath 

func (m ST_TLAnimateBehaviorCalcMode) ValidateWithPath(path string) error

type ST_TLAnimateBehaviorValueType 

type ST_TLAnimateBehaviorValueType byte
const (
	ST_TLAnimateBehaviorValueTypeUnset ST_TLAnimateBehaviorValueType = 0
	ST_TLAnimateBehaviorValueTypeStr   ST_TLAnimateBehaviorValueType = 1
	ST_TLAnimateBehaviorValueTypeNum   ST_TLAnimateBehaviorValueType = 2
	ST_TLAnimateBehaviorValueTypeClr   ST_TLAnimateBehaviorValueType = 3
)

func (ST_TLAnimateBehaviorValueType) MarshalXML 

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

func (ST_TLAnimateBehaviorValueType) MarshalXMLAttr 

func (e ST_TLAnimateBehaviorValueType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLAnimateBehaviorValueType) String 

func (m ST_TLAnimateBehaviorValueType) String() string

func (*ST_TLAnimateBehaviorValueType) UnmarshalXML 

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

func (*ST_TLAnimateBehaviorValueType) UnmarshalXMLAttr 

func (e *ST_TLAnimateBehaviorValueType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLAnimateBehaviorValueType) Validate 

func (m ST_TLAnimateBehaviorValueType) Validate() error

func (ST_TLAnimateBehaviorValueType) ValidateWithPath 

func (m ST_TLAnimateBehaviorValueType) ValidateWithPath(path string) error

type ST_TLAnimateColorDirection 

type ST_TLAnimateColorDirection byte
const (
	ST_TLAnimateColorDirectionUnset ST_TLAnimateColorDirection = 0
	ST_TLAnimateColorDirectionCw    ST_TLAnimateColorDirection = 1
	ST_TLAnimateColorDirectionCcw   ST_TLAnimateColorDirection = 2
)

func (ST_TLAnimateColorDirection) MarshalXML 

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

func (ST_TLAnimateColorDirection) MarshalXMLAttr 

func (e ST_TLAnimateColorDirection) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLAnimateColorDirection) String 

func (m ST_TLAnimateColorDirection) String() string

func (*ST_TLAnimateColorDirection) UnmarshalXML 

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

func (*ST_TLAnimateColorDirection) UnmarshalXMLAttr 

func (e *ST_TLAnimateColorDirection) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLAnimateColorDirection) Validate 

func (m ST_TLAnimateColorDirection) Validate() error

func (ST_TLAnimateColorDirection) ValidateWithPath 

func (m ST_TLAnimateColorDirection) ValidateWithPath(path string) error

type ST_TLAnimateColorSpace 

type ST_TLAnimateColorSpace byte
const (
	ST_TLAnimateColorSpaceUnset ST_TLAnimateColorSpace = 0
	ST_TLAnimateColorSpaceRgb   ST_TLAnimateColorSpace = 1
	ST_TLAnimateColorSpaceHsl   ST_TLAnimateColorSpace = 2
)

func (ST_TLAnimateColorSpace) MarshalXML 

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

func (ST_TLAnimateColorSpace) MarshalXMLAttr 

func (e ST_TLAnimateColorSpace) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLAnimateColorSpace) String 

func (m ST_TLAnimateColorSpace) String() string

func (*ST_TLAnimateColorSpace) UnmarshalXML 

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

func (*ST_TLAnimateColorSpace) UnmarshalXMLAttr 

func (e *ST_TLAnimateColorSpace) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLAnimateColorSpace) Validate 

func (m ST_TLAnimateColorSpace) Validate() error

func (ST_TLAnimateColorSpace) ValidateWithPath 

func (m ST_TLAnimateColorSpace) ValidateWithPath(path string) error

type ST_TLAnimateEffectTransition 

type ST_TLAnimateEffectTransition byte
const (
	ST_TLAnimateEffectTransitionUnset ST_TLAnimateEffectTransition = 0
	ST_TLAnimateEffectTransitionIn    ST_TLAnimateEffectTransition = 1
	ST_TLAnimateEffectTransitionOut   ST_TLAnimateEffectTransition = 2
	ST_TLAnimateEffectTransitionNone  ST_TLAnimateEffectTransition = 3
)

func (ST_TLAnimateEffectTransition) MarshalXML 

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

func (ST_TLAnimateEffectTransition) MarshalXMLAttr 

func (e ST_TLAnimateEffectTransition) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLAnimateEffectTransition) String 

func (m ST_TLAnimateEffectTransition) String() string

func (*ST_TLAnimateEffectTransition) UnmarshalXML 

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

func (*ST_TLAnimateEffectTransition) UnmarshalXMLAttr 

func (e *ST_TLAnimateEffectTransition) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLAnimateEffectTransition) Validate 

func (m ST_TLAnimateEffectTransition) Validate() error

func (ST_TLAnimateEffectTransition) ValidateWithPath 

func (m ST_TLAnimateEffectTransition) ValidateWithPath(path string) error

type ST_TLAnimateMotionBehaviorOrigin 

type ST_TLAnimateMotionBehaviorOrigin byte
const (
	ST_TLAnimateMotionBehaviorOriginUnset  ST_TLAnimateMotionBehaviorOrigin = 0
	ST_TLAnimateMotionBehaviorOriginParent ST_TLAnimateMotionBehaviorOrigin = 1
	ST_TLAnimateMotionBehaviorOriginLayout ST_TLAnimateMotionBehaviorOrigin = 2
)

func (ST_TLAnimateMotionBehaviorOrigin) MarshalXML 

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

func (ST_TLAnimateMotionBehaviorOrigin) MarshalXMLAttr 

func (e ST_TLAnimateMotionBehaviorOrigin) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLAnimateMotionBehaviorOrigin) String 

func (m ST_TLAnimateMotionBehaviorOrigin) String() string

func (*ST_TLAnimateMotionBehaviorOrigin) UnmarshalXML 

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

func (*ST_TLAnimateMotionBehaviorOrigin) UnmarshalXMLAttr 

func (e *ST_TLAnimateMotionBehaviorOrigin) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLAnimateMotionBehaviorOrigin) Validate 

func (m ST_TLAnimateMotionBehaviorOrigin) Validate() error

func (ST_TLAnimateMotionBehaviorOrigin) ValidateWithPath 

func (m ST_TLAnimateMotionBehaviorOrigin) ValidateWithPath(path string) error

type ST_TLAnimateMotionPathEditMode 

type ST_TLAnimateMotionPathEditMode byte
const (
	ST_TLAnimateMotionPathEditModeUnset    ST_TLAnimateMotionPathEditMode = 0
	ST_TLAnimateMotionPathEditModeRelative ST_TLAnimateMotionPathEditMode = 1
	ST_TLAnimateMotionPathEditModeFixed    ST_TLAnimateMotionPathEditMode = 2
)

func (ST_TLAnimateMotionPathEditMode) MarshalXML 

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

func (ST_TLAnimateMotionPathEditMode) MarshalXMLAttr 

func (e ST_TLAnimateMotionPathEditMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLAnimateMotionPathEditMode) String 

func (m ST_TLAnimateMotionPathEditMode) String() string

func (*ST_TLAnimateMotionPathEditMode) UnmarshalXML 

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

func (*ST_TLAnimateMotionPathEditMode) UnmarshalXMLAttr 

func (e *ST_TLAnimateMotionPathEditMode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLAnimateMotionPathEditMode) Validate 

func (m ST_TLAnimateMotionPathEditMode) Validate() error

func (ST_TLAnimateMotionPathEditMode) ValidateWithPath 

func (m ST_TLAnimateMotionPathEditMode) ValidateWithPath(path string) error

type ST_TLBehaviorAccumulateType 

type ST_TLBehaviorAccumulateType byte
const (
	ST_TLBehaviorAccumulateTypeUnset  ST_TLBehaviorAccumulateType = 0
	ST_TLBehaviorAccumulateTypeNone   ST_TLBehaviorAccumulateType = 1
	ST_TLBehaviorAccumulateTypeAlways ST_TLBehaviorAccumulateType = 2
)

func (ST_TLBehaviorAccumulateType) MarshalXML 

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

func (ST_TLBehaviorAccumulateType) MarshalXMLAttr 

func (e ST_TLBehaviorAccumulateType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLBehaviorAccumulateType) String 

func (m ST_TLBehaviorAccumulateType) String() string

func (*ST_TLBehaviorAccumulateType) UnmarshalXML 

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

func (*ST_TLBehaviorAccumulateType) UnmarshalXMLAttr 

func (e *ST_TLBehaviorAccumulateType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLBehaviorAccumulateType) Validate 

func (m ST_TLBehaviorAccumulateType) Validate() error

func (ST_TLBehaviorAccumulateType) ValidateWithPath 

func (m ST_TLBehaviorAccumulateType) ValidateWithPath(path string) error

type ST_TLBehaviorAdditiveType 

type ST_TLBehaviorAdditiveType byte
const (
	ST_TLBehaviorAdditiveTypeUnset ST_TLBehaviorAdditiveType = 0
	ST_TLBehaviorAdditiveTypeBase  ST_TLBehaviorAdditiveType = 1
	ST_TLBehaviorAdditiveTypeSum   ST_TLBehaviorAdditiveType = 2
	ST_TLBehaviorAdditiveTypeRepl  ST_TLBehaviorAdditiveType = 3
	ST_TLBehaviorAdditiveTypeMult  ST_TLBehaviorAdditiveType = 4
	ST_TLBehaviorAdditiveTypeNone  ST_TLBehaviorAdditiveType = 5
)

func (ST_TLBehaviorAdditiveType) MarshalXML 

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

func (ST_TLBehaviorAdditiveType) MarshalXMLAttr 

func (e ST_TLBehaviorAdditiveType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLBehaviorAdditiveType) String 

func (m ST_TLBehaviorAdditiveType) String() string

func (*ST_TLBehaviorAdditiveType) UnmarshalXML 

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

func (*ST_TLBehaviorAdditiveType) UnmarshalXMLAttr 

func (e *ST_TLBehaviorAdditiveType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLBehaviorAdditiveType) Validate 

func (m ST_TLBehaviorAdditiveType) Validate() error

func (ST_TLBehaviorAdditiveType) ValidateWithPath 

func (m ST_TLBehaviorAdditiveType) ValidateWithPath(path string) error

type ST_TLBehaviorOverrideType 

type ST_TLBehaviorOverrideType byte
const (
	ST_TLBehaviorOverrideTypeUnset      ST_TLBehaviorOverrideType = 0
	ST_TLBehaviorOverrideTypeNormal     ST_TLBehaviorOverrideType = 1
	ST_TLBehaviorOverrideTypeChildStyle ST_TLBehaviorOverrideType = 2
)

func (ST_TLBehaviorOverrideType) MarshalXML 

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

func (ST_TLBehaviorOverrideType) MarshalXMLAttr 

func (e ST_TLBehaviorOverrideType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLBehaviorOverrideType) String 

func (m ST_TLBehaviorOverrideType) String() string

func (*ST_TLBehaviorOverrideType) UnmarshalXML 

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

func (*ST_TLBehaviorOverrideType) UnmarshalXMLAttr 

func (e *ST_TLBehaviorOverrideType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLBehaviorOverrideType) Validate 

func (m ST_TLBehaviorOverrideType) Validate() error

func (ST_TLBehaviorOverrideType) ValidateWithPath 

func (m ST_TLBehaviorOverrideType) ValidateWithPath(path string) error

type ST_TLBehaviorTransformType 

type ST_TLBehaviorTransformType byte
const (
	ST_TLBehaviorTransformTypeUnset ST_TLBehaviorTransformType = 0
	ST_TLBehaviorTransformTypePt    ST_TLBehaviorTransformType = 1
	ST_TLBehaviorTransformTypeImg   ST_TLBehaviorTransformType = 2
)

func (ST_TLBehaviorTransformType) MarshalXML 

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

func (ST_TLBehaviorTransformType) MarshalXMLAttr 

func (e ST_TLBehaviorTransformType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLBehaviorTransformType) String 

func (m ST_TLBehaviorTransformType) String() string

func (*ST_TLBehaviorTransformType) UnmarshalXML 

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

func (*ST_TLBehaviorTransformType) UnmarshalXMLAttr 

func (e *ST_TLBehaviorTransformType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLBehaviorTransformType) Validate 

func (m ST_TLBehaviorTransformType) Validate() error

func (ST_TLBehaviorTransformType) ValidateWithPath 

func (m ST_TLBehaviorTransformType) ValidateWithPath(path string) error

type ST_TLChartSubelementType 

type ST_TLChartSubelementType byte
const (
	ST_TLChartSubelementTypeUnset        ST_TLChartSubelementType = 0
	ST_TLChartSubelementTypeGridLegend   ST_TLChartSubelementType = 1
	ST_TLChartSubelementTypeSeries       ST_TLChartSubelementType = 2
	ST_TLChartSubelementTypeCategory     ST_TLChartSubelementType = 3
	ST_TLChartSubelementTypePtInSeries   ST_TLChartSubelementType = 4
	ST_TLChartSubelementTypePtInCategory ST_TLChartSubelementType = 5
)

func (ST_TLChartSubelementType) MarshalXML 

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

func (ST_TLChartSubelementType) MarshalXMLAttr 

func (e ST_TLChartSubelementType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLChartSubelementType) String 

func (m ST_TLChartSubelementType) String() string

func (*ST_TLChartSubelementType) UnmarshalXML 

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

func (*ST_TLChartSubelementType) UnmarshalXMLAttr 

func (e *ST_TLChartSubelementType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLChartSubelementType) Validate 

func (m ST_TLChartSubelementType) Validate() error

func (ST_TLChartSubelementType) ValidateWithPath 

func (m ST_TLChartSubelementType) ValidateWithPath(path string) error

type ST_TLCommandType 

type ST_TLCommandType byte
const (
	ST_TLCommandTypeUnset ST_TLCommandType = 0
	ST_TLCommandTypeEvt   ST_TLCommandType = 1
	ST_TLCommandTypeCall  ST_TLCommandType = 2
	ST_TLCommandTypeVerb  ST_TLCommandType = 3
)

func (ST_TLCommandType) MarshalXML 

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

func (ST_TLCommandType) MarshalXMLAttr 

func (e ST_TLCommandType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLCommandType) String 

func (m ST_TLCommandType) String() string

func (*ST_TLCommandType) UnmarshalXML 

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

func (*ST_TLCommandType) UnmarshalXMLAttr 

func (e *ST_TLCommandType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLCommandType) Validate 

func (m ST_TLCommandType) Validate() error

func (ST_TLCommandType) ValidateWithPath 

func (m ST_TLCommandType) ValidateWithPath(path string) error

type ST_TLDiagramBuildType 

type ST_TLDiagramBuildType byte
const (
	ST_TLDiagramBuildTypeUnset         ST_TLDiagramBuildType = 0
	ST_TLDiagramBuildTypeWhole         ST_TLDiagramBuildType = 1
	ST_TLDiagramBuildTypeDepthByNode   ST_TLDiagramBuildType = 2
	ST_TLDiagramBuildTypeDepthByBranch ST_TLDiagramBuildType = 3
	ST_TLDiagramBuildTypeBreadthByNode ST_TLDiagramBuildType = 4
	ST_TLDiagramBuildTypeBreadthByLvl  ST_TLDiagramBuildType = 5
	ST_TLDiagramBuildTypeCw            ST_TLDiagramBuildType = 6
	ST_TLDiagramBuildTypeCwIn          ST_TLDiagramBuildType = 7
	ST_TLDiagramBuildTypeCwOut         ST_TLDiagramBuildType = 8
	ST_TLDiagramBuildTypeCcw           ST_TLDiagramBuildType = 9
	ST_TLDiagramBuildTypeCcwIn         ST_TLDiagramBuildType = 10
	ST_TLDiagramBuildTypeCcwOut        ST_TLDiagramBuildType = 11
	ST_TLDiagramBuildTypeInByRing      ST_TLDiagramBuildType = 12
	ST_TLDiagramBuildTypeOutByRing     ST_TLDiagramBuildType = 13
	ST_TLDiagramBuildTypeUp            ST_TLDiagramBuildType = 14
	ST_TLDiagramBuildTypeDown          ST_TLDiagramBuildType = 15
	ST_TLDiagramBuildTypeAllAtOnce     ST_TLDiagramBuildType = 16
	ST_TLDiagramBuildTypeCust          ST_TLDiagramBuildType = 17
)

func (ST_TLDiagramBuildType) MarshalXML 

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

func (ST_TLDiagramBuildType) MarshalXMLAttr 

func (e ST_TLDiagramBuildType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLDiagramBuildType) String 

func (m ST_TLDiagramBuildType) String() string

func (*ST_TLDiagramBuildType) UnmarshalXML 

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

func (*ST_TLDiagramBuildType) UnmarshalXMLAttr 

func (e *ST_TLDiagramBuildType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLDiagramBuildType) Validate 

func (m ST_TLDiagramBuildType) Validate() error

func (ST_TLDiagramBuildType) ValidateWithPath 

func (m ST_TLDiagramBuildType) ValidateWithPath(path string) error

type ST_TLNextActionType 

type ST_TLNextActionType byte
const (
	ST_TLNextActionTypeUnset ST_TLNextActionType = 0
	ST_TLNextActionTypeNone  ST_TLNextActionType = 1
	ST_TLNextActionTypeSeek  ST_TLNextActionType = 2
)

func (ST_TLNextActionType) MarshalXML 

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

func (ST_TLNextActionType) MarshalXMLAttr 

func (e ST_TLNextActionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLNextActionType) String 

func (m ST_TLNextActionType) String() string

func (*ST_TLNextActionType) UnmarshalXML 

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

func (*ST_TLNextActionType) UnmarshalXMLAttr 

func (e *ST_TLNextActionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLNextActionType) Validate 

func (m ST_TLNextActionType) Validate() error

func (ST_TLNextActionType) ValidateWithPath 

func (m ST_TLNextActionType) ValidateWithPath(path string) error

type ST_TLOleChartBuildType 

type ST_TLOleChartBuildType byte
const (
	ST_TLOleChartBuildTypeUnset      ST_TLOleChartBuildType = 0
	ST_TLOleChartBuildTypeAllAtOnce  ST_TLOleChartBuildType = 1
	ST_TLOleChartBuildTypeSeries     ST_TLOleChartBuildType = 2
	ST_TLOleChartBuildTypeCategory   ST_TLOleChartBuildType = 3
	ST_TLOleChartBuildTypeSeriesEl   ST_TLOleChartBuildType = 4
	ST_TLOleChartBuildTypeCategoryEl ST_TLOleChartBuildType = 5
)

func (ST_TLOleChartBuildType) MarshalXML 

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

func (ST_TLOleChartBuildType) MarshalXMLAttr 

func (e ST_TLOleChartBuildType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLOleChartBuildType) String 

func (m ST_TLOleChartBuildType) String() string

func (*ST_TLOleChartBuildType) UnmarshalXML 

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

func (*ST_TLOleChartBuildType) UnmarshalXMLAttr 

func (e *ST_TLOleChartBuildType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLOleChartBuildType) Validate 

func (m ST_TLOleChartBuildType) Validate() error

func (ST_TLOleChartBuildType) ValidateWithPath 

func (m ST_TLOleChartBuildType) ValidateWithPath(path string) error

type ST_TLParaBuildType 

type ST_TLParaBuildType byte
const (
	ST_TLParaBuildTypeUnset     ST_TLParaBuildType = 0
	ST_TLParaBuildTypeAllAtOnce ST_TLParaBuildType = 1
	ST_TLParaBuildTypeP         ST_TLParaBuildType = 2
	ST_TLParaBuildTypeCust      ST_TLParaBuildType = 3
	ST_TLParaBuildTypeWhole     ST_TLParaBuildType = 4
)

func (ST_TLParaBuildType) MarshalXML 

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

func (ST_TLParaBuildType) MarshalXMLAttr 

func (e ST_TLParaBuildType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLParaBuildType) String 

func (m ST_TLParaBuildType) String() string

func (*ST_TLParaBuildType) UnmarshalXML 

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

func (*ST_TLParaBuildType) UnmarshalXMLAttr 

func (e *ST_TLParaBuildType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLParaBuildType) Validate 

func (m ST_TLParaBuildType) Validate() error

func (ST_TLParaBuildType) ValidateWithPath 

func (m ST_TLParaBuildType) ValidateWithPath(path string) error

type ST_TLPreviousActionType 

type ST_TLPreviousActionType byte
const (
	ST_TLPreviousActionTypeUnset     ST_TLPreviousActionType = 0
	ST_TLPreviousActionTypeNone      ST_TLPreviousActionType = 1
	ST_TLPreviousActionTypeSkipTimed ST_TLPreviousActionType = 2
)

func (ST_TLPreviousActionType) MarshalXML 

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

func (ST_TLPreviousActionType) MarshalXMLAttr 

func (e ST_TLPreviousActionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLPreviousActionType) String 

func (m ST_TLPreviousActionType) String() string

func (*ST_TLPreviousActionType) UnmarshalXML 

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

func (*ST_TLPreviousActionType) UnmarshalXMLAttr 

func (e *ST_TLPreviousActionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLPreviousActionType) Validate 

func (m ST_TLPreviousActionType) Validate() error

func (ST_TLPreviousActionType) ValidateWithPath 

func (m ST_TLPreviousActionType) ValidateWithPath(path string) error

type ST_TLTime 

type ST_TLTime struct {
	Uint32              *uint32
	ST_TLTimeIndefinite ST_TLTimeIndefinite
}

ST_TLTime is a union type

func ParseUnionST_TLTime 

func ParseUnionST_TLTime(s string) (ST_TLTime, error)

func (ST_TLTime) MarshalXML 

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

func (ST_TLTime) String 

func (m ST_TLTime) String() string

func (*ST_TLTime) Validate 

func (m *ST_TLTime) Validate() error

func (*ST_TLTime) ValidateWithPath 

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

type ST_TLTimeAnimateValueTime 

type ST_TLTimeAnimateValueTime struct {
	ST_PositiveFixedPercentage *dml.ST_PositiveFixedPercentage
	ST_TLTimeIndefinite        ST_TLTimeIndefinite
}

ST_TLTimeAnimateValueTime is a union type

func ParseUnionST_TLTimeAnimateValueTime 

func ParseUnionST_TLTimeAnimateValueTime(s string) (ST_TLTimeAnimateValueTime, error)

func (ST_TLTimeAnimateValueTime) MarshalXML 

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

func (ST_TLTimeAnimateValueTime) String 

func (m ST_TLTimeAnimateValueTime) String() string

func (*ST_TLTimeAnimateValueTime) Validate 

func (m *ST_TLTimeAnimateValueTime) Validate() error

func (*ST_TLTimeAnimateValueTime) ValidateWithPath 

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

type ST_TLTimeIndefinite 

type ST_TLTimeIndefinite byte
const (
	ST_TLTimeIndefiniteUnset      ST_TLTimeIndefinite = 0
	ST_TLTimeIndefiniteIndefinite ST_TLTimeIndefinite = 1
)

func (ST_TLTimeIndefinite) MarshalXML 

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

func (ST_TLTimeIndefinite) MarshalXMLAttr 

func (e ST_TLTimeIndefinite) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTimeIndefinite) String 

func (m ST_TLTimeIndefinite) String() string

func (*ST_TLTimeIndefinite) UnmarshalXML 

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

func (*ST_TLTimeIndefinite) UnmarshalXMLAttr 

func (e *ST_TLTimeIndefinite) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTimeIndefinite) Validate 

func (m ST_TLTimeIndefinite) Validate() error

func (ST_TLTimeIndefinite) ValidateWithPath 

func (m ST_TLTimeIndefinite) ValidateWithPath(path string) error

type ST_TLTimeNodeFillType 

type ST_TLTimeNodeFillType byte
const (
	ST_TLTimeNodeFillTypeUnset      ST_TLTimeNodeFillType = 0
	ST_TLTimeNodeFillTypeRemove     ST_TLTimeNodeFillType = 1
	ST_TLTimeNodeFillTypeFreeze     ST_TLTimeNodeFillType = 2
	ST_TLTimeNodeFillTypeHold       ST_TLTimeNodeFillType = 3
	ST_TLTimeNodeFillTypeTransition ST_TLTimeNodeFillType = 4
)

func (ST_TLTimeNodeFillType) MarshalXML 

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

func (ST_TLTimeNodeFillType) MarshalXMLAttr 

func (e ST_TLTimeNodeFillType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTimeNodeFillType) String 

func (m ST_TLTimeNodeFillType) String() string

func (*ST_TLTimeNodeFillType) UnmarshalXML 

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

func (*ST_TLTimeNodeFillType) UnmarshalXMLAttr 

func (e *ST_TLTimeNodeFillType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTimeNodeFillType) Validate 

func (m ST_TLTimeNodeFillType) Validate() error

func (ST_TLTimeNodeFillType) ValidateWithPath 

func (m ST_TLTimeNodeFillType) ValidateWithPath(path string) error

type ST_TLTimeNodeMasterRelation 

type ST_TLTimeNodeMasterRelation byte
const (
	ST_TLTimeNodeMasterRelationUnset     ST_TLTimeNodeMasterRelation = 0
	ST_TLTimeNodeMasterRelationSameClick ST_TLTimeNodeMasterRelation = 1
	ST_TLTimeNodeMasterRelationLastClick ST_TLTimeNodeMasterRelation = 2
	ST_TLTimeNodeMasterRelationNextClick ST_TLTimeNodeMasterRelation = 3
)

func (ST_TLTimeNodeMasterRelation) MarshalXML 

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

func (ST_TLTimeNodeMasterRelation) MarshalXMLAttr 

func (e ST_TLTimeNodeMasterRelation) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTimeNodeMasterRelation) String 

func (m ST_TLTimeNodeMasterRelation) String() string

func (*ST_TLTimeNodeMasterRelation) UnmarshalXML 

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

func (*ST_TLTimeNodeMasterRelation) UnmarshalXMLAttr 

func (e *ST_TLTimeNodeMasterRelation) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTimeNodeMasterRelation) Validate 

func (m ST_TLTimeNodeMasterRelation) Validate() error

func (ST_TLTimeNodeMasterRelation) ValidateWithPath 

func (m ST_TLTimeNodeMasterRelation) ValidateWithPath(path string) error

type ST_TLTimeNodePresetClassType 

type ST_TLTimeNodePresetClassType byte
const (
	ST_TLTimeNodePresetClassTypeUnset     ST_TLTimeNodePresetClassType = 0
	ST_TLTimeNodePresetClassTypeEntr      ST_TLTimeNodePresetClassType = 1
	ST_TLTimeNodePresetClassTypeExit      ST_TLTimeNodePresetClassType = 2
	ST_TLTimeNodePresetClassTypeEmph      ST_TLTimeNodePresetClassType = 3
	ST_TLTimeNodePresetClassTypePath      ST_TLTimeNodePresetClassType = 4
	ST_TLTimeNodePresetClassTypeVerb      ST_TLTimeNodePresetClassType = 5
	ST_TLTimeNodePresetClassTypeMediacall ST_TLTimeNodePresetClassType = 6
)

func (ST_TLTimeNodePresetClassType) MarshalXML 

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

func (ST_TLTimeNodePresetClassType) MarshalXMLAttr 

func (e ST_TLTimeNodePresetClassType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTimeNodePresetClassType) String 

func (m ST_TLTimeNodePresetClassType) String() string

func (*ST_TLTimeNodePresetClassType) UnmarshalXML 

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

func (*ST_TLTimeNodePresetClassType) UnmarshalXMLAttr 

func (e *ST_TLTimeNodePresetClassType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTimeNodePresetClassType) Validate 

func (m ST_TLTimeNodePresetClassType) Validate() error

func (ST_TLTimeNodePresetClassType) ValidateWithPath 

func (m ST_TLTimeNodePresetClassType) ValidateWithPath(path string) error

type ST_TLTimeNodeRestartType 

type ST_TLTimeNodeRestartType byte
const (
	ST_TLTimeNodeRestartTypeUnset         ST_TLTimeNodeRestartType = 0
	ST_TLTimeNodeRestartTypeAlways        ST_TLTimeNodeRestartType = 1
	ST_TLTimeNodeRestartTypeWhenNotActive ST_TLTimeNodeRestartType = 2
	ST_TLTimeNodeRestartTypeNever         ST_TLTimeNodeRestartType = 3
)

func (ST_TLTimeNodeRestartType) MarshalXML 

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

func (ST_TLTimeNodeRestartType) MarshalXMLAttr 

func (e ST_TLTimeNodeRestartType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTimeNodeRestartType) String 

func (m ST_TLTimeNodeRestartType) String() string

func (*ST_TLTimeNodeRestartType) UnmarshalXML 

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

func (*ST_TLTimeNodeRestartType) UnmarshalXMLAttr 

func (e *ST_TLTimeNodeRestartType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTimeNodeRestartType) Validate 

func (m ST_TLTimeNodeRestartType) Validate() error

func (ST_TLTimeNodeRestartType) ValidateWithPath 

func (m ST_TLTimeNodeRestartType) ValidateWithPath(path string) error

type ST_TLTimeNodeSyncType 

type ST_TLTimeNodeSyncType byte
const (
	ST_TLTimeNodeSyncTypeUnset   ST_TLTimeNodeSyncType = 0
	ST_TLTimeNodeSyncTypeCanSlip ST_TLTimeNodeSyncType = 1
	ST_TLTimeNodeSyncTypeLocked  ST_TLTimeNodeSyncType = 2
)

func (ST_TLTimeNodeSyncType) MarshalXML 

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

func (ST_TLTimeNodeSyncType) MarshalXMLAttr 

func (e ST_TLTimeNodeSyncType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTimeNodeSyncType) String 

func (m ST_TLTimeNodeSyncType) String() string

func (*ST_TLTimeNodeSyncType) UnmarshalXML 

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

func (*ST_TLTimeNodeSyncType) UnmarshalXMLAttr 

func (e *ST_TLTimeNodeSyncType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTimeNodeSyncType) Validate 

func (m ST_TLTimeNodeSyncType) Validate() error

func (ST_TLTimeNodeSyncType) ValidateWithPath 

func (m ST_TLTimeNodeSyncType) ValidateWithPath(path string) error

type ST_TLTimeNodeType 

type ST_TLTimeNodeType byte
const (
	ST_TLTimeNodeTypeUnset          ST_TLTimeNodeType = 0
	ST_TLTimeNodeTypeClickEffect    ST_TLTimeNodeType = 1
	ST_TLTimeNodeTypeWithEffect     ST_TLTimeNodeType = 2
	ST_TLTimeNodeTypeAfterEffect    ST_TLTimeNodeType = 3
	ST_TLTimeNodeTypeMainSeq        ST_TLTimeNodeType = 4
	ST_TLTimeNodeTypeInteractiveSeq ST_TLTimeNodeType = 5
	ST_TLTimeNodeTypeClickPar       ST_TLTimeNodeType = 6
	ST_TLTimeNodeTypeWithGroup      ST_TLTimeNodeType = 7
	ST_TLTimeNodeTypeAfterGroup     ST_TLTimeNodeType = 8
	ST_TLTimeNodeTypeTmRoot         ST_TLTimeNodeType = 9
)

func (ST_TLTimeNodeType) MarshalXML 

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

func (ST_TLTimeNodeType) MarshalXMLAttr 

func (e ST_TLTimeNodeType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTimeNodeType) String 

func (m ST_TLTimeNodeType) String() string

func (*ST_TLTimeNodeType) UnmarshalXML 

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

func (*ST_TLTimeNodeType) UnmarshalXMLAttr 

func (e *ST_TLTimeNodeType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTimeNodeType) Validate 

func (m ST_TLTimeNodeType) Validate() error

func (ST_TLTimeNodeType) ValidateWithPath 

func (m ST_TLTimeNodeType) ValidateWithPath(path string) error

type ST_TLTriggerEvent 

type ST_TLTriggerEvent byte
const (
	ST_TLTriggerEventUnset       ST_TLTriggerEvent = 0
	ST_TLTriggerEventOnBegin     ST_TLTriggerEvent = 1
	ST_TLTriggerEventOnEnd       ST_TLTriggerEvent = 2
	ST_TLTriggerEventBegin       ST_TLTriggerEvent = 3
	ST_TLTriggerEventEnd         ST_TLTriggerEvent = 4
	ST_TLTriggerEventOnClick     ST_TLTriggerEvent = 5
	ST_TLTriggerEventOnDblClick  ST_TLTriggerEvent = 6
	ST_TLTriggerEventOnMouseOver ST_TLTriggerEvent = 7
	ST_TLTriggerEventOnMouseOut  ST_TLTriggerEvent = 8
	ST_TLTriggerEventOnNext      ST_TLTriggerEvent = 9
	ST_TLTriggerEventOnPrev      ST_TLTriggerEvent = 10
	ST_TLTriggerEventOnStopAudio ST_TLTriggerEvent = 11
)

func (ST_TLTriggerEvent) MarshalXML 

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

func (ST_TLTriggerEvent) MarshalXMLAttr 

func (e ST_TLTriggerEvent) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTriggerEvent) String 

func (m ST_TLTriggerEvent) String() string

func (*ST_TLTriggerEvent) UnmarshalXML 

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

func (*ST_TLTriggerEvent) UnmarshalXMLAttr 

func (e *ST_TLTriggerEvent) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTriggerEvent) Validate 

func (m ST_TLTriggerEvent) Validate() error

func (ST_TLTriggerEvent) ValidateWithPath 

func (m ST_TLTriggerEvent) ValidateWithPath(path string) error

type ST_TLTriggerRuntimeNode 

type ST_TLTriggerRuntimeNode byte
const (
	ST_TLTriggerRuntimeNodeUnset ST_TLTriggerRuntimeNode = 0
	ST_TLTriggerRuntimeNodeFirst ST_TLTriggerRuntimeNode = 1
	ST_TLTriggerRuntimeNodeLast  ST_TLTriggerRuntimeNode = 2
	ST_TLTriggerRuntimeNodeAll   ST_TLTriggerRuntimeNode = 3
)

func (ST_TLTriggerRuntimeNode) MarshalXML 

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

func (ST_TLTriggerRuntimeNode) MarshalXMLAttr 

func (e ST_TLTriggerRuntimeNode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TLTriggerRuntimeNode) String 

func (m ST_TLTriggerRuntimeNode) String() string

func (*ST_TLTriggerRuntimeNode) UnmarshalXML 

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

func (*ST_TLTriggerRuntimeNode) UnmarshalXMLAttr 

func (e *ST_TLTriggerRuntimeNode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TLTriggerRuntimeNode) Validate 

func (m ST_TLTriggerRuntimeNode) Validate() error

func (ST_TLTriggerRuntimeNode) ValidateWithPath 

func (m ST_TLTriggerRuntimeNode) ValidateWithPath(path string) error

type ST_TransitionCornerDirectionType 

type ST_TransitionCornerDirectionType byte
const (
	ST_TransitionCornerDirectionTypeUnset ST_TransitionCornerDirectionType = 0
	ST_TransitionCornerDirectionTypeLu    ST_TransitionCornerDirectionType = 1
	ST_TransitionCornerDirectionTypeRu    ST_TransitionCornerDirectionType = 2
	ST_TransitionCornerDirectionTypeLd    ST_TransitionCornerDirectionType = 3
	ST_TransitionCornerDirectionTypeRd    ST_TransitionCornerDirectionType = 4
)

func (ST_TransitionCornerDirectionType) MarshalXML 

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

func (ST_TransitionCornerDirectionType) MarshalXMLAttr 

func (e ST_TransitionCornerDirectionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TransitionCornerDirectionType) String 

func (m ST_TransitionCornerDirectionType) String() string

func (*ST_TransitionCornerDirectionType) UnmarshalXML 

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

func (*ST_TransitionCornerDirectionType) UnmarshalXMLAttr 

func (e *ST_TransitionCornerDirectionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TransitionCornerDirectionType) Validate 

func (m ST_TransitionCornerDirectionType) Validate() error

func (ST_TransitionCornerDirectionType) ValidateWithPath 

func (m ST_TransitionCornerDirectionType) ValidateWithPath(path string) error

type ST_TransitionEightDirectionType 

type ST_TransitionEightDirectionType struct {
	ST_TransitionSideDirectionType   ST_TransitionSideDirectionType
	ST_TransitionCornerDirectionType ST_TransitionCornerDirectionType
}

ST_TransitionEightDirectionType is a union type

func ParseUnionST_TransitionEightDirectionType 

func ParseUnionST_TransitionEightDirectionType(s string) (ST_TransitionEightDirectionType, error)

func (ST_TransitionEightDirectionType) MarshalXML 

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

func (ST_TransitionEightDirectionType) String 

func (m ST_TransitionEightDirectionType) String() string

func (*ST_TransitionEightDirectionType) Validate 

func (m *ST_TransitionEightDirectionType) Validate() error

func (*ST_TransitionEightDirectionType) ValidateWithPath 

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

type ST_TransitionInOutDirectionType 

type ST_TransitionInOutDirectionType byte
const (
	ST_TransitionInOutDirectionTypeUnset ST_TransitionInOutDirectionType = 0
	ST_TransitionInOutDirectionTypeOut   ST_TransitionInOutDirectionType = 1
	ST_TransitionInOutDirectionTypeIn    ST_TransitionInOutDirectionType = 2
)

func (ST_TransitionInOutDirectionType) MarshalXML 

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

func (ST_TransitionInOutDirectionType) MarshalXMLAttr 

func (e ST_TransitionInOutDirectionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TransitionInOutDirectionType) String 

func (m ST_TransitionInOutDirectionType) String() string

func (*ST_TransitionInOutDirectionType) UnmarshalXML 

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

func (*ST_TransitionInOutDirectionType) UnmarshalXMLAttr 

func (e *ST_TransitionInOutDirectionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TransitionInOutDirectionType) Validate 

func (m ST_TransitionInOutDirectionType) Validate() error

func (ST_TransitionInOutDirectionType) ValidateWithPath 

func (m ST_TransitionInOutDirectionType) ValidateWithPath(path string) error

type ST_TransitionSideDirectionType 

type ST_TransitionSideDirectionType byte
const (
	ST_TransitionSideDirectionTypeUnset ST_TransitionSideDirectionType = 0
	ST_TransitionSideDirectionTypeL     ST_TransitionSideDirectionType = 1
	ST_TransitionSideDirectionTypeU     ST_TransitionSideDirectionType = 2
	ST_TransitionSideDirectionTypeR     ST_TransitionSideDirectionType = 3
	ST_TransitionSideDirectionTypeD     ST_TransitionSideDirectionType = 4
)

func (ST_TransitionSideDirectionType) MarshalXML 

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

func (ST_TransitionSideDirectionType) MarshalXMLAttr 

func (e ST_TransitionSideDirectionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TransitionSideDirectionType) String 

func (m ST_TransitionSideDirectionType) String() string

func (*ST_TransitionSideDirectionType) UnmarshalXML 

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

func (*ST_TransitionSideDirectionType) UnmarshalXMLAttr 

func (e *ST_TransitionSideDirectionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TransitionSideDirectionType) Validate 

func (m ST_TransitionSideDirectionType) Validate() error

func (ST_TransitionSideDirectionType) ValidateWithPath 

func (m ST_TransitionSideDirectionType) ValidateWithPath(path string) error

type ST_TransitionSpeed 

type ST_TransitionSpeed byte
const (
	ST_TransitionSpeedUnset ST_TransitionSpeed = 0
	ST_TransitionSpeedSlow  ST_TransitionSpeed = 1
	ST_TransitionSpeedMed   ST_TransitionSpeed = 2
	ST_TransitionSpeedFast  ST_TransitionSpeed = 3
)

func (ST_TransitionSpeed) MarshalXML 

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

func (ST_TransitionSpeed) MarshalXMLAttr 

func (e ST_TransitionSpeed) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TransitionSpeed) String 

func (m ST_TransitionSpeed) String() string

func (*ST_TransitionSpeed) UnmarshalXML 

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

func (*ST_TransitionSpeed) UnmarshalXMLAttr 

func (e *ST_TransitionSpeed) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TransitionSpeed) Validate 

func (m ST_TransitionSpeed) Validate() error

func (ST_TransitionSpeed) ValidateWithPath 

func (m ST_TransitionSpeed) ValidateWithPath(path string) error

type ST_ViewType 

type ST_ViewType byte
const (
	ST_ViewTypeUnset            ST_ViewType = 0
	ST_ViewTypeSldView          ST_ViewType = 1
	ST_ViewTypeSldMasterView    ST_ViewType = 2
	ST_ViewTypeNotesView        ST_ViewType = 3
	ST_ViewTypeHandoutView      ST_ViewType = 4
	ST_ViewTypeNotesMasterView  ST_ViewType = 5
	ST_ViewTypeOutlineView      ST_ViewType = 6
	ST_ViewTypeSldSorterView    ST_ViewType = 7
	ST_ViewTypeSldThumbnailView ST_ViewType = 8
)

func (ST_ViewType) MarshalXML 

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

func (ST_ViewType) MarshalXMLAttr 

func (e ST_ViewType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ViewType) String 

func (m ST_ViewType) String() string

func (*ST_ViewType) UnmarshalXML 

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

func (*ST_ViewType) UnmarshalXMLAttr 

func (e *ST_ViewType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ViewType) Validate 

func (m ST_ViewType) Validate() error

func (ST_ViewType) ValidateWithPath 

func (m ST_ViewType) ValidateWithPath(path string) error

type ST_WebColorType 

type ST_WebColorType byte
const (
	ST_WebColorTypeUnset              ST_WebColorType = 0
	ST_WebColorTypeNone               ST_WebColorType = 1
	ST_WebColorTypeBrowser            ST_WebColorType = 2
	ST_WebColorTypePresentationText   ST_WebColorType = 3
	ST_WebColorTypePresentationAccent ST_WebColorType = 4
	ST_WebColorTypeWhiteTextOnBlack   ST_WebColorType = 5
	ST_WebColorTypeBlackTextOnWhite   ST_WebColorType = 6
)

func (ST_WebColorType) MarshalXML 

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

func (ST_WebColorType) MarshalXMLAttr 

func (e ST_WebColorType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_WebColorType) String 

func (m ST_WebColorType) String() string

func (*ST_WebColorType) UnmarshalXML 

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

func (*ST_WebColorType) UnmarshalXMLAttr 

func (e *ST_WebColorType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_WebColorType) Validate 

func (m ST_WebColorType) Validate() error

func (ST_WebColorType) ValidateWithPath 

func (m ST_WebColorType) ValidateWithPath(path string) error

type ST_WebScreenSize 

type ST_WebScreenSize byte
const (
	ST_WebScreenSizeUnset     ST_WebScreenSize = 0
	ST_WebScreenSize544x376   ST_WebScreenSize = 1
	ST_WebScreenSize640x480   ST_WebScreenSize = 2
	ST_WebScreenSize720x512   ST_WebScreenSize = 3
	ST_WebScreenSize800x600   ST_WebScreenSize = 4
	ST_WebScreenSize1024x768  ST_WebScreenSize = 5
	ST_WebScreenSize1152x882  ST_WebScreenSize = 6
	ST_WebScreenSize1152x900  ST_WebScreenSize = 7
	ST_WebScreenSize1280x1024 ST_WebScreenSize = 8
	ST_WebScreenSize1600x1200 ST_WebScreenSize = 9
	ST_WebScreenSize1800x1400 ST_WebScreenSize = 10
	ST_WebScreenSize1920x1200 ST_WebScreenSize = 11
)

func (ST_WebScreenSize) MarshalXML 

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

func (ST_WebScreenSize) MarshalXMLAttr 

func (e ST_WebScreenSize) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_WebScreenSize) String 

func (m ST_WebScreenSize) String() string

func (*ST_WebScreenSize) UnmarshalXML 

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

func (*ST_WebScreenSize) UnmarshalXMLAttr 

func (e *ST_WebScreenSize) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_WebScreenSize) Validate 

func (m ST_WebScreenSize) Validate() error

func (ST_WebScreenSize) ValidateWithPath 

func (m ST_WebScreenSize) ValidateWithPath(path string) error

type Sld 

type Sld struct {
	CT_Slide
}

func NewSld 

func NewSld() *Sld

func (*Sld) MarshalXML 

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

func (*Sld) UnmarshalXML 

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

func (*Sld) Validate 

func (m *Sld) Validate() error

Validate validates the Sld and its children

func (*Sld) ValidateWithPath 

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

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

type SldLayout 

type SldLayout struct {
	CT_SlideLayout
}

func NewSldLayout 

func NewSldLayout() *SldLayout

func (*SldLayout) MarshalXML 

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

func (*SldLayout) UnmarshalXML 

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

func (*SldLayout) Validate 

func (m *SldLayout) Validate() error

Validate validates the SldLayout and its children

func (*SldLayout) ValidateWithPath 

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

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

type SldMaster 

type SldMaster struct {
	CT_SlideMaster
}

func NewSldMaster 

func NewSldMaster() *SldMaster

func (*SldMaster) MarshalXML 

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

func (*SldMaster) UnmarshalXML 

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

func (*SldMaster) Validate 

func (m *SldMaster) Validate() error

Validate validates the SldMaster and its children

func (*SldMaster) ValidateWithPath 

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

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

type SldSyncPr 

type SldSyncPr struct {
	CT_SlideSyncProperties
}

func NewSldSyncPr 

func NewSldSyncPr() *SldSyncPr

func (*SldSyncPr) MarshalXML 

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

func (*SldSyncPr) UnmarshalXML 

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

func (*SldSyncPr) Validate 

func (m *SldSyncPr) Validate() error

Validate validates the SldSyncPr and its children

func (*SldSyncPr) ValidateWithPath 

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

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

type TagLst 

type TagLst struct {
	CT_TagList
}

func NewTagLst 

func NewTagLst() *TagLst

func (*TagLst) MarshalXML 

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

func (*TagLst) UnmarshalXML 

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

func (*TagLst) Validate 

func (m *TagLst) Validate() error

Validate validates the TagLst and its children

func (*TagLst) ValidateWithPath 

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

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

type ViewPr 

type ViewPr struct {
	CT_ViewProperties
}

func NewViewPr 

func NewViewPr() *ViewPr

func (*ViewPr) MarshalXML 

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

func (*ViewPr) UnmarshalXML 

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

func (*ViewPr) Validate 

func (m *ViewPr) Validate() error

Validate validates the ViewPr and its children

func (*ViewPr) ValidateWithPath 

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

ValidateWithPath validates the ViewPr 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.