...
Documentation
Documentation

# Package math

## Overview ▹

## Overview ▾

## Index ▹

## Index ▾

### Package files

CT_Acc.go CT_AccPr.go CT_Bar.go CT_BarPr.go CT_BorderBox.go CT_BorderBoxPr.go CT_Box.go CT_BoxPr.go CT_BreakBin.go CT_BreakBinSub.go CT_Char.go CT_CtrlPr.go CT_D.go CT_DPr.go CT_EqArr.go CT_EqArrPr.go CT_F.go CT_FPr.go CT_FType.go CT_Func.go CT_FuncPr.go CT_GroupChr.go CT_GroupChrPr.go CT_Integer2.go CT_Integer255.go CT_LimLoc.go CT_LimLow.go CT_LimLowPr.go CT_LimUpp.go CT_LimUppPr.go CT_M.go CT_MC.go CT_MCPr.go CT_MCS.go CT_MPr.go CT_MR.go CT_ManualBreak.go CT_MathPr.go CT_MathPrChoice.go CT_Nary.go CT_NaryPr.go CT_OMath.go CT_OMathArg.go CT_OMathArgPr.go CT_OMathJc.go CT_OMathPara.go CT_OMathParaPr.go CT_OnOff.go CT_Phant.go CT_PhantPr.go CT_R.go CT_RChoice.go CT_RPR.go CT_Rad.go CT_RadPr.go CT_SPre.go CT_SPrePr.go CT_SSub.go CT_SSubPr.go CT_SSubSup.go CT_SSubSupPr.go CT_SSup.go CT_SSupPr.go CT_Script.go CT_Shp.go CT_SpacingRule.go CT_String.go CT_Style.go CT_Text.go CT_TopBot.go CT_TwipsMeasure.go CT_UnSignedInteger.go CT_XAlign.go CT_YAlign.go EG_OMathElements.go EG_OMathElementsChoice.go EG_OMathMathElements.go EG_OMathMathElementsChoice.go EG_ScriptStyle.go MathPr.go OMath.go OMathPara.go common.go

## func ParseUnionST_OnOff ¶

    func ParseUnionST_OnOff(s string) (sharedTypes.ST_OnOff, error)

## func ParseUnionST_TwipsMeasure ¶

    func ParseUnionST_TwipsMeasure(s string) (sharedTypes.ST_TwipsMeasure, error)

## type CT_Acc ¶

    type CT_Acc struct {
        // Accent Properties
        AccPr *CT_AccPr
        // Base
        E *CT_OMathArg
    }

### func NewCT_Acc ¶

    func NewCT_Acc() *CT_Acc

### func (*CT_Acc) MarshalXML ¶

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

### func (*CT_Acc) UnmarshalXML ¶

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

### func (*CT_Acc) Validate ¶

    func (m *CT_Acc) Validate() error

Validate validates the CT_Acc and its children

### func (*CT_Acc) ValidateWithPath ¶

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

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

## type CT_AccPr ¶

    type CT_AccPr struct {
        // Character
        Chr *CT_Char
        // Control Properties
        CtrlPr *CT_CtrlPr
    }

### func NewCT_AccPr ¶

    func NewCT_AccPr() *CT_AccPr

### func (*CT_AccPr) MarshalXML ¶

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

### func (*CT_AccPr) UnmarshalXML ¶

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

### func (*CT_AccPr) Validate ¶

    func (m *CT_AccPr) Validate() error

Validate validates the CT_AccPr and its children

### func (*CT_AccPr) ValidateWithPath ¶

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

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

## type CT_Bar ¶

    type CT_Bar struct {
        // Bar Properties
        BarPr *CT_BarPr
        // Base
        E *CT_OMathArg
    }

### func NewCT_Bar ¶

    func NewCT_Bar() *CT_Bar

### func (*CT_Bar) MarshalXML ¶

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

### func (*CT_Bar) UnmarshalXML ¶

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

### func (*CT_Bar) Validate ¶

    func (m *CT_Bar) Validate() error

Validate validates the CT_Bar and its children

### func (*CT_Bar) ValidateWithPath ¶

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

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

## type CT_BarPr ¶

    type CT_BarPr struct {
        // Position
        Pos    *CT_TopBot
        CtrlPr *CT_CtrlPr
    }

### func NewCT_BarPr ¶

    func NewCT_BarPr() *CT_BarPr

### func (*CT_BarPr) MarshalXML ¶

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

### func (*CT_BarPr) UnmarshalXML ¶

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

### func (*CT_BarPr) Validate ¶

    func (m *CT_BarPr) Validate() error

Validate validates the CT_BarPr and its children

### func (*CT_BarPr) ValidateWithPath ¶

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

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

## type CT_BorderBox ¶

    type CT_BorderBox struct {
        // Border-Box Properties
        BorderBoxPr *CT_BorderBoxPr
        // Base
        E *CT_OMathArg
    }

### func NewCT_BorderBox ¶

    func NewCT_BorderBox() *CT_BorderBox

### func (*CT_BorderBox) MarshalXML ¶

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

### func (*CT_BorderBox) UnmarshalXML ¶

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

### func (*CT_BorderBox) Validate ¶

    func (m *CT_BorderBox) Validate() error

Validate validates the CT_BorderBox and its children

### func (*CT_BorderBox) ValidateWithPath ¶

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

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

## type CT_BorderBoxPr ¶

    type CT_BorderBoxPr struct {
        // Hide Top Edge
        HideTop *CT_OnOff
        // Hide Bottom Edge
        HideBot *CT_OnOff
        // Hide Left Edge
        HideLeft *CT_OnOff
        // Hide Right Edge
        HideRight *CT_OnOff
        // Border Box Strikethrough Horizontal
        StrikeH *CT_OnOff
        // Border Box Strikethrough Vertical
        StrikeV *CT_OnOff
        // Border Box Strikethrough Bottom-Left to Top-Right
        StrikeBLTR *CT_OnOff
        // Border Box Strikethrough Top-Left to Bottom-Right
        StrikeTLBR *CT_OnOff
        CtrlPr     *CT_CtrlPr
    }

### func NewCT_BorderBoxPr ¶

    func NewCT_BorderBoxPr() *CT_BorderBoxPr

### func (*CT_BorderBoxPr) MarshalXML ¶

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

### func (*CT_BorderBoxPr) UnmarshalXML ¶

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

### func (*CT_BorderBoxPr) Validate ¶

    func (m *CT_BorderBoxPr) Validate() error

Validate validates the CT_BorderBoxPr and its children

### func (*CT_BorderBoxPr) ValidateWithPath ¶

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

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

## type CT_Box ¶

    type CT_Box struct {
        // Box Properties
        BoxPr *CT_BoxPr
        // Base
        E *CT_OMathArg
    }

### func NewCT_Box ¶

    func NewCT_Box() *CT_Box

### func (*CT_Box) MarshalXML ¶

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

### func (*CT_Box) UnmarshalXML ¶

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

### func (*CT_Box) Validate ¶

    func (m *CT_Box) Validate() error

Validate validates the CT_Box and its children

### func (*CT_Box) ValidateWithPath ¶

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

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

## type CT_BoxPr ¶

    type CT_BoxPr struct {
        // Operator Emulator
        OpEmu *CT_OnOff
        // No Break
        NoBreak *CT_OnOff
        // Differential
        Diff *CT_OnOff
        // Break
        Brk *CT_ManualBreak
        // Alignment
        Aln    *CT_OnOff
        CtrlPr *CT_CtrlPr
    }

### func NewCT_BoxPr ¶

    func NewCT_BoxPr() *CT_BoxPr

### func (*CT_BoxPr) MarshalXML ¶

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

### func (*CT_BoxPr) UnmarshalXML ¶

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

### func (*CT_BoxPr) Validate ¶

    func (m *CT_BoxPr) Validate() error

