chart

package
v0.0.0-...-c517a80 Latest Latest
Warning

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

 Go to latest Published: Sep 3, 2021 License: AGPL-3.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const ST_BubbleScalePercentPattern = `0*(([0-9])|([1-9][0-9])|([1-2][0-9][0-9])|300)%`
View Source 
const ST_DepthPercentWithSymbolPattern = `0*(([2-9][0-9])|([1-9][0-9][0-9])|(1[0-9][0-9][0-9])|2000)%`
View Source 
const ST_GapAmountPercentPattern = `0*(([0-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%`
View Source 
const ST_HPercentWithSymbolPattern = `0*(([5-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%`
View Source 
const ST_HoleSizePercentPattern = `0*([1-9]|([1-8][0-9])|90)%`
View Source 
const ST_LblOffsetPercentPattern = `0*(([0-9])|([1-9][0-9])|([1-9][0-9][0-9])|1000)%`
View Source 
const ST_OverlapPercentPattern = `(-?0*(([0-9])|([1-9][0-9])|100))%`
View Source 
const ST_SecondPieSizePercentPattern = `0*(([5-9])|([1-9][0-9])|(1[0-9][0-9])|200)%`
View Source 
const ST_ThicknessPercentPattern = `([0-9]+)%`

Variables

View Source 
var ST_BubbleScalePercentPatternRe = regexp.MustCompile(ST_BubbleScalePercentPattern)
View Source 
var ST_DepthPercentWithSymbolPatternRe = regexp.MustCompile(ST_DepthPercentWithSymbolPattern)
View Source 
var ST_GapAmountPercentPatternRe = regexp.MustCompile(ST_GapAmountPercentPattern)
View Source 
var ST_HPercentWithSymbolPatternRe = regexp.MustCompile(ST_HPercentWithSymbolPattern)
View Source 
var ST_HoleSizePercentPatternRe = regexp.MustCompile(ST_HoleSizePercentPattern)
View Source 
var ST_LblOffsetPercentPatternRe = regexp.MustCompile(ST_LblOffsetPercentPattern)
View Source 
var ST_OverlapPercentPatternRe = regexp.MustCompile(ST_OverlapPercentPattern)
View Source 
var ST_SecondPieSizePercentPatternRe = regexp.MustCompile(ST_SecondPieSizePercentPattern)
View Source 
var ST_ThicknessPercentPatternRe = regexp.MustCompile(ST_ThicknessPercentPattern)

Functions

This section is empty.

Types

type Any 

type Any interface {
	MarshalXML(e *xml.Encoder, start xml.StartElement) error
	UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
}

type CT_Area3DChart 

