diagram

package
v0.6.0 Latest Latest
Warning

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

Go to latest
Published: Feb 6, 2018 License: AGPL-3.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AG_ConstraintAttributes

type AG_ConstraintAttributes struct {
	TypeAttr    ST_ConstraintType
	ForAttr     ST_ConstraintRelationship
	ForNameAttr *string
	PtTypeAttr  ST_ElementType
}

func NewAG_ConstraintAttributes

func NewAG_ConstraintAttributes() *AG_ConstraintAttributes

func (*AG_ConstraintAttributes) MarshalXML

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

func (*AG_ConstraintAttributes) UnmarshalXML

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

func (*AG_ConstraintAttributes) Validate

func (m *AG_ConstraintAttributes) Validate() error

Validate validates the AG_ConstraintAttributes and its children

func (*AG_ConstraintAttributes) ValidateWithPath

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

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

type AG_ConstraintRefAttributes

type AG_ConstraintRefAttributes struct {
	RefTypeAttr    ST_ConstraintType
	RefForAttr     ST_ConstraintRelationship
	RefForNameAttr *string
	RefPtTypeAttr  ST_ElementType
}

func NewAG_ConstraintRefAttributes

func NewAG_ConstraintRefAttributes() *AG_ConstraintRefAttributes

func (*AG_ConstraintRefAttributes) MarshalXML

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

func (*AG_ConstraintRefAttributes) UnmarshalXML

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

func (*AG_ConstraintRefAttributes) Validate

func (m *AG_ConstraintRefAttributes) Validate() error

Validate validates the AG_ConstraintRefAttributes and its children

func (*AG_ConstraintRefAttributes) ValidateWithPath

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

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

type AG_IteratorAttributes

type AG_IteratorAttributes struct {
	AxisAttr          *ST_AxisTypes
	PtTypeAttr        *ST_ElementTypes
	HideLastTransAttr *ST_Booleans
	StAttr            *ST_Ints
	CntAttr           *ST_UnsignedInts
	StepAttr          *ST_Ints
}

func NewAG_IteratorAttributes

func NewAG_IteratorAttributes() *AG_IteratorAttributes

func (*AG_IteratorAttributes) MarshalXML

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

func (*AG_IteratorAttributes) UnmarshalXML

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

func (*AG_IteratorAttributes) Validate

func (m *AG_IteratorAttributes) Validate() error

Validate validates the AG_IteratorAttributes and its children

func (*AG_IteratorAttributes) ValidateWithPath

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

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

type CT_Adj

type CT_Adj struct {
	IdxAttr uint32
	ValAttr float64
}

func NewCT_Adj

func NewCT_Adj() *CT_Adj

func (*CT_Adj) MarshalXML

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

func (*CT_Adj) UnmarshalXML

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

func (*CT_Adj) Validate

func (m *CT_Adj) Validate() error

Validate validates the CT_Adj and its children

func (*CT_Adj) ValidateWithPath

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

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

type CT_AdjLst

type CT_AdjLst struct {
	Adj []*CT_Adj
}

func NewCT_AdjLst

func NewCT_AdjLst() *CT_AdjLst

func (*CT_AdjLst) MarshalXML

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

func (*CT_AdjLst) UnmarshalXML

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

func (*CT_AdjLst) Validate

func (m *CT_AdjLst) Validate() error

Validate validates the CT_AdjLst and its children

func (*CT_AdjLst) ValidateWithPath

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

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

type CT_Algorithm

type CT_Algorithm struct {
	TypeAttr ST_AlgorithmType
	RevAttr  *uint32
	Param    []*CT_Parameter
	ExtLst   *dml.CT_OfficeArtExtensionList
}

func NewCT_Algorithm

func NewCT_Algorithm() *CT_Algorithm

func (*CT_Algorithm) MarshalXML

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

func (*CT_Algorithm) UnmarshalXML

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

func (*CT_Algorithm) Validate

func (m *CT_Algorithm) Validate() error

Validate validates the CT_Algorithm and its children

func (*CT_Algorithm) ValidateWithPath

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

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

type CT_AnimLvl

type CT_AnimLvl struct {
	ValAttr ST_AnimLvlStr
}

func NewCT_AnimLvl

func NewCT_AnimLvl() *CT_AnimLvl

func (*CT_AnimLvl) MarshalXML

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

func (*CT_AnimLvl) UnmarshalXML

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

func (*CT_AnimLvl) Validate

func (m *CT_AnimLvl) Validate() error

Validate validates the CT_AnimLvl and its children

func (*CT_AnimLvl) ValidateWithPath

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

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

type CT_AnimOne

type CT_AnimOne struct {
	ValAttr ST_AnimOneStr
}

func NewCT_AnimOne

func NewCT_AnimOne() *CT_AnimOne

func (*CT_AnimOne) MarshalXML

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

func (*CT_AnimOne) UnmarshalXML

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

func (*CT_AnimOne) Validate

func (m *CT_AnimOne) Validate() error

Validate validates the CT_AnimOne and its children

func (*CT_AnimOne) ValidateWithPath

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

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

type CT_BulletEnabled

type CT_BulletEnabled struct {
	ValAttr *bool
}

func NewCT_BulletEnabled

func NewCT_BulletEnabled() *CT_BulletEnabled

func (*CT_BulletEnabled) MarshalXML

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

func (*CT_BulletEnabled) UnmarshalXML

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

func (*CT_BulletEnabled) Validate

func (m *CT_BulletEnabled) Validate() error

Validate validates the CT_BulletEnabled and its children

func (*CT_BulletEnabled) ValidateWithPath

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

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

type CT_CTCategories

type CT_CTCategories struct {
	Cat []*CT_CTCategory
}

func NewCT_CTCategories

func NewCT_CTCategories() *CT_CTCategories

func (*CT_CTCategories) MarshalXML

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

func (*CT_CTCategories) UnmarshalXML

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

func (*CT_CTCategories) Validate

func (m *CT_CTCategories) Validate() error

Validate validates the CT_CTCategories and its children

func (*CT_CTCategories) ValidateWithPath

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

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

type CT_CTCategory

type CT_CTCategory struct {
	TypeAttr string
	PriAttr  uint32
}

func NewCT_CTCategory

func NewCT_CTCategory() *CT_CTCategory

func (*CT_CTCategory) MarshalXML

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

func (*CT_CTCategory) UnmarshalXML

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

func (*CT_CTCategory) Validate

func (m *CT_CTCategory) Validate() error

Validate validates the CT_CTCategory and its children

func (*CT_CTCategory) ValidateWithPath

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

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

type CT_CTDescription

type CT_CTDescription struct {
	LangAttr *string
	ValAttr  string
}

func NewCT_CTDescription

func NewCT_CTDescription() *CT_CTDescription

func (*CT_CTDescription) MarshalXML

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

func (*CT_CTDescription) UnmarshalXML

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

func (*CT_CTDescription) Validate

func (m *CT_CTDescription) Validate() error

Validate validates the CT_CTDescription and its children

func (*CT_CTDescription) ValidateWithPath

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

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

type CT_CTName

type CT_CTName struct {
	LangAttr *string
	ValAttr  string
}

func NewCT_CTName

func NewCT_CTName() *CT_CTName

func (*CT_CTName) MarshalXML

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

func (*CT_CTName) UnmarshalXML

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

func (*CT_CTName) Validate

func (m *CT_CTName) Validate() error

Validate validates the CT_CTName and its children

func (*CT_CTName) ValidateWithPath

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

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

type CT_CTStyleLabel

type CT_CTStyleLabel struct {
	NameAttr       string
	FillClrLst     *CT_Colors
	LinClrLst      *CT_Colors
	EffectClrLst   *CT_Colors
	TxLinClrLst    *CT_Colors
	TxFillClrLst   *CT_Colors
	TxEffectClrLst *CT_Colors
	ExtLst         *dml.CT_OfficeArtExtensionList
}

func NewCT_CTStyleLabel

func NewCT_CTStyleLabel() *CT_CTStyleLabel

func (*CT_CTStyleLabel) MarshalXML

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

func (*CT_CTStyleLabel) UnmarshalXML

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

func (*CT_CTStyleLabel) Validate

func (m *CT_CTStyleLabel) Validate() error

Validate validates the CT_CTStyleLabel and its children

func (*CT_CTStyleLabel) ValidateWithPath

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

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

type CT_Categories

type CT_Categories struct {
	Cat []*CT_Category
}

func NewCT_Categories

func NewCT_Categories() *CT_Categories

func (*CT_Categories) MarshalXML

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

func (*CT_Categories) UnmarshalXML

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

func (*CT_Categories) Validate

func (m *CT_Categories) Validate() error

Validate validates the CT_Categories and its children

func (*CT_Categories) ValidateWithPath

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

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

type CT_Category

type CT_Category struct {
	TypeAttr string
	PriAttr  uint32
}

func NewCT_Category

func NewCT_Category() *CT_Category

func (*CT_Category) MarshalXML

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

func (*CT_Category) UnmarshalXML

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

func (*CT_Category) Validate

func (m *CT_Category) Validate() error

Validate validates the CT_Category and its children

func (*CT_Category) ValidateWithPath

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

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

type CT_ChildMax

type CT_ChildMax struct {
	ValAttr *int32
}

func NewCT_ChildMax

func NewCT_ChildMax() *CT_ChildMax

func (*CT_ChildMax) MarshalXML

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

func (*CT_ChildMax) UnmarshalXML

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

func (*CT_ChildMax) Validate

func (m *CT_ChildMax) Validate() error

Validate validates the CT_ChildMax and its children

func (*CT_ChildMax) ValidateWithPath

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

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

type CT_ChildPref

type CT_ChildPref struct {
	ValAttr *int32
}

func NewCT_ChildPref

func NewCT_ChildPref() *CT_ChildPref

func (*CT_ChildPref) MarshalXML

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

func (*CT_ChildPref) UnmarshalXML

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

func (*CT_ChildPref) Validate

func (m *CT_ChildPref) Validate() error

Validate validates the CT_ChildPref and its children

func (*CT_ChildPref) ValidateWithPath

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

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

type CT_Choose

type CT_Choose struct {
	NameAttr *string
	If       []*CT_When
	Else     *CT_Otherwise
}

func NewCT_Choose

func NewCT_Choose() *CT_Choose

func (*CT_Choose) MarshalXML

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

func (*CT_Choose) UnmarshalXML

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

func (*CT_Choose) Validate

func (m *CT_Choose) Validate() error

Validate validates the CT_Choose and its children

func (*CT_Choose) ValidateWithPath

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

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

type CT_ColorTransform

type CT_ColorTransform struct {
	UniqueIdAttr *string
	MinVerAttr   *string
	Title        []*CT_CTName
	Desc         []*CT_CTDescription
	CatLst       *CT_CTCategories
	StyleLbl     []*CT_CTStyleLabel
	ExtLst       *dml.CT_OfficeArtExtensionList
}

func NewCT_ColorTransform

func NewCT_ColorTransform() *CT_ColorTransform

func (*CT_ColorTransform) MarshalXML

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

func (*CT_ColorTransform) UnmarshalXML

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

func (*CT_ColorTransform) Validate

func (m *CT_ColorTransform) Validate() error

Validate validates the CT_ColorTransform and its children

func (*CT_ColorTransform) ValidateWithPath

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

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

type CT_ColorTransformHeader

type CT_ColorTransformHeader struct {
	UniqueIdAttr string
	MinVerAttr   *string
	ResIdAttr    *int32
	Title        []*CT_CTName
	Desc         []*CT_CTDescription
	CatLst       *CT_CTCategories
	ExtLst       *dml.CT_OfficeArtExtensionList
}

func NewCT_ColorTransformHeader

func NewCT_ColorTransformHeader() *CT_ColorTransformHeader

func (*CT_ColorTransformHeader) MarshalXML

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

func (*CT_ColorTransformHeader) UnmarshalXML

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

func (*CT_ColorTransformHeader) Validate

func (m *CT_ColorTransformHeader) Validate() error

Validate validates the CT_ColorTransformHeader and its children

func (*CT_ColorTransformHeader) ValidateWithPath

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

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

type CT_ColorTransformHeaderLst

type CT_ColorTransformHeaderLst struct {
	ColorsDefHdr []*CT_ColorTransformHeader
}

func NewCT_ColorTransformHeaderLst

func NewCT_ColorTransformHeaderLst() *CT_ColorTransformHeaderLst

func (*CT_ColorTransformHeaderLst) MarshalXML

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

func (*CT_ColorTransformHeaderLst) UnmarshalXML

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

func (*CT_ColorTransformHeaderLst) Validate

func (m *CT_ColorTransformHeaderLst) Validate() error

Validate validates the CT_ColorTransformHeaderLst and its children

func (*CT_ColorTransformHeaderLst) ValidateWithPath

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

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

type CT_Colors

type CT_Colors struct {
	MethAttr       ST_ClrAppMethod
	HueDirAttr     ST_HueDir
	EG_ColorChoice []*dml.EG_ColorChoice
}

func NewCT_Colors

func NewCT_Colors() *CT_Colors

func (*CT_Colors) MarshalXML

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

func (*CT_Colors) UnmarshalXML

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

func (*CT_Colors) Validate

func (m *CT_Colors) Validate() error

Validate validates the CT_Colors and its children

func (*CT_Colors) ValidateWithPath

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

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

type CT_Constraint

type CT_Constraint struct {
	OpAttr         ST_BoolOperator
	ValAttr        *float64
	FactAttr       *float64
	ExtLst         *dml.CT_OfficeArtExtensionList
	TypeAttr       ST_ConstraintType
	ForAttr        ST_ConstraintRelationship
	ForNameAttr    *string
	PtTypeAttr     ST_ElementType
	RefTypeAttr    ST_ConstraintType
	RefForAttr     ST_ConstraintRelationship
	RefForNameAttr *string
	RefPtTypeAttr  ST_ElementType
}

func NewCT_Constraint

func NewCT_Constraint() *CT_Constraint

func (*CT_Constraint) MarshalXML

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

func (*CT_Constraint) UnmarshalXML

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

func (*CT_Constraint) Validate

func (m *CT_Constraint) Validate() error

Validate validates the CT_Constraint and its children

func (*CT_Constraint) ValidateWithPath

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

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

type CT_Constraints

type CT_Constraints struct {
	Constr []*CT_Constraint
}

func NewCT_Constraints

func NewCT_Constraints() *CT_Constraints

func (*CT_Constraints) MarshalXML

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

func (*CT_Constraints) UnmarshalXML

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

func (*CT_Constraints) Validate

func (m *CT_Constraints) Validate() error

Validate validates the CT_Constraints and its children

func (*CT_Constraints) ValidateWithPath

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

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

type CT_Cxn

type CT_Cxn struct {
	ModelIdAttr    ST_ModelId
	TypeAttr       ST_CxnType
	SrcIdAttr      ST_ModelId
	DestIdAttr     ST_ModelId
	SrcOrdAttr     uint32
	DestOrdAttr    uint32
	ParTransIdAttr *ST_ModelId
	SibTransIdAttr *ST_ModelId
	PresIdAttr     *string
	ExtLst         *dml.CT_OfficeArtExtensionList
}

func NewCT_Cxn

func NewCT_Cxn() *CT_Cxn

func (*CT_Cxn) MarshalXML

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

func (*CT_Cxn) UnmarshalXML

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

func (*CT_Cxn) Validate

func (m *CT_Cxn) Validate() error

Validate validates the CT_Cxn and its children

func (*CT_Cxn) ValidateWithPath

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

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

type CT_CxnList

type CT_CxnList struct {
	Cxn []*CT_Cxn
}

func NewCT_CxnList

func NewCT_CxnList() *CT_CxnList

func (*CT_CxnList) MarshalXML

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

func (*CT_CxnList) UnmarshalXML

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

func (*CT_CxnList) Validate

func (m *CT_CxnList) Validate() error

Validate validates the CT_CxnList and its children

func (*CT_CxnList) ValidateWithPath

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

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

type CT_DataModel

type CT_DataModel struct {
	PtLst  *CT_PtList
	CxnLst *CT_CxnList
	Bg     *dml.CT_BackgroundFormatting
	Whole  *dml.CT_WholeE2oFormatting
	ExtLst *dml.CT_OfficeArtExtensionList
}

func NewCT_DataModel

func NewCT_DataModel() *CT_DataModel

func (*CT_DataModel) MarshalXML

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

func (*CT_DataModel) UnmarshalXML

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

func (*CT_DataModel) Validate

func (m *CT_DataModel) Validate() error

Validate validates the CT_DataModel and its children

func (*CT_DataModel) ValidateWithPath

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

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

type CT_Description

type CT_Description struct {
	LangAttr *string
	ValAttr  string
}

func NewCT_Description

func NewCT_Description() *CT_Description

func (*CT_Description) MarshalXML

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

func (*CT_Description) UnmarshalXML

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

func (*CT_Description) Validate

func (m *CT_Description) Validate() error

Validate validates the CT_Description and its children

func (*CT_Description) ValidateWithPath

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

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

type CT_DiagramDefinition

type CT_DiagramDefinition struct {
	UniqueIdAttr *string
	MinVerAttr   *string
	DefStyleAttr *string
	Title        []*CT_Name
	Desc         []*CT_Description
	CatLst       *CT_Categories
	SampData     *CT_SampleData
	StyleData    *CT_SampleData
	ClrData      *CT_SampleData
	LayoutNode   *CT_LayoutNode
	ExtLst       *dml.CT_OfficeArtExtensionList
}

func NewCT_DiagramDefinition

func NewCT_DiagramDefinition() *CT_DiagramDefinition

func (*CT_DiagramDefinition) MarshalXML

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

func (*CT_DiagramDefinition) UnmarshalXML

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

func (*CT_DiagramDefinition) Validate

func (m *CT_DiagramDefinition) Validate() error

Validate validates the CT_DiagramDefinition and its children

func (*CT_DiagramDefinition) ValidateWithPath

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

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

type CT_DiagramDefinitionHeader

type CT_DiagramDefinitionHeader struct {
	UniqueIdAttr string
	MinVerAttr   *string
	DefStyleAttr *string
	ResIdAttr    *int32
	Title        []*CT_Name
	Desc         []*CT_Description
	CatLst       *CT_Categories
	ExtLst       *dml.CT_OfficeArtExtensionList
}

func NewCT_DiagramDefinitionHeader

func NewCT_DiagramDefinitionHeader() *CT_DiagramDefinitionHeader

func (*CT_DiagramDefinitionHeader) MarshalXML

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

func (*CT_DiagramDefinitionHeader) UnmarshalXML

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

func (*CT_DiagramDefinitionHeader) Validate

func (m *CT_DiagramDefinitionHeader) Validate() error

Validate validates the CT_DiagramDefinitionHeader and its children

func (*CT_DiagramDefinitionHeader) ValidateWithPath

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

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

type CT_DiagramDefinitionHeaderLst

type CT_DiagramDefinitionHeaderLst struct {
	LayoutDefHdr []*CT_DiagramDefinitionHeader
}

func NewCT_DiagramDefinitionHeaderLst

func NewCT_DiagramDefinitionHeaderLst() *CT_DiagramDefinitionHeaderLst

func (*CT_DiagramDefinitionHeaderLst) MarshalXML

func (*CT_DiagramDefinitionHeaderLst) UnmarshalXML

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

func (*CT_DiagramDefinitionHeaderLst) Validate

func (m *CT_DiagramDefinitionHeaderLst) Validate() error

Validate validates the CT_DiagramDefinitionHeaderLst and its children

func (*CT_DiagramDefinitionHeaderLst) ValidateWithPath

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

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

type CT_Direction

type CT_Direction struct {
	ValAttr ST_Direction
}

func NewCT_Direction

func NewCT_Direction() *CT_Direction

func (*CT_Direction) MarshalXML

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

func (*CT_Direction) UnmarshalXML

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

func (*CT_Direction) Validate

func (m *CT_Direction) Validate() error

Validate validates the CT_Direction and its children

func (*CT_Direction) ValidateWithPath

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

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

type CT_ElemPropSet

type CT_ElemPropSet struct {
	PresAssocIDAttr          *ST_ModelId
	PresNameAttr             *string
	PresStyleLblAttr         *string
	PresStyleIdxAttr         *int32
	PresStyleCntAttr         *int32
	LoTypeIdAttr             *string
	LoCatIdAttr              *string
	QsTypeIdAttr             *string
	QsCatIdAttr              *string
	CsTypeIdAttr             *string
	CsCatIdAttr              *string
	Coherent3DOffAttr        *bool
	PhldrTAttr               *string
	PhldrAttr                *bool
	CustAngAttr              *int32
	CustFlipVertAttr         *bool
	CustFlipHorAttr          *bool
	CustSzXAttr              *int32
	CustSzYAttr              *int32
	CustScaleXAttr           *ST_PrSetCustVal
	CustScaleYAttr           *ST_PrSetCustVal
	CustTAttr                *bool
	CustLinFactXAttr         *ST_PrSetCustVal
	CustLinFactYAttr         *ST_PrSetCustVal
	CustLinFactNeighborXAttr *ST_PrSetCustVal
	CustLinFactNeighborYAttr *ST_PrSetCustVal
	CustRadScaleRadAttr      *ST_PrSetCustVal
	CustRadScaleIncAttr      *ST_PrSetCustVal
	PresLayoutVars           *CT_LayoutVariablePropertySet
	Style                    *dml.CT_ShapeStyle
}

func NewCT_ElemPropSet

func NewCT_ElemPropSet() *CT_ElemPropSet

func (*CT_ElemPropSet) MarshalXML

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

func (*CT_ElemPropSet) UnmarshalXML

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

func (*CT_ElemPropSet) Validate

func (m *CT_ElemPropSet) Validate() error

Validate validates the CT_ElemPropSet and its children

func (*CT_ElemPropSet) ValidateWithPath

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

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

type CT_ForEach

type CT_ForEach struct {
	NameAttr          *string
	RefAttr           *string
	Alg               []*CT_Algorithm
	Shape             []*CT_Shape
	PresOf            []*CT_PresentationOf
	ConstrLst         []*CT_Constraints
	RuleLst           []*CT_Rules
	ForEach           []*CT_ForEach
	LayoutNode        []*CT_LayoutNode
	Choose            []*CT_Choose
	ExtLst            []*dml.CT_OfficeArtExtensionList
	AxisAttr          *ST_AxisTypes
	PtTypeAttr        *ST_ElementTypes
	HideLastTransAttr *ST_Booleans
	StAttr            *ST_Ints
	CntAttr           *ST_UnsignedInts
	StepAttr          *ST_Ints
}

func NewCT_ForEach

func NewCT_ForEach() *CT_ForEach

func (*CT_ForEach) MarshalXML

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

func (*CT_ForEach) UnmarshalXML

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

func (*CT_ForEach) Validate

func (m *CT_ForEach) Validate() error

Validate validates the CT_ForEach and its children

func (*CT_ForEach) ValidateWithPath

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

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

type CT_HierBranchStyle

type CT_HierBranchStyle struct {
	ValAttr ST_HierBranchStyle
}

func NewCT_HierBranchStyle

func NewCT_HierBranchStyle() *CT_HierBranchStyle

func (*CT_HierBranchStyle) MarshalXML

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

func (*CT_HierBranchStyle) UnmarshalXML

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

func (*CT_HierBranchStyle) Validate

func (m *CT_HierBranchStyle) Validate() error

Validate validates the CT_HierBranchStyle and its children

func (*CT_HierBranchStyle) ValidateWithPath

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

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

type CT_LayoutNode

type CT_LayoutNode struct {
	NameAttr     *string
	StyleLblAttr *string
	ChOrderAttr  ST_ChildOrderType
	MoveWithAttr *string
	Alg          []*CT_Algorithm
	Shape        []*CT_Shape
	PresOf       []*CT_PresentationOf
	ConstrLst    []*CT_Constraints
	RuleLst      []*CT_Rules
	VarLst       []*CT_LayoutVariablePropertySet
	ForEach      []*CT_ForEach
	LayoutNode   []*CT_LayoutNode
	Choose       []*CT_Choose
	ExtLst       []*dml.CT_OfficeArtExtensionList
}

func NewCT_LayoutNode

func NewCT_LayoutNode() *CT_LayoutNode

func (*CT_LayoutNode) MarshalXML

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

func (*CT_LayoutNode) UnmarshalXML

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

func (*CT_LayoutNode) Validate

func (m *CT_LayoutNode) Validate() error

Validate validates the CT_LayoutNode and its children

func (*CT_LayoutNode) ValidateWithPath

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

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

type CT_LayoutVariablePropertySet

type CT_LayoutVariablePropertySet struct {
	OrgChart      *CT_OrgChart
	ChMax         *CT_ChildMax
	ChPref        *CT_ChildPref
	BulletEnabled *CT_BulletEnabled
	Dir           *CT_Direction
	HierBranch    *CT_HierBranchStyle
	AnimOne       *CT_AnimOne
	AnimLvl       *CT_AnimLvl
	ResizeHandles *CT_ResizeHandles
}

func NewCT_LayoutVariablePropertySet

func NewCT_LayoutVariablePropertySet() *CT_LayoutVariablePropertySet

func (*CT_LayoutVariablePropertySet) MarshalXML

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

func (*CT_LayoutVariablePropertySet) UnmarshalXML

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

func (*CT_LayoutVariablePropertySet) Validate

func (m *CT_LayoutVariablePropertySet) Validate() error

Validate validates the CT_LayoutVariablePropertySet and its children

func (*CT_LayoutVariablePropertySet) ValidateWithPath

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

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

type CT_Name

type CT_Name struct {
	LangAttr *string
	ValAttr  string
}

func NewCT_Name

func NewCT_Name() *CT_Name

func (*CT_Name) MarshalXML

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

func (*CT_Name) UnmarshalXML

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

func (*CT_Name) Validate

func (m *CT_Name) Validate() error

Validate validates the CT_Name and its children

func (*CT_Name) ValidateWithPath

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

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

type CT_NumericRule

type CT_NumericRule struct {
	ValAttr     *float64
	FactAttr    *float64
	MaxAttr     *float64
	ExtLst      *dml.CT_OfficeArtExtensionList
	TypeAttr    ST_ConstraintType
	ForAttr     ST_ConstraintRelationship
	ForNameAttr *string
	PtTypeAttr  ST_ElementType
}

func NewCT_NumericRule

func NewCT_NumericRule() *CT_NumericRule

func (*CT_NumericRule) MarshalXML

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

func (*CT_NumericRule) UnmarshalXML

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

func (*CT_NumericRule) Validate

func (m *CT_NumericRule) Validate() error

Validate validates the CT_NumericRule and its children

func (*CT_NumericRule) ValidateWithPath

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

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

type CT_OrgChart

type CT_OrgChart struct {
	ValAttr *bool
}

func NewCT_OrgChart

func NewCT_OrgChart() *CT_OrgChart

func (*CT_OrgChart) MarshalXML

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

func (*CT_OrgChart) UnmarshalXML

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

func (*CT_OrgChart) Validate

func (m *CT_OrgChart) Validate() error

Validate validates the CT_OrgChart and its children

func (*CT_OrgChart) ValidateWithPath

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

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

type CT_Otherwise

type CT_Otherwise struct {
	NameAttr   *string
	Alg        []*CT_Algorithm
	Shape      []*CT_Shape
	PresOf     []*CT_PresentationOf
	ConstrLst  []*CT_Constraints
	RuleLst    []*CT_Rules
	ForEach    []*CT_ForEach
	LayoutNode []*CT_LayoutNode
	Choose     []*CT_Choose
	ExtLst     []*dml.CT_OfficeArtExtensionList
}

func NewCT_Otherwise

func NewCT_Otherwise() *CT_Otherwise

func (*CT_Otherwise) MarshalXML

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

func (*CT_Otherwise) UnmarshalXML

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

func (*CT_Otherwise) Validate

func (m *CT_Otherwise) Validate() error

Validate validates the CT_Otherwise and its children

func (*CT_Otherwise) ValidateWithPath

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

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

type CT_Parameter

type CT_Parameter struct {
	TypeAttr ST_ParameterId
	ValAttr  ST_ParameterVal
}

func NewCT_Parameter

func NewCT_Parameter() *CT_Parameter

func (*CT_Parameter) MarshalXML

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

func (*CT_Parameter) UnmarshalXML

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

func (*CT_Parameter) Validate

func (m *CT_Parameter) Validate() error

Validate validates the CT_Parameter and its children

func (*CT_Parameter) ValidateWithPath

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

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

type CT_PresentationOf

type CT_PresentationOf struct {
	ExtLst            *dml.CT_OfficeArtExtensionList
	AxisAttr          *ST_AxisTypes
	PtTypeAttr        *ST_ElementTypes
	HideLastTransAttr *ST_Booleans
	StAttr            *ST_Ints
	CntAttr           *ST_UnsignedInts
	StepAttr          *ST_Ints
}

func NewCT_PresentationOf

func NewCT_PresentationOf() *CT_PresentationOf

func (*CT_PresentationOf) MarshalXML

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

func (*CT_PresentationOf) UnmarshalXML

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

func (*CT_PresentationOf) Validate

func (m *CT_PresentationOf) Validate() error

Validate validates the CT_PresentationOf and its children

func (*CT_PresentationOf) ValidateWithPath

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

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

type CT_Pt

type CT_Pt struct {
	ModelIdAttr ST_ModelId
	TypeAttr    ST_PtType
	CxnIdAttr   *ST_ModelId
	PrSet       *CT_ElemPropSet
	SpPr        *dml.CT_ShapeProperties
	T           *dml.CT_TextBody
	ExtLst      *dml.CT_OfficeArtExtensionList
}

func NewCT_Pt

func NewCT_Pt() *CT_Pt

func (*CT_Pt) MarshalXML

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

func (*CT_Pt) UnmarshalXML

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

func (*CT_Pt) Validate

func (m *CT_Pt) Validate() error

Validate validates the CT_Pt and its children

func (*CT_Pt) ValidateWithPath

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

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

type CT_PtList

type CT_PtList struct {
	Pt []*CT_Pt
}

func NewCT_PtList

func NewCT_PtList() *CT_PtList

func (*CT_PtList) MarshalXML

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

func (*CT_PtList) UnmarshalXML

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

func (*CT_PtList) Validate

func (m *CT_PtList) Validate() error

Validate validates the CT_PtList and its children

func (*CT_PtList) ValidateWithPath

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

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

type CT_RelIds

type CT_RelIds struct {
	DmAttr string
	LoAttr string
	QsAttr string
	CsAttr string
}

func NewCT_RelIds

func NewCT_RelIds() *CT_RelIds

func (*CT_RelIds) MarshalXML

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

func (*CT_RelIds) UnmarshalXML

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

func (*CT_RelIds) Validate

func (m *CT_RelIds) Validate() error

Validate validates the CT_RelIds and its children

func (*CT_RelIds) ValidateWithPath

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

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

type CT_ResizeHandles

type CT_ResizeHandles struct {
	ValAttr ST_ResizeHandlesStr
}

func NewCT_ResizeHandles

func NewCT_ResizeHandles() *CT_ResizeHandles

func (*CT_ResizeHandles) MarshalXML

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

func (*CT_ResizeHandles) UnmarshalXML

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

func (*CT_ResizeHandles) Validate

func (m *CT_ResizeHandles) Validate() error

Validate validates the CT_ResizeHandles and its children

func (*CT_ResizeHandles) ValidateWithPath

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

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

type CT_Rules

type CT_Rules struct {
	Rule []*CT_NumericRule
}

func NewCT_Rules

func NewCT_Rules() *CT_Rules

func (*CT_Rules) MarshalXML

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

func (*CT_Rules) UnmarshalXML

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

func (*CT_Rules) Validate

func (m *CT_Rules) Validate() error

Validate validates the CT_Rules and its children

func (*CT_Rules) ValidateWithPath

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

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

type CT_SDCategories

type CT_SDCategories struct {
	Cat []*CT_SDCategory
}

func NewCT_SDCategories

func NewCT_SDCategories() *CT_SDCategories

func (*CT_SDCategories) MarshalXML

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

func (*CT_SDCategories) UnmarshalXML

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

func (*CT_SDCategories) Validate

func (m *CT_SDCategories) Validate() error

Validate validates the CT_SDCategories and its children

func (*CT_SDCategories) ValidateWithPath

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

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

type CT_SDCategory

type CT_SDCategory struct {
	TypeAttr string
	PriAttr  uint32
}

func NewCT_SDCategory

func NewCT_SDCategory() *CT_SDCategory

func (*CT_SDCategory) MarshalXML

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

func (*CT_SDCategory) UnmarshalXML

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

func (*CT_SDCategory) Validate

func (m *CT_SDCategory) Validate() error

Validate validates the CT_SDCategory and its children

func (*CT_SDCategory) ValidateWithPath

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

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

type CT_SDDescription

type CT_SDDescription struct {
	LangAttr *string
	ValAttr  string
}

func NewCT_SDDescription

func NewCT_SDDescription() *CT_SDDescription

func (*CT_SDDescription) MarshalXML

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

func (*CT_SDDescription) UnmarshalXML

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

func (*CT_SDDescription) Validate

func (m *CT_SDDescription) Validate() error

Validate validates the CT_SDDescription and its children

func (*CT_SDDescription) ValidateWithPath

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

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

type CT_SDName

type CT_SDName struct {
	LangAttr *string
	ValAttr  string
}

func NewCT_SDName

func NewCT_SDName() *CT_SDName

func (*CT_SDName) MarshalXML

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

func (*CT_SDName) UnmarshalXML

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

func (*CT_SDName) Validate

func (m *CT_SDName) Validate() error

Validate validates the CT_SDName and its children

func (*CT_SDName) ValidateWithPath

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

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

type CT_SampleData

type CT_SampleData struct {
	UseDefAttr *bool
	DataModel  *CT_DataModel
}

func NewCT_SampleData

func NewCT_SampleData() *CT_SampleData

func (*CT_SampleData) MarshalXML

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

func (*CT_SampleData) UnmarshalXML

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

func (*CT_SampleData) Validate

func (m *CT_SampleData) Validate() error

Validate validates the CT_SampleData and its children

func (*CT_SampleData) ValidateWithPath

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

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

type CT_Shape

type CT_Shape struct {
	RotAttr       *float64
	TypeAttr      *ST_LayoutShapeType
	BlipAttr      *string
	ZOrderOffAttr *int32
	HideGeomAttr  *bool
	LkTxEntryAttr *bool
	BlipPhldrAttr *bool
	AdjLst        *CT_AdjLst
	ExtLst        *dml.CT_OfficeArtExtensionList
}

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_StyleDefinition

type CT_StyleDefinition struct {
	UniqueIdAttr *string
	MinVerAttr   *string
	Title        []*CT_SDName
	Desc         []*CT_SDDescription
	CatLst       *CT_SDCategories
	Scene3d      *dml.CT_Scene3D
	StyleLbl     []*CT_StyleLabel
	ExtLst       *dml.CT_OfficeArtExtensionList
}

func NewCT_StyleDefinition

func NewCT_StyleDefinition() *CT_StyleDefinition

func (*CT_StyleDefinition) MarshalXML

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

func (*CT_StyleDefinition) UnmarshalXML

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

func (*CT_StyleDefinition) Validate

func (m *CT_StyleDefinition) Validate() error

Validate validates the CT_StyleDefinition and its children

func (*CT_StyleDefinition) ValidateWithPath

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

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

type CT_StyleDefinitionHeader

type CT_StyleDefinitionHeader struct {
	UniqueIdAttr string
	MinVerAttr   *string
	ResIdAttr    *int32
	Title        []*CT_SDName
	Desc         []*CT_SDDescription
	CatLst       *CT_SDCategories
	ExtLst       *dml.CT_OfficeArtExtensionList
}

func NewCT_StyleDefinitionHeader

func NewCT_StyleDefinitionHeader() *CT_StyleDefinitionHeader

func (*CT_StyleDefinitionHeader) MarshalXML

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

func (*CT_StyleDefinitionHeader) UnmarshalXML

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

func (*CT_StyleDefinitionHeader) Validate

func (m *CT_StyleDefinitionHeader) Validate() error

Validate validates the CT_StyleDefinitionHeader and its children

func (*CT_StyleDefinitionHeader) ValidateWithPath

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

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

type CT_StyleDefinitionHeaderLst

type CT_StyleDefinitionHeaderLst struct {
	StyleDefHdr []*CT_StyleDefinitionHeader
}

func NewCT_StyleDefinitionHeaderLst

func NewCT_StyleDefinitionHeaderLst() *CT_StyleDefinitionHeaderLst

func (*CT_StyleDefinitionHeaderLst) MarshalXML

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

func (*CT_StyleDefinitionHeaderLst) UnmarshalXML

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

func (*CT_StyleDefinitionHeaderLst) Validate

func (m *CT_StyleDefinitionHeaderLst) Validate() error

Validate validates the CT_StyleDefinitionHeaderLst and its children

func (*CT_StyleDefinitionHeaderLst) ValidateWithPath

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

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

type CT_StyleLabel

type CT_StyleLabel struct {
	NameAttr string
	Scene3d  *dml.CT_Scene3D
	Sp3d     *dml.CT_Shape3D
	TxPr     *CT_TextProps
	Style    *dml.CT_ShapeStyle
	ExtLst   *dml.CT_OfficeArtExtensionList
}

func NewCT_StyleLabel

func NewCT_StyleLabel() *CT_StyleLabel

func (*CT_StyleLabel) MarshalXML

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

func (*CT_StyleLabel) UnmarshalXML

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

func (*CT_StyleLabel) Validate

func (m *CT_StyleLabel) Validate() error

Validate validates the CT_StyleLabel and its children

func (*CT_StyleLabel) ValidateWithPath

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

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

type CT_TextProps

type CT_TextProps struct {
	Sp3d   *dml.CT_Shape3D
	FlatTx *dml.CT_FlatText
}

func NewCT_TextProps

func NewCT_TextProps() *CT_TextProps

func (*CT_TextProps) MarshalXML

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

func (*CT_TextProps) UnmarshalXML

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

func (*CT_TextProps) Validate

func (m *CT_TextProps) Validate() error

Validate validates the CT_TextProps and its children

func (*CT_TextProps) ValidateWithPath

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

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

type CT_When

type CT_When struct {
	NameAttr          *string
	FuncAttr          ST_FunctionType
	ArgAttr           *ST_FunctionArgument
	OpAttr            ST_FunctionOperator
	ValAttr           ST_FunctionValue
	Alg               []*CT_Algorithm
	Shape             []*CT_Shape
	PresOf            []*CT_PresentationOf
	ConstrLst         []*CT_Constraints
	RuleLst           []*CT_Rules
	ForEach           []*CT_ForEach
	LayoutNode        []*CT_LayoutNode
	Choose            []*CT_Choose
	ExtLst            []*dml.CT_OfficeArtExtensionList
	AxisAttr          *ST_AxisTypes
	PtTypeAttr        *ST_ElementTypes
	HideLastTransAttr *ST_Booleans
	StAttr            *ST_Ints
	CntAttr           *ST_UnsignedInts
	StepAttr          *ST_Ints
}

func NewCT_When

func NewCT_When() *CT_When

func (*CT_When) MarshalXML

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

func (*CT_When) UnmarshalXML

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

func (*CT_When) Validate

func (m *CT_When) Validate() error

Validate validates the CT_When and its children

func (*CT_When) ValidateWithPath

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

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

type ColorsDef

type ColorsDef struct {
	CT_ColorTransform
}

func NewColorsDef

func NewColorsDef() *ColorsDef

func (*ColorsDef) MarshalXML

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

func (*ColorsDef) UnmarshalXML

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

func (*ColorsDef) Validate

func (m *ColorsDef) Validate() error

Validate validates the ColorsDef and its children

func (*ColorsDef) ValidateWithPath

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

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

type ColorsDefHdr

type ColorsDefHdr struct {
	CT_ColorTransformHeader
}

func NewColorsDefHdr

func NewColorsDefHdr() *ColorsDefHdr

func (*ColorsDefHdr) MarshalXML

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

func (*ColorsDefHdr) UnmarshalXML

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

func (*ColorsDefHdr) Validate

func (m *ColorsDefHdr) Validate() error

Validate validates the ColorsDefHdr and its children

func (*ColorsDefHdr) ValidateWithPath

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

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

type ColorsDefHdrLst

type ColorsDefHdrLst struct {
	CT_ColorTransformHeaderLst
}

func NewColorsDefHdrLst

func NewColorsDefHdrLst() *ColorsDefHdrLst

func (*ColorsDefHdrLst) MarshalXML

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

func (*ColorsDefHdrLst) UnmarshalXML

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

func (*ColorsDefHdrLst) Validate

func (m *ColorsDefHdrLst) Validate() error

Validate validates the ColorsDefHdrLst and its children

func (*ColorsDefHdrLst) ValidateWithPath

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

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

type DataModel

type DataModel struct {
	CT_DataModel
}

func NewDataModel

func NewDataModel() *DataModel

func (*DataModel) MarshalXML

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

func (*DataModel) UnmarshalXML

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

func (*DataModel) Validate

func (m *DataModel) Validate() error

Validate validates the DataModel and its children

func (*DataModel) ValidateWithPath

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

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

type LayoutDef

type LayoutDef struct {
	CT_DiagramDefinition
}

func NewLayoutDef

func NewLayoutDef() *LayoutDef

func (*LayoutDef) MarshalXML

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

func (*LayoutDef) UnmarshalXML

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

func (*LayoutDef) Validate

func (m *LayoutDef) Validate() error

Validate validates the LayoutDef and its children

func (*LayoutDef) ValidateWithPath

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

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

type LayoutDefHdr

type LayoutDefHdr struct {
	CT_DiagramDefinitionHeader
}

func NewLayoutDefHdr

func NewLayoutDefHdr() *LayoutDefHdr

func (*LayoutDefHdr) MarshalXML

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

func (*LayoutDefHdr) UnmarshalXML

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

func (*LayoutDefHdr) Validate

func (m *LayoutDefHdr) Validate() error

Validate validates the LayoutDefHdr and its children

func (*LayoutDefHdr) ValidateWithPath

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

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

type LayoutDefHdrLst

type LayoutDefHdrLst struct {
	CT_DiagramDefinitionHeaderLst
}

func NewLayoutDefHdrLst

func NewLayoutDefHdrLst() *LayoutDefHdrLst

func (*LayoutDefHdrLst) MarshalXML

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

func (*LayoutDefHdrLst) UnmarshalXML

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

func (*LayoutDefHdrLst) Validate

func (m *LayoutDefHdrLst) Validate() error

Validate validates the LayoutDefHdrLst and its children

func (*LayoutDefHdrLst) ValidateWithPath

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

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

type RelIds

type RelIds struct {
	CT_RelIds
}

func NewRelIds

func NewRelIds() *RelIds

func (*RelIds) MarshalXML

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

func (*RelIds) UnmarshalXML

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

func (*RelIds) Validate

func (m *RelIds) Validate() error

Validate validates the RelIds and its children

func (*RelIds) ValidateWithPath

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

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

type ST_AlgorithmType

type ST_AlgorithmType byte
const (
	ST_AlgorithmTypeUnset     ST_AlgorithmType = 0
	ST_AlgorithmTypeComposite ST_AlgorithmType = 1
	ST_AlgorithmTypeConn      ST_AlgorithmType = 2
	ST_AlgorithmTypeCycle     ST_AlgorithmType = 3
	ST_AlgorithmTypeHierChild ST_AlgorithmType = 4
	ST_AlgorithmTypeHierRoot  ST_AlgorithmType = 5
	ST_AlgorithmTypePyra      ST_AlgorithmType = 6
	ST_AlgorithmTypeLin       ST_AlgorithmType = 7
	ST_AlgorithmTypeSp        ST_AlgorithmType = 8
	ST_AlgorithmTypeTx        ST_AlgorithmType = 9
	ST_AlgorithmTypeSnake     ST_AlgorithmType = 10
)

func (ST_AlgorithmType) MarshalXML

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

func (ST_AlgorithmType) MarshalXMLAttr

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

func (ST_AlgorithmType) String

func (m ST_AlgorithmType) String() string

func (*ST_AlgorithmType) UnmarshalXML

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

func (*ST_AlgorithmType) UnmarshalXMLAttr

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

func (ST_AlgorithmType) Validate

func (m ST_AlgorithmType) Validate() error

func (ST_AlgorithmType) ValidateWithPath

func (m ST_AlgorithmType) ValidateWithPath(path string) error

type ST_AnimLvlStr

type ST_AnimLvlStr byte
const (
	ST_AnimLvlStrUnset ST_AnimLvlStr = 0
	ST_AnimLvlStrNone  ST_AnimLvlStr = 1
	ST_AnimLvlStrLvl   ST_AnimLvlStr = 2
	ST_AnimLvlStrCtr   ST_AnimLvlStr = 3
)

func (ST_AnimLvlStr) MarshalXML

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

func (ST_AnimLvlStr) MarshalXMLAttr

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

func (ST_AnimLvlStr) String

func (m ST_AnimLvlStr) String() string

func (*ST_AnimLvlStr) UnmarshalXML

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

func (*ST_AnimLvlStr) UnmarshalXMLAttr

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

func (ST_AnimLvlStr) Validate

func (m ST_AnimLvlStr) Validate() error

func (ST_AnimLvlStr) ValidateWithPath

func (m ST_AnimLvlStr) ValidateWithPath(path string) error

type ST_AnimOneStr

type ST_AnimOneStr byte
const (
	ST_AnimOneStrUnset  ST_AnimOneStr = 0
	ST_AnimOneStrNone   ST_AnimOneStr = 1
	ST_AnimOneStrOne    ST_AnimOneStr = 2
	ST_AnimOneStrBranch ST_AnimOneStr = 3
)

func (ST_AnimOneStr) MarshalXML

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

func (ST_AnimOneStr) MarshalXMLAttr

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

func (ST_AnimOneStr) String

func (m ST_AnimOneStr) String() string

func (*ST_AnimOneStr) UnmarshalXML

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

func (*ST_AnimOneStr) UnmarshalXMLAttr

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

func (ST_AnimOneStr) Validate

func (m ST_AnimOneStr) Validate() error

func (ST_AnimOneStr) ValidateWithPath

func (m ST_AnimOneStr) ValidateWithPath(path string) error

type ST_ArrowheadStyle

type ST_ArrowheadStyle byte
const (
	ST_ArrowheadStyleUnset ST_ArrowheadStyle = 0
	ST_ArrowheadStyleAuto  ST_ArrowheadStyle = 1
	ST_ArrowheadStyleArr   ST_ArrowheadStyle = 2
	ST_ArrowheadStyleNoArr ST_ArrowheadStyle = 3
)

func (ST_ArrowheadStyle) MarshalXML

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

func (ST_ArrowheadStyle) MarshalXMLAttr

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

func (ST_ArrowheadStyle) String

func (m ST_ArrowheadStyle) String() string

func (*ST_ArrowheadStyle) UnmarshalXML

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

func (*ST_ArrowheadStyle) UnmarshalXMLAttr

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

func (ST_ArrowheadStyle) Validate

func (m ST_ArrowheadStyle) Validate() error

func (ST_ArrowheadStyle) ValidateWithPath

func (m ST_ArrowheadStyle) ValidateWithPath(path string) error

type ST_AutoTextRotation

type ST_AutoTextRotation byte
const (
	ST_AutoTextRotationUnset ST_AutoTextRotation = 0
	ST_AutoTextRotationNone  ST_AutoTextRotation = 1
	ST_AutoTextRotationUpr   ST_AutoTextRotation = 2
	ST_AutoTextRotationGrav  ST_AutoTextRotation = 3
)

func (ST_AutoTextRotation) MarshalXML

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

func (ST_AutoTextRotation) MarshalXMLAttr

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

func (ST_AutoTextRotation) String

func (m ST_AutoTextRotation) String() string

func (*ST_AutoTextRotation) UnmarshalXML

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

func (*ST_AutoTextRotation) UnmarshalXMLAttr

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

func (ST_AutoTextRotation) Validate

func (m ST_AutoTextRotation) Validate() error

func (ST_AutoTextRotation) ValidateWithPath

func (m ST_AutoTextRotation) ValidateWithPath(path string) error

type ST_AxisType

type ST_AxisType byte
const (
	ST_AxisTypeUnset       ST_AxisType = 0
	ST_AxisTypeSelf        ST_AxisType = 1
	ST_AxisTypeCh          ST_AxisType = 2
	ST_AxisTypeDes         ST_AxisType = 3
	ST_AxisTypeDesOrSelf   ST_AxisType = 4
	ST_AxisTypePar         ST_AxisType = 5
	ST_AxisTypeAncst       ST_AxisType = 6
	ST_AxisTypeAncstOrSelf ST_AxisType = 7
	ST_AxisTypeFollowSib   ST_AxisType = 8
	ST_AxisTypePrecedSib   ST_AxisType = 9
	ST_AxisTypeFollow      ST_AxisType = 10
	ST_AxisTypePreced      ST_AxisType = 11
	ST_AxisTypeRoot        ST_AxisType = 12
	ST_AxisTypeNone        ST_AxisType = 13
)

func (ST_AxisType) MarshalXML

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

func (ST_AxisType) MarshalXMLAttr

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

func (ST_AxisType) String

func (m ST_AxisType) String() string

func (*ST_AxisType) UnmarshalXML

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

func (*ST_AxisType) UnmarshalXMLAttr

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

func (ST_AxisType) Validate

func (m ST_AxisType) Validate() error

func (ST_AxisType) ValidateWithPath

func (m ST_AxisType) ValidateWithPath(path string) error

type ST_AxisTypes

type ST_AxisTypes []ST_AxisType

func ParseSliceST_AxisTypes

func ParseSliceST_AxisTypes(s string) (ST_AxisTypes, error)

type ST_BendPoint

type ST_BendPoint byte
const (
	ST_BendPointUnset ST_BendPoint = 0
	ST_BendPointBeg   ST_BendPoint = 1
	ST_BendPointDef   ST_BendPoint = 2
	ST_BendPointEnd   ST_BendPoint = 3
)

func (ST_BendPoint) MarshalXML

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

func (ST_BendPoint) MarshalXMLAttr

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

func (ST_BendPoint) String

func (m ST_BendPoint) String() string

func (*ST_BendPoint) UnmarshalXML

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

func (*ST_BendPoint) UnmarshalXMLAttr

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

func (ST_BendPoint) Validate

func (m ST_BendPoint) Validate() error

func (ST_BendPoint) ValidateWithPath

func (m ST_BendPoint) ValidateWithPath(path string) error

type ST_BoolOperator

type ST_BoolOperator byte
const (
	ST_BoolOperatorUnset ST_BoolOperator = 0
	ST_BoolOperatorNone  ST_BoolOperator = 1
	ST_BoolOperatorEqu   ST_BoolOperator = 2
	ST_BoolOperatorGte   ST_BoolOperator = 3
	ST_BoolOperatorLte   ST_BoolOperator = 4
)

func (ST_BoolOperator) MarshalXML

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

func (ST_BoolOperator) MarshalXMLAttr

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

func (ST_BoolOperator) String

func (m ST_BoolOperator) String() string

func (*ST_BoolOperator) UnmarshalXML

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

func (*ST_BoolOperator) UnmarshalXMLAttr

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

func (ST_BoolOperator) Validate

func (m ST_BoolOperator) Validate() error

func (ST_BoolOperator) ValidateWithPath

func (m ST_BoolOperator) ValidateWithPath(path string) error

type ST_Booleans

type ST_Booleans []bool

func ParseSliceST_Booleans

func ParseSliceST_Booleans(s string) (ST_Booleans, error)

type ST_Breakpoint

type ST_Breakpoint byte
const (
	ST_BreakpointUnset  ST_Breakpoint = 0
	ST_BreakpointEndCnv ST_Breakpoint = 1
	ST_BreakpointBal    ST_Breakpoint = 2
	ST_BreakpointFixed  ST_Breakpoint = 3
)

func (ST_Breakpoint) MarshalXML

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

func (ST_Breakpoint) MarshalXMLAttr

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

func (ST_Breakpoint) String

func (m ST_Breakpoint) String() string

func (*ST_Breakpoint) UnmarshalXML

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

func (*ST_Breakpoint) UnmarshalXMLAttr

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

func (ST_Breakpoint) Validate

func (m ST_Breakpoint) Validate() error

func (ST_Breakpoint) ValidateWithPath

func (m ST_Breakpoint) ValidateWithPath(path string) error

type ST_CenterShapeMapping

type ST_CenterShapeMapping byte
const (
	ST_CenterShapeMappingUnset ST_CenterShapeMapping = 0
	ST_CenterShapeMappingNone  ST_CenterShapeMapping = 1
	ST_CenterShapeMappingFNode ST_CenterShapeMapping = 2
)

func (ST_CenterShapeMapping) MarshalXML

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

func (ST_CenterShapeMapping) MarshalXMLAttr

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

func (ST_CenterShapeMapping) String

func (m ST_CenterShapeMapping) String() string

func (*ST_CenterShapeMapping) UnmarshalXML

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

func (*ST_CenterShapeMapping) UnmarshalXMLAttr

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

func (ST_CenterShapeMapping) Validate

func (m ST_CenterShapeMapping) Validate() error

func (ST_CenterShapeMapping) ValidateWithPath

func (m ST_CenterShapeMapping) ValidateWithPath(path string) error

type ST_ChildAlignment

type ST_ChildAlignment byte
const (
	ST_ChildAlignmentUnset ST_ChildAlignment = 0
	ST_ChildAlignmentT     ST_ChildAlignment = 1
	ST_ChildAlignmentB     ST_ChildAlignment = 2
	ST_ChildAlignmentL     ST_ChildAlignment = 3
	ST_ChildAlignmentR     ST_ChildAlignment = 4
)

func (ST_ChildAlignment) MarshalXML

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

func (ST_ChildAlignment) MarshalXMLAttr

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

func (ST_ChildAlignment) String

func (m ST_ChildAlignment) String() string

func (*ST_ChildAlignment) UnmarshalXML

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

func (*ST_ChildAlignment) UnmarshalXMLAttr

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

func (ST_ChildAlignment) Validate

func (m ST_ChildAlignment) Validate() error

func (ST_ChildAlignment) ValidateWithPath

func (m ST_ChildAlignment) ValidateWithPath(path string) error

type ST_ChildDirection

type ST_ChildDirection byte
const (
	ST_ChildDirectionUnset ST_ChildDirection = 0
	ST_ChildDirectionHorz  ST_ChildDirection = 1
	ST_ChildDirectionVert  ST_ChildDirection = 2
)

func (ST_ChildDirection) MarshalXML

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

func (ST_ChildDirection) MarshalXMLAttr

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

func (ST_ChildDirection) String

func (m ST_ChildDirection) String() string

func (*ST_ChildDirection) UnmarshalXML

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

func (*ST_ChildDirection) UnmarshalXMLAttr

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

func (ST_ChildDirection) Validate

func (m ST_ChildDirection) Validate() error

func (ST_ChildDirection) ValidateWithPath

func (m ST_ChildDirection) ValidateWithPath(path string) error

type ST_ChildOrderType

type ST_ChildOrderType byte
const (
	ST_ChildOrderTypeUnset ST_ChildOrderType = 0
	ST_ChildOrderTypeB     ST_ChildOrderType = 1
	ST_ChildOrderTypeT     ST_ChildOrderType = 2
)

func (ST_ChildOrderType) MarshalXML

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

func (ST_ChildOrderType) MarshalXMLAttr

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

func (ST_ChildOrderType) String

func (m ST_ChildOrderType) String() string

func (*ST_ChildOrderType) UnmarshalXML

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

func (*ST_ChildOrderType) UnmarshalXMLAttr

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

func (ST_ChildOrderType) Validate

func (m ST_ChildOrderType) Validate() error

func (ST_ChildOrderType) ValidateWithPath

func (m ST_ChildOrderType) ValidateWithPath(path string) error

type ST_ClrAppMethod

type ST_ClrAppMethod byte
const (
	ST_ClrAppMethodUnset  ST_ClrAppMethod = 0
	ST_ClrAppMethodSpan   ST_ClrAppMethod = 1
	ST_ClrAppMethodCycle  ST_ClrAppMethod = 2
	ST_ClrAppMethodRepeat ST_ClrAppMethod = 3
)

func (ST_ClrAppMethod) MarshalXML

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

func (ST_ClrAppMethod) MarshalXMLAttr

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

func (ST_ClrAppMethod) String

func (m ST_ClrAppMethod) String() string

func (*ST_ClrAppMethod) UnmarshalXML

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

func (*ST_ClrAppMethod) UnmarshalXMLAttr

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

func (ST_ClrAppMethod) Validate

func (m ST_ClrAppMethod) Validate() error

func (ST_ClrAppMethod) ValidateWithPath

func (m ST_ClrAppMethod) ValidateWithPath(path string) error

type ST_ConnectorDimension

type ST_ConnectorDimension byte
const (
	ST_ConnectorDimensionUnset ST_ConnectorDimension = 0
	ST_ConnectorDimension1D    ST_ConnectorDimension = 1
	ST_ConnectorDimension2D    ST_ConnectorDimension = 2
	ST_ConnectorDimensionCust  ST_ConnectorDimension = 3
)

func (ST_ConnectorDimension) MarshalXML

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

func (ST_ConnectorDimension) MarshalXMLAttr

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

func (ST_ConnectorDimension) String

func (m ST_ConnectorDimension) String() string

func (*ST_ConnectorDimension) UnmarshalXML

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

func (*ST_ConnectorDimension) UnmarshalXMLAttr

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

func (ST_ConnectorDimension) Validate

func (m ST_ConnectorDimension) Validate() error

func (ST_ConnectorDimension) ValidateWithPath

func (m ST_ConnectorDimension) ValidateWithPath(path string) error

type ST_ConnectorPoint

type ST_ConnectorPoint byte
const (
	ST_ConnectorPointUnset  ST_ConnectorPoint = 0
	ST_ConnectorPointAuto   ST_ConnectorPoint = 1
	ST_ConnectorPointBCtr   ST_ConnectorPoint = 2
	ST_ConnectorPointCtr    ST_ConnectorPoint = 3
	ST_ConnectorPointMidL   ST_ConnectorPoint = 4
	ST_ConnectorPointMidR   ST_ConnectorPoint = 5
	ST_ConnectorPointTCtr   ST_ConnectorPoint = 6
	ST_ConnectorPointBL     ST_ConnectorPoint = 7
	ST_ConnectorPointBR     ST_ConnectorPoint = 8
	ST_ConnectorPointTL     ST_ConnectorPoint = 9
	ST_ConnectorPointTR     ST_ConnectorPoint = 10
	ST_ConnectorPointRadial ST_ConnectorPoint = 11
)

func (ST_ConnectorPoint) MarshalXML

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

func (ST_ConnectorPoint) MarshalXMLAttr

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

func (ST_ConnectorPoint) String

func (m ST_ConnectorPoint) String() string

func (*ST_ConnectorPoint) UnmarshalXML

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

func (*ST_ConnectorPoint) UnmarshalXMLAttr

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

func (ST_ConnectorPoint) Validate

func (m ST_ConnectorPoint) Validate() error

func (ST_ConnectorPoint) ValidateWithPath

func (m ST_ConnectorPoint) ValidateWithPath(path string) error

type ST_ConnectorRouting

type ST_ConnectorRouting byte
const (
	ST_ConnectorRoutingUnset     ST_ConnectorRouting = 0
	ST_ConnectorRoutingStra      ST_ConnectorRouting = 1
	ST_ConnectorRoutingBend      ST_ConnectorRouting = 2
	ST_ConnectorRoutingCurve     ST_ConnectorRouting = 3
	ST_ConnectorRoutingLongCurve ST_ConnectorRouting = 4
)

func (ST_ConnectorRouting) MarshalXML

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

func (ST_ConnectorRouting) MarshalXMLAttr

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

func (ST_ConnectorRouting) String

func (m ST_ConnectorRouting) String() string

func (*ST_ConnectorRouting) UnmarshalXML

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

func (*ST_ConnectorRouting) UnmarshalXMLAttr

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

func (ST_ConnectorRouting) Validate

func (m ST_ConnectorRouting) Validate() error

func (ST_ConnectorRouting) ValidateWithPath

func (m ST_ConnectorRouting) ValidateWithPath(path string) error

type ST_ConstraintRelationship

type ST_ConstraintRelationship byte
const (
	ST_ConstraintRelationshipUnset ST_ConstraintRelationship = 0
	ST_ConstraintRelationshipSelf  ST_ConstraintRelationship = 1
	ST_ConstraintRelationshipCh    ST_ConstraintRelationship = 2
	ST_ConstraintRelationshipDes   ST_ConstraintRelationship = 3
)

func (ST_ConstraintRelationship) MarshalXML

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

func (ST_ConstraintRelationship) MarshalXMLAttr

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

func (ST_ConstraintRelationship) String

func (m ST_ConstraintRelationship) String() string

func (*ST_ConstraintRelationship) UnmarshalXML

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

func (*ST_ConstraintRelationship) UnmarshalXMLAttr

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

func (ST_ConstraintRelationship) Validate

func (m ST_ConstraintRelationship) Validate() error

func (ST_ConstraintRelationship) ValidateWithPath

func (m ST_ConstraintRelationship) ValidateWithPath(path string) error

type ST_ConstraintType

type ST_ConstraintType byte
const (
	ST_ConstraintTypeUnset         ST_ConstraintType = 0
	ST_ConstraintTypeNone          ST_ConstraintType = 1
	ST_ConstraintTypeAlignOff      ST_ConstraintType = 2
	ST_ConstraintTypeBegMarg       ST_ConstraintType = 3
	ST_ConstraintTypeBendDist      ST_ConstraintType = 4
	ST_ConstraintTypeBegPad        ST_ConstraintType = 5
	ST_ConstraintTypeB             ST_ConstraintType = 6
	ST_ConstraintTypeBMarg         ST_ConstraintType = 7
	ST_ConstraintTypeBOff          ST_ConstraintType = 8
	ST_ConstraintTypeCtrX          ST_ConstraintType = 9
	ST_ConstraintTypeCtrXOff       ST_ConstraintType = 10
	ST_ConstraintTypeCtrY          ST_ConstraintType = 11
	ST_ConstraintTypeCtrYOff       ST_ConstraintType = 12
	ST_ConstraintTypeConnDist      ST_ConstraintType = 13
	ST_ConstraintTypeDiam          ST_ConstraintType = 14
	ST_ConstraintTypeEndMarg       ST_ConstraintType = 15
	ST_ConstraintTypeEndPad        ST_ConstraintType = 16
	ST_ConstraintTypeH             ST_ConstraintType = 17
	ST_ConstraintTypeHArH          ST_ConstraintType = 18
	ST_ConstraintTypeHOff          ST_ConstraintType = 19
	ST_ConstraintTypeL             ST_ConstraintType = 20
	ST_ConstraintTypeLMarg         ST_ConstraintType = 21
	ST_ConstraintTypeLOff          ST_ConstraintType = 22
	ST_ConstraintTypeR             ST_ConstraintType = 23
	ST_ConstraintTypeRMarg         ST_ConstraintType = 24
	ST_ConstraintTypeROff          ST_ConstraintType = 25
	ST_ConstraintTypePrimFontSz    ST_ConstraintType = 26
	ST_ConstraintTypePyraAcctRatio ST_ConstraintType = 27
	ST_ConstraintTypeSecFontSz     ST_ConstraintType = 28
	ST_ConstraintTypeSibSp         ST_ConstraintType = 29
	ST_ConstraintTypeSecSibSp      ST_ConstraintType = 30
	ST_ConstraintTypeSp            ST_ConstraintType = 31
	ST_ConstraintTypeStemThick     ST_ConstraintType = 32
	ST_ConstraintTypeT             ST_ConstraintType = 33
	ST_ConstraintTypeTMarg         ST_ConstraintType = 34
	ST_ConstraintTypeTOff          ST_ConstraintType = 35
	ST_ConstraintTypeUserA         ST_ConstraintType = 36
	ST_ConstraintTypeUserB         ST_ConstraintType = 37
	ST_ConstraintTypeUserC         ST_ConstraintType = 38
	ST_ConstraintTypeUserD         ST_ConstraintType = 39
	ST_ConstraintTypeUserE         ST_ConstraintType = 40
	ST_ConstraintTypeUserF         ST_ConstraintType = 41
	ST_ConstraintTypeUserG         ST_ConstraintType = 42
	ST_ConstraintTypeUserH         ST_ConstraintType = 43
	ST_ConstraintTypeUserI         ST_ConstraintType = 44
	ST_ConstraintTypeUserJ         ST_ConstraintType = 45
	ST_ConstraintTypeUserK         ST_ConstraintType = 46
	ST_ConstraintTypeUserL         ST_ConstraintType = 47
	ST_ConstraintTypeUserM         ST_ConstraintType = 48
	ST_ConstraintTypeUserN         ST_ConstraintType = 49
	ST_ConstraintTypeUserO         ST_ConstraintType = 50
	ST_ConstraintTypeUserP         ST_ConstraintType = 51
	ST_ConstraintTypeUserQ         ST_ConstraintType = 52
	ST_ConstraintTypeUserR         ST_ConstraintType = 53
	ST_ConstraintTypeUserS         ST_ConstraintType = 54
	ST_ConstraintTypeUserT         ST_ConstraintType = 55
	ST_ConstraintTypeUserU         ST_ConstraintType = 56
	ST_ConstraintTypeUserV         ST_ConstraintType = 57
	ST_ConstraintTypeUserW         ST_ConstraintType = 58
	ST_ConstraintTypeUserX         ST_ConstraintType = 59
	ST_ConstraintTypeUserY         ST_ConstraintType = 60
	ST_ConstraintTypeUserZ         ST_ConstraintType = 61
	ST_ConstraintTypeW             ST_ConstraintType = 62
	ST_ConstraintTypeWArH          ST_ConstraintType = 63
	ST_ConstraintTypeWOff          ST_ConstraintType = 64
)

func (ST_ConstraintType) MarshalXML

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

func (ST_ConstraintType) MarshalXMLAttr

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

func (ST_ConstraintType) String

func (m ST_ConstraintType) String() string

func (*ST_ConstraintType) UnmarshalXML

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

func (*ST_ConstraintType) UnmarshalXMLAttr

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

func (ST_ConstraintType) Validate

func (m ST_ConstraintType) Validate() error

func (ST_ConstraintType) ValidateWithPath

func (m ST_ConstraintType) ValidateWithPath(path string) error

type ST_ContinueDirection

type ST_ContinueDirection byte
const (
	ST_ContinueDirectionUnset   ST_ContinueDirection = 0
	ST_ContinueDirectionRevDir  ST_ContinueDirection = 1
	ST_ContinueDirectionSameDir ST_ContinueDirection = 2
)

func (ST_ContinueDirection) MarshalXML

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

func (ST_ContinueDirection) MarshalXMLAttr

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

func (ST_ContinueDirection) String

func (m ST_ContinueDirection) String() string

func (*ST_ContinueDirection) UnmarshalXML

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

func (*ST_ContinueDirection) UnmarshalXMLAttr

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

func (ST_ContinueDirection) Validate

func (m ST_ContinueDirection) Validate() error

func (ST_ContinueDirection) ValidateWithPath

func (m ST_ContinueDirection) ValidateWithPath(path string) error

type ST_CxnType

type ST_CxnType byte
const (
	ST_CxnTypeUnset               ST_CxnType = 0
	ST_CxnTypeParOf               ST_CxnType = 1
	ST_CxnTypePresOf              ST_CxnType = 2
	ST_CxnTypePresParOf           ST_CxnType = 3
	ST_CxnTypeUnknownRelationship ST_CxnType = 4
)

func (ST_CxnType) MarshalXML

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

func (ST_CxnType) MarshalXMLAttr

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

func (ST_CxnType) String

func (m ST_CxnType) String() string

func (*ST_CxnType) UnmarshalXML

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

func (*ST_CxnType) UnmarshalXMLAttr

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

func (ST_CxnType) Validate

func (m ST_CxnType) Validate() error

func (ST_CxnType) ValidateWithPath

func (m ST_CxnType) ValidateWithPath(path string) error

type ST_DiagramHorizontalAlignment

type ST_DiagramHorizontalAlignment byte
const (
	ST_DiagramHorizontalAlignmentUnset ST_DiagramHorizontalAlignment = 0
	ST_DiagramHorizontalAlignmentL     ST_DiagramHorizontalAlignment = 1
	ST_DiagramHorizontalAlignmentCtr   ST_DiagramHorizontalAlignment = 2
	ST_DiagramHorizontalAlignmentR     ST_DiagramHorizontalAlignment = 3
	ST_DiagramHorizontalAlignmentNone  ST_DiagramHorizontalAlignment = 4
)

func (ST_DiagramHorizontalAlignment) MarshalXML

func (ST_DiagramHorizontalAlignment) MarshalXMLAttr

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

func (ST_DiagramHorizontalAlignment) String

func (*ST_DiagramHorizontalAlignment) UnmarshalXML

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

func (*ST_DiagramHorizontalAlignment) UnmarshalXMLAttr

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

func (ST_DiagramHorizontalAlignment) Validate

func (m ST_DiagramHorizontalAlignment) Validate() error

func (ST_DiagramHorizontalAlignment) ValidateWithPath

func (m ST_DiagramHorizontalAlignment) ValidateWithPath(path string) error

type ST_DiagramTextAlignment

type ST_DiagramTextAlignment byte
const (
	ST_DiagramTextAlignmentUnset ST_DiagramTextAlignment = 0
	ST_DiagramTextAlignmentL     ST_DiagramTextAlignment = 1
	ST_DiagramTextAlignmentCtr   ST_DiagramTextAlignment = 2
	ST_DiagramTextAlignmentR     ST_DiagramTextAlignment = 3
)

func (ST_DiagramTextAlignment) MarshalXML

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

func (ST_DiagramTextAlignment) MarshalXMLAttr

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

func (ST_DiagramTextAlignment) String

func (m ST_DiagramTextAlignment) String() string

func (*ST_DiagramTextAlignment) UnmarshalXML

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

func (*ST_DiagramTextAlignment) UnmarshalXMLAttr

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

func (ST_DiagramTextAlignment) Validate

func (m ST_DiagramTextAlignment) Validate() error

func (ST_DiagramTextAlignment) ValidateWithPath

func (m ST_DiagramTextAlignment) ValidateWithPath(path string) error

type ST_Direction

type ST_Direction byte
const (
	ST_DirectionUnset ST_Direction = 0
	ST_DirectionNorm  ST_Direction = 1
	ST_DirectionRev   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_ElementType

type ST_ElementType byte
const (
	ST_ElementTypeUnset    ST_ElementType = 0
	ST_ElementTypeAll      ST_ElementType = 1
	ST_ElementTypeDoc      ST_ElementType = 2
	ST_ElementTypeNode     ST_ElementType = 3
	ST_ElementTypeNorm     ST_ElementType = 4
	ST_ElementTypeNonNorm  ST_ElementType = 5
	ST_ElementTypeAsst     ST_ElementType = 6
	ST_ElementTypeNonAsst  ST_ElementType = 7
	ST_ElementTypeParTrans ST_ElementType = 8
	ST_ElementTypePres     ST_ElementType = 9
	ST_ElementTypeSibTrans ST_ElementType = 10
)

func (ST_ElementType) MarshalXML

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

func (ST_ElementType) MarshalXMLAttr

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

func (ST_ElementType) String

func (m ST_ElementType) String() string

func (*ST_ElementType) UnmarshalXML

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

func (*ST_ElementType) UnmarshalXMLAttr

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

func (ST_ElementType) Validate

func (m ST_ElementType) Validate() error

func (ST_ElementType) ValidateWithPath

func (m ST_ElementType) ValidateWithPath(path string) error

type ST_ElementTypes

type ST_ElementTypes []ST_ElementType

func ParseSliceST_ElementTypes

func ParseSliceST_ElementTypes(s string) (ST_ElementTypes, error)

type ST_FallbackDimension

type ST_FallbackDimension byte
const (
	ST_FallbackDimensionUnset ST_FallbackDimension = 0
	ST_FallbackDimension1D    ST_FallbackDimension = 1
	ST_FallbackDimension2D    ST_FallbackDimension = 2
)

func (ST_FallbackDimension) MarshalXML

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

func (ST_FallbackDimension) MarshalXMLAttr

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

func (ST_FallbackDimension) String

func (m ST_FallbackDimension) String() string

func (*ST_FallbackDimension) UnmarshalXML

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

func (*ST_FallbackDimension) UnmarshalXMLAttr

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

func (ST_FallbackDimension) Validate

func (m ST_FallbackDimension) Validate() error

func (ST_FallbackDimension) ValidateWithPath

func (m ST_FallbackDimension) ValidateWithPath(path string) error

type ST_FlowDirection

type ST_FlowDirection byte
const (
	ST_FlowDirectionUnset ST_FlowDirection = 0
	ST_FlowDirectionRow   ST_FlowDirection = 1
	ST_FlowDirectionCol   ST_FlowDirection = 2
)

func (ST_FlowDirection) MarshalXML

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

func (ST_FlowDirection) MarshalXMLAttr

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

func (ST_FlowDirection) String

func (m ST_FlowDirection) String() string

func (*ST_FlowDirection) UnmarshalXML

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

func (*ST_FlowDirection) UnmarshalXMLAttr

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

func (ST_FlowDirection) Validate

func (m ST_FlowDirection) Validate() error

func (ST_FlowDirection) ValidateWithPath

func (m ST_FlowDirection) ValidateWithPath(path string) error

type ST_FunctionArgument

type ST_FunctionArgument struct {
	ST_VariableType ST_VariableType
}

ST_FunctionArgument is a union type

func ParseUnionST_FunctionArgument

func ParseUnionST_FunctionArgument(s string) (ST_FunctionArgument, error)

func (ST_FunctionArgument) MarshalXML

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

func (ST_FunctionArgument) String

func (m ST_FunctionArgument) String() string

func (*ST_FunctionArgument) Validate

func (m *ST_FunctionArgument) Validate() error

func (*ST_FunctionArgument) ValidateWithPath

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

type ST_FunctionOperator

type ST_FunctionOperator byte
const (
	ST_FunctionOperatorUnset ST_FunctionOperator = 0
	ST_FunctionOperatorEqu   ST_FunctionOperator = 1
	ST_FunctionOperatorNeq   ST_FunctionOperator = 2
	ST_FunctionOperatorGt    ST_FunctionOperator = 3
	ST_FunctionOperatorLt    ST_FunctionOperator = 4
	ST_FunctionOperatorGte   ST_FunctionOperator = 5
	ST_FunctionOperatorLte   ST_FunctionOperator = 6
)

func (ST_FunctionOperator) MarshalXML

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

func (ST_FunctionOperator) MarshalXMLAttr

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

func (ST_FunctionOperator) String

func (m ST_FunctionOperator) String() string

func (*ST_FunctionOperator) UnmarshalXML

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

func (*ST_FunctionOperator) UnmarshalXMLAttr

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

func (ST_FunctionOperator) Validate

func (m ST_FunctionOperator) Validate() error

func (ST_FunctionOperator) ValidateWithPath

func (m ST_FunctionOperator) ValidateWithPath(path string) error

type ST_FunctionType

type ST_FunctionType byte
const (
	ST_FunctionTypeUnset    ST_FunctionType = 0
	ST_FunctionTypeCnt      ST_FunctionType = 1
	ST_FunctionTypePos      ST_FunctionType = 2
	ST_FunctionTypeRevPos   ST_FunctionType = 3
	ST_FunctionTypePosEven  ST_FunctionType = 4
	ST_FunctionTypePosOdd   ST_FunctionType = 5
	ST_FunctionTypeVar      ST_FunctionType = 6
	ST_FunctionTypeDepth    ST_FunctionType = 7
	ST_FunctionTypeMaxDepth ST_FunctionType = 8
)

func (ST_FunctionType) MarshalXML

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

func (ST_FunctionType) MarshalXMLAttr

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

func (ST_FunctionType) String

func (m ST_FunctionType) String() string

func (*ST_FunctionType) UnmarshalXML

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

func (*ST_FunctionType) UnmarshalXMLAttr

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

func (ST_FunctionType) Validate

func (m ST_FunctionType) Validate() error

func (ST_FunctionType) ValidateWithPath

func (m ST_FunctionType) ValidateWithPath(path string) error

type ST_FunctionValue

type ST_FunctionValue struct {
	Int32               *int32
	Bool                *bool
	ST_Direction        ST_Direction
	ST_HierBranchStyle  ST_HierBranchStyle
	ST_AnimOneStr       ST_AnimOneStr
	ST_AnimLvlStr       ST_AnimLvlStr
	ST_ResizeHandlesStr ST_ResizeHandlesStr
}

ST_FunctionValue is a union type

func ParseUnionST_FunctionValue

func ParseUnionST_FunctionValue(s string) (ST_FunctionValue, error)

func (ST_FunctionValue) MarshalXML

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

func (ST_FunctionValue) String

func (m ST_FunctionValue) String() string

func (*ST_FunctionValue) Validate

func (m *ST_FunctionValue) Validate() error

func (*ST_FunctionValue) ValidateWithPath

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

type ST_GrowDirection

type ST_GrowDirection byte
const (
	ST_GrowDirectionUnset ST_GrowDirection = 0
	ST_GrowDirectionTL    ST_GrowDirection = 1
	ST_GrowDirectionTR    ST_GrowDirection = 2
	ST_GrowDirectionBL    ST_GrowDirection = 3
	ST_GrowDirectionBR    ST_GrowDirection = 4
)

func (ST_GrowDirection) MarshalXML

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

func (ST_GrowDirection) MarshalXMLAttr

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

func (ST_GrowDirection) String

func (m ST_GrowDirection) String() string

func (*ST_GrowDirection) UnmarshalXML

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

func (*ST_GrowDirection) UnmarshalXMLAttr

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

func (ST_GrowDirection) Validate

func (m ST_GrowDirection) Validate() error

func (ST_GrowDirection) ValidateWithPath

func (m ST_GrowDirection) ValidateWithPath(path string) error

type ST_HierBranchStyle

type ST_HierBranchStyle byte
const (
	ST_HierBranchStyleUnset ST_HierBranchStyle = 0
	ST_HierBranchStyleL     ST_HierBranchStyle = 1
	ST_HierBranchStyleR     ST_HierBranchStyle = 2
	ST_HierBranchStyleHang  ST_HierBranchStyle = 3
	ST_HierBranchStyleStd   ST_HierBranchStyle = 4
	ST_HierBranchStyleInit  ST_HierBranchStyle = 5
)

func (ST_HierBranchStyle) MarshalXML

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

func (ST_HierBranchStyle) MarshalXMLAttr

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

func (ST_HierBranchStyle) String

func (m ST_HierBranchStyle) String() string

func (*ST_HierBranchStyle) UnmarshalXML

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

func (*ST_HierBranchStyle) UnmarshalXMLAttr

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

func (ST_HierBranchStyle) Validate

func (m ST_HierBranchStyle) Validate() error

func (ST_HierBranchStyle) ValidateWithPath

func (m ST_HierBranchStyle) ValidateWithPath(path string) error

type ST_HierarchyAlignment

type ST_HierarchyAlignment byte
const (
	ST_HierarchyAlignmentUnset   ST_HierarchyAlignment = 0
	ST_HierarchyAlignmentTL      ST_HierarchyAlignment = 1
	ST_HierarchyAlignmentTR      ST_HierarchyAlignment = 2
	ST_HierarchyAlignmentTCtrCh  ST_HierarchyAlignment = 3
	ST_HierarchyAlignmentTCtrDes ST_HierarchyAlignment = 4
	ST_HierarchyAlignmentBL      ST_HierarchyAlignment = 5
	ST_HierarchyAlignmentBR      ST_HierarchyAlignment = 6
	ST_HierarchyAlignmentBCtrCh  ST_HierarchyAlignment = 7
	ST_HierarchyAlignmentBCtrDes ST_HierarchyAlignment = 8
	ST_HierarchyAlignmentLT      ST_HierarchyAlignment = 9
	ST_HierarchyAlignmentLB      ST_HierarchyAlignment = 10
	ST_HierarchyAlignmentLCtrCh  ST_HierarchyAlignment = 11
	ST_HierarchyAlignmentLCtrDes ST_HierarchyAlignment = 12
	ST_HierarchyAlignmentRT      ST_HierarchyAlignment = 13
	ST_HierarchyAlignmentRB      ST_HierarchyAlignment = 14
	ST_HierarchyAlignmentRCtrCh  ST_HierarchyAlignment = 15
	ST_HierarchyAlignmentRCtrDes ST_HierarchyAlignment = 16
)

func (ST_HierarchyAlignment) MarshalXML

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

func (ST_HierarchyAlignment) MarshalXMLAttr

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

func (ST_HierarchyAlignment) String

func (m ST_HierarchyAlignment) String() string

func (*ST_HierarchyAlignment) UnmarshalXML

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

func (*ST_HierarchyAlignment) UnmarshalXMLAttr

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

func (ST_HierarchyAlignment) Validate

func (m ST_HierarchyAlignment) Validate() error

func (ST_HierarchyAlignment) ValidateWithPath

func (m ST_HierarchyAlignment) ValidateWithPath(path string) error

type ST_HueDir

type ST_HueDir byte
const (
	ST_HueDirUnset ST_HueDir = 0
	ST_HueDirCw    ST_HueDir = 1
	ST_HueDirCcw   ST_HueDir = 2
)

func (ST_HueDir) MarshalXML

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

func (ST_HueDir) MarshalXMLAttr

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

func (ST_HueDir) String

func (m ST_HueDir) String() string

func (*ST_HueDir) UnmarshalXML

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

func (*ST_HueDir) UnmarshalXMLAttr

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

func (ST_HueDir) Validate

func (m ST_HueDir) Validate() error

func (ST_HueDir) ValidateWithPath

func (m ST_HueDir) ValidateWithPath(path string) error

type ST_Ints

type ST_Ints []int32

func ParseSliceST_Ints

func ParseSliceST_Ints(s string) (ST_Ints, error)

type ST_LayoutShapeType

type ST_LayoutShapeType struct {
	ST_ShapeType       dml.ST_ShapeType
	ST_OutputShapeType ST_OutputShapeType
}

ST_LayoutShapeType is a union type

func ParseUnionST_LayoutShapeType

func ParseUnionST_LayoutShapeType(s string) (ST_LayoutShapeType, error)

func (ST_LayoutShapeType) MarshalXML

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

func (ST_LayoutShapeType) String

func (m ST_LayoutShapeType) String() string

func (*ST_LayoutShapeType) Validate

func (m *ST_LayoutShapeType) Validate() error

func (*ST_LayoutShapeType) ValidateWithPath

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

type ST_LinearDirection

type ST_LinearDirection byte
const (
	ST_LinearDirectionUnset ST_LinearDirection = 0
	ST_LinearDirectionFromL ST_LinearDirection = 1
	ST_LinearDirectionFromR ST_LinearDirection = 2
	ST_LinearDirectionFromT ST_LinearDirection = 3
	ST_LinearDirectionFromB ST_LinearDirection = 4
)

func (ST_LinearDirection) MarshalXML

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

func (ST_LinearDirection) MarshalXMLAttr

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

func (ST_LinearDirection) String

func (m ST_LinearDirection) String() string

func (*ST_LinearDirection) UnmarshalXML

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

func (*ST_LinearDirection) UnmarshalXMLAttr

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

func (ST_LinearDirection) Validate

func (m ST_LinearDirection) Validate() error

func (ST_LinearDirection) ValidateWithPath

func (m ST_LinearDirection) ValidateWithPath(path string) error

type ST_ModelId

type ST_ModelId struct {
	Int32   *int32
	ST_Guid *string
}

ST_ModelId is a union type

func ParseUnionST_ModelId

func ParseUnionST_ModelId(s string) (ST_ModelId, error)

func (ST_ModelId) MarshalXML

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

func (ST_ModelId) String

func (m ST_ModelId) String() string

func (*ST_ModelId) Validate

func (m *ST_ModelId) Validate() error

func (*ST_ModelId) ValidateWithPath

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

type ST_NodeHorizontalAlignment

type ST_NodeHorizontalAlignment byte
const (
	ST_NodeHorizontalAlignmentUnset ST_NodeHorizontalAlignment = 0
	ST_NodeHorizontalAlignmentL     ST_NodeHorizontalAlignment = 1
	ST_NodeHorizontalAlignmentCtr   ST_NodeHorizontalAlignment = 2
	ST_NodeHorizontalAlignmentR     ST_NodeHorizontalAlignment = 3
)

func (ST_NodeHorizontalAlignment) MarshalXML

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

func (ST_NodeHorizontalAlignment) MarshalXMLAttr

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

func (ST_NodeHorizontalAlignment) String

func (*ST_NodeHorizontalAlignment) UnmarshalXML

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

func (*ST_NodeHorizontalAlignment) UnmarshalXMLAttr

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

func (ST_NodeHorizontalAlignment) Validate

func (m ST_NodeHorizontalAlignment) Validate() error

func (ST_NodeHorizontalAlignment) ValidateWithPath

func (m ST_NodeHorizontalAlignment) ValidateWithPath(path string) error

type ST_NodeVerticalAlignment

type ST_NodeVerticalAlignment byte
const (
	ST_NodeVerticalAlignmentUnset ST_NodeVerticalAlignment = 0
	ST_NodeVerticalAlignmentT     ST_NodeVerticalAlignment = 1
	ST_NodeVerticalAlignmentMid   ST_NodeVerticalAlignment = 2
	ST_NodeVerticalAlignmentB     ST_NodeVerticalAlignment = 3
)

func (ST_NodeVerticalAlignment) MarshalXML

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

func (ST_NodeVerticalAlignment) MarshalXMLAttr

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

func (ST_NodeVerticalAlignment) String

func (m ST_NodeVerticalAlignment) String() string

func (*ST_NodeVerticalAlignment) UnmarshalXML

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

func (*ST_NodeVerticalAlignment) UnmarshalXMLAttr

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

func (ST_NodeVerticalAlignment) Validate

func (m ST_NodeVerticalAlignment) Validate() error

func (ST_NodeVerticalAlignment) ValidateWithPath

func (m ST_NodeVerticalAlignment) ValidateWithPath(path string) error

type ST_Offset

type ST_Offset byte
const (
	ST_OffsetUnset ST_Offset = 0
	ST_OffsetCtr   ST_Offset = 1
	ST_OffsetOff   ST_Offset = 2
)

func (ST_Offset) MarshalXML

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

func (ST_Offset) MarshalXMLAttr

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

func (ST_Offset) String

func (m ST_Offset) String() string

func (*ST_Offset) UnmarshalXML

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

func (*ST_Offset) UnmarshalXMLAttr

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

func (ST_Offset) Validate

func (m ST_Offset) Validate() error

func (ST_Offset) ValidateWithPath

func (m ST_Offset) ValidateWithPath(path string) error

type ST_OutputShapeType

type ST_OutputShapeType byte
const (
	ST_OutputShapeTypeUnset ST_OutputShapeType = 0
	ST_OutputShapeTypeNone  ST_OutputShapeType = 1
	ST_OutputShapeTypeConn  ST_OutputShapeType = 2
)

func (ST_OutputShapeType) MarshalXML

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

func (ST_OutputShapeType) MarshalXMLAttr

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

func (ST_OutputShapeType) String

func (m ST_OutputShapeType) String() string

func (*ST_OutputShapeType) UnmarshalXML

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

func (*ST_OutputShapeType) UnmarshalXMLAttr

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

func (ST_OutputShapeType) Validate

func (m ST_OutputShapeType) Validate() error

func (ST_OutputShapeType) ValidateWithPath

func (m ST_OutputShapeType) ValidateWithPath(path string) error

type ST_ParameterId

type ST_ParameterId byte
const (
	ST_ParameterIdUnset            ST_ParameterId = 0
	ST_ParameterIdHorzAlign        ST_ParameterId = 1
	ST_ParameterIdVertAlign        ST_ParameterId = 2
	ST_ParameterIdChDir            ST_ParameterId = 3
	ST_ParameterIdChAlign          ST_ParameterId = 4
	ST_ParameterIdSecChAlign       ST_ParameterId = 5
	ST_ParameterIdLinDir           ST_ParameterId = 6
	ST_ParameterIdSecLinDir        ST_ParameterId = 7
	ST_ParameterIdStElem           ST_ParameterId = 8
	ST_ParameterIdBendPt           ST_ParameterId = 9
	ST_ParameterIdConnRout         ST_ParameterId = 10
	ST_ParameterIdBegSty           ST_ParameterId = 11
	ST_ParameterIdEndSty           ST_ParameterId = 12
	ST_ParameterIdDim              ST_ParameterId = 13
	ST_ParameterIdRotPath          ST_ParameterId = 14
	ST_ParameterIdCtrShpMap        ST_ParameterId = 15
	ST_ParameterIdNodeHorzAlign    ST_ParameterId = 16
	ST_ParameterIdNodeVertAlign    ST_ParameterId = 17
	ST_ParameterIdFallback         ST_ParameterId = 18
	ST_ParameterIdTxDir            ST_ParameterId = 19
	ST_ParameterIdPyraAcctPos      ST_ParameterId = 20
	ST_ParameterIdPyraAcctTxMar    ST_ParameterId = 21
	ST_ParameterIdTxBlDir          ST_ParameterId = 22
	ST_ParameterIdTxAnchorHorz     ST_ParameterId = 23
	ST_ParameterIdTxAnchorVert     ST_ParameterId = 24
	ST_ParameterIdTxAnchorHorzCh   ST_ParameterId = 25
	ST_ParameterIdTxAnchorVertCh   ST_ParameterId = 26
	ST_ParameterIdParTxLTRAlign    ST_ParameterId = 27
	ST_ParameterIdParTxRTLAlign    ST_ParameterId = 28
	ST_ParameterIdShpTxLTRAlignCh  ST_ParameterId = 29
	ST_ParameterIdShpTxRTLAlignCh  ST_ParameterId = 30
	ST_ParameterIdAutoTxRot        ST_ParameterId = 31
	ST_ParameterIdGrDir            ST_ParameterId = 32
	ST_ParameterIdFlowDir          ST_ParameterId = 33
	ST_ParameterIdContDir          ST_ParameterId = 34
	ST_ParameterIdBkpt             ST_ParameterId = 35
	ST_ParameterIdOff              ST_ParameterId = 36
	ST_ParameterIdHierAlign        ST_ParameterId = 37
	ST_ParameterIdBkPtFixedVal     ST_ParameterId = 38
	ST_ParameterIdStBulletLvl      ST_ParameterId = 39
	ST_ParameterIdStAng            ST_ParameterId = 40
	ST_ParameterIdSpanAng          ST_ParameterId = 41
	ST_ParameterIdAr               ST_ParameterId = 42
	ST_ParameterIdLnSpPar          ST_ParameterId = 43
	ST_ParameterIdLnSpAfParP       ST_ParameterId = 44
	ST_ParameterIdLnSpCh           ST_ParameterId = 45
	ST_ParameterIdLnSpAfChP        ST_ParameterId = 46
	ST_ParameterIdRtShortDist      ST_ParameterId = 47
	ST_ParameterIdAlignTx          ST_ParameterId = 48
	ST_ParameterIdPyraLvlNode      ST_ParameterId = 49
	ST_ParameterIdPyraAcctBkgdNode ST_ParameterId = 50
	ST_ParameterIdPyraAcctTxNode   ST_ParameterId = 51
	ST_ParameterIdSrcNode          ST_ParameterId = 52
	ST_ParameterIdDstNode          ST_ParameterId = 53
	ST_ParameterIdBegPts           ST_ParameterId = 54
	ST_ParameterIdEndPts           ST_ParameterId = 55
)

func (ST_ParameterId) MarshalXML

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

func (ST_ParameterId) MarshalXMLAttr

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

func (ST_ParameterId) String

func (m ST_ParameterId) String() string

func (*ST_ParameterId) UnmarshalXML

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

func (*ST_ParameterId) UnmarshalXMLAttr

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

func (ST_ParameterId) Validate

func (m ST_ParameterId) Validate() error

func (ST_ParameterId) ValidateWithPath

func (m ST_ParameterId) ValidateWithPath(path string) error

type ST_ParameterVal

type ST_ParameterVal struct {
	ST_DiagramHorizontalAlignment ST_DiagramHorizontalAlignment
	ST_VerticalAlignment          ST_VerticalAlignment
	ST_ChildDirection             ST_ChildDirection
	ST_ChildAlignment             ST_ChildAlignment
	ST_SecondaryChildAlignment    ST_SecondaryChildAlignment
	ST_LinearDirection            ST_LinearDirection
	ST_SecondaryLinearDirection   ST_SecondaryLinearDirection
	ST_StartingElement            ST_StartingElement
	ST_BendPoint                  ST_BendPoint
	ST_ConnectorRouting           ST_ConnectorRouting
	ST_ArrowheadStyle             ST_ArrowheadStyle
	ST_ConnectorDimension         ST_ConnectorDimension
	ST_RotationPath               ST_RotationPath
	ST_CenterShapeMapping         ST_CenterShapeMapping
	ST_NodeHorizontalAlignment    ST_NodeHorizontalAlignment
	ST_NodeVerticalAlignment      ST_NodeVerticalAlignment
	ST_FallbackDimension          ST_FallbackDimension
	ST_TextDirection              ST_TextDirection
	ST_PyramidAccentPosition      ST_PyramidAccentPosition
	ST_PyramidAccentTextMargin    ST_PyramidAccentTextMargin
	ST_TextBlockDirection         ST_TextBlockDirection
	ST_TextAnchorHorizontal       ST_TextAnchorHorizontal
	ST_TextAnchorVertical         ST_TextAnchorVertical
	ST_DiagramTextAlignment       ST_DiagramTextAlignment
	ST_AutoTextRotation           ST_AutoTextRotation
	ST_GrowDirection              ST_GrowDirection
	ST_FlowDirection              ST_FlowDirection
	ST_ContinueDirection          ST_ContinueDirection
	ST_Breakpoint                 ST_Breakpoint
	ST_Offset                     ST_Offset
	ST_HierarchyAlignment         ST_HierarchyAlignment
	Int32                         *int32
	Float64                       *float64
	Bool                          *bool
	StringVal                     *string
	ST_ConnectorPoint             ST_ConnectorPoint
}

ST_ParameterVal is a union type

func ParseUnionST_ParameterVal

func ParseUnionST_ParameterVal(s string) (ST_ParameterVal, error)

func (ST_ParameterVal) MarshalXML

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

func (ST_ParameterVal) String

func (m ST_ParameterVal) String() string

func (*ST_ParameterVal) Validate

func (m *ST_ParameterVal) Validate() error

func (*ST_ParameterVal) ValidateWithPath

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

type ST_PrSetCustVal

type ST_PrSetCustVal struct {
	ST_Percentage *string
	Int32         *int32
}

ST_PrSetCustVal is a union type

func ParseUnionST_PrSetCustVal

func ParseUnionST_PrSetCustVal(s string) (ST_PrSetCustVal, error)

func (ST_PrSetCustVal) MarshalXML

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

func (ST_PrSetCustVal) String

func (m ST_PrSetCustVal) String() string

func (*ST_PrSetCustVal) Validate

func (m *ST_PrSetCustVal) Validate() error

func (*ST_PrSetCustVal) ValidateWithPath

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

type ST_PtType

type ST_PtType byte
const (
	ST_PtTypeUnset    ST_PtType = 0
	ST_PtTypeNode     ST_PtType = 1
	ST_PtTypeAsst     ST_PtType = 2
	ST_PtTypeDoc      ST_PtType = 3
	ST_PtTypePres     ST_PtType = 4
	ST_PtTypeParTrans ST_PtType = 5
	ST_PtTypeSibTrans ST_PtType = 6
)

func (ST_PtType) MarshalXML

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

func (ST_PtType) MarshalXMLAttr

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

func (ST_PtType) String

func (m ST_PtType) String() string

func (*ST_PtType) UnmarshalXML

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

func (*ST_PtType) UnmarshalXMLAttr

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

func (ST_PtType) Validate

func (m ST_PtType) Validate() error

func (ST_PtType) ValidateWithPath

func (m ST_PtType) ValidateWithPath(path string) error

type ST_PyramidAccentPosition

type ST_PyramidAccentPosition byte
const (
	ST_PyramidAccentPositionUnset ST_PyramidAccentPosition = 0
	ST_PyramidAccentPositionBef   ST_PyramidAccentPosition = 1
	ST_PyramidAccentPositionAft   ST_PyramidAccentPosition = 2
)

func (ST_PyramidAccentPosition) MarshalXML

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

func (ST_PyramidAccentPosition) MarshalXMLAttr

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

func (ST_PyramidAccentPosition) String

func (m ST_PyramidAccentPosition) String() string

func (*ST_PyramidAccentPosition) UnmarshalXML

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

func (*ST_PyramidAccentPosition) UnmarshalXMLAttr

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

func (ST_PyramidAccentPosition) Validate

func (m ST_PyramidAccentPosition) Validate() error

func (ST_PyramidAccentPosition) ValidateWithPath

func (m ST_PyramidAccentPosition) ValidateWithPath(path string) error

type ST_PyramidAccentTextMargin

type ST_PyramidAccentTextMargin byte
const (
	ST_PyramidAccentTextMarginUnset ST_PyramidAccentTextMargin = 0
	ST_PyramidAccentTextMarginStep  ST_PyramidAccentTextMargin = 1
	ST_PyramidAccentTextMarginStack ST_PyramidAccentTextMargin = 2
)

func (ST_PyramidAccentTextMargin) MarshalXML

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

func (ST_PyramidAccentTextMargin) MarshalXMLAttr

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

func (ST_PyramidAccentTextMargin) String

func (*ST_PyramidAccentTextMargin) UnmarshalXML

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

func (*ST_PyramidAccentTextMargin) UnmarshalXMLAttr

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

func (ST_PyramidAccentTextMargin) Validate

func (m ST_PyramidAccentTextMargin) Validate() error

func (ST_PyramidAccentTextMargin) ValidateWithPath

func (m ST_PyramidAccentTextMargin) ValidateWithPath(path string) error

type ST_ResizeHandlesStr

type ST_ResizeHandlesStr byte
const (
	ST_ResizeHandlesStrUnset ST_ResizeHandlesStr = 0
	ST_ResizeHandlesStrExact ST_ResizeHandlesStr = 1
	ST_ResizeHandlesStrRel   ST_ResizeHandlesStr = 2
)

func (ST_ResizeHandlesStr) MarshalXML

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

func (ST_ResizeHandlesStr) MarshalXMLAttr

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

func (ST_ResizeHandlesStr) String

func (m ST_ResizeHandlesStr) String() string

func (*ST_ResizeHandlesStr) UnmarshalXML

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

func (*ST_ResizeHandlesStr) UnmarshalXMLAttr

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

func (ST_ResizeHandlesStr) Validate

func (m ST_ResizeHandlesStr) Validate() error

func (ST_ResizeHandlesStr) ValidateWithPath

func (m ST_ResizeHandlesStr) ValidateWithPath(path string) error

type ST_RotationPath

type ST_RotationPath byte
const (
	ST_RotationPathUnset     ST_RotationPath = 0
	ST_RotationPathNone      ST_RotationPath = 1
	ST_RotationPathAlongPath ST_RotationPath = 2
)

func (ST_RotationPath) MarshalXML

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

func (ST_RotationPath) MarshalXMLAttr

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

func (ST_RotationPath) String

func (m ST_RotationPath) String() string

func (*ST_RotationPath) UnmarshalXML

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

func (*ST_RotationPath) UnmarshalXMLAttr

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

func (ST_RotationPath) Validate

func (m ST_RotationPath) Validate() error

func (ST_RotationPath) ValidateWithPath

func (m ST_RotationPath) ValidateWithPath(path string) error

type ST_SecondaryChildAlignment

type ST_SecondaryChildAlignment byte
const (
	ST_SecondaryChildAlignmentUnset ST_SecondaryChildAlignment = 0
	ST_SecondaryChildAlignmentNone  ST_SecondaryChildAlignment = 1
	ST_SecondaryChildAlignmentT     ST_SecondaryChildAlignment = 2
	ST_SecondaryChildAlignmentB     ST_SecondaryChildAlignment = 3
	ST_SecondaryChildAlignmentL     ST_SecondaryChildAlignment = 4
	ST_SecondaryChildAlignmentR     ST_SecondaryChildAlignment = 5
)

func (ST_SecondaryChildAlignment) MarshalXML

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

func (ST_SecondaryChildAlignment) MarshalXMLAttr

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

func (ST_SecondaryChildAlignment) String

func (*ST_SecondaryChildAlignment) UnmarshalXML

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

func (*ST_SecondaryChildAlignment) UnmarshalXMLAttr

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

func (ST_SecondaryChildAlignment) Validate

func (m ST_SecondaryChildAlignment) Validate() error

func (ST_SecondaryChildAlignment) ValidateWithPath

func (m ST_SecondaryChildAlignment) ValidateWithPath(path string) error

type ST_SecondaryLinearDirection

type ST_SecondaryLinearDirection byte
const (
	ST_SecondaryLinearDirectionUnset ST_SecondaryLinearDirection = 0
	ST_SecondaryLinearDirectionNone  ST_SecondaryLinearDirection = 1
	ST_SecondaryLinearDirectionFromL ST_SecondaryLinearDirection = 2
	ST_SecondaryLinearDirectionFromR ST_SecondaryLinearDirection = 3
	ST_SecondaryLinearDirectionFromT ST_SecondaryLinearDirection = 4
	ST_SecondaryLinearDirectionFromB ST_SecondaryLinearDirection = 5
)

func (ST_SecondaryLinearDirection) MarshalXML

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

func (ST_SecondaryLinearDirection) MarshalXMLAttr

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

func (ST_SecondaryLinearDirection) String

func (*ST_SecondaryLinearDirection) UnmarshalXML

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

func (*ST_SecondaryLinearDirection) UnmarshalXMLAttr

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

func (ST_SecondaryLinearDirection) Validate

func (m ST_SecondaryLinearDirection) Validate() error

func (ST_SecondaryLinearDirection) ValidateWithPath

func (m ST_SecondaryLinearDirection) ValidateWithPath(path string) error

type ST_StartingElement

type ST_StartingElement byte
const (
	ST_StartingElementUnset ST_StartingElement = 0
	ST_StartingElementNode  ST_StartingElement = 1
	ST_StartingElementTrans ST_StartingElement = 2
)

func (ST_StartingElement) MarshalXML

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

func (ST_StartingElement) MarshalXMLAttr

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

func (ST_StartingElement) String

func (m ST_StartingElement) String() string

func (*ST_StartingElement) UnmarshalXML

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

func (*ST_StartingElement) UnmarshalXMLAttr

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

func (ST_StartingElement) Validate

func (m ST_StartingElement) Validate() error

func (ST_StartingElement) ValidateWithPath

func (m ST_StartingElement) ValidateWithPath(path string) error

type ST_TextAnchorHorizontal

type ST_TextAnchorHorizontal byte
const (
	ST_TextAnchorHorizontalUnset ST_TextAnchorHorizontal = 0
	ST_TextAnchorHorizontalNone  ST_TextAnchorHorizontal = 1
	ST_TextAnchorHorizontalCtr   ST_TextAnchorHorizontal = 2
)

func (ST_TextAnchorHorizontal) MarshalXML

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

func (ST_TextAnchorHorizontal) MarshalXMLAttr

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

func (ST_TextAnchorHorizontal) String

func (m ST_TextAnchorHorizontal) String() string

func (*ST_TextAnchorHorizontal) UnmarshalXML

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

func (*ST_TextAnchorHorizontal) UnmarshalXMLAttr

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

func (ST_TextAnchorHorizontal) Validate

func (m ST_TextAnchorHorizontal) Validate() error

func (ST_TextAnchorHorizontal) ValidateWithPath

func (m ST_TextAnchorHorizontal) ValidateWithPath(path string) error

type ST_TextAnchorVertical

type ST_TextAnchorVertical byte
const (
	ST_TextAnchorVerticalUnset ST_TextAnchorVertical = 0
	ST_TextAnchorVerticalT     ST_TextAnchorVertical = 1
	ST_TextAnchorVerticalMid   ST_TextAnchorVertical = 2
	ST_TextAnchorVerticalB     ST_TextAnchorVertical = 3
)

func (ST_TextAnchorVertical) MarshalXML

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

func (ST_TextAnchorVertical) MarshalXMLAttr

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

func (ST_TextAnchorVertical) String

func (m ST_TextAnchorVertical) String() string

func (*ST_TextAnchorVertical) UnmarshalXML

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

func (*ST_TextAnchorVertical) UnmarshalXMLAttr

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

func (ST_TextAnchorVertical) Validate

func (m ST_TextAnchorVertical) Validate() error

func (ST_TextAnchorVertical) ValidateWithPath

func (m ST_TextAnchorVertical) ValidateWithPath(path string) error

type ST_TextBlockDirection

type ST_TextBlockDirection byte
const (
	ST_TextBlockDirectionUnset ST_TextBlockDirection = 0
	ST_TextBlockDirectionHorz  ST_TextBlockDirection = 1
	ST_TextBlockDirectionVert  ST_TextBlockDirection = 2
)

func (ST_TextBlockDirection) MarshalXML

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

func (ST_TextBlockDirection) MarshalXMLAttr

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

func (ST_TextBlockDirection) String

func (m ST_TextBlockDirection) String() string

func (*ST_TextBlockDirection) UnmarshalXML

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

func (*ST_TextBlockDirection) UnmarshalXMLAttr

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

func (ST_TextBlockDirection) Validate

func (m ST_TextBlockDirection) Validate() error

func (ST_TextBlockDirection) ValidateWithPath

func (m ST_TextBlockDirection) ValidateWithPath(path string) error

type ST_TextDirection

type ST_TextDirection byte
const (
	ST_TextDirectionUnset ST_TextDirection = 0
	ST_TextDirectionFromT ST_TextDirection = 1
	ST_TextDirectionFromB ST_TextDirection = 2
)

func (ST_TextDirection) MarshalXML

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

func (ST_TextDirection) MarshalXMLAttr

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

func (ST_TextDirection) String

func (m ST_TextDirection) String() string

func (*ST_TextDirection) UnmarshalXML

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

func (*ST_TextDirection) UnmarshalXMLAttr

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

func (ST_TextDirection) Validate

func (m ST_TextDirection) Validate() error

func (ST_TextDirection) ValidateWithPath

func (m ST_TextDirection) ValidateWithPath(path string) error

type ST_UnsignedInts

type ST_UnsignedInts []uint32

func ParseSliceST_UnsignedInts

func ParseSliceST_UnsignedInts(s string) (ST_UnsignedInts, error)

type ST_VariableType

type ST_VariableType byte
const (
	ST_VariableTypeUnset         ST_VariableType = 0
	ST_VariableTypeNone          ST_VariableType = 1
	ST_VariableTypeOrgChart      ST_VariableType = 2
	ST_VariableTypeChMax         ST_VariableType = 3
	ST_VariableTypeChPref        ST_VariableType = 4
	ST_VariableTypeBulEnabled    ST_VariableType = 5
	ST_VariableTypeDir           ST_VariableType = 6
	ST_VariableTypeHierBranch    ST_VariableType = 7
	ST_VariableTypeAnimOne       ST_VariableType = 8
	ST_VariableTypeAnimLvl       ST_VariableType = 9
	ST_VariableTypeResizeHandles ST_VariableType = 10
)

func (ST_VariableType) MarshalXML

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

func (ST_VariableType) MarshalXMLAttr

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

func (ST_VariableType) String

func (m ST_VariableType) String() string

func (*ST_VariableType) UnmarshalXML

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

func (*ST_VariableType) UnmarshalXMLAttr

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

func (ST_VariableType) Validate

func (m ST_VariableType) Validate() error

func (ST_VariableType) ValidateWithPath

func (m ST_VariableType) ValidateWithPath(path string) error

type ST_VerticalAlignment

type ST_VerticalAlignment byte
const (
	ST_VerticalAlignmentUnset ST_VerticalAlignment = 0
	ST_VerticalAlignmentT     ST_VerticalAlignment = 1
	ST_VerticalAlignmentMid   ST_VerticalAlignment = 2
	ST_VerticalAlignmentB     ST_VerticalAlignment = 3
	ST_VerticalAlignmentNone  ST_VerticalAlignment = 4
)

func (ST_VerticalAlignment) MarshalXML

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

func (ST_VerticalAlignment) MarshalXMLAttr

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

func (ST_VerticalAlignment) String

func (m ST_VerticalAlignment) String() string

func (*ST_VerticalAlignment) UnmarshalXML

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

func (*ST_VerticalAlignment) UnmarshalXMLAttr

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

func (ST_VerticalAlignment) Validate

func (m ST_VerticalAlignment) Validate() error

func (ST_VerticalAlignment) ValidateWithPath

func (m ST_VerticalAlignment) ValidateWithPath(path string) error

type StyleDef

type StyleDef struct {
	CT_StyleDefinition
}

func NewStyleDef

func NewStyleDef() *StyleDef

func (*StyleDef) MarshalXML

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

func (*StyleDef) UnmarshalXML

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

func (*StyleDef) Validate

func (m *StyleDef) Validate() error

Validate validates the StyleDef and its children

func (*StyleDef) ValidateWithPath

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

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

type StyleDefHdr

type StyleDefHdr struct {
	CT_StyleDefinitionHeader
}

func NewStyleDefHdr

func NewStyleDefHdr() *StyleDefHdr

func (*StyleDefHdr) MarshalXML

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

func (*StyleDefHdr) UnmarshalXML

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

func (*StyleDefHdr) Validate

func (m *StyleDefHdr) Validate() error

Validate validates the StyleDefHdr and its children

func (*StyleDefHdr) ValidateWithPath

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

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

type StyleDefHdrLst

type StyleDefHdrLst struct {
	CT_StyleDefinitionHeaderLst
}

func NewStyleDefHdrLst

func NewStyleDefHdrLst() *StyleDefHdrLst

func (*StyleDefHdrLst) MarshalXML

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

func (*StyleDefHdrLst) UnmarshalXML

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

func (*StyleDefHdrLst) Validate

func (m *StyleDefHdrLst) Validate() error

Validate validates the StyleDefHdrLst and its children

func (*StyleDefHdrLst) ValidateWithPath

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

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

Jump to

Keyboard shortcuts

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