Validate validates the CT_BoxPr and its children

### func (*CT_BoxPr) ValidateWithPath ¶

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

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

## type CT_BreakBin ¶

    type CT_BreakBin struct {
        // Value
        ValAttr ST_BreakBin
    }

### func NewCT_BreakBin ¶

    func NewCT_BreakBin() *CT_BreakBin

### func (*CT_BreakBin) MarshalXML ¶

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

### func (*CT_BreakBin) UnmarshalXML ¶

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

### func (*CT_BreakBin) Validate ¶

    func (m *CT_BreakBin) Validate() error

Validate validates the CT_BreakBin and its children

### func (*CT_BreakBin) ValidateWithPath ¶

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

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

## type CT_BreakBinSub ¶

    type CT_BreakBinSub struct {
        // Value
        ValAttr ST_BreakBinSub
    }

### func NewCT_BreakBinSub ¶

    func NewCT_BreakBinSub() *CT_BreakBinSub

### func (*CT_BreakBinSub) MarshalXML ¶

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

### func (*CT_BreakBinSub) UnmarshalXML ¶

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

### func (*CT_BreakBinSub) Validate ¶

    func (m *CT_BreakBinSub) Validate() error

Validate validates the CT_BreakBinSub and its children

### func (*CT_BreakBinSub) ValidateWithPath ¶

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

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

## type CT_Char ¶

    type CT_Char struct {
        // value
        ValAttr string
    }

### func NewCT_Char ¶

    func NewCT_Char() *CT_Char

### func (*CT_Char) MarshalXML ¶

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

### func (*CT_Char) UnmarshalXML ¶

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

### func (*CT_Char) Validate ¶

    func (m *CT_Char) Validate() error

Validate validates the CT_Char and its children

### func (*CT_Char) ValidateWithPath ¶

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

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

## type CT_CtrlPr ¶

    type CT_CtrlPr struct {
    }

### func NewCT_CtrlPr ¶

    func NewCT_CtrlPr() *CT_CtrlPr

### func (*CT_CtrlPr) MarshalXML ¶

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

### func (*CT_CtrlPr) UnmarshalXML ¶

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

### func (*CT_CtrlPr) Validate ¶

    func (m *CT_CtrlPr) Validate() error

Validate validates the CT_CtrlPr and its children

### func (*CT_CtrlPr) ValidateWithPath ¶

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

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

## type CT_D ¶

    type CT_D struct {
        // Delimiter Properties
        DPr *CT_DPr
        // Base
        E []*CT_OMathArg
    }

### func NewCT_D ¶

    func NewCT_D() *CT_D

### func (*CT_D) MarshalXML ¶

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

### func (*CT_D) UnmarshalXML ¶

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

### func (*CT_D) Validate ¶

    func (m *CT_D) Validate() error

Validate validates the CT_D and its children

### func (*CT_D) ValidateWithPath ¶

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

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

## type CT_DPr ¶

    type CT_DPr struct {
        // Delimiter Beginning Character
        BegChr *CT_Char
        // Delimiter Separator Character
        SepChr *CT_Char
        // Delimiter Ending Character
        EndChr *CT_Char
        // Delimiter Grow
        Grow *CT_OnOff
        // Shape (Delimiters)
        Shp    *CT_Shp
        CtrlPr *CT_CtrlPr
    }

### func NewCT_DPr ¶

    func NewCT_DPr() *CT_DPr

### func (*CT_DPr) MarshalXML ¶

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

### func (*CT_DPr) UnmarshalXML ¶

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

### func (*CT_DPr) Validate ¶

    func (m *CT_DPr) Validate() error

Validate validates the CT_DPr and its children

### func (*CT_DPr) ValidateWithPath ¶

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

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

## type CT_EqArr ¶

    type CT_EqArr struct {
        // Array Properties
        EqArrPr *CT_EqArrPr
        // Element
        E []*CT_OMathArg
    }

### func NewCT_EqArr ¶

    func NewCT_EqArr() *CT_EqArr

### func (*CT_EqArr) MarshalXML ¶

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

### func (*CT_EqArr) UnmarshalXML ¶

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

### func (*CT_EqArr) Validate ¶

    func (m *CT_EqArr) Validate() error

Validate validates the CT_EqArr and its children

### func (*CT_EqArr) ValidateWithPath ¶

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

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

## type CT_EqArrPr ¶

    type CT_EqArrPr struct {
        // Equation Array Base Justification
        BaseJc *CT_YAlign
        // Maximum Distribution
        MaxDist *CT_OnOff
        // Object Distribution
        ObjDist *CT_OnOff
        // Row Spacing Rule
        RSpRule *CT_SpacingRule
        // Row Spacing (Array)
        RSp    *CT_UnSignedInteger
        CtrlPr *CT_CtrlPr
    }

### func NewCT_EqArrPr ¶

    func NewCT_EqArrPr() *CT_EqArrPr

### func (*CT_EqArrPr) MarshalXML ¶

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

### func (*CT_EqArrPr) UnmarshalXML ¶

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

### func (*CT_EqArrPr) Validate ¶

    func (m *CT_EqArrPr) Validate() error

Validate validates the CT_EqArrPr and its children

### func (*CT_EqArrPr) ValidateWithPath ¶

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

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

## type CT_F ¶

    type CT_F struct {
        // Fraction Properties
        FPr *CT_FPr
        // Numerator
        Num *CT_OMathArg
        // Denominator
        Den *CT_OMathArg
    }

### func NewCT_F ¶

    func NewCT_F() *CT_F

### func (*CT_F) MarshalXML ¶

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

### func (*CT_F) UnmarshalXML ¶

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

### func (*CT_F) Validate ¶

    func (m *CT_F) Validate() error

Validate validates the CT_F and its children

### func (*CT_F) ValidateWithPath ¶

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

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

## type CT_FPr ¶

    type CT_FPr struct {
        // Fraction type
        Type   *CT_FType
        CtrlPr *CT_CtrlPr
    }

### func NewCT_FPr ¶

    func NewCT_FPr() *CT_FPr

### func (*CT_FPr) MarshalXML ¶

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

### func (*CT_FPr) UnmarshalXML ¶

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

### func (*CT_FPr) Validate ¶

    func (m *CT_FPr) Validate() error

Validate validates the CT_FPr and its children

### func (*CT_FPr) ValidateWithPath ¶

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

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

## type CT_FType ¶

    type CT_FType struct {
        // Value
        ValAttr ST_FType
    }

### func NewCT_FType ¶

    func NewCT_FType() *CT_FType

### func (*CT_FType) MarshalXML ¶

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

### func (*CT_FType) UnmarshalXML ¶

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

### func (*CT_FType) Validate ¶

    func (m *CT_FType) Validate() error

Validate validates the CT_FType and its children

### func (*CT_FType) ValidateWithPath ¶

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

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

## type CT_Func ¶

    type CT_Func struct {
        // Function Properties
        FuncPr *CT_FuncPr
        // Function Name
        FName *CT_OMathArg
        // Element (Argument)
        E *CT_OMathArg
    }

### func NewCT_Func ¶

    func NewCT_Func() *CT_Func

### func (*CT_Func) MarshalXML ¶

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

### func (*CT_Func) UnmarshalXML ¶

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

### func (*CT_Func) Validate ¶

    func (m *CT_Func) Validate() error

Validate validates the CT_Func and its children

### func (*CT_Func) ValidateWithPath ¶

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

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

## type CT_FuncPr ¶

    type CT_FuncPr struct {
        CtrlPr *CT_CtrlPr
    }

### func NewCT_FuncPr ¶

    func NewCT_FuncPr() *CT_FuncPr

### func (*CT_FuncPr) MarshalXML ¶

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

### func (*CT_FuncPr) UnmarshalXML ¶

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

### func (*CT_FuncPr) Validate ¶

    func (m *CT_FuncPr) Validate() error

Validate validates the CT_FuncPr and its children

### func (*CT_FuncPr) ValidateWithPath ¶

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

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

## type CT_GroupChr ¶

    type CT_GroupChr struct {
        // Group-Character Properties
        GroupChrPr *CT_GroupChrPr
        // Base
        E *CT_OMathArg
    }

### func NewCT_GroupChr ¶

    func NewCT_GroupChr() *CT_GroupChr

### func (*CT_GroupChr) MarshalXML ¶

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

### func (*CT_GroupChr) UnmarshalXML ¶

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

### func (*CT_GroupChr) Validate ¶

    func (m *CT_GroupChr) Validate() error

Validate validates the CT_GroupChr and its children

### func (*CT_GroupChr) ValidateWithPath ¶

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

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

## type CT_GroupChrPr ¶

    type CT_GroupChrPr struct {
        // Group Character (Grouping Character)
        Chr *CT_Char
        // Position (Group Character)
        Pos *CT_TopBot
        // Vertical Justification
        VertJc *CT_TopBot
        CtrlPr *CT_CtrlPr
    }

### func NewCT_GroupChrPr ¶

    func NewCT_GroupChrPr() *CT_GroupChrPr

### func (*CT_GroupChrPr) MarshalXML ¶

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

### func (*CT_GroupChrPr) UnmarshalXML ¶

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

### func (*CT_GroupChrPr) Validate ¶

    func (m *CT_GroupChrPr) Validate() error

Validate validates the CT_GroupChrPr and its children

### func (*CT_GroupChrPr) ValidateWithPath ¶

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

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

## type CT_Integer2 ¶

    type CT_Integer2 struct {
        // Value
        ValAttr int64
    }

### func NewCT_Integer2 ¶

    func NewCT_Integer2() *CT_Integer2

### func (*CT_Integer2) MarshalXML ¶

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

### func (*CT_Integer2) UnmarshalXML ¶

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

### func (*CT_Integer2) Validate ¶

    func (m *CT_Integer2) Validate() error

Validate validates the CT_Integer2 and its children

### func (*CT_Integer2) ValidateWithPath ¶

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

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

## type CT_Integer255 ¶

    type CT_Integer255 struct {
        // Value
        ValAttr int64
    }

### func NewCT_Integer255 ¶

    func NewCT_Integer255() *CT_Integer255

### func (*CT_Integer255) MarshalXML ¶

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

### func (*CT_Integer255) UnmarshalXML ¶

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

### func (*CT_Integer255) Validate ¶

    func (m *CT_Integer255) Validate() error

Validate validates the CT_Integer255 and its children

### func (*CT_Integer255) ValidateWithPath ¶

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

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

## type CT_LimLoc ¶

    type CT_LimLoc struct {
        // Value
        ValAttr ST_LimLoc
    }

### func NewCT_LimLoc ¶

    func NewCT_LimLoc() *CT_LimLoc

### func (*CT_LimLoc) MarshalXML ¶

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

### func (*CT_LimLoc) UnmarshalXML ¶

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

### func (*CT_LimLoc) Validate ¶

    func (m *CT_LimLoc) Validate() error

Validate validates the CT_LimLoc and its children

### func (*CT_LimLoc) ValidateWithPath ¶

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

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

## type CT_LimLow ¶

    type CT_LimLow struct {
        // Lower-Limit Properties
        LimLowPr *CT_LimLowPr
        // Base
        E *CT_OMathArg
        // Limit
        Lim *CT_OMathArg
    }

### func NewCT_LimLow ¶

    func NewCT_LimLow() *CT_LimLow

### func (*CT_LimLow) MarshalXML ¶

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

### func (*CT_LimLow) UnmarshalXML ¶

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

### func (*CT_LimLow) Validate ¶

    func (m *CT_LimLow) Validate() error

Validate validates the CT_LimLow and its children

### func (*CT_LimLow) ValidateWithPath ¶

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

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

## type CT_LimLowPr ¶

    type CT_LimLowPr struct {
        CtrlPr *CT_CtrlPr
    }

### func NewCT_LimLowPr ¶

    func NewCT_LimLowPr() *CT_LimLowPr

### func (*CT_LimLowPr) MarshalXML ¶

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

### func (*CT_LimLowPr) UnmarshalXML ¶

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

### func (*CT_LimLowPr) Validate ¶

    func (m *CT_LimLowPr) Validate() error

Validate validates the CT_LimLowPr and its children

### func (*CT_LimLowPr) ValidateWithPath ¶

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

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

## type CT_LimUpp ¶

    type CT_LimUpp struct {
        // Upper-Limit Properties
        LimUppPr *CT_LimUppPr
        // Base
        E *CT_OMathArg
        // Limit (Upper)
        Lim *CT_OMathArg
    }

### func NewCT_LimUpp ¶

    func NewCT_LimUpp() *CT_LimUpp

### func (*CT_LimUpp) MarshalXML ¶

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

### func (*CT_LimUpp) UnmarshalXML ¶

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

### func (*CT_LimUpp) Validate ¶

    func (m *CT_LimUpp) Validate() error

Validate validates the CT_LimUpp and its children

### func (*CT_LimUpp) ValidateWithPath ¶

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

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

## type CT_LimUppPr ¶

    type CT_LimUppPr struct {
        CtrlPr *CT_CtrlPr
    }

### func NewCT_LimUppPr ¶

    func NewCT_LimUppPr() *CT_LimUppPr

### func (*CT_LimUppPr) MarshalXML ¶

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

### func (*CT_LimUppPr) UnmarshalXML ¶

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

### func (*CT_LimUppPr) Validate ¶

    func (m *CT_LimUppPr) Validate() error

Validate validates the CT_LimUppPr and its children

### func (*CT_LimUppPr) ValidateWithPath ¶

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

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

## type CT_M ¶

    type CT_M struct {
        // Matrix Properties
        MPr *CT_MPr
        // Matrix Row
        Mr []*CT_MR
    }

### func NewCT_M ¶

    func NewCT_M() *CT_M

### func (*CT_M) MarshalXML ¶

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

### func (*CT_M) UnmarshalXML ¶

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

### func (*CT_M) Validate ¶

    func (m *CT_M) Validate() error

Validate validates the CT_M and its children

### func (*CT_M) ValidateWithPath ¶

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

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

## type CT_MC ¶

    type CT_MC struct {
        // Matrix Column Properties
        McPr *CT_MCPr
    }

### func NewCT_MC ¶

    func NewCT_MC() *CT_MC

### func (*CT_MC) MarshalXML ¶

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

### func (*CT_MC) UnmarshalXML ¶

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

### func (*CT_MC) Validate ¶

    func (m *CT_MC) Validate() error

Validate validates the CT_MC and its children

### func (*CT_MC) ValidateWithPath ¶

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

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

## type CT_MCPr ¶

    type CT_MCPr struct {
        // Matrix Column Count
        Count *CT_Integer255
        // Matrix Column Justification
        McJc *CT_XAlign
    }

### func NewCT_MCPr ¶

    func NewCT_MCPr() *CT_MCPr

### func (*CT_MCPr) MarshalXML ¶

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

### func (*CT_MCPr) UnmarshalXML ¶

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

### func (*CT_MCPr) Validate ¶

    func (m *CT_MCPr) Validate() error

Validate validates the CT_MCPr and its children

### func (*CT_MCPr) ValidateWithPath ¶

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

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

## type CT_MCS ¶

    type CT_MCS struct {
        // Matrix Column
        Mc []*CT_MC
    }

### func NewCT_MCS ¶

    func NewCT_MCS() *CT_MCS

### func (*CT_MCS) MarshalXML ¶

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

### func (*CT_MCS) UnmarshalXML ¶

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

### func (*CT_MCS) Validate ¶

    func (m *CT_MCS) Validate() error

Validate validates the CT_MCS and its children

### func (*CT_MCS) ValidateWithPath ¶

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

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

## type CT_MPr ¶

    type CT_MPr struct {
        // Matrix Base Justification
        BaseJc *CT_YAlign
        // Hide Placeholders (Matrix)
        PlcHide *CT_OnOff
        // Row Spacing Rule
        RSpRule *CT_SpacingRule
        // Matrix Column Gap Rule
        CGpRule *CT_SpacingRule
        // Row Spacing (Matrix)
        RSp *CT_UnSignedInteger
        // Minimum Matrix Column Width
        CSp *CT_UnSignedInteger
        // Matrix Column Gap
        CGp *CT_UnSignedInteger
        // Matrix Columns
        Mcs    *CT_MCS
        CtrlPr *CT_CtrlPr
    }

### func NewCT_MPr ¶

    func NewCT_MPr() *CT_MPr

### func (*CT_MPr) MarshalXML ¶

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

### func (*CT_MPr) UnmarshalXML ¶

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

### func (*CT_MPr) Validate ¶

    func (m *CT_MPr) Validate() error

Validate validates the CT_MPr and its children

### func (*CT_MPr) ValidateWithPath ¶

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

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

## type CT_MR ¶

    type CT_MR struct {
        // Element
        E []*CT_OMathArg
    }

### func NewCT_MR ¶

    func NewCT_MR() *CT_MR

### func (*CT_MR) MarshalXML ¶

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

### func (*CT_MR) UnmarshalXML ¶

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

### func (*CT_MR) Validate ¶

    func (m *CT_MR) Validate() error

Validate validates the CT_MR and its children

### func (*CT_MR) ValidateWithPath ¶

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

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

## type CT_ManualBreak ¶

    type CT_ManualBreak struct {
        // Index of Operator to Align To
        AlnAtAttr *int64
    }

### func NewCT_ManualBreak ¶

    func NewCT_ManualBreak() *CT_ManualBreak

### func (*CT_ManualBreak) MarshalXML ¶

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

### func (*CT_ManualBreak) UnmarshalXML ¶

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

### func (*CT_ManualBreak) Validate ¶

    func (m *CT_ManualBreak) Validate() error

Validate validates the CT_ManualBreak and its children

### func (*CT_ManualBreak) ValidateWithPath ¶

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

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

## type CT_MathPr ¶

    type CT_MathPr struct {
        // Math Font
        MathFont *CT_String
        // Break on Binary Operators
        BrkBin *CT_BreakBin
        // Break on Binary Subtraction
        BrkBinSub *CT_BreakBinSub
        // Small Fraction
        SmallFrac *CT_OnOff
        // Use Display Math Defaults
        DispDef *CT_OnOff
        // Left Margin
        LMargin *CT_TwipsMeasure
        // Right Margin
        RMargin *CT_TwipsMeasure
        // Default Justification
        DefJc *CT_OMathJc
        // Pre-Paragraph Spacing
        PreSp *CT_TwipsMeasure
        // Post-Paragraph Spacing
        PostSp *CT_TwipsMeasure
        // Inter-Equation Spacing
        InterSp *CT_TwipsMeasure
        // Intra-Equation Spacing
        IntraSp      *CT_TwipsMeasure
        MathPrChoice *CT_MathPrChoice
        // Integral Limit Locations
        IntLim *CT_LimLoc
        // n-ary Limit Location
        NaryLim *CT_LimLoc
    }

### func NewCT_MathPr ¶

    func NewCT_MathPr() *CT_MathPr

### func (*CT_MathPr) MarshalXML ¶

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

### func (*CT_MathPr) UnmarshalXML ¶

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

### func (*CT_MathPr) Validate ¶

    func (m *CT_MathPr) Validate() error

Validate validates the CT_MathPr and its children

### func (*CT_MathPr) ValidateWithPath ¶

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

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

## type CT_MathPrChoice ¶

    type CT_MathPrChoice struct {
        WrapIndent *CT_TwipsMeasure
        WrapRight  *CT_OnOff
    }

### func NewCT_MathPrChoice ¶

    func NewCT_MathPrChoice() *CT_MathPrChoice

### func (*CT_MathPrChoice) MarshalXML ¶

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

### func (*CT_MathPrChoice) UnmarshalXML ¶

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

### func (*CT_MathPrChoice) Validate ¶

    func (m *CT_MathPrChoice) Validate() error

Validate validates the CT_MathPrChoice and its children

### func (*CT_MathPrChoice) ValidateWithPath ¶

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

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

## type CT_Nary ¶

    type CT_Nary struct {
        // n-ary Properties
        NaryPr *CT_NaryPr
        // Lower limit (n-ary)
        Sub *CT_OMathArg
        // Upper limit (n-ary)
        Sup *CT_OMathArg
        // Base (Argument)
        E *CT_OMathArg
    }

### func NewCT_Nary ¶

    func NewCT_Nary() *CT_Nary

### func (*CT_Nary) MarshalXML ¶

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

### func (*CT_Nary) UnmarshalXML ¶

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

### func (*CT_Nary) Validate ¶

    func (m *CT_Nary) Validate() error

Validate validates the CT_Nary and its children

### func (*CT_Nary) ValidateWithPath ¶

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

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

## type CT_NaryPr ¶

    type CT_NaryPr struct {
        // n-ary Operator Character
        Chr *CT_Char
        // n-ary Limit Location
        LimLoc *CT_LimLoc
        // n-ary Grow
        Grow *CT_OnOff
        // Hide Subscript (n-ary)
        SubHide *CT_OnOff
        // Hide Superscript (n-ary)
        SupHide *CT_OnOff
        CtrlPr  *CT_CtrlPr
    }

### func NewCT_NaryPr ¶

    func NewCT_NaryPr() *CT_NaryPr

### func (*CT_NaryPr) MarshalXML ¶

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

### func (*CT_NaryPr) UnmarshalXML ¶

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

### func (*CT_NaryPr) Validate ¶

    func (m *CT_NaryPr) Validate() error

Validate validates the CT_NaryPr and its children

### func (*CT_NaryPr) ValidateWithPath ¶

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

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

## type CT_OMath ¶

    type CT_OMath struct {
        EG_OMathElements []*EG_OMathElements
    }

### func NewCT_OMath ¶

    func NewCT_OMath() *CT_OMath

### func (*CT_OMath) MarshalXML ¶

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

### func (*CT_OMath) UnmarshalXML ¶

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

### func (*CT_OMath) Validate ¶

    func (m *CT_OMath) Validate() error

Validate validates the CT_OMath and its children

### func (*CT_OMath) ValidateWithPath ¶

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

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

## type CT_OMathArg ¶

    type CT_OMathArg struct {
        // Argument Properties
        ArgPr            *CT_OMathArgPr
        EG_OMathElements []*EG_OMathElements
        CtrlPr           *CT_CtrlPr
    }

### func NewCT_OMathArg ¶

    func NewCT_OMathArg() *CT_OMathArg

### func (*CT_OMathArg) MarshalXML ¶

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

### func (*CT_OMathArg) UnmarshalXML ¶

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

### func (*CT_OMathArg) Validate ¶

    func (m *CT_OMathArg) Validate() error

Validate validates the CT_OMathArg and its children

### func (*CT_OMathArg) ValidateWithPath ¶

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

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

## type CT_OMathArgPr ¶

    type CT_OMathArgPr struct {
        // Argument Size
        ArgSz *CT_Integer2
    }

### func NewCT_OMathArgPr ¶

    func NewCT_OMathArgPr() *CT_OMathArgPr

### func (*CT_OMathArgPr) MarshalXML ¶

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

### func (*CT_OMathArgPr) UnmarshalXML ¶

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

### func (*CT_OMathArgPr) Validate ¶

    func (m *CT_OMathArgPr) Validate() error

Validate validates the CT_OMathArgPr and its children

### func (*CT_OMathArgPr) ValidateWithPath ¶

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

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

## type CT_OMathJc ¶

    type CT_OMathJc struct {
        // Value
        ValAttr ST_Jc
    }

### func NewCT_OMathJc ¶

    func NewCT_OMathJc() *CT_OMathJc

### func (*CT_OMathJc) MarshalXML ¶

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

### func (*CT_OMathJc) UnmarshalXML ¶

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

### func (*CT_OMathJc) Validate ¶

    func (m *CT_OMathJc) Validate() error

Validate validates the CT_OMathJc and its children

### func (*CT_OMathJc) ValidateWithPath ¶

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

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

## type CT_OMathPara ¶

    type CT_OMathPara struct {
        // Office Math Paragraph Properties
        OMathParaPr *CT_OMathParaPr
        // Office Math
        OMath []*CT_OMath
    }

### func NewCT_OMathPara ¶

    func NewCT_OMathPara() *CT_OMathPara

### func (*CT_OMathPara) MarshalXML ¶

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

### func (*CT_OMathPara) UnmarshalXML ¶

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

### func (*CT_OMathPara) Validate ¶

    func (m *CT_OMathPara) Validate() error

Validate validates the CT_OMathPara and its children

### func (*CT_OMathPara) ValidateWithPath ¶

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

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

## type CT_OMathParaPr ¶

    type CT_OMathParaPr struct {
        // Justification
        Jc *CT_OMathJc
    }

### func NewCT_OMathParaPr ¶

    func NewCT_OMathParaPr() *CT_OMathParaPr

### func (*CT_OMathParaPr) MarshalXML ¶

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

### func (*CT_OMathParaPr) UnmarshalXML ¶

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

### func (*CT_OMathParaPr) Validate ¶

    func (m *CT_OMathParaPr) Validate() error

Validate validates the CT_OMathParaPr and its children

### func (*CT_OMathParaPr) ValidateWithPath ¶

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

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

## type CT_OnOff ¶

    type CT_OnOff struct {
        // value
        ValAttr *sharedTypes.ST_OnOff
    }

### func NewCT_OnOff ¶

    func NewCT_OnOff() *CT_OnOff

### func (*CT_OnOff) MarshalXML ¶

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

### func (*CT_OnOff) UnmarshalXML ¶

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

### func (*CT_OnOff) Validate ¶

    func (m *CT_OnOff) Validate() error

Validate validates the CT_OnOff and its children

### func (*CT_OnOff) ValidateWithPath ¶

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

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

## type CT_Phant ¶

    type CT_Phant struct {
        // Phantom Properties
        PhantPr *CT_PhantPr
        // Base
        E *CT_OMathArg
    }

### func NewCT_Phant ¶

    func NewCT_Phant() *CT_Phant

### func (*CT_Phant) MarshalXML ¶

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

### func (*CT_Phant) UnmarshalXML ¶

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

### func (*CT_Phant) Validate ¶

    func (m *CT_Phant) Validate() error

Validate validates the CT_Phant and its children

### func (*CT_Phant) ValidateWithPath ¶

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

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

## type CT_PhantPr ¶

    type CT_PhantPr struct {
        // Phantom Show
        Show *CT_OnOff
        // Phantom Zero Width
        ZeroWid *CT_OnOff
        // Phantom Zero Ascent
        ZeroAsc *CT_OnOff
        // Phantom Zero Descent
        ZeroDesc *CT_OnOff
        // Transparent (Phantom)
        Transp *CT_OnOff
        CtrlPr *CT_CtrlPr
    }

### func NewCT_PhantPr ¶

    func NewCT_PhantPr() *CT_PhantPr

### func (*CT_PhantPr) MarshalXML ¶

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

### func (*CT_PhantPr) UnmarshalXML ¶

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

### func (*CT_PhantPr) Validate ¶

    func (m *CT_PhantPr) Validate() error

Validate validates the CT_PhantPr and its children

### func (*CT_PhantPr) ValidateWithPath ¶

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

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

## type CT_R ¶

    type CT_R struct {
        // Run Properties
        RPr     *CT_RPR
        RChoice []*CT_RChoice
    }

### func NewCT_R ¶

    func NewCT_R() *CT_R

### func (*CT_R) MarshalXML ¶

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

### func (*CT_R) UnmarshalXML ¶

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

### func (*CT_R) Validate ¶

    func (m *CT_R) Validate() error

Validate validates the CT_R and its children

### func (*CT_R) ValidateWithPath ¶

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

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

## type CT_RChoice ¶

    type CT_RChoice struct {
        T *CT_Text
    }

### func NewCT_RChoice ¶

    func NewCT_RChoice() *CT_RChoice

### func (*CT_RChoice) MarshalXML ¶

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

### func (*CT_RChoice) UnmarshalXML ¶

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

### func (*CT_RChoice) Validate ¶

    func (m *CT_RChoice) Validate() error

Validate validates the CT_RChoice and its children

### func (*CT_RChoice) ValidateWithPath ¶

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

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

## type CT_RPR ¶

    type CT_RPR struct {
        // Literal
        Lit *CT_OnOff
        Nor *CT_OnOff
        // Break
        Brk *CT_ManualBreak
        // Align
        Aln *CT_OnOff
    }

### func NewCT_RPR ¶

    func NewCT_RPR() *CT_RPR

### func (*CT_RPR) MarshalXML ¶

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

### func (*CT_RPR) UnmarshalXML ¶

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

### func (*CT_RPR) Validate ¶

    func (m *CT_RPR) Validate() error

Validate validates the CT_RPR and its children

### func (*CT_RPR) ValidateWithPath ¶

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

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

## type CT_Rad ¶

    type CT_Rad struct {
        // Radical Properties
        RadPr *CT_RadPr
        // Degree
        Deg *CT_OMathArg
        // Base
        E *CT_OMathArg
    }

### func NewCT_Rad ¶

    func NewCT_Rad() *CT_Rad

### func (*CT_Rad) MarshalXML ¶

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

### func (*CT_Rad) UnmarshalXML ¶

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

### func (*CT_Rad) Validate ¶

    func (m *CT_Rad) Validate() error

Validate validates the CT_Rad and its children

### func (*CT_Rad) ValidateWithPath ¶

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

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

## type CT_RadPr ¶

    type CT_RadPr struct {
        // Hide Degree
        DegHide *CT_OnOff
        CtrlPr  *CT_CtrlPr
    }

### func NewCT_RadPr ¶

    func NewCT_RadPr() *CT_RadPr

### func (*CT_RadPr) MarshalXML ¶

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

### func (*CT_RadPr) UnmarshalXML ¶

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

### func (*CT_RadPr) Validate ¶

    func (m *CT_RadPr) Validate() error

Validate validates the CT_RadPr and its children

### func (*CT_RadPr) ValidateWithPath ¶

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

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

## type CT_SPre ¶

    type CT_SPre struct {
        // Pre-Sub-Superscript Properties
        SPrePr *CT_SPrePr
        // Subscript (Pre-Sub-Superscript)
        Sub *CT_OMathArg
        // Superscript(Pre-Sub-Superscript function)
        Sup *CT_OMathArg
        // Base
        E *CT_OMathArg
    }

### func NewCT_SPre ¶

    func NewCT_SPre() *CT_SPre

### func (*CT_SPre) MarshalXML ¶

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

### func (*CT_SPre) UnmarshalXML ¶

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

### func (*CT_SPre) Validate ¶

    func (m *CT_SPre) Validate() error

Validate validates the CT_SPre and its children

### func (*CT_SPre) ValidateWithPath ¶

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

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

## type CT_SPrePr ¶

    type CT_SPrePr struct {
        CtrlPr *CT_CtrlPr
    }

### func NewCT_SPrePr ¶

    func NewCT_SPrePr() *CT_SPrePr

### func (*CT_SPrePr) MarshalXML ¶

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

### func (*CT_SPrePr) UnmarshalXML ¶

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

### func (*CT_SPrePr) Validate ¶

    func (m *CT_SPrePr) Validate() error

Validate validates the CT_SPrePr and its children

### func (*CT_SPrePr) ValidateWithPath ¶

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

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

## type CT_SSub ¶

    type CT_SSub struct {
        // Subscript Properties
        SSubPr *CT_SSubPr
        // Base
        E *CT_OMathArg
        // Subscript (Subscript function)
        Sub *CT_OMathArg
    }

### func NewCT_SSub ¶

    func NewCT_SSub() *CT_SSub

### func (*CT_SSub) MarshalXML ¶

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

### func (*CT_SSub) UnmarshalXML ¶

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

### func (*CT_SSub) Validate ¶

    func (m *CT_SSub) Validate() error

Validate validates the CT_SSub and its children

### func (*CT_SSub) ValidateWithPath ¶

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

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

## type CT_SSubPr ¶

    type CT_SSubPr struct {
        CtrlPr *CT_CtrlPr
    }

### func NewCT_SSubPr ¶

    func NewCT_SSubPr() *CT_SSubPr

### func (*CT_SSubPr) MarshalXML ¶

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

### func (*CT_SSubPr) UnmarshalXML ¶

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

### func (*CT_SSubPr) Validate ¶

    func (m *CT_SSubPr) Validate() error

Validate validates the CT_SSubPr and its children

### func (*CT_SSubPr) ValidateWithPath ¶

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

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

## type CT_SSubSup ¶

    type CT_SSubSup struct {
        // Sub-Superscript Properties
        SSubSupPr *CT_SSubSupPr
        // Base
        E *CT_OMathArg
        // Subscript (Sub-Superscript)
        Sub *CT_OMathArg
        // Superscript (Sub-Superscript function)
        Sup *CT_OMathArg
    }

### func NewCT_SSubSup ¶

    func NewCT_SSubSup() *CT_SSubSup

### func (*CT_SSubSup) MarshalXML ¶

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

### func (*CT_SSubSup) UnmarshalXML ¶

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

### func (*CT_SSubSup) Validate ¶

    func (m *CT_SSubSup) Validate() error

Validate validates the CT_SSubSup and its children

### func (*CT_SSubSup) ValidateWithPath ¶

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

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

## type CT_SSubSupPr ¶

    type CT_SSubSupPr struct {
        // Align Scripts
        AlnScr *CT_OnOff
        CtrlPr *CT_CtrlPr
    }

### func NewCT_SSubSupPr ¶

    func NewCT_SSubSupPr() *CT_SSubSupPr

### func (*CT_SSubSupPr) MarshalXML ¶

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

### func (*CT_SSubSupPr) UnmarshalXML ¶

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

### func (*CT_SSubSupPr) Validate ¶

    func (m *CT_SSubSupPr) Validate() error

Validate validates the CT_SSubSupPr and its children

### func (*CT_SSubSupPr) ValidateWithPath ¶

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

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

## type CT_SSup ¶

    type CT_SSup struct {
        // Superscript Properties
        SSupPr *CT_SSupPr
        // Base
        E *CT_OMathArg
        // Superscript (Superscript object)
        Sup *CT_OMathArg
    }

### func NewCT_SSup ¶

    func NewCT_SSup() *CT_SSup

### func (*CT_SSup) MarshalXML ¶

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

### func (*CT_SSup) UnmarshalXML ¶

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

### func (*CT_SSup) Validate ¶

    func (m *CT_SSup) Validate() error

Validate validates the CT_SSup and its children

### func (*CT_SSup) ValidateWithPath ¶

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

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

## type CT_SSupPr ¶

    type CT_SSupPr struct {
        CtrlPr *CT_CtrlPr
    }

### func NewCT_SSupPr ¶

    func NewCT_SSupPr() *CT_SSupPr

### func (*CT_SSupPr) MarshalXML ¶

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

### func (*CT_SSupPr) UnmarshalXML ¶

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

### func (*CT_SSupPr) Validate ¶

    func (m *CT_SSupPr) Validate() error

Validate validates the CT_SSupPr and its children

### func (*CT_SSupPr) ValidateWithPath ¶

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

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

## type CT_Script ¶

    type CT_Script struct {
        // Value
        ValAttr ST_Script
    }

### func NewCT_Script ¶

    func NewCT_Script() *CT_Script

### func (*CT_Script) MarshalXML ¶

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

### func (*CT_Script) UnmarshalXML ¶

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

### func (*CT_Script) Validate ¶

    func (m *CT_Script) Validate() error

Validate validates the CT_Script and its children

### func (*CT_Script) ValidateWithPath ¶

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

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

## type CT_Shp ¶

    type CT_Shp struct {
        // Value
        ValAttr ST_Shp
    }

### func NewCT_Shp ¶

    func NewCT_Shp() *CT_Shp

### func (*CT_Shp) MarshalXML ¶

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

### func (*CT_Shp) UnmarshalXML ¶

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

### func (*CT_Shp) Validate ¶

    func (m *CT_Shp) Validate() error

Validate validates the CT_Shp and its children

### func (*CT_Shp) ValidateWithPath ¶

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

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

## type CT_SpacingRule ¶

    type CT_SpacingRule struct {
        // Value
        ValAttr int64
    }

### func NewCT_SpacingRule ¶

    func NewCT_SpacingRule() *CT_SpacingRule

### func (*CT_SpacingRule) MarshalXML ¶

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

### func (*CT_SpacingRule) UnmarshalXML ¶

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

### func (*CT_SpacingRule) Validate ¶

    func (m *CT_SpacingRule) Validate() error

Validate validates the CT_SpacingRule and its children

### func (*CT_SpacingRule) ValidateWithPath ¶

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

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

## type CT_String ¶

    type CT_String struct {
        // value
        ValAttr *string
    }

### func NewCT_String ¶

    func NewCT_String() *CT_String

### func (*CT_String) MarshalXML ¶

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

### func (*CT_String) UnmarshalXML ¶

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

### func (*CT_String) Validate ¶

    func (m *CT_String) Validate() error

Validate validates the CT_String and its children

### func (*CT_String) ValidateWithPath ¶

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

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

## type CT_Style ¶

    type CT_Style struct {
        // Value
        ValAttr ST_Style
    }

### 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_Text ¶

    type CT_Text struct {
        SpaceAttr *string
        Content   string
    }

### func NewCT_Text ¶

    func NewCT_Text() *CT_Text

### func (*CT_Text) MarshalXML ¶

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

### func (*CT_Text) UnmarshalXML ¶

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

### func (*CT_Text) Validate ¶

    func (m *CT_Text) Validate() error

Validate validates the CT_Text and its children

### func (*CT_Text) ValidateWithPath ¶

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

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

## type CT_TopBot ¶

    type CT_TopBot struct {
        // Value
        ValAttr ST_TopBot
    }

### func NewCT_TopBot ¶

    func NewCT_TopBot() *CT_TopBot

### func (*CT_TopBot) MarshalXML ¶

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

### func (*CT_TopBot) UnmarshalXML ¶

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

### func (*CT_TopBot) Validate ¶

    func (m *CT_TopBot) Validate() error

Validate validates the CT_TopBot and its children

### func (*CT_TopBot) ValidateWithPath ¶

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

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

## type CT_TwipsMeasure ¶

    type CT_TwipsMeasure struct {
        // Value
        ValAttr sharedTypes.ST_TwipsMeasure
    }

### func NewCT_TwipsMeasure ¶

    func NewCT_TwipsMeasure() *CT_TwipsMeasure

### func (*CT_TwipsMeasure) MarshalXML ¶

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

### func (*CT_TwipsMeasure) UnmarshalXML ¶

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

### func (*CT_TwipsMeasure) Validate ¶

    func (m *CT_TwipsMeasure) Validate() error

Validate validates the CT_TwipsMeasure and its children

### func (*CT_TwipsMeasure) ValidateWithPath ¶

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

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

## type CT_UnSignedInteger ¶

    type CT_UnSignedInteger struct {
        // Value
        ValAttr uint32
    }

### func NewCT_UnSignedInteger ¶

    func NewCT_UnSignedInteger() *CT_UnSignedInteger

### func (*CT_UnSignedInteger) MarshalXML ¶

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

### func (*CT_UnSignedInteger) UnmarshalXML ¶

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

### func (*CT_UnSignedInteger) Validate ¶

    func (m *CT_UnSignedInteger) Validate() error

Validate validates the CT_UnSignedInteger and its children

### func (*CT_UnSignedInteger) ValidateWithPath ¶

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

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

## type CT_XAlign ¶

    type CT_XAlign struct {
        // Value
        ValAttr sharedTypes.ST_XAlign
    }

### func NewCT_XAlign ¶

    func NewCT_XAlign() *CT_XAlign

### func (*CT_XAlign) MarshalXML ¶

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

### func (*CT_XAlign) UnmarshalXML ¶

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

### func (*CT_XAlign) Validate ¶

    func (m *CT_XAlign) Validate() error

Validate validates the CT_XAlign and its children

### func (*CT_XAlign) ValidateWithPath ¶

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

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

## type CT_YAlign ¶

    type CT_YAlign struct {
        // Value
        ValAttr sharedTypes.ST_YAlign
    }

### func NewCT_YAlign ¶

    func NewCT_YAlign() *CT_YAlign

### func (*CT_YAlign) MarshalXML ¶

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

### func (*CT_YAlign) UnmarshalXML ¶

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

### func (*CT_YAlign) Validate ¶

    func (m *CT_YAlign) Validate() error

Validate validates the CT_YAlign and its children

### func (*CT_YAlign) ValidateWithPath ¶

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

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

## type EG_OMathElements ¶

    type EG_OMathElements struct {
        OMathElementsChoice *EG_OMathElementsChoice
    }

### func NewEG_OMathElements ¶

    func NewEG_OMathElements() *EG_OMathElements

### func (*EG_OMathElements) MarshalXML ¶

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

### func (*EG_OMathElements) UnmarshalXML ¶

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

### func (*EG_OMathElements) Validate ¶

    func (m *EG_OMathElements) Validate() error

Validate validates the EG_OMathElements and its children

### func (*EG_OMathElements) ValidateWithPath ¶

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

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

## type EG_OMathElementsChoice ¶

    type EG_OMathElementsChoice struct {
        OMathMathElementsChoice *EG_OMathMathElementsChoice
    }

### func NewEG_OMathElementsChoice ¶

    func NewEG_OMathElementsChoice() *EG_OMathElementsChoice

### func (*EG_OMathElementsChoice) MarshalXML ¶

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

### func (*EG_OMathElementsChoice) UnmarshalXML ¶

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

### func (*EG_OMathElementsChoice) Validate ¶

    func (m *EG_OMathElementsChoice) Validate() error

Validate validates the EG_OMathElementsChoice and its children

### func (*EG_OMathElementsChoice) ValidateWithPath ¶

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

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

## type EG_OMathMathElements ¶

    type EG_OMathMathElements struct {
        OMathMathElementsChoice *EG_OMathMathElementsChoice
    }

### func NewEG_OMathMathElements ¶

    func NewEG_OMathMathElements() *EG_OMathMathElements

### func (*EG_OMathMathElements) MarshalXML ¶

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

### func (*EG_OMathMathElements) UnmarshalXML ¶

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

### func (*EG_OMathMathElements) Validate ¶

    func (m *EG_OMathMathElements) Validate() error

Validate validates the EG_OMathMathElements and its children

### func (*EG_OMathMathElements) ValidateWithPath ¶

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

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

## type EG_OMathMathElementsChoice ¶

    type EG_OMathMathElementsChoice struct {
        // Accent
        Acc *CT_Acc
        // Bar
        Bar *CT_Bar
        // Box Object
        Box *CT_Box
        // Border-Box Object
        BorderBox *CT_BorderBox
        // Delimiter Object
        D *CT_D
        // Array Object
        EqArr *CT_EqArr
        // Fraction Object
        F *CT_F
        // Function Apply Object
        Func *CT_Func
        // Group-Character Object
        GroupChr *CT_GroupChr
        // Lower-Limit Object
        LimLow *CT_LimLow
        // Upper-Limit Object
        LimUpp *CT_LimUpp
        // Matrix Object
        M *CT_M
        // n-ary Operator Object
        Nary *CT_Nary
        // Phantom Object
        Phant *CT_Phant
        // Radical Object
        Rad *CT_Rad
        // Pre-Sub-Superscript Object
        SPre *CT_SPre
        // Subscript Object
        SSub *CT_SSub
        // Sub-Superscript Object
        SSubSup *CT_SSubSup
        // Superscript Object
        SSup *CT_SSup
        // Run
        R *CT_R
    }

### func NewEG_OMathMathElementsChoice ¶

    func NewEG_OMathMathElementsChoice() *EG_OMathMathElementsChoice

### func (*EG_OMathMathElementsChoice) MarshalXML ¶

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

### func (*EG_OMathMathElementsChoice) UnmarshalXML ¶

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

### func (*EG_OMathMathElementsChoice) Validate ¶

    func (m *EG_OMathMathElementsChoice) Validate() error

Validate validates the EG_OMathMathElementsChoice and its children

### func (*EG_OMathMathElementsChoice) ValidateWithPath ¶

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

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

## type EG_ScriptStyle ¶

    type EG_ScriptStyle struct {
        // Script
        Scr *CT_Script
        // style
        Sty *CT_Style
    }

### func NewEG_ScriptStyle ¶

    func NewEG_ScriptStyle() *EG_ScriptStyle

### func (*EG_ScriptStyle) MarshalXML ¶

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

### func (*EG_ScriptStyle) UnmarshalXML ¶

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

### func (*EG_ScriptStyle) Validate ¶

    func (m *EG_ScriptStyle) Validate() error

Validate validates the EG_ScriptStyle and its children

### func (*EG_ScriptStyle) ValidateWithPath ¶

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

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

## type MathPr ¶

    type MathPr struct {
        CT_MathPr
    }

### func NewMathPr ¶

    func NewMathPr() *MathPr

### func (*MathPr) MarshalXML ¶

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

### func (*MathPr) UnmarshalXML ¶

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

### func (*MathPr) Validate ¶

    func (m *MathPr) Validate() error

Validate validates the MathPr and its children

### func (*MathPr) ValidateWithPath ¶

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

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

## type OMath ¶

    type OMath struct {
        CT_OMath
    }

### func NewOMath ¶

    func NewOMath() *OMath

### func (*OMath) MarshalXML ¶

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

### func (*OMath) UnmarshalXML ¶

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

### func (*OMath) Validate ¶

    func (m *OMath) Validate() error

Validate validates the OMath and its children

### func (*OMath) ValidateWithPath ¶

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

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

## type OMathPara ¶

    type OMathPara struct {
        CT_OMathPara
    }

### func NewOMathPara ¶

    func NewOMathPara() *OMathPara

### func (*OMathPara) MarshalXML ¶

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

### func (*OMathPara) UnmarshalXML ¶

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

### func (*OMathPara) Validate ¶

    func (m *OMathPara) Validate() error

Validate validates the OMathPara and its children