type CT_Area3DChart struct {
	Grouping   *CT_Grouping
	VaryColors *CT_Boolean
	Ser        []*CT_AreaSer
	DLbls      *CT_DLbls
	DropLines  *CT_ChartLines
	GapDepth   *CT_GapAmount
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_Area3DChart 

func NewCT_Area3DChart() *CT_Area3DChart

func (*CT_Area3DChart) MarshalXML 

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

func (*CT_Area3DChart) UnmarshalXML 

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

func (*CT_Area3DChart) Validate 

func (m *CT_Area3DChart) Validate() error

Validate validates the CT_Area3DChart and its children

func (*CT_Area3DChart) ValidateWithPath 

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

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

type CT_AreaChart 

type CT_AreaChart struct {
	Grouping   *CT_Grouping
	VaryColors *CT_Boolean
	Ser        []*CT_AreaSer
	DLbls      *CT_DLbls
	DropLines  *CT_ChartLines
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_AreaChart 

func NewCT_AreaChart() *CT_AreaChart

func (*CT_AreaChart) MarshalXML 

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

func (*CT_AreaChart) UnmarshalXML 

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

func (*CT_AreaChart) Validate 

func (m *CT_AreaChart) Validate() error

Validate validates the CT_AreaChart and its children

func (*CT_AreaChart) ValidateWithPath 

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

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

type CT_AreaSer 

type CT_AreaSer struct {
	Idx            *CT_UnsignedInt
	Order          *CT_UnsignedInt
	Tx             *CT_SerTx
	SpPr           *dml.CT_ShapeProperties
	PictureOptions *CT_PictureOptions
	DPt            []*CT_DPt
	DLbls          *CT_DLbls
	Trendline      []*CT_Trendline
	ErrBars        []*CT_ErrBars
	Cat            *CT_AxDataSource
	Val            *CT_NumDataSource
	ExtLst         *CT_ExtensionList
}

func NewCT_AreaSer 

func NewCT_AreaSer() *CT_AreaSer

func (*CT_AreaSer) MarshalXML 

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

func (*CT_AreaSer) UnmarshalXML 

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

func (*CT_AreaSer) Validate 

func (m *CT_AreaSer) Validate() error

Validate validates the CT_AreaSer and its children

func (*CT_AreaSer) ValidateWithPath 

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

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

type CT_AxDataSource 

type CT_AxDataSource struct {
	Choice *CT_AxDataSourceChoice
}

func NewCT_AxDataSource 

func NewCT_AxDataSource() *CT_AxDataSource

func (*CT_AxDataSource) MarshalXML 

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

func (*CT_AxDataSource) UnmarshalXML 

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

func (*CT_AxDataSource) Validate 

func (m *CT_AxDataSource) Validate() error

Validate validates the CT_AxDataSource and its children

func (*CT_AxDataSource) ValidateWithPath 

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

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

type CT_AxDataSourceChoice 

type CT_AxDataSourceChoice struct {
	MultiLvlStrRef *CT_MultiLvlStrRef
	NumRef         *CT_NumRef
	NumLit         *CT_NumData
	StrRef         *CT_StrRef
	StrLit         *CT_StrData
}

func NewCT_AxDataSourceChoice 

func NewCT_AxDataSourceChoice() *CT_AxDataSourceChoice

func (*CT_AxDataSourceChoice) MarshalXML 

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

func (*CT_AxDataSourceChoice) UnmarshalXML 

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

func (*CT_AxDataSourceChoice) Validate 

func (m *CT_AxDataSourceChoice) Validate() error

Validate validates the CT_AxDataSourceChoice and its children

func (*CT_AxDataSourceChoice) ValidateWithPath 

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

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

type CT_AxPos 

type CT_AxPos struct {
	ValAttr ST_AxPos
}

func NewCT_AxPos 

func NewCT_AxPos() *CT_AxPos

func (*CT_AxPos) MarshalXML 

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

func (*CT_AxPos) UnmarshalXML 

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

func (*CT_AxPos) Validate 

func (m *CT_AxPos) Validate() error

Validate validates the CT_AxPos and its children

func (*CT_AxPos) ValidateWithPath 

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

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

type CT_AxisUnit 

type CT_AxisUnit struct {
	ValAttr float64
}

func NewCT_AxisUnit 

func NewCT_AxisUnit() *CT_AxisUnit

func (*CT_AxisUnit) MarshalXML 

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

func (*CT_AxisUnit) UnmarshalXML 

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

func (*CT_AxisUnit) Validate 

func (m *CT_AxisUnit) Validate() error

Validate validates the CT_AxisUnit and its children

func (*CT_AxisUnit) ValidateWithPath 

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

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

type CT_BandFmt 

type CT_BandFmt struct {
	Idx  *CT_UnsignedInt
	SpPr *dml.CT_ShapeProperties
}

func NewCT_BandFmt 

func NewCT_BandFmt() *CT_BandFmt

func (*CT_BandFmt) MarshalXML 

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

func (*CT_BandFmt) UnmarshalXML 

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

func (*CT_BandFmt) Validate 

func (m *CT_BandFmt) Validate() error

Validate validates the CT_BandFmt and its children

func (*CT_BandFmt) ValidateWithPath 

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

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

type CT_BandFmts 

type CT_BandFmts struct {
	BandFmt []*CT_BandFmt
}

func NewCT_BandFmts 

func NewCT_BandFmts() *CT_BandFmts

func (*CT_BandFmts) MarshalXML 

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

func (*CT_BandFmts) UnmarshalXML 

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

func (*CT_BandFmts) Validate 

func (m *CT_BandFmts) Validate() error

Validate validates the CT_BandFmts and its children

func (*CT_BandFmts) ValidateWithPath 

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

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

type CT_Bar3DChart 

type CT_Bar3DChart struct {
	BarDir     *CT_BarDir
	Grouping   *CT_BarGrouping
	VaryColors *CT_Boolean
	Ser        []*CT_BarSer
	DLbls      *CT_DLbls
	GapWidth   *CT_GapAmount
	GapDepth   *CT_GapAmount
	Shape      *CT_Shape
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_Bar3DChart 

func NewCT_Bar3DChart() *CT_Bar3DChart

func (*CT_Bar3DChart) MarshalXML 

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

func (*CT_Bar3DChart) UnmarshalXML 

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

func (*CT_Bar3DChart) Validate 

func (m *CT_Bar3DChart) Validate() error

Validate validates the CT_Bar3DChart and its children

func (*CT_Bar3DChart) ValidateWithPath 

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

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

type CT_BarChart 

type CT_BarChart struct {
	BarDir     *CT_BarDir
	Grouping   *CT_BarGrouping
	VaryColors *CT_Boolean
	Ser        []*CT_BarSer
	DLbls      *CT_DLbls
	GapWidth   *CT_GapAmount
	Overlap    *CT_Overlap
	SerLines   []*CT_ChartLines
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_BarChart 

func NewCT_BarChart() *CT_BarChart

func (*CT_BarChart) MarshalXML 

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

func (*CT_BarChart) UnmarshalXML 

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

func (*CT_BarChart) Validate 

func (m *CT_BarChart) Validate() error

Validate validates the CT_BarChart and its children

func (*CT_BarChart) ValidateWithPath 

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

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

type CT_BarDir 

type CT_BarDir struct {
	ValAttr ST_BarDir
}

func NewCT_BarDir 

func NewCT_BarDir() *CT_BarDir

func (*CT_BarDir) MarshalXML 

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

func (*CT_BarDir) UnmarshalXML 

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

func (*CT_BarDir) Validate 

func (m *CT_BarDir) Validate() error

Validate validates the CT_BarDir and its children

func (*CT_BarDir) ValidateWithPath 

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

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

type CT_BarGrouping 

type CT_BarGrouping struct {
	ValAttr ST_BarGrouping
}

func NewCT_BarGrouping 

func NewCT_BarGrouping() *CT_BarGrouping

func (*CT_BarGrouping) MarshalXML 

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

func (*CT_BarGrouping) UnmarshalXML 

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

func (*CT_BarGrouping) Validate 

func (m *CT_BarGrouping) Validate() error

Validate validates the CT_BarGrouping and its children

func (*CT_BarGrouping) ValidateWithPath 

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

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

type CT_BarSer 

type CT_BarSer struct {
	Idx              *CT_UnsignedInt
	Order            *CT_UnsignedInt
	Tx               *CT_SerTx
	SpPr             *dml.CT_ShapeProperties
	InvertIfNegative *CT_Boolean
	PictureOptions   *CT_PictureOptions
	DPt              []*CT_DPt
	DLbls            *CT_DLbls
	Trendline        []*CT_Trendline
	ErrBars          *CT_ErrBars
	Cat              *CT_AxDataSource
	Val              *CT_NumDataSource
	Shape            *CT_Shape
	ExtLst           *CT_ExtensionList
}

func NewCT_BarSer 

func NewCT_BarSer() *CT_BarSer

func (*CT_BarSer) MarshalXML 

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

func (*CT_BarSer) UnmarshalXML 

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

func (*CT_BarSer) Validate 

func (m *CT_BarSer) Validate() error

Validate validates the CT_BarSer and its children

func (*CT_BarSer) ValidateWithPath 

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

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

type CT_Boolean 

type CT_Boolean struct {
	ValAttr *bool
}

func NewCT_Boolean 

func NewCT_Boolean() *CT_Boolean

func (*CT_Boolean) MarshalXML 

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

func (*CT_Boolean) UnmarshalXML 

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

func (*CT_Boolean) Validate 

func (m *CT_Boolean) Validate() error

Validate validates the CT_Boolean and its children

func (*CT_Boolean) ValidateWithPath 

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

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

type CT_BubbleChart 

type CT_BubbleChart struct {
	VaryColors     *CT_Boolean
	Ser            []*CT_BubbleSer
	DLbls          *CT_DLbls
	Bubble3D       *CT_Boolean
	BubbleScale    *CT_BubbleScale
	ShowNegBubbles *CT_Boolean
	SizeRepresents *CT_SizeRepresents
	AxId           []*CT_UnsignedInt
	ExtLst         *CT_ExtensionList
}

func NewCT_BubbleChart 

func NewCT_BubbleChart() *CT_BubbleChart

func (*CT_BubbleChart) MarshalXML 

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

func (*CT_BubbleChart) UnmarshalXML 

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

func (*CT_BubbleChart) Validate 

func (m *CT_BubbleChart) Validate() error

Validate validates the CT_BubbleChart and its children

func (*CT_BubbleChart) ValidateWithPath 

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

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

type CT_BubbleScale 

type CT_BubbleScale struct {
	ValAttr *ST_BubbleScale
}

func NewCT_BubbleScale 

func NewCT_BubbleScale() *CT_BubbleScale

func (*CT_BubbleScale) MarshalXML 

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

func (*CT_BubbleScale) UnmarshalXML 

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

func (*CT_BubbleScale) Validate 

func (m *CT_BubbleScale) Validate() error

Validate validates the CT_BubbleScale and its children

func (*CT_BubbleScale) ValidateWithPath 

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

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

type CT_BubbleSer 

type CT_BubbleSer struct {
	Idx              *CT_UnsignedInt
	Order            *CT_UnsignedInt
	Tx               *CT_SerTx
	SpPr             *dml.CT_ShapeProperties
	InvertIfNegative *CT_Boolean
	DPt              []*CT_DPt
	DLbls            *CT_DLbls
	Trendline        []*CT_Trendline
	ErrBars          []*CT_ErrBars
	XVal             *CT_AxDataSource
	YVal             *CT_NumDataSource
	BubbleSize       *CT_NumDataSource
	Bubble3D         *CT_Boolean
	ExtLst           *CT_ExtensionList
}

func NewCT_BubbleSer 

func NewCT_BubbleSer() *CT_BubbleSer

func (*CT_BubbleSer) MarshalXML 

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

func (*CT_BubbleSer) UnmarshalXML 

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

func (*CT_BubbleSer) Validate 

func (m *CT_BubbleSer) Validate() error

Validate validates the CT_BubbleSer and its children

func (*CT_BubbleSer) ValidateWithPath 

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

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

type CT_BuiltInUnit 

type CT_BuiltInUnit struct {
	ValAttr ST_BuiltInUnit
}

func NewCT_BuiltInUnit 

func NewCT_BuiltInUnit() *CT_BuiltInUnit

func (*CT_BuiltInUnit) MarshalXML 

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

func (*CT_BuiltInUnit) UnmarshalXML 

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

func (*CT_BuiltInUnit) Validate 

func (m *CT_BuiltInUnit) Validate() error

Validate validates the CT_BuiltInUnit and its children

func (*CT_BuiltInUnit) ValidateWithPath 

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

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

type CT_CatAx 

type CT_CatAx struct {
	AxId           *CT_UnsignedInt
	Scaling        *CT_Scaling
	Delete         *CT_Boolean
	AxPos          *CT_AxPos
	MajorGridlines *CT_ChartLines
	MinorGridlines *CT_ChartLines
	Title          *CT_Title
	NumFmt         *CT_NumFmt
	MajorTickMark  *CT_TickMark
	MinorTickMark  *CT_TickMark
	TickLblPos     *CT_TickLblPos
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	CrossAx        *CT_UnsignedInt
	Choice         *EG_AxSharedChoice
	Auto           *CT_Boolean
	LblAlgn        *CT_LblAlgn
	LblOffset      *CT_LblOffset
	TickLblSkip    *CT_Skip
	TickMarkSkip   *CT_Skip
	NoMultiLvlLbl  *CT_Boolean
	ExtLst         *CT_ExtensionList
}

func NewCT_CatAx 

func NewCT_CatAx() *CT_CatAx

func (*CT_CatAx) MarshalXML 

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

func (*CT_CatAx) UnmarshalXML 

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

func (*CT_CatAx) Validate 

func (m *CT_CatAx) Validate() error

Validate validates the CT_CatAx and its children

func (*CT_CatAx) ValidateWithPath 

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

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

type CT_Chart 

type CT_Chart struct {
	Title            *CT_Title
	AutoTitleDeleted *CT_Boolean
	PivotFmts        *CT_PivotFmts
	View3D           *CT_View3D
	Floor            *CT_Surface
	SideWall         *CT_Surface
	BackWall         *CT_Surface
	PlotArea         *CT_PlotArea
	Legend           *CT_Legend
	PlotVisOnly      *CT_Boolean
	DispBlanksAs     *CT_DispBlanksAs
	ShowDLblsOverMax *CT_Boolean
	ExtLst           *CT_ExtensionList
}

func NewCT_Chart 

func NewCT_Chart() *CT_Chart

func (*CT_Chart) MarshalXML 

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

func (*CT_Chart) UnmarshalXML 

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

func (*CT_Chart) Validate 

func (m *CT_Chart) Validate() error

Validate validates the CT_Chart and its children

func (*CT_Chart) ValidateWithPath 

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

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

type CT_ChartLines 

type CT_ChartLines struct {
	SpPr *dml.CT_ShapeProperties
}

func NewCT_ChartLines 

func NewCT_ChartLines() *CT_ChartLines

func (*CT_ChartLines) MarshalXML 

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

func (*CT_ChartLines) UnmarshalXML 

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

func (*CT_ChartLines) Validate 

func (m *CT_ChartLines) Validate() error

Validate validates the CT_ChartLines and its children

func (*CT_ChartLines) ValidateWithPath 

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

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

type CT_ChartSpace 

type CT_ChartSpace struct {
	Date1904       *CT_Boolean
	Lang           *CT_TextLanguageID
	RoundedCorners *CT_Boolean
	Style          *CT_Style
	ClrMapOvr      *dml.CT_ColorMapping
	PivotSource    *CT_PivotSource
	Protection     *CT_Protection
	Chart          *CT_Chart
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	ExternalData   *CT_ExternalData
	PrintSettings  *CT_PrintSettings
	UserShapes     *CT_RelId
	ExtLst         *CT_ExtensionList
}

func NewCT_ChartSpace 

func NewCT_ChartSpace() *CT_ChartSpace

func (*CT_ChartSpace) MarshalXML 

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

func (*CT_ChartSpace) UnmarshalXML 

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

func (*CT_ChartSpace) Validate 

func (m *CT_ChartSpace) Validate() error

Validate validates the CT_ChartSpace and its children

func (*CT_ChartSpace) ValidateWithPath 

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

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

type CT_CrossBetween 

type CT_CrossBetween struct {
	ValAttr ST_CrossBetween
}

func NewCT_CrossBetween 

func NewCT_CrossBetween() *CT_CrossBetween

func (*CT_CrossBetween) MarshalXML 

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

func (*CT_CrossBetween) UnmarshalXML 

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

func (*CT_CrossBetween) Validate 

func (m *CT_CrossBetween) Validate() error

Validate validates the CT_CrossBetween and its children

func (*CT_CrossBetween) ValidateWithPath 

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

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

type CT_Crosses 

type CT_Crosses struct {
	ValAttr ST_Crosses
}

func NewCT_Crosses 

func NewCT_Crosses() *CT_Crosses

func (*CT_Crosses) MarshalXML 

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

func (*CT_Crosses) UnmarshalXML 

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

func (*CT_Crosses) Validate 

func (m *CT_Crosses) Validate() error

Validate validates the CT_Crosses and its children

func (*CT_Crosses) ValidateWithPath 

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

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

type CT_CustSplit 

type CT_CustSplit struct {
	SecondPiePt []*CT_UnsignedInt
}

func NewCT_CustSplit 

func NewCT_CustSplit() *CT_CustSplit

func (*CT_CustSplit) MarshalXML 

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

func (*CT_CustSplit) UnmarshalXML 

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

func (*CT_CustSplit) Validate 

func (m *CT_CustSplit) Validate() error

Validate validates the CT_CustSplit and its children

func (*CT_CustSplit) ValidateWithPath 

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

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

type CT_DLbl 

type CT_DLbl struct {
	Idx    *CT_UnsignedInt
	Choice *CT_DLblChoice
	ExtLst *CT_ExtensionList
}

func NewCT_DLbl 

func NewCT_DLbl() *CT_DLbl

func (*CT_DLbl) MarshalXML 

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

func (*CT_DLbl) UnmarshalXML 

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

func (*CT_DLbl) Validate 

func (m *CT_DLbl) Validate() error

Validate validates the CT_DLbl and its children

func (*CT_DLbl) ValidateWithPath 

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

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

type CT_DLblChoice 

type CT_DLblChoice struct {
	Delete         *CT_Boolean
	Layout         *CT_Layout
	Tx             *CT_Tx
	NumFmt         *CT_NumFmt
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	DLblPos        *CT_DLblPos
	ShowLegendKey  *CT_Boolean
	ShowVal        *CT_Boolean
	ShowCatName    *CT_Boolean
	ShowSerName    *CT_Boolean
	ShowPercent    *CT_Boolean
	ShowBubbleSize *CT_Boolean
	Separator      *string
}

func NewCT_DLblChoice 

func NewCT_DLblChoice() *CT_DLblChoice

func (*CT_DLblChoice) MarshalXML 

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

func (*CT_DLblChoice) UnmarshalXML 

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

func (*CT_DLblChoice) Validate 

func (m *CT_DLblChoice) Validate() error

Validate validates the CT_DLblChoice and its children

func (*CT_DLblChoice) ValidateWithPath 

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

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

type CT_DLblPos 

type CT_DLblPos struct {
	ValAttr ST_DLblPos
}

func NewCT_DLblPos 

func NewCT_DLblPos() *CT_DLblPos

func (*CT_DLblPos) MarshalXML 

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

func (*CT_DLblPos) UnmarshalXML 

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

func (*CT_DLblPos) Validate 

func (m *CT_DLblPos) Validate() error

Validate validates the CT_DLblPos and its children

func (*CT_DLblPos) ValidateWithPath 

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

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

type CT_DLbls 

type CT_DLbls struct {
	DLbl   []*CT_DLbl
	Choice *CT_DLblsChoice
	ExtLst *CT_ExtensionList
}

func NewCT_DLbls 

func NewCT_DLbls() *CT_DLbls

func (*CT_DLbls) MarshalXML 

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

func (*CT_DLbls) UnmarshalXML 

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

func (*CT_DLbls) Validate 

func (m *CT_DLbls) Validate() error

Validate validates the CT_DLbls and its children

func (*CT_DLbls) ValidateWithPath 

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

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

type CT_DLblsChoice 

type CT_DLblsChoice struct {
	Delete          *CT_Boolean
	NumFmt          *CT_NumFmt
	SpPr            *dml.CT_ShapeProperties
	TxPr            *dml.CT_TextBody
	DLblPos         *CT_DLblPos
	ShowLegendKey   *CT_Boolean
	ShowVal         *CT_Boolean
	ShowCatName     *CT_Boolean
	ShowSerName     *CT_Boolean
	ShowPercent     *CT_Boolean
	ShowBubbleSize  *CT_Boolean
	Separator       *string
	ShowLeaderLines *CT_Boolean
	LeaderLines     *CT_ChartLines
}

func NewCT_DLblsChoice 

func NewCT_DLblsChoice() *CT_DLblsChoice

func (*CT_DLblsChoice) MarshalXML 

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

func (*CT_DLblsChoice) UnmarshalXML 

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

func (*CT_DLblsChoice) Validate 

func (m *CT_DLblsChoice) Validate() error

Validate validates the CT_DLblsChoice and its children

func (*CT_DLblsChoice) ValidateWithPath 

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

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

type CT_DPt 

type CT_DPt struct {
	Idx              *CT_UnsignedInt
	InvertIfNegative *CT_Boolean
	Marker           *CT_Marker
	Bubble3D         *CT_Boolean
	Explosion        *CT_UnsignedInt
	SpPr             *dml.CT_ShapeProperties
	PictureOptions   *CT_PictureOptions
	ExtLst           *CT_ExtensionList
}

func NewCT_DPt 

func NewCT_DPt() *CT_DPt

func (*CT_DPt) MarshalXML 

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

func (*CT_DPt) UnmarshalXML 

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

func (*CT_DPt) Validate 

func (m *CT_DPt) Validate() error

Validate validates the CT_DPt and its children

func (*CT_DPt) ValidateWithPath 

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

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

type CT_DTable 

type CT_DTable struct {
	ShowHorzBorder *CT_Boolean
	ShowVertBorder *CT_Boolean
	ShowOutline    *CT_Boolean
	ShowKeys       *CT_Boolean
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	ExtLst         *CT_ExtensionList
}

func NewCT_DTable 

func NewCT_DTable() *CT_DTable

func (*CT_DTable) MarshalXML 

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

func (*CT_DTable) UnmarshalXML 

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

func (*CT_DTable) Validate 

func (m *CT_DTable) Validate() error

Validate validates the CT_DTable and its children

func (*CT_DTable) ValidateWithPath 

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

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

type CT_DateAx 

type CT_DateAx struct {
	AxId           *CT_UnsignedInt
	Scaling        *CT_Scaling
	Delete         *CT_Boolean
	AxPos          *CT_AxPos
	MajorGridlines *CT_ChartLines
	MinorGridlines *CT_ChartLines
	Title          *CT_Title
	NumFmt         *CT_NumFmt
	MajorTickMark  *CT_TickMark
	MinorTickMark  *CT_TickMark
	TickLblPos     *CT_TickLblPos
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	CrossAx        *CT_UnsignedInt
	Choice         *EG_AxSharedChoice
	Auto           *CT_Boolean
	LblOffset      *CT_LblOffset
	BaseTimeUnit   *CT_TimeUnit
	MajorUnit      *CT_AxisUnit
	MajorTimeUnit  *CT_TimeUnit
	MinorUnit      *CT_AxisUnit
	MinorTimeUnit  *CT_TimeUnit
	ExtLst         *CT_ExtensionList
}

func NewCT_DateAx 

func NewCT_DateAx() *CT_DateAx

func (*CT_DateAx) MarshalXML 

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

func (*CT_DateAx) UnmarshalXML 

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

func (*CT_DateAx) Validate 

func (m *CT_DateAx) Validate() error

Validate validates the CT_DateAx and its children

func (*CT_DateAx) ValidateWithPath 

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

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

type CT_DepthPercent 

type CT_DepthPercent struct {
	ValAttr *ST_DepthPercent
}

func NewCT_DepthPercent 

func NewCT_DepthPercent() *CT_DepthPercent

func (*CT_DepthPercent) MarshalXML 

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

func (*CT_DepthPercent) UnmarshalXML 

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

func (*CT_DepthPercent) Validate 

func (m *CT_DepthPercent) Validate() error

Validate validates the CT_DepthPercent and its children

func (*CT_DepthPercent) ValidateWithPath 

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

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

type CT_DispBlanksAs 

type CT_DispBlanksAs struct {
	ValAttr ST_DispBlanksAs
}

func NewCT_DispBlanksAs 

func NewCT_DispBlanksAs() *CT_DispBlanksAs

func (*CT_DispBlanksAs) MarshalXML 

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

func (*CT_DispBlanksAs) UnmarshalXML 

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

func (*CT_DispBlanksAs) Validate 

func (m *CT_DispBlanksAs) Validate() error

Validate validates the CT_DispBlanksAs and its children

func (*CT_DispBlanksAs) ValidateWithPath 

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

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

type CT_DispUnits 

type CT_DispUnits struct {
	Choice       *CT_DispUnitsChoice
	DispUnitsLbl *CT_DispUnitsLbl
	ExtLst       *CT_ExtensionList
}

func NewCT_DispUnits 

func NewCT_DispUnits() *CT_DispUnits

func (*CT_DispUnits) MarshalXML 

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

func (*CT_DispUnits) UnmarshalXML 

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

func (*CT_DispUnits) Validate 

func (m *CT_DispUnits) Validate() error

Validate validates the CT_DispUnits and its children

func (*CT_DispUnits) ValidateWithPath 

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

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

type CT_DispUnitsChoice 

type CT_DispUnitsChoice struct {
	CustUnit    *CT_Double
	BuiltInUnit *CT_BuiltInUnit
}

func NewCT_DispUnitsChoice 

func NewCT_DispUnitsChoice() *CT_DispUnitsChoice

func (*CT_DispUnitsChoice) MarshalXML 

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

func (*CT_DispUnitsChoice) UnmarshalXML 

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

func (*CT_DispUnitsChoice) Validate 

func (m *CT_DispUnitsChoice) Validate() error

Validate validates the CT_DispUnitsChoice and its children

func (*CT_DispUnitsChoice) ValidateWithPath 

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

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

type CT_DispUnitsLbl 

type CT_DispUnitsLbl struct {
	Layout *CT_Layout
	Tx     *CT_Tx
	SpPr   *dml.CT_ShapeProperties
	TxPr   *dml.CT_TextBody
}

func NewCT_DispUnitsLbl 

func NewCT_DispUnitsLbl() *CT_DispUnitsLbl

func (*CT_DispUnitsLbl) MarshalXML 

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

func (*CT_DispUnitsLbl) UnmarshalXML 

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

func (*CT_DispUnitsLbl) Validate 

func (m *CT_DispUnitsLbl) Validate() error

Validate validates the CT_DispUnitsLbl and its children

func (*CT_DispUnitsLbl) ValidateWithPath 

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

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

type CT_Double 

type CT_Double struct {
	ValAttr float64
}

func NewCT_Double 

func NewCT_Double() *CT_Double

func (*CT_Double) MarshalXML 

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

func (*CT_Double) UnmarshalXML 

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

func (*CT_Double) Validate 

func (m *CT_Double) Validate() error

Validate validates the CT_Double and its children

func (*CT_Double) ValidateWithPath 

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

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

type CT_DoughnutChart 

type CT_DoughnutChart struct {
	VaryColors    *CT_Boolean
	Ser           []*CT_PieSer
	DLbls         *CT_DLbls
	FirstSliceAng *CT_FirstSliceAng
	HoleSize      *CT_HoleSize
	ExtLst        *CT_ExtensionList
}

func NewCT_DoughnutChart 

func NewCT_DoughnutChart() *CT_DoughnutChart

func (*CT_DoughnutChart) MarshalXML 

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

func (*CT_DoughnutChart) UnmarshalXML 

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

func (*CT_DoughnutChart) Validate 

func (m *CT_DoughnutChart) Validate() error

Validate validates the CT_DoughnutChart and its children

func (*CT_DoughnutChart) ValidateWithPath 

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

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

type CT_ErrBarType 

type CT_ErrBarType struct {
	ValAttr ST_ErrBarType
}

func NewCT_ErrBarType 

func NewCT_ErrBarType() *CT_ErrBarType

func (*CT_ErrBarType) MarshalXML 

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

func (*CT_ErrBarType) UnmarshalXML 

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

func (*CT_ErrBarType) Validate 

func (m *CT_ErrBarType) Validate() error

Validate validates the CT_ErrBarType and its children

func (*CT_ErrBarType) ValidateWithPath 

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

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

type CT_ErrBars 

type CT_ErrBars struct {
	ErrDir     *CT_ErrDir
	ErrBarType *CT_ErrBarType
	ErrValType *CT_ErrValType
	NoEndCap   *CT_Boolean
	Plus       *CT_NumDataSource
	Minus      *CT_NumDataSource
	Val        *CT_Double
	SpPr       *dml.CT_ShapeProperties
	ExtLst     *CT_ExtensionList
}

func NewCT_ErrBars 

func NewCT_ErrBars() *CT_ErrBars

func (*CT_ErrBars) MarshalXML 

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

func (*CT_ErrBars) UnmarshalXML 

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

func (*CT_ErrBars) Validate 

func (m *CT_ErrBars) Validate() error

Validate validates the CT_ErrBars and its children

func (*CT_ErrBars) ValidateWithPath 

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

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

type CT_ErrDir 

type CT_ErrDir struct {
	ValAttr ST_ErrDir
}

func NewCT_ErrDir 

func NewCT_ErrDir() *CT_ErrDir

func (*CT_ErrDir) MarshalXML 

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

func (*CT_ErrDir) UnmarshalXML 

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

func (*CT_ErrDir) Validate 

func (m *CT_ErrDir) Validate() error

Validate validates the CT_ErrDir and its children

func (*CT_ErrDir) ValidateWithPath 

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

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

type CT_ErrValType 

type CT_ErrValType struct {
	ValAttr ST_ErrValType
}

func NewCT_ErrValType 

func NewCT_ErrValType() *CT_ErrValType

func (*CT_ErrValType) MarshalXML 

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

func (*CT_ErrValType) UnmarshalXML 

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

func (*CT_ErrValType) Validate 

func (m *CT_ErrValType) Validate() error

Validate validates the CT_ErrValType and its children

func (*CT_ErrValType) ValidateWithPath 

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

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

type CT_Extension 

type CT_Extension struct {
	UriAttr *string
	Any     gooxml.Any
}

func NewCT_Extension 

func NewCT_Extension() *CT_Extension

func (*CT_Extension) MarshalXML 

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

func (*CT_Extension) UnmarshalXML 

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

func (*CT_Extension) Validate 

func (m *CT_Extension) Validate() error

Validate validates the CT_Extension and its children

func (*CT_Extension) ValidateWithPath 

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

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

type CT_ExtensionList 

type CT_ExtensionList struct {
	Ext []*CT_Extension
}

func NewCT_ExtensionList 

func NewCT_ExtensionList() *CT_ExtensionList

func (*CT_ExtensionList) MarshalXML 

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

func (*CT_ExtensionList) UnmarshalXML 

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

func (*CT_ExtensionList) Validate 

func (m *CT_ExtensionList) Validate() error

Validate validates the CT_ExtensionList and its children

func (*CT_ExtensionList) ValidateWithPath 

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

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

type CT_ExternalData 

type CT_ExternalData struct {
	IdAttr     string
	AutoUpdate *CT_Boolean
}

func NewCT_ExternalData 

func NewCT_ExternalData() *CT_ExternalData

func (*CT_ExternalData) MarshalXML 

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

func (*CT_ExternalData) UnmarshalXML 

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

func (*CT_ExternalData) Validate 

func (m *CT_ExternalData) Validate() error

Validate validates the CT_ExternalData and its children

func (*CT_ExternalData) ValidateWithPath 

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

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

type CT_FirstSliceAng 

type CT_FirstSliceAng struct {
	ValAttr *uint16
}

func NewCT_FirstSliceAng 

func NewCT_FirstSliceAng() *CT_FirstSliceAng

func (*CT_FirstSliceAng) MarshalXML 

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

func (*CT_FirstSliceAng) UnmarshalXML 

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

func (*CT_FirstSliceAng) Validate 

func (m *CT_FirstSliceAng) Validate() error

Validate validates the CT_FirstSliceAng and its children

func (*CT_FirstSliceAng) ValidateWithPath 

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

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

type CT_GapAmount 

type CT_GapAmount struct {
	ValAttr *ST_GapAmount
}

func NewCT_GapAmount 

func NewCT_GapAmount() *CT_GapAmount

func (*CT_GapAmount) MarshalXML 

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

func (*CT_GapAmount) UnmarshalXML 

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

func (*CT_GapAmount) Validate 

func (m *CT_GapAmount) Validate() error

Validate validates the CT_GapAmount and its children

func (*CT_GapAmount) ValidateWithPath 

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

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

type CT_Grouping 

type CT_Grouping struct {
	ValAttr ST_Grouping
}

func NewCT_Grouping 

func NewCT_Grouping() *CT_Grouping

func (*CT_Grouping) MarshalXML 

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

func (*CT_Grouping) UnmarshalXML 

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

func (*CT_Grouping) Validate 

func (m *CT_Grouping) Validate() error

Validate validates the CT_Grouping and its children

func (*CT_Grouping) ValidateWithPath 

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

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

type CT_HPercent 

type CT_HPercent struct {
	ValAttr *ST_HPercent
}

func NewCT_HPercent 

func NewCT_HPercent() *CT_HPercent

func (*CT_HPercent) MarshalXML 

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

func (*CT_HPercent) UnmarshalXML 

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

func (*CT_HPercent) Validate 

func (m *CT_HPercent) Validate() error

Validate validates the CT_HPercent and its children

func (*CT_HPercent) ValidateWithPath 

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

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

type CT_HeaderFooter 

type CT_HeaderFooter struct {
	AlignWithMarginsAttr *bool
	DifferentOddEvenAttr *bool
	DifferentFirstAttr   *bool
	OddHeader            *string
	OddFooter            *string
	EvenHeader           *string
	EvenFooter           *string
	FirstHeader          *string
	FirstFooter          *string
}

func NewCT_HeaderFooter 

func NewCT_HeaderFooter() *CT_HeaderFooter

func (*CT_HeaderFooter) MarshalXML 

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

func (*CT_HeaderFooter) UnmarshalXML 

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

func (*CT_HeaderFooter) Validate 

func (m *CT_HeaderFooter) Validate() error

Validate validates the CT_HeaderFooter and its children

func (*CT_HeaderFooter) ValidateWithPath 

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

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

type CT_HoleSize 

type CT_HoleSize struct {
	ValAttr *ST_HoleSize
}

func NewCT_HoleSize 

func NewCT_HoleSize() *CT_HoleSize

func (*CT_HoleSize) MarshalXML 

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

func (*CT_HoleSize) UnmarshalXML 

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

func (*CT_HoleSize) Validate 

func (m *CT_HoleSize) Validate() error

Validate validates the CT_HoleSize and its children

func (*CT_HoleSize) ValidateWithPath 

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

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

type CT_Layout 

type CT_Layout struct {
	ManualLayout *CT_ManualLayout
	ExtLst       *CT_ExtensionList
}

func NewCT_Layout 

func NewCT_Layout() *CT_Layout

func (*CT_Layout) MarshalXML 

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

func (*CT_Layout) UnmarshalXML 

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

func (*CT_Layout) Validate 

func (m *CT_Layout) Validate() error

Validate validates the CT_Layout and its children

func (*CT_Layout) ValidateWithPath 

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

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

type CT_LayoutMode 

type CT_LayoutMode struct {
	ValAttr ST_LayoutMode
}

func NewCT_LayoutMode 

func NewCT_LayoutMode() *CT_LayoutMode

func (*CT_LayoutMode) MarshalXML 

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

func (*CT_LayoutMode) UnmarshalXML 

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

func (*CT_LayoutMode) Validate 

func (m *CT_LayoutMode) Validate() error

Validate validates the CT_LayoutMode and its children

func (*CT_LayoutMode) ValidateWithPath 

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

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

type CT_LayoutTarget 

type CT_LayoutTarget struct {
	ValAttr ST_LayoutTarget
}

func NewCT_LayoutTarget 

func NewCT_LayoutTarget() *CT_LayoutTarget

func (*CT_LayoutTarget) MarshalXML 

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

func (*CT_LayoutTarget) UnmarshalXML 

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

func (*CT_LayoutTarget) Validate 

func (m *CT_LayoutTarget) Validate() error

Validate validates the CT_LayoutTarget and its children

func (*CT_LayoutTarget) ValidateWithPath 

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

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

type CT_LblAlgn 

type CT_LblAlgn struct {
	ValAttr ST_LblAlgn
}

func NewCT_LblAlgn 

func NewCT_LblAlgn() *CT_LblAlgn

func (*CT_LblAlgn) MarshalXML 

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

func (*CT_LblAlgn) UnmarshalXML 

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

func (*CT_LblAlgn) Validate 

func (m *CT_LblAlgn) Validate() error

Validate validates the CT_LblAlgn and its children

func (*CT_LblAlgn) ValidateWithPath 

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

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

type CT_LblOffset 

type CT_LblOffset struct {
	ValAttr *ST_LblOffset
}

func NewCT_LblOffset 

func NewCT_LblOffset() *CT_LblOffset

func (*CT_LblOffset) MarshalXML 

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

func (*CT_LblOffset) UnmarshalXML 

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

func (*CT_LblOffset) Validate 

func (m *CT_LblOffset) Validate() error

Validate validates the CT_LblOffset and its children

func (*CT_LblOffset) ValidateWithPath 

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

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

type CT_Legend 

type CT_Legend struct {
	LegendPos   *CT_LegendPos
	LegendEntry []*CT_LegendEntry
	Layout      *CT_Layout
	Overlay     *CT_Boolean
	SpPr        *dml.CT_ShapeProperties
	TxPr        *dml.CT_TextBody
	ExtLst      *CT_ExtensionList
}

func NewCT_Legend 

func NewCT_Legend() *CT_Legend

func (*CT_Legend) MarshalXML 

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

func (*CT_Legend) UnmarshalXML 

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

func (*CT_Legend) Validate 

func (m *CT_Legend) Validate() error

Validate validates the CT_Legend and its children

func (*CT_Legend) ValidateWithPath 

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

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

type CT_LegendEntry 

type CT_LegendEntry struct {
	Idx    *CT_UnsignedInt
	Choice *CT_LegendEntryChoice
	ExtLst *CT_ExtensionList
}

func NewCT_LegendEntry 

func NewCT_LegendEntry() *CT_LegendEntry

func (*CT_LegendEntry) MarshalXML 

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

func (*CT_LegendEntry) UnmarshalXML 

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

func (*CT_LegendEntry) Validate 

func (m *CT_LegendEntry) Validate() error

Validate validates the CT_LegendEntry and its children

func (*CT_LegendEntry) ValidateWithPath 

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

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

type CT_LegendEntryChoice 

type CT_LegendEntryChoice struct {
	Delete *CT_Boolean
	TxPr   *dml.CT_TextBody
}

func NewCT_LegendEntryChoice 

func NewCT_LegendEntryChoice() *CT_LegendEntryChoice

func (*CT_LegendEntryChoice) MarshalXML 

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

func (*CT_LegendEntryChoice) UnmarshalXML 

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

func (*CT_LegendEntryChoice) Validate 

func (m *CT_LegendEntryChoice) Validate() error

Validate validates the CT_LegendEntryChoice and its children

func (*CT_LegendEntryChoice) ValidateWithPath 

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

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

type CT_LegendPos 

type CT_LegendPos struct {
	ValAttr ST_LegendPos
}

func NewCT_LegendPos 

func NewCT_LegendPos() *CT_LegendPos

func (*CT_LegendPos) MarshalXML 

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

func (*CT_LegendPos) UnmarshalXML 

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

func (*CT_LegendPos) Validate 

func (m *CT_LegendPos) Validate() error

Validate validates the CT_LegendPos and its children

func (*CT_LegendPos) ValidateWithPath 

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

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

type CT_Line3DChart 

type CT_Line3DChart struct {
	Grouping   *CT_Grouping
	VaryColors *CT_Boolean
	Ser        []*CT_LineSer
	DLbls      *CT_DLbls
	DropLines  *CT_ChartLines
	GapDepth   *CT_GapAmount
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_Line3DChart 

func NewCT_Line3DChart() *CT_Line3DChart

func (*CT_Line3DChart) MarshalXML 

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

func (*CT_Line3DChart) UnmarshalXML 

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

func (*CT_Line3DChart) Validate 

func (m *CT_Line3DChart) Validate() error

Validate validates the CT_Line3DChart and its children

func (*CT_Line3DChart) ValidateWithPath 

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

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

type CT_LineChart 

type CT_LineChart struct {
	Grouping   *CT_Grouping
	VaryColors *CT_Boolean
	Ser        []*CT_LineSer
	DLbls      *CT_DLbls
	DropLines  *CT_ChartLines
	HiLowLines *CT_ChartLines
	UpDownBars *CT_UpDownBars
	Marker     *CT_Boolean
	Smooth     *CT_Boolean
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_LineChart 

func NewCT_LineChart() *CT_LineChart

func (*CT_LineChart) MarshalXML 

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

func (*CT_LineChart) UnmarshalXML 

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

func (*CT_LineChart) Validate 

func (m *CT_LineChart) Validate() error

Validate validates the CT_LineChart and its children

func (*CT_LineChart) ValidateWithPath 

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

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

type CT_LineSer 

type CT_LineSer struct {
	Idx       *CT_UnsignedInt
	Order     *CT_UnsignedInt
	Tx        *CT_SerTx
	SpPr      *dml.CT_ShapeProperties
	Marker    *CT_Marker
	DPt       []*CT_DPt
	DLbls     *CT_DLbls
	Trendline []*CT_Trendline
	ErrBars   *CT_ErrBars
	Cat       *CT_AxDataSource
	Val       *CT_NumDataSource
	Smooth    *CT_Boolean
	ExtLst    *CT_ExtensionList
}

func NewCT_LineSer 

func NewCT_LineSer() *CT_LineSer

func (*CT_LineSer) MarshalXML 

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

func (*CT_LineSer) UnmarshalXML 

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

func (*CT_LineSer) Validate 

func (m *CT_LineSer) Validate() error

Validate validates the CT_LineSer and its children

func (*CT_LineSer) ValidateWithPath 

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

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

type CT_LogBase 

type CT_LogBase struct {
	ValAttr float64
}

func NewCT_LogBase 

func NewCT_LogBase() *CT_LogBase

func (*CT_LogBase) MarshalXML 

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

func (*CT_LogBase) UnmarshalXML 

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

func (*CT_LogBase) Validate 

func (m *CT_LogBase) Validate() error

Validate validates the CT_LogBase and its children

func (*CT_LogBase) ValidateWithPath 

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

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

type CT_Lvl 

type CT_Lvl struct {
	Pt []*CT_StrVal
}

func NewCT_Lvl 

func NewCT_Lvl() *CT_Lvl

func (*CT_Lvl) MarshalXML 

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

func (*CT_Lvl) UnmarshalXML 

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

func (*CT_Lvl) Validate 

func (m *CT_Lvl) Validate() error

Validate validates the CT_Lvl and its children

func (*CT_Lvl) ValidateWithPath 

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

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

type CT_ManualLayout 

type CT_ManualLayout struct {
	LayoutTarget *CT_LayoutTarget
	XMode        *CT_LayoutMode
	YMode        *CT_LayoutMode
	WMode        *CT_LayoutMode
	HMode        *CT_LayoutMode
	X            *CT_Double
	Y            *CT_Double
	W            *CT_Double
	H            *CT_Double
	ExtLst       *CT_ExtensionList
}

func NewCT_ManualLayout 

func NewCT_ManualLayout() *CT_ManualLayout

func (*CT_ManualLayout) MarshalXML 

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

func (*CT_ManualLayout) UnmarshalXML 

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

func (*CT_ManualLayout) Validate 

func (m *CT_ManualLayout) Validate() error

Validate validates the CT_ManualLayout and its children

func (*CT_ManualLayout) ValidateWithPath 

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

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

type CT_Marker 

type CT_Marker struct {
	Symbol *CT_MarkerStyle
	Size   *CT_MarkerSize
	SpPr   *dml.CT_ShapeProperties
	ExtLst *CT_ExtensionList
}

func NewCT_Marker 

func NewCT_Marker() *CT_Marker

func (*CT_Marker) MarshalXML 

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

func (*CT_Marker) UnmarshalXML 

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

func (*CT_Marker) Validate 

func (m *CT_Marker) Validate() error

Validate validates the CT_Marker and its children

func (*CT_Marker) ValidateWithPath 

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

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

type CT_MarkerSize 

type CT_MarkerSize struct {
	ValAttr *uint8
}

func NewCT_MarkerSize 

func NewCT_MarkerSize() *CT_MarkerSize

func (*CT_MarkerSize) MarshalXML 

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

func (*CT_MarkerSize) UnmarshalXML 

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

func (*CT_MarkerSize) Validate 

func (m *CT_MarkerSize) Validate() error

Validate validates the CT_MarkerSize and its children

func (*CT_MarkerSize) ValidateWithPath 

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

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

type CT_MarkerStyle 

type CT_MarkerStyle struct {
	ValAttr ST_MarkerStyle
}

func NewCT_MarkerStyle 

func NewCT_MarkerStyle() *CT_MarkerStyle

func (*CT_MarkerStyle) MarshalXML 

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

func (*CT_MarkerStyle) UnmarshalXML 

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

func (*CT_MarkerStyle) Validate 

func (m *CT_MarkerStyle) Validate() error

Validate validates the CT_MarkerStyle and its children

func (*CT_MarkerStyle) ValidateWithPath 

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

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

type CT_MultiLvlStrData 

type CT_MultiLvlStrData struct {
	PtCount *CT_UnsignedInt
	Lvl     []*CT_Lvl
	ExtLst  *CT_ExtensionList
}

func NewCT_MultiLvlStrData 

func NewCT_MultiLvlStrData() *CT_MultiLvlStrData

func (*CT_MultiLvlStrData) MarshalXML 

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

func (*CT_MultiLvlStrData) UnmarshalXML 

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

func (*CT_MultiLvlStrData) Validate 

func (m *CT_MultiLvlStrData) Validate() error

Validate validates the CT_MultiLvlStrData and its children

func (*CT_MultiLvlStrData) ValidateWithPath 

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

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

type CT_MultiLvlStrRef 

type CT_MultiLvlStrRef struct {
	F                string
	MultiLvlStrCache *CT_MultiLvlStrData
	ExtLst           *CT_ExtensionList
}

func NewCT_MultiLvlStrRef 

func NewCT_MultiLvlStrRef() *CT_MultiLvlStrRef

func (*CT_MultiLvlStrRef) MarshalXML 

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

func (*CT_MultiLvlStrRef) UnmarshalXML 

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

func (*CT_MultiLvlStrRef) Validate 

func (m *CT_MultiLvlStrRef) Validate() error

Validate validates the CT_MultiLvlStrRef and its children

func (*CT_MultiLvlStrRef) ValidateWithPath 

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

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

type CT_NumData 

type CT_NumData struct {
	FormatCode *string
	PtCount    *CT_UnsignedInt
	Pt         []*CT_NumVal
	ExtLst     *CT_ExtensionList
}

func NewCT_NumData 

func NewCT_NumData() *CT_NumData

func (*CT_NumData) MarshalXML 

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

func (*CT_NumData) UnmarshalXML 

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

func (*CT_NumData) Validate 

func (m *CT_NumData) Validate() error

Validate validates the CT_NumData and its children

func (*CT_NumData) ValidateWithPath 

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

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

type CT_NumDataSource 

type CT_NumDataSource struct {
	Choice *CT_NumDataSourceChoice
}

func NewCT_NumDataSource 

func NewCT_NumDataSource() *CT_NumDataSource

func (*CT_NumDataSource) MarshalXML 

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

func (*CT_NumDataSource) UnmarshalXML 

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

func (*CT_NumDataSource) Validate 

func (m *CT_NumDataSource) Validate() error

Validate validates the CT_NumDataSource and its children

func (*CT_NumDataSource) ValidateWithPath 

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

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

type CT_NumDataSourceChoice 

type CT_NumDataSourceChoice struct {
	NumRef *CT_NumRef
	NumLit *CT_NumData
}

func NewCT_NumDataSourceChoice 

func NewCT_NumDataSourceChoice() *CT_NumDataSourceChoice

func (*CT_NumDataSourceChoice) MarshalXML 

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

func (*CT_NumDataSourceChoice) UnmarshalXML 

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

func (*CT_NumDataSourceChoice) Validate 

func (m *CT_NumDataSourceChoice) Validate() error

Validate validates the CT_NumDataSourceChoice and its children

func (*CT_NumDataSourceChoice) ValidateWithPath 

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

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

type CT_NumFmt 

type CT_NumFmt struct {
	FormatCodeAttr   string
	SourceLinkedAttr *bool
}

func NewCT_NumFmt 

func NewCT_NumFmt() *CT_NumFmt

func (*CT_NumFmt) MarshalXML 

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

func (*CT_NumFmt) UnmarshalXML 

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

func (*CT_NumFmt) Validate 

func (m *CT_NumFmt) Validate() error

Validate validates the CT_NumFmt and its children

func (*CT_NumFmt) ValidateWithPath 

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

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

type CT_NumRef 

type CT_NumRef struct {
	F        string
	NumCache *CT_NumData
	ExtLst   *CT_ExtensionList
}

func NewCT_NumRef 

func NewCT_NumRef() *CT_NumRef

func (*CT_NumRef) MarshalXML 

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

func (*CT_NumRef) UnmarshalXML 

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

func (*CT_NumRef) Validate 

func (m *CT_NumRef) Validate() error

Validate validates the CT_NumRef and its children

func (*CT_NumRef) ValidateWithPath 

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

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

type CT_NumVal 

type CT_NumVal struct {
	IdxAttr        uint32
	FormatCodeAttr *string
	V              string
}

func NewCT_NumVal 

func NewCT_NumVal() *CT_NumVal

func (*CT_NumVal) MarshalXML 

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

func (*CT_NumVal) UnmarshalXML 

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

func (*CT_NumVal) Validate 

func (m *CT_NumVal) Validate() error

Validate validates the CT_NumVal and its children

func (*CT_NumVal) ValidateWithPath 

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

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

type CT_OfPieChart 

type CT_OfPieChart struct {
	OfPieType     *CT_OfPieType
	VaryColors    *CT_Boolean
	Ser           []*CT_PieSer
	DLbls         *CT_DLbls
	GapWidth      *CT_GapAmount
	SplitType     *CT_SplitType
	SplitPos      *CT_Double
	CustSplit     *CT_CustSplit
	SecondPieSize *CT_SecondPieSize
	SerLines      []*CT_ChartLines
	ExtLst        *CT_ExtensionList
}

func NewCT_OfPieChart 

func NewCT_OfPieChart() *CT_OfPieChart

func (*CT_OfPieChart) MarshalXML 

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

func (*CT_OfPieChart) UnmarshalXML 

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

func (*CT_OfPieChart) Validate 

func (m *CT_OfPieChart) Validate() error

Validate validates the CT_OfPieChart and its children

func (*CT_OfPieChart) ValidateWithPath 

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

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

type CT_OfPieType 

type CT_OfPieType struct {
	ValAttr ST_OfPieType
}

func NewCT_OfPieType 

func NewCT_OfPieType() *CT_OfPieType

func (*CT_OfPieType) MarshalXML 

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

func (*CT_OfPieType) UnmarshalXML 

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

func (*CT_OfPieType) Validate 

func (m *CT_OfPieType) Validate() error

Validate validates the CT_OfPieType and its children

func (*CT_OfPieType) ValidateWithPath 

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

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

type CT_Order 

type CT_Order struct {
	ValAttr *uint8
}

func NewCT_Order 

func NewCT_Order() *CT_Order

func (*CT_Order) MarshalXML 

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

func (*CT_Order) UnmarshalXML 

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

func (*CT_Order) Validate 

func (m *CT_Order) Validate() error

Validate validates the CT_Order and its children

func (*CT_Order) ValidateWithPath 

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

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

type CT_Orientation 

type CT_Orientation struct {
	ValAttr ST_Orientation
}

func NewCT_Orientation 

func NewCT_Orientation() *CT_Orientation

func (*CT_Orientation) MarshalXML 

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

func (*CT_Orientation) UnmarshalXML 

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

func (*CT_Orientation) Validate 

func (m *CT_Orientation) Validate() error

Validate validates the CT_Orientation and its children

func (*CT_Orientation) ValidateWithPath 

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

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

type CT_Overlap 

type CT_Overlap struct {
	ValAttr *ST_Overlap
}

func NewCT_Overlap 

func NewCT_Overlap() *CT_Overlap

func (*CT_Overlap) MarshalXML 

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

func (*CT_Overlap) UnmarshalXML 

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

func (*CT_Overlap) Validate 

func (m *CT_Overlap) Validate() error

Validate validates the CT_Overlap and its children

func (*CT_Overlap) ValidateWithPath 

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

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

type CT_PageMargins 

type CT_PageMargins struct {
	LAttr      float64
	RAttr      float64
	TAttr      float64
	BAttr      float64
	HeaderAttr float64
	FooterAttr float64
}

func NewCT_PageMargins 

func NewCT_PageMargins() *CT_PageMargins

func (*CT_PageMargins) MarshalXML 

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

func (*CT_PageMargins) UnmarshalXML 

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

func (*CT_PageMargins) Validate 

func (m *CT_PageMargins) Validate() error

Validate validates the CT_PageMargins and its children

func (*CT_PageMargins) ValidateWithPath 

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

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

type CT_PageSetup 

type CT_PageSetup struct {
	PaperSizeAttr          *uint32
	PaperHeightAttr        *string
	PaperWidthAttr         *string
	FirstPageNumberAttr    *uint32
	OrientationAttr        ST_PageSetupOrientation
	BlackAndWhiteAttr      *bool
	DraftAttr              *bool
	UseFirstPageNumberAttr *bool
	HorizontalDpiAttr      *int32
	VerticalDpiAttr        *int32
	CopiesAttr             *uint32
}

func NewCT_PageSetup 

func NewCT_PageSetup() *CT_PageSetup

func (*CT_PageSetup) MarshalXML 

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

func (*CT_PageSetup) UnmarshalXML 

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

func (*CT_PageSetup) Validate 

func (m *CT_PageSetup) Validate() error

Validate validates the CT_PageSetup and its children

func (*CT_PageSetup) ValidateWithPath 

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

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

type CT_Period 

type CT_Period struct {
	ValAttr *uint32
}

func NewCT_Period 

func NewCT_Period() *CT_Period

func (*CT_Period) MarshalXML 

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

func (*CT_Period) UnmarshalXML 

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

func (*CT_Period) Validate 

func (m *CT_Period) Validate() error

Validate validates the CT_Period and its children

func (*CT_Period) ValidateWithPath 

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

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

type CT_Perspective 

type CT_Perspective struct {
	ValAttr *uint8
}

func NewCT_Perspective 

func NewCT_Perspective() *CT_Perspective

func (*CT_Perspective) MarshalXML 

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

func (*CT_Perspective) UnmarshalXML 

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

func (*CT_Perspective) Validate 

func (m *CT_Perspective) Validate() error

Validate validates the CT_Perspective and its children

func (*CT_Perspective) ValidateWithPath 

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

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

type CT_PictureFormat 

type CT_PictureFormat struct {
	ValAttr ST_PictureFormat
}

func NewCT_PictureFormat 

func NewCT_PictureFormat() *CT_PictureFormat

func (*CT_PictureFormat) MarshalXML 

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

func (*CT_PictureFormat) UnmarshalXML 

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

func (*CT_PictureFormat) Validate 

func (m *CT_PictureFormat) Validate() error

Validate validates the CT_PictureFormat and its children

func (*CT_PictureFormat) ValidateWithPath 

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

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

type CT_PictureOptions 

type CT_PictureOptions struct {
	ApplyToFront     *CT_Boolean
	ApplyToSides     *CT_Boolean
	ApplyToEnd       *CT_Boolean
	PictureFormat    *CT_PictureFormat
	PictureStackUnit *CT_PictureStackUnit
}

func NewCT_PictureOptions 

func NewCT_PictureOptions() *CT_PictureOptions

func (*CT_PictureOptions) MarshalXML 

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

func (*CT_PictureOptions) UnmarshalXML 

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

func (*CT_PictureOptions) Validate 

func (m *CT_PictureOptions) Validate() error

Validate validates the CT_PictureOptions and its children

func (*CT_PictureOptions) ValidateWithPath 

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

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

type CT_PictureStackUnit 

type CT_PictureStackUnit struct {
	ValAttr float64
}

func NewCT_PictureStackUnit 

func NewCT_PictureStackUnit() *CT_PictureStackUnit

func (*CT_PictureStackUnit) MarshalXML 

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

func (*CT_PictureStackUnit) UnmarshalXML 

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

func (*CT_PictureStackUnit) Validate 

func (m *CT_PictureStackUnit) Validate() error

Validate validates the CT_PictureStackUnit and its children

func (*CT_PictureStackUnit) ValidateWithPath 

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

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

type CT_Pie3DChart 

type CT_Pie3DChart struct {
	VaryColors *CT_Boolean
	Ser        []*CT_PieSer
	DLbls      *CT_DLbls
	ExtLst     *CT_ExtensionList
}

func NewCT_Pie3DChart 

func NewCT_Pie3DChart() *CT_Pie3DChart

func (*CT_Pie3DChart) MarshalXML 

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

func (*CT_Pie3DChart) UnmarshalXML 

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

func (*CT_Pie3DChart) Validate 

func (m *CT_Pie3DChart) Validate() error

Validate validates the CT_Pie3DChart and its children

func (*CT_Pie3DChart) ValidateWithPath 

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

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

type CT_PieChart 

type CT_PieChart struct {
	VaryColors    *CT_Boolean
	Ser           []*CT_PieSer
	DLbls         *CT_DLbls
	FirstSliceAng *CT_FirstSliceAng
	ExtLst        *CT_ExtensionList
}

func NewCT_PieChart 

func NewCT_PieChart() *CT_PieChart

func (*CT_PieChart) MarshalXML 

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

func (*CT_PieChart) UnmarshalXML 

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

func (*CT_PieChart) Validate 

func (m *CT_PieChart) Validate() error

Validate validates the CT_PieChart and its children

func (*CT_PieChart) ValidateWithPath 

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

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

type CT_PieSer 

type CT_PieSer struct {
	Idx       *CT_UnsignedInt
	Order     *CT_UnsignedInt
	Tx        *CT_SerTx
	SpPr      *dml.CT_ShapeProperties
	Explosion *CT_UnsignedInt
	DPt       []*CT_DPt
	DLbls     *CT_DLbls
	Cat       *CT_AxDataSource
	Val       *CT_NumDataSource
	ExtLst    *CT_ExtensionList
}

func NewCT_PieSer 

func NewCT_PieSer() *CT_PieSer

func (*CT_PieSer) MarshalXML 

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

func (*CT_PieSer) UnmarshalXML 

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

func (*CT_PieSer) Validate 

func (m *CT_PieSer) Validate() error

Validate validates the CT_PieSer and its children

func (*CT_PieSer) ValidateWithPath 

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

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

type CT_PivotFmt 

type CT_PivotFmt struct {
	Idx    *CT_UnsignedInt
	SpPr   *dml.CT_ShapeProperties
	TxPr   *dml.CT_TextBody
	Marker *CT_Marker
	DLbl   *CT_DLbl
	ExtLst *CT_ExtensionList
}

func NewCT_PivotFmt 

func NewCT_PivotFmt() *CT_PivotFmt

func (*CT_PivotFmt) MarshalXML 

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

func (*CT_PivotFmt) UnmarshalXML 

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

func (*CT_PivotFmt) Validate 

func (m *CT_PivotFmt) Validate() error

Validate validates the CT_PivotFmt and its children

func (*CT_PivotFmt) ValidateWithPath 

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

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

type CT_PivotFmts 

type CT_PivotFmts struct {
	PivotFmt []*CT_PivotFmt
}

func NewCT_PivotFmts 

func NewCT_PivotFmts() *CT_PivotFmts

func (*CT_PivotFmts) MarshalXML 

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

func (*CT_PivotFmts) UnmarshalXML 

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

func (*CT_PivotFmts) Validate 

func (m *CT_PivotFmts) Validate() error

Validate validates the CT_PivotFmts and its children

func (*CT_PivotFmts) ValidateWithPath 

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

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

type CT_PivotSource 

type CT_PivotSource struct {
	Name   string
	FmtId  *CT_UnsignedInt
	ExtLst []*CT_ExtensionList
}

func NewCT_PivotSource 

func NewCT_PivotSource() *CT_PivotSource

func (*CT_PivotSource) MarshalXML 

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

func (*CT_PivotSource) UnmarshalXML 

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

func (*CT_PivotSource) Validate 

func (m *CT_PivotSource) Validate() error

Validate validates the CT_PivotSource and its children

func (*CT_PivotSource) ValidateWithPath 

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

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

type CT_PlotArea 

type CT_PlotArea struct {
	Layout  *CT_Layout
	Choice  []*CT_PlotAreaChoice
	CChoice *CT_PlotAreaChoice1
	DTable  *CT_DTable
	SpPr    *dml.CT_ShapeProperties
	ExtLst  *CT_ExtensionList
}

func NewCT_PlotArea 

func NewCT_PlotArea() *CT_PlotArea

func (*CT_PlotArea) MarshalXML 

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

func (*CT_PlotArea) UnmarshalXML 

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

func (*CT_PlotArea) Validate 

func (m *CT_PlotArea) Validate() error

Validate validates the CT_PlotArea and its children

func (*CT_PlotArea) ValidateWithPath 

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

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

type CT_PlotAreaChoice 

type CT_PlotAreaChoice struct {
	AreaChart      *CT_AreaChart
	Area3DChart    *CT_Area3DChart
	LineChart      *CT_LineChart
	Line3DChart    *CT_Line3DChart
	StockChart     *CT_StockChart
	RadarChart     *CT_RadarChart
	ScatterChart   *CT_ScatterChart
	PieChart       *CT_PieChart
	Pie3DChart     *CT_Pie3DChart
	DoughnutChart  *CT_DoughnutChart
	BarChart       *CT_BarChart
	Bar3DChart     *CT_Bar3DChart
	OfPieChart     *CT_OfPieChart
	SurfaceChart   *CT_SurfaceChart
	Surface3DChart *CT_Surface3DChart
	BubbleChart    *CT_BubbleChart
}

func NewCT_PlotAreaChoice 

func NewCT_PlotAreaChoice() *CT_PlotAreaChoice

func (*CT_PlotAreaChoice) MarshalXML 

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

func (*CT_PlotAreaChoice) UnmarshalXML 

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

func (*CT_PlotAreaChoice) Validate 

func (m *CT_PlotAreaChoice) Validate() error

Validate validates the CT_PlotAreaChoice and its children

func (*CT_PlotAreaChoice) ValidateWithPath 

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

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

type CT_PlotAreaChoice1 

type CT_PlotAreaChoice1 struct {
	ValAx  []*CT_ValAx
	CatAx  []*CT_CatAx
	DateAx []*CT_DateAx
	SerAx  []*CT_SerAx
}

func NewCT_PlotAreaChoice1 

func NewCT_PlotAreaChoice1() *CT_PlotAreaChoice1

func (*CT_PlotAreaChoice1) MarshalXML 

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

func (*CT_PlotAreaChoice1) UnmarshalXML 

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

func (*CT_PlotAreaChoice1) Validate 

func (m *CT_PlotAreaChoice1) Validate() error

Validate validates the CT_PlotAreaChoice1 and its children

func (*CT_PlotAreaChoice1) ValidateWithPath 

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

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

type CT_PrintSettings 

type CT_PrintSettings struct {
	HeaderFooter    *CT_HeaderFooter
	PageMargins     *CT_PageMargins
	PageSetup       *CT_PageSetup
	LegacyDrawingHF *CT_RelId
}

func NewCT_PrintSettings 

func NewCT_PrintSettings() *CT_PrintSettings

func (*CT_PrintSettings) MarshalXML 

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

func (*CT_PrintSettings) UnmarshalXML 

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

func (*CT_PrintSettings) Validate 

func (m *CT_PrintSettings) Validate() error

Validate validates the CT_PrintSettings and its children

func (*CT_PrintSettings) ValidateWithPath 

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

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

type CT_Protection 

type CT_Protection struct {
	ChartObject   *CT_Boolean
	Data          *CT_Boolean
	Formatting    *CT_Boolean
	Selection     *CT_Boolean
	UserInterface *CT_Boolean
}

func NewCT_Protection 

func NewCT_Protection() *CT_Protection

func (*CT_Protection) MarshalXML 

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

func (*CT_Protection) UnmarshalXML 

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

func (*CT_Protection) Validate 

func (m *CT_Protection) Validate() error

Validate validates the CT_Protection and its children

func (*CT_Protection) ValidateWithPath 

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

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

type CT_RadarChart 

type CT_RadarChart struct {
	RadarStyle *CT_RadarStyle
	VaryColors *CT_Boolean
	Ser        []*CT_RadarSer
	DLbls      *CT_DLbls
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_RadarChart 

func NewCT_RadarChart() *CT_RadarChart

func (*CT_RadarChart) MarshalXML 

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

func (*CT_RadarChart) UnmarshalXML 

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

func (*CT_RadarChart) Validate 

func (m *CT_RadarChart) Validate() error

Validate validates the CT_RadarChart and its children

func (*CT_RadarChart) ValidateWithPath 

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

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

type CT_RadarSer 

type CT_RadarSer struct {
	Idx    *CT_UnsignedInt
	Order  *CT_UnsignedInt
	Tx     *CT_SerTx
	SpPr   *dml.CT_ShapeProperties
	Marker *CT_Marker
	DPt    []*CT_DPt
	DLbls  *CT_DLbls
	Cat    *CT_AxDataSource
	Val    *CT_NumDataSource
	ExtLst *CT_ExtensionList
}

func NewCT_RadarSer 

func NewCT_RadarSer() *CT_RadarSer

func (*CT_RadarSer) MarshalXML 

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

func (*CT_RadarSer) UnmarshalXML 

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

func (*CT_RadarSer) Validate 

func (m *CT_RadarSer) Validate() error

Validate validates the CT_RadarSer and its children

func (*CT_RadarSer) ValidateWithPath 

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

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

type CT_RadarStyle 

type CT_RadarStyle struct {
	ValAttr ST_RadarStyle
}

func NewCT_RadarStyle 

func NewCT_RadarStyle() *CT_RadarStyle

func (*CT_RadarStyle) MarshalXML 

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

func (*CT_RadarStyle) UnmarshalXML 

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

func (*CT_RadarStyle) Validate 

func (m *CT_RadarStyle) Validate() error

Validate validates the CT_RadarStyle and its children

func (*CT_RadarStyle) ValidateWithPath 

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

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

type CT_RelId 

type CT_RelId struct {
	IdAttr string
}

func NewCT_RelId 

func NewCT_RelId() *CT_RelId

func (*CT_RelId) MarshalXML 

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

func (*CT_RelId) UnmarshalXML 

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

func (*CT_RelId) Validate 

func (m *CT_RelId) Validate() error

Validate validates the CT_RelId and its children

func (*CT_RelId) ValidateWithPath 

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

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

type CT_RotX 

type CT_RotX struct {
	ValAttr *int8
}

func NewCT_RotX 

func NewCT_RotX() *CT_RotX

func (*CT_RotX) MarshalXML 

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

func (*CT_RotX) UnmarshalXML 

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

func (*CT_RotX) Validate 

func (m *CT_RotX) Validate() error

Validate validates the CT_RotX and its children

func (*CT_RotX) ValidateWithPath 

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

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

type CT_RotY 

type CT_RotY struct {
	ValAttr *uint16
}

func NewCT_RotY 

func NewCT_RotY() *CT_RotY

func (*CT_RotY) MarshalXML 

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

func (*CT_RotY) UnmarshalXML 

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

func (*CT_RotY) Validate 

func (m *CT_RotY) Validate() error

Validate validates the CT_RotY and its children

func (*CT_RotY) ValidateWithPath 

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

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

type CT_Scaling 

type CT_Scaling struct {
	LogBase     *CT_LogBase
	Orientation *CT_Orientation
	Max         *CT_Double
	Min         *CT_Double
	ExtLst      *CT_ExtensionList
}

func NewCT_Scaling 

func NewCT_Scaling() *CT_Scaling

func (*CT_Scaling) MarshalXML 

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

func (*CT_Scaling) UnmarshalXML 

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

func (*CT_Scaling) Validate 

func (m *CT_Scaling) Validate() error

Validate validates the CT_Scaling and its children

func (*CT_Scaling) ValidateWithPath 

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

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

type CT_ScatterChart 

type CT_ScatterChart struct {
	ScatterStyle *CT_ScatterStyle
	VaryColors   *CT_Boolean
	Ser          []*CT_ScatterSer
	DLbls        *CT_DLbls
	AxId         []*CT_UnsignedInt
	ExtLst       *CT_ExtensionList
}

func NewCT_ScatterChart 

func NewCT_ScatterChart() *CT_ScatterChart

func (*CT_ScatterChart) MarshalXML 

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

func (*CT_ScatterChart) UnmarshalXML 

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

func (*CT_ScatterChart) Validate 

func (m *CT_ScatterChart) Validate() error

Validate validates the CT_ScatterChart and its children

func (*CT_ScatterChart) ValidateWithPath 

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

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

type CT_ScatterSer 

type CT_ScatterSer struct {
	Idx       *CT_UnsignedInt
	Order     *CT_UnsignedInt
	Tx        *CT_SerTx
	SpPr      *dml.CT_ShapeProperties
	Marker    *CT_Marker
	DPt       []*CT_DPt
	DLbls     *CT_DLbls
	Trendline []*CT_Trendline
	ErrBars   []*CT_ErrBars
	XVal      *CT_AxDataSource
	YVal      *CT_NumDataSource
	Smooth    *CT_Boolean
	ExtLst    *CT_ExtensionList
}

func NewCT_ScatterSer 

func NewCT_ScatterSer() *CT_ScatterSer

func (*CT_ScatterSer) MarshalXML 

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

func (*CT_ScatterSer) UnmarshalXML 

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

func (*CT_ScatterSer) Validate 

func (m *CT_ScatterSer) Validate() error

Validate validates the CT_ScatterSer and its children

func (*CT_ScatterSer) ValidateWithPath 

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

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

type CT_ScatterStyle 

type CT_ScatterStyle struct {
	ValAttr ST_ScatterStyle
}

func NewCT_ScatterStyle 

func NewCT_ScatterStyle() *CT_ScatterStyle

func (*CT_ScatterStyle) MarshalXML 

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

func (*CT_ScatterStyle) UnmarshalXML 

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

func (*CT_ScatterStyle) Validate 

func (m *CT_ScatterStyle) Validate() error

Validate validates the CT_ScatterStyle and its children

func (*CT_ScatterStyle) ValidateWithPath 

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

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

type CT_SecondPieSize 

type CT_SecondPieSize struct {
	ValAttr *ST_SecondPieSize
}

func NewCT_SecondPieSize 

func NewCT_SecondPieSize() *CT_SecondPieSize

func (*CT_SecondPieSize) MarshalXML 

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

func (*CT_SecondPieSize) UnmarshalXML 

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

func (*CT_SecondPieSize) Validate 

func (m *CT_SecondPieSize) Validate() error

Validate validates the CT_SecondPieSize and its children

func (*CT_SecondPieSize) ValidateWithPath 

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

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

type CT_SerAx 

type CT_SerAx struct {
	AxId           *CT_UnsignedInt
	Scaling        *CT_Scaling
	Delete         *CT_Boolean
	AxPos          *CT_AxPos
	MajorGridlines *CT_ChartLines
	MinorGridlines *CT_ChartLines
	Title          *CT_Title
	NumFmt         *CT_NumFmt
	MajorTickMark  *CT_TickMark
	MinorTickMark  *CT_TickMark
	TickLblPos     *CT_TickLblPos
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	CrossAx        *CT_UnsignedInt
	Choice         *EG_AxSharedChoice
	TickLblSkip    *CT_Skip
	TickMarkSkip   *CT_Skip
	ExtLst         *CT_ExtensionList
}

func NewCT_SerAx 

func NewCT_SerAx() *CT_SerAx

func (*CT_SerAx) MarshalXML 

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

func (*CT_SerAx) UnmarshalXML 

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

func (*CT_SerAx) Validate 

func (m *CT_SerAx) Validate() error

Validate validates the CT_SerAx and its children

func (*CT_SerAx) ValidateWithPath 

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

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

type CT_SerTx 

type CT_SerTx struct {
	Choice *CT_SerTxChoice
}

func NewCT_SerTx 

func NewCT_SerTx() *CT_SerTx

func (*CT_SerTx) MarshalXML 

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

func (*CT_SerTx) UnmarshalXML 

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

func (*CT_SerTx) Validate 

func (m *CT_SerTx) Validate() error

Validate validates the CT_SerTx and its children

func (*CT_SerTx) ValidateWithPath 

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

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

type CT_SerTxChoice 

type CT_SerTxChoice struct {
	StrRef *CT_StrRef
	V      *string
}

func NewCT_SerTxChoice 

func NewCT_SerTxChoice() *CT_SerTxChoice

func (*CT_SerTxChoice) MarshalXML 

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

func (*CT_SerTxChoice) UnmarshalXML 

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

func (*CT_SerTxChoice) Validate 

func (m *CT_SerTxChoice) Validate() error

Validate validates the CT_SerTxChoice and its children

func (*CT_SerTxChoice) ValidateWithPath 

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

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

type CT_Shape 

type CT_Shape struct {
	ValAttr ST_Shape
}

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_SizeRepresents 

type CT_SizeRepresents struct {
	ValAttr ST_SizeRepresents
}

func NewCT_SizeRepresents 

func NewCT_SizeRepresents() *CT_SizeRepresents

func (*CT_SizeRepresents) MarshalXML 

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

func (*CT_SizeRepresents) UnmarshalXML 

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

func (*CT_SizeRepresents) Validate 

func (m *CT_SizeRepresents) Validate() error

Validate validates the CT_SizeRepresents and its children

func (*CT_SizeRepresents) ValidateWithPath 

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

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

type CT_Skip 

type CT_Skip struct {
	ValAttr uint32
}

func NewCT_Skip 

func NewCT_Skip() *CT_Skip

func (*CT_Skip) MarshalXML 

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

func (*CT_Skip) UnmarshalXML 

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

func (*CT_Skip) Validate 

func (m *CT_Skip) Validate() error

Validate validates the CT_Skip and its children

func (*CT_Skip) ValidateWithPath 

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

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

type CT_SplitType 

type CT_SplitType struct {
	ValAttr ST_SplitType
}

func NewCT_SplitType 

func NewCT_SplitType() *CT_SplitType

func (*CT_SplitType) MarshalXML 

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

func (*CT_SplitType) UnmarshalXML 

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

func (*CT_SplitType) Validate 

func (m *CT_SplitType) Validate() error

Validate validates the CT_SplitType and its children

func (*CT_SplitType) ValidateWithPath 

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

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

type CT_StockChart 

type CT_StockChart struct {
	Ser        []*CT_LineSer
	DLbls      *CT_DLbls
	DropLines  *CT_ChartLines
	HiLowLines *CT_ChartLines
	UpDownBars *CT_UpDownBars
	AxId       []*CT_UnsignedInt
	ExtLst     *CT_ExtensionList
}

func NewCT_StockChart 

func NewCT_StockChart() *CT_StockChart

func (*CT_StockChart) MarshalXML 

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

func (*CT_StockChart) UnmarshalXML 

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

func (*CT_StockChart) Validate 

func (m *CT_StockChart) Validate() error

Validate validates the CT_StockChart and its children

func (*CT_StockChart) ValidateWithPath 

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

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

type CT_StrData 

type CT_StrData struct {
	PtCount *CT_UnsignedInt
	Pt      []*CT_StrVal
	ExtLst  *CT_ExtensionList
}

func NewCT_StrData 

func NewCT_StrData() *CT_StrData

func (*CT_StrData) MarshalXML 

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

func (*CT_StrData) UnmarshalXML 

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

func (*CT_StrData) Validate 

func (m *CT_StrData) Validate() error

Validate validates the CT_StrData and its children

func (*CT_StrData) ValidateWithPath 

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

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

type CT_StrRef 

type CT_StrRef struct {
	F        string
	StrCache *CT_StrData
	ExtLst   *CT_ExtensionList
}

func NewCT_StrRef 

func NewCT_StrRef() *CT_StrRef

func (*CT_StrRef) MarshalXML 

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

func (*CT_StrRef) UnmarshalXML 

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

func (*CT_StrRef) Validate 

func (m *CT_StrRef) Validate() error

Validate validates the CT_StrRef and its children

func (*CT_StrRef) ValidateWithPath 

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

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

type CT_StrVal 

type CT_StrVal struct {
	IdxAttr uint32
	V       string
}

func NewCT_StrVal 

func NewCT_StrVal() *CT_StrVal

func (*CT_StrVal) MarshalXML 

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

func (*CT_StrVal) UnmarshalXML 

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

func (*CT_StrVal) Validate 

func (m *CT_StrVal) Validate() error

Validate validates the CT_StrVal and its children

func (*CT_StrVal) ValidateWithPath 

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

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

type CT_Style 

type CT_Style struct {
	ValAttr uint8
}

func NewCT_Style 

func NewCT_Style() *CT_Style

func (*CT_Style) MarshalXML 

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

func (*CT_Style) UnmarshalXML 

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

func (*CT_Style) Validate 

func (m *CT_Style) Validate() error

Validate validates the CT_Style and its children

func (*CT_Style) ValidateWithPath 

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

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

type CT_Surface 

type CT_Surface struct {
	Thickness      *CT_Thickness
	SpPr           *dml.CT_ShapeProperties
	PictureOptions *CT_PictureOptions
	ExtLst         *CT_ExtensionList
}

func NewCT_Surface 

func NewCT_Surface() *CT_Surface

func (*CT_Surface) MarshalXML 

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

func (*CT_Surface) UnmarshalXML 

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

func (*CT_Surface) Validate 

func (m *CT_Surface) Validate() error

Validate validates the CT_Surface and its children

func (*CT_Surface) ValidateWithPath 

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

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

type CT_Surface3DChart 

type CT_Surface3DChart struct {
	Wireframe *CT_Boolean
	Ser       []*CT_SurfaceSer
	BandFmts  *CT_BandFmts
	AxId      []*CT_UnsignedInt
	ExtLst    *CT_ExtensionList
}

func NewCT_Surface3DChart 

func NewCT_Surface3DChart() *CT_Surface3DChart

func (*CT_Surface3DChart) MarshalXML 

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

func (*CT_Surface3DChart) UnmarshalXML 

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

func (*CT_Surface3DChart) Validate 

func (m *CT_Surface3DChart) Validate() error

Validate validates the CT_Surface3DChart and its children

func (*CT_Surface3DChart) ValidateWithPath 

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

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

type CT_SurfaceChart 

type CT_SurfaceChart struct {
	Wireframe *CT_Boolean
	Ser       []*CT_SurfaceSer
	BandFmts  *CT_BandFmts
	AxId      []*CT_UnsignedInt
	ExtLst    *CT_ExtensionList
}

func NewCT_SurfaceChart 

func NewCT_SurfaceChart() *CT_SurfaceChart

func (*CT_SurfaceChart) MarshalXML 

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

func (*CT_SurfaceChart) UnmarshalXML 

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

func (*CT_SurfaceChart) Validate 

func (m *CT_SurfaceChart) Validate() error

Validate validates the CT_SurfaceChart and its children

func (*CT_SurfaceChart) ValidateWithPath 

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

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

type CT_SurfaceSer 

type CT_SurfaceSer struct {
	Idx    *CT_UnsignedInt
	Order  *CT_UnsignedInt
	Tx     *CT_SerTx
	SpPr   *dml.CT_ShapeProperties
	Cat    *CT_AxDataSource
	Val    *CT_NumDataSource
	ExtLst *CT_ExtensionList
}

func NewCT_SurfaceSer 

func NewCT_SurfaceSer() *CT_SurfaceSer

func (*CT_SurfaceSer) MarshalXML 

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

func (*CT_SurfaceSer) UnmarshalXML 

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

func (*CT_SurfaceSer) Validate 

func (m *CT_SurfaceSer) Validate() error

Validate validates the CT_SurfaceSer and its children

func (*CT_SurfaceSer) ValidateWithPath 

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

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

type CT_TextLanguageID 

type CT_TextLanguageID struct {
	ValAttr string
}

func NewCT_TextLanguageID 

func NewCT_TextLanguageID() *CT_TextLanguageID

func (*CT_TextLanguageID) MarshalXML 

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

func (*CT_TextLanguageID) UnmarshalXML 

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

func (*CT_TextLanguageID) Validate 

func (m *CT_TextLanguageID) Validate() error

Validate validates the CT_TextLanguageID and its children

func (*CT_TextLanguageID) ValidateWithPath 

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

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

type CT_Thickness 

type CT_Thickness struct {
	ValAttr ST_Thickness
}

func NewCT_Thickness 

func NewCT_Thickness() *CT_Thickness

func (*CT_Thickness) MarshalXML 

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

func (*CT_Thickness) UnmarshalXML 

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

func (*CT_Thickness) Validate 

func (m *CT_Thickness) Validate() error

Validate validates the CT_Thickness and its children

func (*CT_Thickness) ValidateWithPath 

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

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

type CT_TickLblPos 

type CT_TickLblPos struct {
	ValAttr ST_TickLblPos
}

func NewCT_TickLblPos 

func NewCT_TickLblPos() *CT_TickLblPos

func (*CT_TickLblPos) MarshalXML 

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

func (*CT_TickLblPos) UnmarshalXML 

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

func (*CT_TickLblPos) Validate 

func (m *CT_TickLblPos) Validate() error

Validate validates the CT_TickLblPos and its children

func (*CT_TickLblPos) ValidateWithPath 

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

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

type CT_TickMark 

type CT_TickMark struct {
	ValAttr ST_TickMark
}

func NewCT_TickMark 

func NewCT_TickMark() *CT_TickMark

func (*CT_TickMark) MarshalXML 

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

func (*CT_TickMark) UnmarshalXML 

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

func (*CT_TickMark) Validate 

func (m *CT_TickMark) Validate() error

Validate validates the CT_TickMark and its children

func (*CT_TickMark) ValidateWithPath 

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

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

type CT_TimeUnit 

type CT_TimeUnit struct {
	ValAttr ST_TimeUnit
}

func NewCT_TimeUnit 

func NewCT_TimeUnit() *CT_TimeUnit

func (*CT_TimeUnit) MarshalXML 

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

func (*CT_TimeUnit) UnmarshalXML 

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

func (*CT_TimeUnit) Validate 

func (m *CT_TimeUnit) Validate() error

Validate validates the CT_TimeUnit and its children

func (*CT_TimeUnit) ValidateWithPath 

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

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

type CT_Title 

type CT_Title struct {
	Tx      *CT_Tx
	Layout  *CT_Layout
	Overlay *CT_Boolean
	SpPr    *dml.CT_ShapeProperties
	TxPr    *dml.CT_TextBody
	ExtLst  *CT_ExtensionList
}

func NewCT_Title 

func NewCT_Title() *CT_Title

func (*CT_Title) MarshalXML 

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

func (*CT_Title) UnmarshalXML 

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

func (*CT_Title) Validate 

func (m *CT_Title) Validate() error

Validate validates the CT_Title and its children

func (*CT_Title) ValidateWithPath 

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

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

type CT_Trendline 

type CT_Trendline struct {
	Name          *string
	SpPr          *dml.CT_ShapeProperties
	TrendlineType *CT_TrendlineType
	Order         *CT_Order
	Period        *CT_Period
	Forward       *CT_Double
	Backward      *CT_Double
	Intercept     *CT_Double
	DispRSqr      *CT_Boolean
	DispEq        *CT_Boolean
	TrendlineLbl  *CT_TrendlineLbl
	ExtLst        *CT_ExtensionList
}

func NewCT_Trendline 

func NewCT_Trendline() *CT_Trendline

func (*CT_Trendline) MarshalXML 

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

func (*CT_Trendline) UnmarshalXML 

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

func (*CT_Trendline) Validate 

func (m *CT_Trendline) Validate() error

Validate validates the CT_Trendline and its children

func (*CT_Trendline) ValidateWithPath 

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

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

type CT_TrendlineLbl 

type CT_TrendlineLbl struct {
	Layout *CT_Layout
	Tx     *CT_Tx
	NumFmt *CT_NumFmt
	SpPr   *dml.CT_ShapeProperties
	TxPr   *dml.CT_TextBody
	ExtLst *CT_ExtensionList
}

func NewCT_TrendlineLbl 

func NewCT_TrendlineLbl() *CT_TrendlineLbl

func (*CT_TrendlineLbl) MarshalXML 

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

func (*CT_TrendlineLbl) UnmarshalXML 

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

func (*CT_TrendlineLbl) Validate 

func (m *CT_TrendlineLbl) Validate() error

Validate validates the CT_TrendlineLbl and its children

func (*CT_TrendlineLbl) ValidateWithPath 

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

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

type CT_TrendlineType 

type CT_TrendlineType struct {
	ValAttr ST_TrendlineType
}

func NewCT_TrendlineType 

func NewCT_TrendlineType() *CT_TrendlineType

func (*CT_TrendlineType) MarshalXML 

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

func (*CT_TrendlineType) UnmarshalXML 

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

func (*CT_TrendlineType) Validate 

func (m *CT_TrendlineType) Validate() error

Validate validates the CT_TrendlineType and its children

func (*CT_TrendlineType) ValidateWithPath 

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

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

type CT_Tx 

type CT_Tx struct {
	Choice *CT_TxChoice
}

func NewCT_Tx 

func NewCT_Tx() *CT_Tx

func (*CT_Tx) MarshalXML 

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

func (*CT_Tx) UnmarshalXML 

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

func (*CT_Tx) Validate 

func (m *CT_Tx) Validate() error

Validate validates the CT_Tx and its children

func (*CT_Tx) ValidateWithPath 

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

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

type CT_TxChoice 

type CT_TxChoice struct {
	StrRef *CT_StrRef
	Rich   *dml.CT_TextBody
}

func NewCT_TxChoice 

func NewCT_TxChoice() *CT_TxChoice

func (*CT_TxChoice) MarshalXML 

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

func (*CT_TxChoice) UnmarshalXML 

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

func (*CT_TxChoice) Validate 

func (m *CT_TxChoice) Validate() error

Validate validates the CT_TxChoice and its children

func (*CT_TxChoice) ValidateWithPath 

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

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

type CT_UnsignedInt 

type CT_UnsignedInt struct {
	ValAttr uint32
}

func NewCT_UnsignedInt 

func NewCT_UnsignedInt() *CT_UnsignedInt

func (*CT_UnsignedInt) MarshalXML 

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

func (*CT_UnsignedInt) UnmarshalXML 

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

func (*CT_UnsignedInt) Validate 

func (m *CT_UnsignedInt) Validate() error

Validate validates the CT_UnsignedInt and its children

func (*CT_UnsignedInt) ValidateWithPath 

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

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

type CT_UpDownBar 

type CT_UpDownBar struct {
	SpPr *dml.CT_ShapeProperties
}

func NewCT_UpDownBar 

func NewCT_UpDownBar() *CT_UpDownBar

func (*CT_UpDownBar) MarshalXML 

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

func (*CT_UpDownBar) UnmarshalXML 

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

func (*CT_UpDownBar) Validate 

func (m *CT_UpDownBar) Validate() error

Validate validates the CT_UpDownBar and its children

func (*CT_UpDownBar) ValidateWithPath 

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

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

type CT_UpDownBars 

type CT_UpDownBars struct {
	GapWidth *CT_GapAmount
	UpBars   *CT_UpDownBar
	DownBars *CT_UpDownBar
	ExtLst   *CT_ExtensionList
}

func NewCT_UpDownBars 

func NewCT_UpDownBars() *CT_UpDownBars

func (*CT_UpDownBars) MarshalXML 

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

func (*CT_UpDownBars) UnmarshalXML 

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

func (*CT_UpDownBars) Validate 

func (m *CT_UpDownBars) Validate() error

Validate validates the CT_UpDownBars and its children

func (*CT_UpDownBars) ValidateWithPath 

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

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

type CT_ValAx 

type CT_ValAx struct {
	AxId           *CT_UnsignedInt
	Scaling        *CT_Scaling
	Delete         *CT_Boolean
	AxPos          *CT_AxPos
	MajorGridlines *CT_ChartLines
	MinorGridlines *CT_ChartLines
	Title          *CT_Title
	NumFmt         *CT_NumFmt
	MajorTickMark  *CT_TickMark
	MinorTickMark  *CT_TickMark
	TickLblPos     *CT_TickLblPos
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	CrossAx        *CT_UnsignedInt
	Choice         *EG_AxSharedChoice
	CrossBetween   *CT_CrossBetween
	MajorUnit      *CT_AxisUnit
	MinorUnit      *CT_AxisUnit
	DispUnits      *CT_DispUnits
	ExtLst         *CT_ExtensionList
}

func NewCT_ValAx 

func NewCT_ValAx() *CT_ValAx

func (*CT_ValAx) MarshalXML 

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

func (*CT_ValAx) UnmarshalXML 

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

func (*CT_ValAx) Validate 

func (m *CT_ValAx) Validate() error

Validate validates the CT_ValAx and its children

func (*CT_ValAx) ValidateWithPath 

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

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

type CT_View3D 

type CT_View3D struct {
	RotX         *CT_RotX
	HPercent     *CT_HPercent
	RotY         *CT_RotY
	DepthPercent *CT_DepthPercent
	RAngAx       *CT_Boolean
	Perspective  *CT_Perspective
	ExtLst       *CT_ExtensionList
}

func NewCT_View3D 

func NewCT_View3D() *CT_View3D

func (*CT_View3D) MarshalXML 

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

func (*CT_View3D) UnmarshalXML 

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

func (*CT_View3D) Validate 

func (m *CT_View3D) Validate() error

Validate validates the CT_View3D and its children

func (*CT_View3D) ValidateWithPath 

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

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

type Chart 

type Chart struct {
	CT_RelId
}

func NewChart 

func NewChart() *Chart

func (*Chart) MarshalXML 

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

func (*Chart) UnmarshalXML 

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

func (*Chart) Validate 

func (m *Chart) Validate() error

Validate validates the Chart and its children

func (*Chart) ValidateWithPath 

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

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

type ChartSpace 

type ChartSpace struct {
	CT_ChartSpace
}

func NewChartSpace 

func NewChartSpace() *ChartSpace

func (*ChartSpace) MarshalXML 

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

func (*ChartSpace) UnmarshalXML 

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

func (*ChartSpace) Validate 

func (m *ChartSpace) Validate() error

Validate validates the ChartSpace and its children

func (*ChartSpace) ValidateWithPath 

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

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

type EG_AreaChartShared 

type EG_AreaChartShared struct {
	Grouping   *CT_Grouping
	VaryColors *CT_Boolean
	Ser        []*CT_AreaSer
	DLbls      *CT_DLbls
	DropLines  *CT_ChartLines
}

func NewEG_AreaChartShared 

func NewEG_AreaChartShared() *EG_AreaChartShared

func (*EG_AreaChartShared) MarshalXML 

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

func (*EG_AreaChartShared) UnmarshalXML 

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

func (*EG_AreaChartShared) Validate 

func (m *EG_AreaChartShared) Validate() error

Validate validates the EG_AreaChartShared and its children

func (*EG_AreaChartShared) ValidateWithPath 

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

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

type EG_AxShared 

type EG_AxShared struct {
	AxId           *CT_UnsignedInt
	Scaling        *CT_Scaling
	Delete         *CT_Boolean
	AxPos          *CT_AxPos
	MajorGridlines *CT_ChartLines
	MinorGridlines *CT_ChartLines
	Title          *CT_Title
	NumFmt         *CT_NumFmt
	MajorTickMark  *CT_TickMark
	MinorTickMark  *CT_TickMark
	TickLblPos     *CT_TickLblPos
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	CrossAx        *CT_UnsignedInt
	Choice         *EG_AxSharedChoice
}

func NewEG_AxShared 

func NewEG_AxShared() *EG_AxShared

func (*EG_AxShared) MarshalXML 

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

func (*EG_AxShared) UnmarshalXML 

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

func (*EG_AxShared) Validate 

func (m *EG_AxShared) Validate() error

Validate validates the EG_AxShared and its children

func (*EG_AxShared) ValidateWithPath 

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

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

type EG_AxSharedChoice 

type EG_AxSharedChoice struct {
	Crosses   *CT_Crosses
	CrossesAt *CT_Double
}

func NewEG_AxSharedChoice 

func NewEG_AxSharedChoice() *EG_AxSharedChoice

func (*EG_AxSharedChoice) MarshalXML 

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

func (*EG_AxSharedChoice) UnmarshalXML 

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

func (*EG_AxSharedChoice) Validate 

func (m *EG_AxSharedChoice) Validate() error

Validate validates the EG_AxSharedChoice and its children

func (*EG_AxSharedChoice) ValidateWithPath 

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

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

type EG_BarChartShared 

type EG_BarChartShared struct {
	BarDir     *CT_BarDir
	Grouping   *CT_BarGrouping
	VaryColors *CT_Boolean
	Ser        []*CT_BarSer
	DLbls      *CT_DLbls
}

func NewEG_BarChartShared 

func NewEG_BarChartShared() *EG_BarChartShared

func (*EG_BarChartShared) MarshalXML 

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

func (*EG_BarChartShared) UnmarshalXML 

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

func (*EG_BarChartShared) Validate 

func (m *EG_BarChartShared) Validate() error

Validate validates the EG_BarChartShared and its children

func (*EG_BarChartShared) ValidateWithPath 

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

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

type EG_DLblShared 

type EG_DLblShared struct {
	NumFmt         *CT_NumFmt
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	DLblPos        *CT_DLblPos
	ShowLegendKey  *CT_Boolean
	ShowVal        *CT_Boolean
	ShowCatName    *CT_Boolean
	ShowSerName    *CT_Boolean
	ShowPercent    *CT_Boolean
	ShowBubbleSize *CT_Boolean
	Separator      *string
}

func NewEG_DLblShared 

func NewEG_DLblShared() *EG_DLblShared

func (*EG_DLblShared) MarshalXML 

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

func (*EG_DLblShared) UnmarshalXML 

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

func (*EG_DLblShared) Validate 

func (m *EG_DLblShared) Validate() error

Validate validates the EG_DLblShared and its children

func (*EG_DLblShared) ValidateWithPath 

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

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

type EG_LegendEntryData 

type EG_LegendEntryData struct {
	TxPr *dml.CT_TextBody
}

func NewEG_LegendEntryData 

func NewEG_LegendEntryData() *EG_LegendEntryData

func (*EG_LegendEntryData) MarshalXML 

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

func (*EG_LegendEntryData) UnmarshalXML 

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

func (*EG_LegendEntryData) Validate 

func (m *EG_LegendEntryData) Validate() error

Validate validates the EG_LegendEntryData and its children

func (*EG_LegendEntryData) ValidateWithPath 

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

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

type EG_LineChartShared 

type EG_LineChartShared struct {
	Grouping   *CT_Grouping
	VaryColors *CT_Boolean
	Ser        []*CT_LineSer
	DLbls      *CT_DLbls
	DropLines  *CT_ChartLines
}

func NewEG_LineChartShared 

func NewEG_LineChartShared() *EG_LineChartShared

func (*EG_LineChartShared) MarshalXML 

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

func (*EG_LineChartShared) UnmarshalXML 

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

func (*EG_LineChartShared) Validate 

func (m *EG_LineChartShared) Validate() error

Validate validates the EG_LineChartShared and its children

func (*EG_LineChartShared) ValidateWithPath 

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

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

type EG_PieChartShared 

type EG_PieChartShared struct {
	VaryColors *CT_Boolean
	Ser        []*CT_PieSer
	DLbls      *CT_DLbls
}

func NewEG_PieChartShared 

func NewEG_PieChartShared() *EG_PieChartShared

func (*EG_PieChartShared) MarshalXML 

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

func (*EG_PieChartShared) UnmarshalXML 

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

func (*EG_PieChartShared) Validate 

func (m *EG_PieChartShared) Validate() error

Validate validates the EG_PieChartShared and its children

func (*EG_PieChartShared) ValidateWithPath 

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

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

type EG_SerShared 

type EG_SerShared struct {
	Idx   *CT_UnsignedInt
	Order *CT_UnsignedInt
	Tx    *CT_SerTx
	SpPr  *dml.CT_ShapeProperties
}

func NewEG_SerShared 

func NewEG_SerShared() *EG_SerShared

func (*EG_SerShared) MarshalXML 

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

func (*EG_SerShared) UnmarshalXML 

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

func (*EG_SerShared) Validate 

func (m *EG_SerShared) Validate() error

Validate validates the EG_SerShared and its children

func (*EG_SerShared) ValidateWithPath 

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

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

type EG_SurfaceChartShared 

type EG_SurfaceChartShared struct {
	Wireframe *CT_Boolean
	Ser       []*CT_SurfaceSer
	BandFmts  *CT_BandFmts
}

func NewEG_SurfaceChartShared 

func NewEG_SurfaceChartShared() *EG_SurfaceChartShared

func (*EG_SurfaceChartShared) MarshalXML 

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

func (*EG_SurfaceChartShared) UnmarshalXML 

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

func (*EG_SurfaceChartShared) Validate 

func (m *EG_SurfaceChartShared) Validate() error

Validate validates the EG_SurfaceChartShared and its children

func (*EG_SurfaceChartShared) ValidateWithPath 

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

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

type Group_DLbl 

type Group_DLbl struct {
	Layout         *CT_Layout
	Tx             *CT_Tx
	NumFmt         *CT_NumFmt
	SpPr           *dml.CT_ShapeProperties
	TxPr           *dml.CT_TextBody
	DLblPos        *CT_DLblPos
	ShowLegendKey  *CT_Boolean
	ShowVal        *CT_Boolean
	ShowCatName    *CT_Boolean
	ShowSerName    *CT_Boolean
	ShowPercent    *CT_Boolean
	ShowBubbleSize *CT_Boolean
	Separator      *string
}

func NewGroup_DLbl 

func NewGroup_DLbl() *Group_DLbl

func (*Group_DLbl) MarshalXML 

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

func (*Group_DLbl) UnmarshalXML 

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

func (*Group_DLbl) Validate 

func (m *Group_DLbl) Validate() error

Validate validates the Group_DLbl and its children

func (*Group_DLbl) ValidateWithPath 

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

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

type Group_DLbls 

type Group_DLbls struct {
	NumFmt          *CT_NumFmt
	SpPr            *dml.CT_ShapeProperties
	TxPr            *dml.CT_TextBody
	DLblPos         *CT_DLblPos
	ShowLegendKey   *CT_Boolean
	ShowVal         *CT_Boolean
	ShowCatName     *CT_Boolean
	ShowSerName     *CT_Boolean
	ShowPercent     *CT_Boolean
	ShowBubbleSize  *CT_Boolean
	Separator       *string
	ShowLeaderLines *CT_Boolean
	LeaderLines     *CT_ChartLines
}

func NewGroup_DLbls 

func NewGroup_DLbls() *Group_DLbls

func (*Group_DLbls) MarshalXML 

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

func (*Group_DLbls) UnmarshalXML 

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

func (*Group_DLbls) Validate 

func (m *Group_DLbls) Validate() error

Validate validates the Group_DLbls and its children

func (*Group_DLbls) ValidateWithPath 

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

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

type ST_AxPos 

type ST_AxPos byte
const (
	ST_AxPosUnset ST_AxPos = 0
	ST_AxPosB     ST_AxPos = 1
	ST_AxPosL     ST_AxPos = 2
	ST_AxPosR     ST_AxPos = 3
	ST_AxPosT     ST_AxPos = 4
)

func (ST_AxPos) MarshalXML 

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

func (ST_AxPos) MarshalXMLAttr 

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

func (ST_AxPos) String 

func (m ST_AxPos) String() string

func (*ST_AxPos) UnmarshalXML 

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

func (*ST_AxPos) UnmarshalXMLAttr 

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

func (ST_AxPos) Validate 

func (m ST_AxPos) Validate() error

func (ST_AxPos) ValidateWithPath 

func (m ST_AxPos) ValidateWithPath(path string) error

type ST_BarDir 

type ST_BarDir byte
const (
	ST_BarDirUnset ST_BarDir = 0
	ST_BarDirBar   ST_BarDir = 1
	ST_BarDirCol   ST_BarDir = 2
)

func (ST_BarDir) MarshalXML 

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

func (ST_BarDir) MarshalXMLAttr 

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

func (ST_BarDir) String 

func (m ST_BarDir) String() string

func (*ST_BarDir) UnmarshalXML 

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

func (*ST_BarDir) UnmarshalXMLAttr 

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

func (ST_BarDir) Validate 

func (m ST_BarDir) Validate() error

func (ST_BarDir) ValidateWithPath 

func (m ST_BarDir) ValidateWithPath(path string) error

type ST_BarGrouping 

type ST_BarGrouping byte
const (
	ST_BarGroupingUnset          ST_BarGrouping = 0
	ST_BarGroupingPercentStacked ST_BarGrouping = 1
	ST_BarGroupingClustered      ST_BarGrouping = 2
	ST_BarGroupingStandard       ST_BarGrouping = 3
	ST_BarGroupingStacked        ST_BarGrouping = 4
)

func (ST_BarGrouping) MarshalXML 

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

func (ST_BarGrouping) MarshalXMLAttr 

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

func (ST_BarGrouping) String 

func (m ST_BarGrouping) String() string

func (*ST_BarGrouping) UnmarshalXML 

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

func (*ST_BarGrouping) UnmarshalXMLAttr 

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

func (ST_BarGrouping) Validate 

func (m ST_BarGrouping) Validate() error

func (ST_BarGrouping) ValidateWithPath 

func (m ST_BarGrouping) ValidateWithPath(path string) error

type ST_BubbleScale 

type ST_BubbleScale struct {
	ST_BubbleScalePercent *string
	ST_BubbleScaleUInt    *uint32
}

ST_BubbleScale is a union type

func ParseUnionST_BubbleScale 

func ParseUnionST_BubbleScale(s string) (ST_BubbleScale, error)

func (ST_BubbleScale) MarshalXML 

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

func (ST_BubbleScale) String 

func (m ST_BubbleScale) String() string

func (*ST_BubbleScale) Validate 

func (m *ST_BubbleScale) Validate() error

func (*ST_BubbleScale) ValidateWithPath 

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

type ST_BuiltInUnit 

type ST_BuiltInUnit byte
const (
	ST_BuiltInUnitUnset            ST_BuiltInUnit = 0
	ST_BuiltInUnitHundreds         ST_BuiltInUnit = 1
	ST_BuiltInUnitThousands        ST_BuiltInUnit = 2
	ST_BuiltInUnitTenThousands     ST_BuiltInUnit = 3
	ST_BuiltInUnitHundredThousands ST_BuiltInUnit = 4
	ST_BuiltInUnitMillions         ST_BuiltInUnit = 5
	ST_BuiltInUnitTenMillions      ST_BuiltInUnit = 6
	ST_BuiltInUnitHundredMillions  ST_BuiltInUnit = 7
	ST_BuiltInUnitBillions         ST_BuiltInUnit = 8
	ST_BuiltInUnitTrillions        ST_BuiltInUnit = 9
)

func (ST_BuiltInUnit) MarshalXML 

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

func (ST_BuiltInUnit) MarshalXMLAttr 

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

func (ST_BuiltInUnit) String 

func (m ST_BuiltInUnit) String() string

func (*ST_BuiltInUnit) UnmarshalXML 

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

func (*ST_BuiltInUnit) UnmarshalXMLAttr 

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

func (ST_BuiltInUnit) Validate 

func (m ST_BuiltInUnit) Validate() error

func (ST_BuiltInUnit) ValidateWithPath 

func (m ST_BuiltInUnit) ValidateWithPath(path string) error

type ST_CrossBetween 

type ST_CrossBetween byte
const (
	ST_CrossBetweenUnset   ST_CrossBetween = 0
	ST_CrossBetweenBetween ST_CrossBetween = 1
	ST_CrossBetweenMidCat  ST_CrossBetween = 2
)

func (ST_CrossBetween) MarshalXML 

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

func (ST_CrossBetween) MarshalXMLAttr 

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

func (ST_CrossBetween) String 

func (m ST_CrossBetween) String() string

func (*ST_CrossBetween) UnmarshalXML 

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

func (*ST_CrossBetween) UnmarshalXMLAttr 

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

func (ST_CrossBetween) Validate 

func (m ST_CrossBetween) Validate() error

func (ST_CrossBetween) ValidateWithPath 

func (m ST_CrossBetween) ValidateWithPath(path string) error

type ST_Crosses 

type ST_Crosses byte
const (
	ST_CrossesUnset    ST_Crosses = 0
	ST_CrossesAutoZero ST_Crosses = 1
	ST_CrossesMax      ST_Crosses = 2
	ST_CrossesMin      ST_Crosses = 3
)

func (ST_Crosses) MarshalXML 

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

func (ST_Crosses) MarshalXMLAttr 

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

func (ST_Crosses) String 

func (m ST_Crosses) String() string

func (*ST_Crosses) UnmarshalXML 

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

func (*ST_Crosses) UnmarshalXMLAttr 

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

func (ST_Crosses) Validate 

func (m ST_Crosses) Validate() error

func (ST_Crosses) ValidateWithPath 

func (m ST_Crosses) ValidateWithPath(path string) error

type ST_DLblPos 

type ST_DLblPos byte
const (
	ST_DLblPosUnset   ST_DLblPos = 0
	ST_DLblPosBestFit ST_DLblPos = 1
	ST_DLblPosB       ST_DLblPos = 2
	ST_DLblPosCtr     ST_DLblPos = 3
	ST_DLblPosInBase  ST_DLblPos = 4
	ST_DLblPosInEnd   ST_DLblPos = 5
	ST_DLblPosL       ST_DLblPos = 6
	ST_DLblPosOutEnd  ST_DLblPos = 7
	ST_DLblPosR       ST_DLblPos = 8
	ST_DLblPosT       ST_DLblPos = 9
)

func (ST_DLblPos) MarshalXML 

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

func (ST_DLblPos) MarshalXMLAttr 

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

func (ST_DLblPos) String 

func (m ST_DLblPos) String() string

func (*ST_DLblPos) UnmarshalXML 

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

func (*ST_DLblPos) UnmarshalXMLAttr 

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

func (ST_DLblPos) Validate 

func (m ST_DLblPos) Validate() error

func (ST_DLblPos) ValidateWithPath 

func (m ST_DLblPos) ValidateWithPath(path string) error

type ST_DepthPercent 

type ST_DepthPercent struct {
	ST_DepthPercentWithSymbol *string
	ST_DepthPercentUShort     *uint16
}

ST_DepthPercent is a union type

func ParseUnionST_DepthPercent 

func ParseUnionST_DepthPercent(s string) (ST_DepthPercent, error)

func (ST_DepthPercent) MarshalXML 

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

func (ST_DepthPercent) String 

func (m ST_DepthPercent) String() string

func (*ST_DepthPercent) Validate 

func (m *ST_DepthPercent) Validate() error

func (*ST_DepthPercent) ValidateWithPath 

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

type ST_DispBlanksAs 

type ST_DispBlanksAs byte
const (
	ST_DispBlanksAsUnset ST_DispBlanksAs = 0
	ST_DispBlanksAsSpan  ST_DispBlanksAs = 1
	ST_DispBlanksAsGap   ST_DispBlanksAs = 2
	ST_DispBlanksAsZero  ST_DispBlanksAs = 3
)

func (ST_DispBlanksAs) MarshalXML 

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

func (ST_DispBlanksAs) MarshalXMLAttr 

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

func (ST_DispBlanksAs) String 

func (m ST_DispBlanksAs) String() string

func (*ST_DispBlanksAs) UnmarshalXML 

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

func (*ST_DispBlanksAs) UnmarshalXMLAttr 

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

func (ST_DispBlanksAs) Validate 

func (m ST_DispBlanksAs) Validate() error

func (ST_DispBlanksAs) ValidateWithPath 

func (m ST_DispBlanksAs) ValidateWithPath(path string) error

type ST_ErrBarType 

type ST_ErrBarType byte
const (
	ST_ErrBarTypeUnset ST_ErrBarType = 0
	ST_ErrBarTypeBoth  ST_ErrBarType = 1
	ST_ErrBarTypeMinus ST_ErrBarType = 2
	ST_ErrBarTypePlus  ST_ErrBarType = 3
)

func (ST_ErrBarType) MarshalXML 

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

func (ST_ErrBarType) MarshalXMLAttr 

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

func (ST_ErrBarType) String 

func (m ST_ErrBarType) String() string

func (*ST_ErrBarType) UnmarshalXML 

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

func (*ST_ErrBarType) UnmarshalXMLAttr 

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

func (ST_ErrBarType) Validate 

func (m ST_ErrBarType) Validate() error

func (ST_ErrBarType) ValidateWithPath 

func (m ST_ErrBarType) ValidateWithPath(path string) error

type ST_ErrDir 

type ST_ErrDir byte
const (
	ST_ErrDirUnset ST_ErrDir = 0
	ST_ErrDirX     ST_ErrDir = 1
	ST_ErrDirY     ST_ErrDir = 2
)

func (ST_ErrDir) MarshalXML 

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

func (ST_ErrDir) MarshalXMLAttr 

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

func (ST_ErrDir) String 

func (m ST_ErrDir) String() string

func (*ST_ErrDir) UnmarshalXML 

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

func (*ST_ErrDir) UnmarshalXMLAttr 

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

func (ST_ErrDir) Validate 

func (m ST_ErrDir) Validate() error

func (ST_ErrDir) ValidateWithPath 

func (m ST_ErrDir) ValidateWithPath(path string) error

type ST_ErrValType 

type ST_ErrValType byte
const (
	ST_ErrValTypeUnset      ST_ErrValType = 0
	ST_ErrValTypeCust       ST_ErrValType = 1
	ST_ErrValTypeFixedVal   ST_ErrValType = 2
	ST_ErrValTypePercentage ST_ErrValType = 3
	ST_ErrValTypeStdDev     ST_ErrValType = 4
	ST_ErrValTypeStdErr     ST_ErrValType = 5
)

func (ST_ErrValType) MarshalXML 

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

func (ST_ErrValType) MarshalXMLAttr 

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

func (ST_ErrValType) String 

func (m ST_ErrValType) String() string

func (*ST_ErrValType) UnmarshalXML 

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

func (*ST_ErrValType) UnmarshalXMLAttr 

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

func (ST_ErrValType) Validate 

func (m ST_ErrValType) Validate() error

func (ST_ErrValType) ValidateWithPath 

func (m ST_ErrValType) ValidateWithPath(path string) error

type ST_GapAmount 

type ST_GapAmount struct {
	ST_GapAmountPercent *string
	ST_GapAmountUShort  *uint16
}

ST_GapAmount is a union type

func ParseUnionST_GapAmount 

func ParseUnionST_GapAmount(s string) (ST_GapAmount, error)

func (ST_GapAmount) MarshalXML 

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

func (ST_GapAmount) String 

func (m ST_GapAmount) String() string

func (*ST_GapAmount) Validate 

func (m *ST_GapAmount) Validate() error

func (*ST_GapAmount) ValidateWithPath 

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

type ST_Grouping 

type ST_Grouping byte
const (
	ST_GroupingUnset          ST_Grouping = 0
	ST_GroupingPercentStacked ST_Grouping = 1
	ST_GroupingStandard       ST_Grouping = 2
	ST_GroupingStacked        ST_Grouping = 3
)

func (ST_Grouping) MarshalXML 

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

func (ST_Grouping) MarshalXMLAttr 

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

func (ST_Grouping) String 

func (m ST_Grouping) String() string

func (*ST_Grouping) UnmarshalXML 

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

func (*ST_Grouping) UnmarshalXMLAttr 

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

func (ST_Grouping) Validate 

func (m ST_Grouping) Validate() error

func (ST_Grouping) ValidateWithPath 

func (m ST_Grouping) ValidateWithPath(path string) error

type ST_HPercent 

type ST_HPercent struct {
	ST_HPercentWithSymbol *string
	ST_HPercentUShort     *uint16
}

ST_HPercent is a union type

func ParseUnionST_HPercent 

func ParseUnionST_HPercent(s string) (ST_HPercent, error)

func (ST_HPercent) MarshalXML 

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

func (ST_HPercent) String 

func (m ST_HPercent) String() string

func (*ST_HPercent) Validate 

func (m *ST_HPercent) Validate() error

func (*ST_HPercent) ValidateWithPath 

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

type ST_HoleSize 

type ST_HoleSize struct {
	ST_HoleSizePercent *string
	ST_HoleSizeUByte   *uint8
}

ST_HoleSize is a union type

func ParseUnionST_HoleSize 

func ParseUnionST_HoleSize(s string) (ST_HoleSize, error)

func (ST_HoleSize) MarshalXML 

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

func (ST_HoleSize) String 

func (m ST_HoleSize) String() string

func (*ST_HoleSize) Validate 

func (m *ST_HoleSize) Validate() error

func (*ST_HoleSize) ValidateWithPath 

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

type ST_LayoutMode 

type ST_LayoutMode byte
const (
	ST_LayoutModeUnset  ST_LayoutMode = 0
	ST_LayoutModeEdge   ST_LayoutMode = 1
	ST_LayoutModeFactor ST_LayoutMode = 2
)

func (ST_LayoutMode) MarshalXML 

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

func (ST_LayoutMode) MarshalXMLAttr 

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

func (ST_LayoutMode) String 

func (m ST_LayoutMode) String() string

func (*ST_LayoutMode) UnmarshalXML 

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

func (*ST_LayoutMode) UnmarshalXMLAttr 

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

func (ST_LayoutMode) Validate 

func (m ST_LayoutMode) Validate() error

func (ST_LayoutMode) ValidateWithPath 

func (m ST_LayoutMode) ValidateWithPath(path string) error

type ST_LayoutTarget 

type ST_LayoutTarget byte
const (
	ST_LayoutTargetUnset ST_LayoutTarget = 0
	ST_LayoutTargetInner ST_LayoutTarget = 1
	ST_LayoutTargetOuter ST_LayoutTarget = 2
)

func (ST_LayoutTarget) MarshalXML 

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

func (ST_LayoutTarget) MarshalXMLAttr 

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

func (ST_LayoutTarget) String 

func (m ST_LayoutTarget) String() string

func (*ST_LayoutTarget) UnmarshalXML 

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

func (*ST_LayoutTarget) UnmarshalXMLAttr 

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

func (ST_LayoutTarget) Validate 

func (m ST_LayoutTarget) Validate() error

func (ST_LayoutTarget) ValidateWithPath 

func (m ST_LayoutTarget) ValidateWithPath(path string) error

type ST_LblAlgn 

type ST_LblAlgn byte
const (
	ST_LblAlgnUnset ST_LblAlgn = 0
	ST_LblAlgnCtr   ST_LblAlgn = 1
	ST_LblAlgnL     ST_LblAlgn = 2
	ST_LblAlgnR     ST_LblAlgn = 3
)

func (ST_LblAlgn) MarshalXML 

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

func (ST_LblAlgn) MarshalXMLAttr 

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

func (ST_LblAlgn) String 

func (m ST_LblAlgn) String() string

func (*ST_LblAlgn) UnmarshalXML 

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

func (*ST_LblAlgn) UnmarshalXMLAttr 

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

func (ST_LblAlgn) Validate 

func (m ST_LblAlgn) Validate() error

func (ST_LblAlgn) ValidateWithPath 

func (m ST_LblAlgn) ValidateWithPath(path string) error

type ST_LblOffset 

type ST_LblOffset struct {
	ST_LblOffsetPercent *string
	ST_LblOffsetUShort  *uint16
}

ST_LblOffset is a union type

func ParseUnionST_LblOffset 

func ParseUnionST_LblOffset(s string) (ST_LblOffset, error)

func (ST_LblOffset) MarshalXML 

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

func (ST_LblOffset) String 

func (m ST_LblOffset) String() string

func (*ST_LblOffset) Validate 

func (m *ST_LblOffset) Validate() error

func (*ST_LblOffset) ValidateWithPath 

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

type ST_LegendPos 

type ST_LegendPos byte
const (
	ST_LegendPosUnset ST_LegendPos = 0
	ST_LegendPosB     ST_LegendPos = 1
	ST_LegendPosTr    ST_LegendPos = 2
	ST_LegendPosL     ST_LegendPos = 3
	ST_LegendPosR     ST_LegendPos = 4
	ST_LegendPosT     ST_LegendPos = 5
)

func (ST_LegendPos) MarshalXML 

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

func (ST_LegendPos) MarshalXMLAttr 

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

func (ST_LegendPos) String 

func (m ST_LegendPos) String() string

func (*ST_LegendPos) UnmarshalXML 

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

func (*ST_LegendPos) UnmarshalXMLAttr 

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

func (ST_LegendPos) Validate 

func (m ST_LegendPos) Validate() error

func (ST_LegendPos) ValidateWithPath 

func (m ST_LegendPos) ValidateWithPath(path string) error

type ST_MarkerStyle 

type ST_MarkerStyle byte
const (
	ST_MarkerStyleUnset    ST_MarkerStyle = 0
	ST_MarkerStyleCircle   ST_MarkerStyle = 1
	ST_MarkerStyleDash     ST_MarkerStyle = 2
	ST_MarkerStyleDiamond  ST_MarkerStyle = 3
	ST_MarkerStyleDot      ST_MarkerStyle = 4
	ST_MarkerStyleNone     ST_MarkerStyle = 5
	ST_MarkerStylePicture  ST_MarkerStyle = 6
	ST_MarkerStylePlus     ST_MarkerStyle = 7
	ST_MarkerStyleSquare   ST_MarkerStyle = 8
	ST_MarkerStyleStar     ST_MarkerStyle = 9
	ST_MarkerStyleTriangle ST_MarkerStyle = 10
	ST_MarkerStyleX        ST_MarkerStyle = 11
	ST_MarkerStyleAuto     ST_MarkerStyle = 12
)

func (ST_MarkerStyle) MarshalXML 

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

func (ST_MarkerStyle) MarshalXMLAttr 

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

func (ST_MarkerStyle) String 

func (m ST_MarkerStyle) String() string

func (*ST_MarkerStyle) UnmarshalXML 

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

func (*ST_MarkerStyle) UnmarshalXMLAttr 

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

func (ST_MarkerStyle) Validate 

func (m ST_MarkerStyle) Validate() error

func (ST_MarkerStyle) ValidateWithPath 

func (m ST_MarkerStyle) ValidateWithPath(path string) error

type ST_OfPieType 

type ST_OfPieType byte
const (
	ST_OfPieTypeUnset ST_OfPieType = 0
	ST_OfPieTypePie   ST_OfPieType = 1
	ST_OfPieTypeBar   ST_OfPieType = 2
)

func (ST_OfPieType) MarshalXML 

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

func (ST_OfPieType) MarshalXMLAttr 

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

func (ST_OfPieType) String 

func (m ST_OfPieType) String() string

func (*ST_OfPieType) UnmarshalXML 

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

func (*ST_OfPieType) UnmarshalXMLAttr 

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

func (ST_OfPieType) Validate 

func (m ST_OfPieType) Validate() error

func (ST_OfPieType) ValidateWithPath 

func (m ST_OfPieType) ValidateWithPath(path string) error

type ST_Orientation 

type ST_Orientation byte
const (
	ST_OrientationUnset  ST_Orientation = 0
	ST_OrientationMaxMin ST_Orientation = 1
	ST_OrientationMinMax ST_Orientation = 2
)

func (ST_Orientation) MarshalXML 

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

func (ST_Orientation) MarshalXMLAttr 

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

func (ST_Orientation) String 

func (m ST_Orientation) String() string

func (*ST_Orientation) UnmarshalXML 

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

func (*ST_Orientation) UnmarshalXMLAttr 

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

func (ST_Orientation) Validate 

func (m ST_Orientation) Validate() error

func (ST_Orientation) ValidateWithPath 

func (m ST_Orientation) ValidateWithPath(path string) error

type ST_Overlap 

type ST_Overlap struct {
	ST_OverlapPercent *string
	ST_OverlapByte    *int8
}

ST_Overlap is a union type

func ParseUnionST_Overlap 

func ParseUnionST_Overlap(s string) (ST_Overlap, error)

func (ST_Overlap) MarshalXML 

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

func (ST_Overlap) String 

func (m ST_Overlap) String() string

func (*ST_Overlap) Validate 

func (m *ST_Overlap) Validate() error

func (*ST_Overlap) ValidateWithPath 

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

type ST_PageSetupOrientation 

type ST_PageSetupOrientation byte
const (
	ST_PageSetupOrientationUnset     ST_PageSetupOrientation = 0
	ST_PageSetupOrientationDefault   ST_PageSetupOrientation = 1
	ST_PageSetupOrientationPortrait  ST_PageSetupOrientation = 2
	ST_PageSetupOrientationLandscape ST_PageSetupOrientation = 3
)

func (ST_PageSetupOrientation) MarshalXML 

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

func (ST_PageSetupOrientation) MarshalXMLAttr 

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

func (ST_PageSetupOrientation) String 

func (m ST_PageSetupOrientation) String() string

func (*ST_PageSetupOrientation) UnmarshalXML 

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

func (*ST_PageSetupOrientation) UnmarshalXMLAttr 

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

func (ST_PageSetupOrientation) Validate 

func (m ST_PageSetupOrientation) Validate() error

func (ST_PageSetupOrientation) ValidateWithPath 

func (m ST_PageSetupOrientation) ValidateWithPath(path string) error

type ST_PictureFormat 

type ST_PictureFormat byte
const (
	ST_PictureFormatUnset      ST_PictureFormat = 0
	ST_PictureFormatStretch    ST_PictureFormat = 1
	ST_PictureFormatStack      ST_PictureFormat = 2
	ST_PictureFormatStackScale ST_PictureFormat = 3
)

func (ST_PictureFormat) MarshalXML 

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

func (ST_PictureFormat) MarshalXMLAttr 

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

func (ST_PictureFormat) String 

func (m ST_PictureFormat) String() string

func (*ST_PictureFormat) UnmarshalXML 

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

func (*ST_PictureFormat) UnmarshalXMLAttr 

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

func (ST_PictureFormat) Validate 

func (m ST_PictureFormat) Validate() error

func (ST_PictureFormat) ValidateWithPath 

func (m ST_PictureFormat) ValidateWithPath(path string) error

type ST_RadarStyle 

type ST_RadarStyle byte
const (
	ST_RadarStyleUnset    ST_RadarStyle = 0
	ST_RadarStyleStandard ST_RadarStyle = 1
	ST_RadarStyleMarker   ST_RadarStyle = 2
	ST_RadarStyleFilled   ST_RadarStyle = 3
)

func (ST_RadarStyle) MarshalXML 

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

func (ST_RadarStyle) MarshalXMLAttr 

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

func (ST_RadarStyle) String 

func (m ST_RadarStyle) String() string

func (*ST_RadarStyle) UnmarshalXML 

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

func (*ST_RadarStyle) UnmarshalXMLAttr 

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

func (ST_RadarStyle) Validate 

func (m ST_RadarStyle) Validate() error

func (ST_RadarStyle) ValidateWithPath 

func (m ST_RadarStyle) ValidateWithPath(path string) error

type ST_ScatterStyle 

type ST_ScatterStyle byte
const (
	ST_ScatterStyleUnset        ST_ScatterStyle = 0
	ST_ScatterStyleNone         ST_ScatterStyle = 1
	ST_ScatterStyleLine         ST_ScatterStyle = 2
	ST_ScatterStyleLineMarker   ST_ScatterStyle = 3
	ST_ScatterStyleMarker       ST_ScatterStyle = 4
	ST_ScatterStyleSmooth       ST_ScatterStyle = 5
	ST_ScatterStyleSmoothMarker ST_ScatterStyle = 6
)

func (ST_ScatterStyle) MarshalXML 

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

func (ST_ScatterStyle) MarshalXMLAttr 

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

func (ST_ScatterStyle) String 

func (m ST_ScatterStyle) String() string

func (*ST_ScatterStyle) UnmarshalXML 

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

func (*ST_ScatterStyle) UnmarshalXMLAttr 

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

func (ST_ScatterStyle) Validate 

func (m ST_ScatterStyle) Validate() error

func (ST_ScatterStyle) ValidateWithPath 

func (m ST_ScatterStyle) ValidateWithPath(path string) error

type ST_SecondPieSize 

type ST_SecondPieSize struct {
	ST_SecondPieSizePercent *string
	ST_SecondPieSizeUShort  *uint16
}

ST_SecondPieSize is a union type

func ParseUnionST_SecondPieSize 

func ParseUnionST_SecondPieSize(s string) (ST_SecondPieSize, error)

func (ST_SecondPieSize) MarshalXML 

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

func (ST_SecondPieSize) String 

func (m ST_SecondPieSize) String() string

func (*ST_SecondPieSize) Validate 

func (m *ST_SecondPieSize) Validate() error

func (*ST_SecondPieSize) ValidateWithPath 

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

type ST_Shape 

type ST_Shape byte
const (
	ST_ShapeUnset        ST_Shape = 0
	ST_ShapeCone         ST_Shape = 1
	ST_ShapeConeToMax    ST_Shape = 2
	ST_ShapeBox          ST_Shape = 3
	ST_ShapeCylinder     ST_Shape = 4
	ST_ShapePyramid      ST_Shape = 5
	ST_ShapePyramidToMax ST_Shape = 6
)

func (ST_Shape) MarshalXML 

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

func (ST_Shape) MarshalXMLAttr 

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

func (ST_Shape) String 

func (m ST_Shape) String() string

func (*ST_Shape) UnmarshalXML 

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

func (*ST_Shape) UnmarshalXMLAttr 

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

func (ST_Shape) Validate 

func (m ST_Shape) Validate() error

func (ST_Shape) ValidateWithPath 

func (m ST_Shape) ValidateWithPath(path string) error

type ST_SizeRepresents 

type ST_SizeRepresents byte
const (
	ST_SizeRepresentsUnset ST_SizeRepresents = 0
	ST_SizeRepresentsArea  ST_SizeRepresents = 1
	ST_SizeRepresentsW     ST_SizeRepresents = 2
)

func (ST_SizeRepresents) MarshalXML 

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

func (ST_SizeRepresents) MarshalXMLAttr 

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

func (ST_SizeRepresents) String 

func (m ST_SizeRepresents) String() string

func (*ST_SizeRepresents) UnmarshalXML 

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

func (*ST_SizeRepresents) UnmarshalXMLAttr 

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

func (ST_SizeRepresents) Validate 

func (m ST_SizeRepresents) Validate() error

func (ST_SizeRepresents) ValidateWithPath 

func (m ST_SizeRepresents) ValidateWithPath(path string) error

type ST_SplitType 

type ST_SplitType byte
const (
	ST_SplitTypeUnset   ST_SplitType = 0
	ST_SplitTypeAuto    ST_SplitType = 1
	ST_SplitTypeCust    ST_SplitType = 2
	ST_SplitTypePercent ST_SplitType = 3
	ST_SplitTypePos     ST_SplitType = 4
	ST_SplitTypeVal     ST_SplitType = 5
)

func (ST_SplitType) MarshalXML 

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

func (ST_SplitType) MarshalXMLAttr 

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

func (ST_SplitType) String 

func (m ST_SplitType) String() string

func (*ST_SplitType) UnmarshalXML 

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

func (*ST_SplitType) UnmarshalXMLAttr 

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

func (ST_SplitType) Validate 

func (m ST_SplitType) Validate() error

func (ST_SplitType) ValidateWithPath 

func (m ST_SplitType) ValidateWithPath(path string) error

type ST_Thickness 

type ST_Thickness struct {
	ST_ThicknessPercent *string
	Uint32              *uint32
}

ST_Thickness is a union type

func ParseUnionST_Thickness 

func ParseUnionST_Thickness(s string) (ST_Thickness, error)

func (ST_Thickness) MarshalXML 

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

func (ST_Thickness) String 

func (m ST_Thickness) String() string

func (*ST_Thickness) Validate 

func (m *ST_Thickness) Validate() error

func (*ST_Thickness) ValidateWithPath 

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

type ST_TickLblPos 

type ST_TickLblPos byte
const (
	ST_TickLblPosUnset  ST_TickLblPos = 0
	ST_TickLblPosHigh   ST_TickLblPos = 1
	ST_TickLblPosLow    ST_TickLblPos = 2
	ST_TickLblPosNextTo ST_TickLblPos = 3
	ST_TickLblPosNone   ST_TickLblPos = 4
)

func (ST_TickLblPos) MarshalXML 

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

func (ST_TickLblPos) MarshalXMLAttr 

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

func (ST_TickLblPos) String 

func (m ST_TickLblPos) String() string

func (*ST_TickLblPos) UnmarshalXML 

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

func (*ST_TickLblPos) UnmarshalXMLAttr 

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

func (ST_TickLblPos) Validate 

func (m ST_TickLblPos) Validate() error

func (ST_TickLblPos) ValidateWithPath 

func (m ST_TickLblPos) ValidateWithPath(path string) error

type ST_TickMark 

type ST_TickMark byte
const (
	ST_TickMarkUnset ST_TickMark = 0
	ST_TickMarkCross ST_TickMark = 1
	ST_TickMarkIn    ST_TickMark = 2
	ST_TickMarkNone  ST_TickMark = 3
	ST_TickMarkOut   ST_TickMark = 4
)

func (ST_TickMark) MarshalXML 

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

func (ST_TickMark) MarshalXMLAttr 

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

func (ST_TickMark) String 

func (m ST_TickMark) String() string

func (*ST_TickMark) UnmarshalXML 

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

func (*ST_TickMark) UnmarshalXMLAttr 

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

func (ST_TickMark) Validate 

func (m ST_TickMark) Validate() error

func (ST_TickMark) ValidateWithPath 

func (m ST_TickMark) ValidateWithPath(path string) error

type ST_TimeUnit 

type ST_TimeUnit byte
const (
	ST_TimeUnitUnset  ST_TimeUnit = 0
	ST_TimeUnitDays   ST_TimeUnit = 1
	ST_TimeUnitMonths ST_TimeUnit = 2
	ST_TimeUnitYears  ST_TimeUnit = 3
)

func (ST_TimeUnit) MarshalXML 

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

func (ST_TimeUnit) MarshalXMLAttr 

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

func (ST_TimeUnit) String 

func (m ST_TimeUnit) String() string

func (*ST_TimeUnit) UnmarshalXML 

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

func (*ST_TimeUnit) UnmarshalXMLAttr 

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

func (ST_TimeUnit) Validate 

func (m ST_TimeUnit) Validate() error

func (ST_TimeUnit) ValidateWithPath 

func (m ST_TimeUnit) ValidateWithPath(path string) error

type ST_TrendlineType 

type ST_TrendlineType byte
const (
	ST_TrendlineTypeUnset     ST_TrendlineType = 0
	ST_TrendlineTypeExp       ST_TrendlineType = 1
	ST_TrendlineTypeLinear    ST_TrendlineType = 2
	ST_TrendlineTypeLog       ST_TrendlineType = 3
	ST_TrendlineTypeMovingAvg ST_TrendlineType = 4
	ST_TrendlineTypePoly      ST_TrendlineType = 5
	ST_TrendlineTypePower     ST_TrendlineType = 6
)

func (ST_TrendlineType) MarshalXML 

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

func (ST_TrendlineType) MarshalXMLAttr 

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

func (ST_TrendlineType) String 

func (m ST_TrendlineType) String() string

func (*ST_TrendlineType) UnmarshalXML 

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

func (*ST_TrendlineType) UnmarshalXMLAttr 

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

func (ST_TrendlineType) Validate 

func (m ST_TrendlineType) Validate() error

func (ST_TrendlineType) ValidateWithPath 

func (m ST_TrendlineType) ValidateWithPath(path string) error

type UserShapes 

type UserShapes struct {
	chartDrawing.CT_Drawing
}

func NewUserShapes 

func NewUserShapes() *UserShapes

func (*UserShapes) MarshalXML 

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

func (*UserShapes) UnmarshalXML 

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

func (*UserShapes) Validate 

func (m *UserShapes) Validate() error

Validate validates the UserShapes and its children

func (*UserShapes) ValidateWithPath 

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

ValidateWithPath validates the UserShapes 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.