pml

package
v0.0.0-...-822f779 Latest Latest
Warning

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

Go to latest
Published: Oct 14, 2019 License: Apache-2.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 (*CT_ApplicationNonVisualDrawingProps) UnmarshalXML

func (*CT_ApplicationNonVisualDrawingProps) Validate

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     []gooxml.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 (*CT_GraphicalObjectFrameNonVisual) UnmarshalXML

func (*CT_GraphicalObjectFrameNonVisual) Validate

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 (*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

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 (*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 (*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 (*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 (ST_OleObjectFollowColorScheme) MarshalXMLAttr

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

func (ST_OleObjectFollowColorScheme) 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 (ST_TLAnimateBehaviorCalcMode) MarshalXMLAttr

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

func (ST_TLAnimateBehaviorCalcMode) 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 (ST_TLAnimateBehaviorValueType) MarshalXMLAttr

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

func (ST_TLAnimateBehaviorValueType) 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 (*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 (ST_TLAnimateEffectTransition) MarshalXMLAttr

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

func (ST_TLAnimateEffectTransition) 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 (ST_TLAnimateMotionBehaviorOrigin) MarshalXMLAttr

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

func (ST_TLAnimateMotionBehaviorOrigin) String

func (*ST_TLAnimateMotionBehaviorOrigin) UnmarshalXML

func (*ST_TLAnimateMotionBehaviorOrigin) UnmarshalXMLAttr

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

func (ST_TLAnimateMotionBehaviorOrigin) Validate

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 (ST_TLAnimateMotionPathEditMode) MarshalXMLAttr

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

func (ST_TLAnimateMotionPathEditMode) 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 (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 (*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 (*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 (*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 (ST_TLTimeNodePresetClassType) MarshalXMLAttr

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

func (ST_TLTimeNodePresetClassType) 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 (ST_TransitionCornerDirectionType) MarshalXMLAttr

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

func (ST_TransitionCornerDirectionType) String

func (*ST_TransitionCornerDirectionType) UnmarshalXML

func (*ST_TransitionCornerDirectionType) UnmarshalXMLAttr

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

func (ST_TransitionCornerDirectionType) Validate

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 (ST_TransitionEightDirectionType) 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 (ST_TransitionInOutDirectionType) MarshalXMLAttr

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

func (ST_TransitionInOutDirectionType) 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 (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 (ST_TransitionSideDirectionType) MarshalXMLAttr

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

func (ST_TransitionSideDirectionType) 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 (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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL