chart

package
v0.6.0 Latest Latest
Warning

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

Go to latest
Published: Feb 6, 2018 License: AGPL-3.0 Imports: 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

Jump to

Keyboard shortcuts

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