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 (m *CT_DiagramDefinitionHeaderLst) MarshalXML(e *xml.Encoder, start xml.StartElement) error

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 (m ST_DiagramHorizontalAlignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DiagramHorizontalAlignment) MarshalXMLAttr 

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

func (ST_DiagramHorizontalAlignment) String 

func (m ST_DiagramHorizontalAlignment) String() 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 (m ST_NodeHorizontalAlignment) String() 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 (m ST_PyramidAccentTextMargin) String() 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 (m ST_SecondaryChildAlignment) String() 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 (m ST_SecondaryLinearDirection) String() 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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.