### func (*OMathPara) ValidateWithPath ¶

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

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

## type ST_BreakBin ¶

    type ST_BreakBin byte

    const (
        ST_BreakBinUnset  ST_BreakBin = 0
        ST_BreakBinBefore ST_BreakBin = 1
        ST_BreakBinAfter  ST_BreakBin = 2
        ST_BreakBinRepeat ST_BreakBin = 3
    )

### func (ST_BreakBin) MarshalXML ¶

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

### func (ST_BreakBin) MarshalXMLAttr ¶

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

### func (ST_BreakBin) String ¶

    func (m ST_BreakBin) String() string

### func (*ST_BreakBin) UnmarshalXML ¶

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

### func (*ST_BreakBin) UnmarshalXMLAttr ¶

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

### func (ST_BreakBin) Validate ¶

    func (m ST_BreakBin) Validate() error

### func (ST_BreakBin) ValidateWithPath ¶

    func (m ST_BreakBin) ValidateWithPath(path string) error

## type ST_BreakBinSub ¶

    type ST_BreakBinSub byte

    const (
        ST_BreakBinSubUnset ST_BreakBinSub = 0
        ST_BreakBinSub__    ST_BreakBinSub = 1
        ST_BreakBinSub___   ST_BreakBinSub = 2
        ST_BreakBinSub____  ST_BreakBinSub = 3
    )

### func (ST_BreakBinSub) MarshalXML ¶

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

### func (ST_BreakBinSub) MarshalXMLAttr ¶

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

### func (ST_BreakBinSub) String ¶

    func (m ST_BreakBinSub) String() string

### func (*ST_BreakBinSub) UnmarshalXML ¶

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

### func (*ST_BreakBinSub) UnmarshalXMLAttr ¶

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

### func (ST_BreakBinSub) Validate ¶

    func (m ST_BreakBinSub) Validate() error

### func (ST_BreakBinSub) ValidateWithPath ¶

    func (m ST_BreakBinSub) ValidateWithPath(path string) error

## type ST_FType ¶

    type ST_FType byte

    const (
        ST_FTypeUnset ST_FType = 0
        ST_FTypeBar   ST_FType = 1
        ST_FTypeSkw   ST_FType = 2
        ST_FTypeLin   ST_FType = 3
        ST_FTypeNoBar ST_FType = 4
    )

### func (ST_FType) MarshalXML ¶

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

### func (ST_FType) MarshalXMLAttr ¶

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

### func (ST_FType) String ¶

    func (m ST_FType) String() string

### func (*ST_FType) UnmarshalXML ¶

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

### func (*ST_FType) UnmarshalXMLAttr ¶

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

### func (ST_FType) Validate ¶

    func (m ST_FType) Validate() error

### func (ST_FType) ValidateWithPath ¶

    func (m ST_FType) ValidateWithPath(path string) error

## type ST_Jc ¶

    type ST_Jc byte

    const (
        ST_JcUnset       ST_Jc = 0
        ST_JcLeft        ST_Jc = 1
        ST_JcRight       ST_Jc = 2
        ST_JcCenter      ST_Jc = 3
        ST_JcCenterGroup ST_Jc = 4
    )

### func (ST_Jc) MarshalXML ¶

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

### func (ST_Jc) MarshalXMLAttr ¶

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

### func (ST_Jc) String ¶

    func (m ST_Jc) String() string

### func (*ST_Jc) UnmarshalXML ¶

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

### func (*ST_Jc) UnmarshalXMLAttr ¶

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

### func (ST_Jc) Validate ¶

    func (m ST_Jc) Validate() error

### func (ST_Jc) ValidateWithPath ¶

    func (m ST_Jc) ValidateWithPath(path string) error

## type ST_LimLoc ¶

    type ST_LimLoc byte

    const (
        ST_LimLocUnset  ST_LimLoc = 0
        ST_LimLocUndOvr ST_LimLoc = 1
        ST_LimLocSubSup ST_LimLoc = 2
    )

### func (ST_LimLoc) MarshalXML ¶

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

### func (ST_LimLoc) MarshalXMLAttr ¶

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

### func (ST_LimLoc) String ¶

    func (m ST_LimLoc) String() string

### func (*ST_LimLoc) UnmarshalXML ¶

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

### func (*ST_LimLoc) UnmarshalXMLAttr ¶

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

### func (ST_LimLoc) Validate ¶

    func (m ST_LimLoc) Validate() error

### func (ST_LimLoc) ValidateWithPath ¶

    func (m ST_LimLoc) ValidateWithPath(path string) error

## type ST_Script ¶

    type ST_Script byte

    const (
        ST_ScriptUnset         ST_Script = 0
        ST_ScriptRoman         ST_Script = 1
        ST_ScriptScript        ST_Script = 2
        ST_ScriptFraktur       ST_Script = 3
        ST_ScriptDouble_struck ST_Script = 4
        ST_ScriptSans_serif    ST_Script = 5
        ST_ScriptMonospace     ST_Script = 6
    )

### func (ST_Script) MarshalXML ¶

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

### func (ST_Script) MarshalXMLAttr ¶

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

### func (ST_Script) String ¶

    func (m ST_Script) String() string

### func (*ST_Script) UnmarshalXML ¶

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

### func (*ST_Script) UnmarshalXMLAttr ¶

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

### func (ST_Script) Validate ¶

    func (m ST_Script) Validate() error

### func (ST_Script) ValidateWithPath ¶

    func (m ST_Script) ValidateWithPath(path string) error

## type ST_Shp ¶

    type ST_Shp byte

    const (
        ST_ShpUnset    ST_Shp = 0
        ST_ShpCentered ST_Shp = 1
        ST_ShpMatch    ST_Shp = 2
    )

### func (ST_Shp) MarshalXML ¶

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

### func (ST_Shp) MarshalXMLAttr ¶

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

### func (ST_Shp) String ¶

    func (m ST_Shp) String() string

### func (*ST_Shp) UnmarshalXML ¶

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

### func (*ST_Shp) UnmarshalXMLAttr ¶

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

### func (ST_Shp) Validate ¶

    func (m ST_Shp) Validate() error

### func (ST_Shp) ValidateWithPath ¶

    func (m ST_Shp) ValidateWithPath(path string) error

## type ST_Style ¶

    type ST_Style byte

    const (
        ST_StyleUnset ST_Style = 0
        ST_StyleP     ST_Style = 1
        ST_StyleB     ST_Style = 2
        ST_StyleI     ST_Style = 3
        ST_StyleBi    ST_Style = 4
    )

### func (ST_Style) MarshalXML ¶

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

### func (ST_Style) MarshalXMLAttr ¶

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

### func (ST_Style) String ¶

    func (m ST_Style) String() string

### func (*ST_Style) UnmarshalXML ¶

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

### func (*ST_Style) UnmarshalXMLAttr ¶

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

### func (ST_Style) Validate ¶

    func (m ST_Style) Validate() error

### func (ST_Style) ValidateWithPath ¶

    func (m ST_Style) ValidateWithPath(path string) error

## type ST_TopBot ¶

    type ST_TopBot byte

    const (
        ST_TopBotUnset ST_TopBot = 0
        ST_TopBotTop   ST_TopBot = 1
        ST_TopBotBot   ST_TopBot = 2
    )

### func (ST_TopBot) MarshalXML ¶

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

### func (ST_TopBot) MarshalXMLAttr ¶

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

### func (ST_TopBot) String ¶

    func (m ST_TopBot) String() string

### func (*ST_TopBot) UnmarshalXML ¶

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

### func (*ST_TopBot) UnmarshalXMLAttr ¶

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

### func (ST_TopBot) Validate ¶

    func (m ST_TopBot) Validate() error

### func (ST_TopBot) ValidateWithPath ¶

    func (m ST_TopBot) ValidateWithPath(path string) error