packaging

package
v0.0.0-...-0fd099e Latest Latest
Warning

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

 Go to latest Published: Nov 25, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ContentTypesPath     = ""
	ContentTypesFileName = "[Content_Types].xml"
)

ContentTypes Defines

View Source 
const (
	CorePropertiesContentType      = "application/vnd.openxmlformats-package.core-properties+xml"
	CorePropertiesRelationshipType = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"

	CorePropertiesPath     = "docProps"
	CorePropertiesFileName = "core.xml"
)

CoreProperties Defines

View Source 
const (
	ExtendedPropertiesContentType      = "application/vnd.openxmlformats-officedocument.extended-properties+xml"
	ExtendedPropertiesRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"

	ExtendedPropertiesPath     = "docProps"
	ExtendedPropertiesFileName = "app.xml"
)

ExtendedProperties Defines

View Source 
const (
	WorkbookRelationshipsPath     = "xl/_rels"
	WorkbookRelationshipsFileName = "workbook.xml.rels"

	RootRelationshipsPath     = "_rels"
	RootRelationshipsFileName = ".rels"
)

Relationships Defines

View Source 
const (
	SharedStringsContentType      = "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"
	SharedStringsRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings"

	SharedStringsPath     = "xl"
	SharedStringsFileName = "sharedStrings.xml"
)

SharedStrings Defines

View Source 
const (
	StyleSheetContentType      = "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"
	StyleSheetRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"

	StyleSheetPath     = "xl"
	StyleSheetFileName = "styles.xml"
)

StyleSheet Defines

View Source 
const (
	TextUnderlineNone            = "none"
	TextUnderlineWords           = "words"
	TextUnderlineSingle          = "sng"
	TextUnderlineDouble          = "dbl"
	TextUnderlineHeavy           = "heavy"
	TextUnderlineDotted          = "dotted"
	TextUnderlineHeavyDotted     = "dottedHeavy"
	TextUnderlineDash            = "dash"
	TextUnderlineDashHeavy       = "dashHeavy"
	TextUnderlineDashLong        = "dashLong"
	TextUnderlineDashLongHeavy   = "dashLongHeavy"
	TextUnderlineDotDash         = "dotDash"
	TextUnderlineDotDashHeavy    = "dotDashHeavy"
	TextUnderlineDotDotDash      = "dotDotDash"
	TextUnderlineDotDotDashHeavy = "dotDotDashHeavy"
	TextUnderlineWavy            = "wavy"
	TextUnderlineWavyHeavy       = "wavyHeavy"
	TextUnderlineWavyDouble      = "wavyDbl"
)

TextUnderlineValues

View Source 
const (
	TextStrikeNoStrike     = "noStrike"
	TextStrikeSingleStrike = "sngStrike"
	TextStrikeDoubleStrike = "dblStrike"
)

TextStrikeValues

View Source 
const (
	ThemeContentType      = "application/vnd.openxmlformats-officedocument.theme+xml"
	ThemeRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"

	ThemePath     = "xl"
	ThemeFileName = "theme/theme%d.xml"
)

Theme Defines

View Source 
const (
	WorkbookContentType      = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"
	WorkbookRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"

	WorkbookPath     = "xl"
	WorkbookFileName = "workbook.xml"
)

Workbook Defines

View Source 
const (
	WorksheetContentType      = "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"
	WorksheetRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"

	WorksheetPath     = "xl"
	WorksheetFileName = "worksheets/sheet%d.xml"
)

Worksheet Defines

View Source 
const (
	// RelationshipContentType rels ContentType
	RelationshipContentType = "application/vnd.openxmlformats-package.relationships+xml"
)
View Source 
const (
	// XMLProlog XML Document Header
	XMLProlog = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type BoolAttr 

type BoolAttr int

func NewBool 

func NewBool(b bool) BoolAttr

func (BoolAttr) MarshalXML 

func (b BoolAttr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*BoolAttr) UnmarshalXML 

func (b *BoolAttr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (BoolAttr) Value 

func (b BoolAttr) Value() bool

type OmitDecimalAttr 

type OmitDecimalAttr decimal.Decimal

func NewOmitDecimal 

func NewOmitDecimal(v decimal.Decimal) OmitDecimalAttr

func (OmitDecimalAttr) MarshalXML 

func (a OmitDecimalAttr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (OmitDecimalAttr) MarshalXMLAttr 

func (i OmitDecimalAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (OmitDecimalAttr) Value 

func (a OmitDecimalAttr) Value() decimal.Decimal

type OmitIntAttr 

type OmitIntAttr int

func (OmitIntAttr) MarshalXML 

func (i OmitIntAttr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (OmitIntAttr) MarshalXMLAttr 

func (i OmitIntAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

type OmitUByteAttr 

type OmitUByteAttr uint8

func (OmitUByteAttr) MarshalXML 

func (i OmitUByteAttr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (OmitUByteAttr) MarshalXMLAttr 

func (i OmitUByteAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

type OmitUIntAttr 

type OmitUIntAttr uint

func (OmitUIntAttr) MarshalXML 

func (i OmitUIntAttr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (OmitUIntAttr) MarshalXMLAttr 

func (i OmitUIntAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

type XAlignment 

type XAlignment struct {
	Horizontal      string   `xml:"horizontal,attr,omitempty"`      // Specifies the type of horizontal alignment in cells.
	Indent          int      `xml:"indent,attr,omitempty"`          // An integer value, where an increment of 1 represents 3 spaces. Indicates the number of spaces (of the normal style font) of indentation for text in a cell.
	JustifyLastLine BoolAttr `xml:"justifyLastLine,attr,omitempty"` // A boolean value indicating if the cells justified or distributed alignment should be used on the last line of text.
	ReadingOrder    int      `xml:"readingOrder,attr,omitempty"`    // An integer value indicating whether the reading order (bidirectionality) of the cell is left-to-right, right-to-left, or context dependent.
	RelativeIndent  int      `xml:"relativeIndent,attr,omitempty"`  // An integer value (used only in a dxf element) to indicate the additional number of spaces of indentation to adjust for text in a cell.
	ShrinkToFit     BoolAttr `xml:"shrinkToFit,attr,omitempty"`     // A boolean value indicating if the displayed text in the cell should be shrunk to fit the cell width. Not applicable when a cell contains multiple lines of text.
	TextRotation    int      `xml:"textRotation,attr,omitempty"`    // Text rotation in cells. Expressed in degrees. Values range from 0 to 180. The first letter of the text is considered the center-point of the arc.
	Vertical        string   `xml:"vertical,attr,omitempty"`        // Vertical alignment in cells.
	WrapText        BoolAttr `xml:"wrapText,attr,omitempty"`        // A boolean value indicating if the text in a cell should be line-wrapped within the cell.
}

XAlignment Alignment type. Formatting information pertaining to text alignment in cells. There are a variety of choices for how text is aligned both horizontally and vertically, as well as indentation settings, and so on. https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.alignment?view=openxml-2.8.1

func (*XAlignment) Equal 

func (a *XAlignment) Equal(other *XAlignment) bool

func (*XAlignment) IsZero 

func (a *XAlignment) IsZero() bool

type XBgFillStyleLst 

type XBgFillStyleLst struct {
	SolidFill []*XSolidFill `xml:"a:solidFill"`
	GradFill  *XGradFill    `xml:"a:gradFill"`
}

XBgFillStyleLst BgFillStyleLst type

type XBgFillStyleLstU 

type XBgFillStyleLstU struct {
	SolidFill []*XSolidFillU `xml:"solidFill"`
	GradFill  *XGradFillU    `xml:"gradFill"`
}

XBgFillStyleLstU fix XML ns

type XBookViews 

type XBookViews struct {
	WorkBookView []*XWorkBookView `xml:"workbookView"`
}

XBookViews BookViews type

type XBookViewsU 

type XBookViewsU struct {
	WorkBookView []*XWorkBookViewU `xml:"workbookView"`
}

XBookViewsU fix XML ns

type XBoolValAttr 

type XBoolValAttr struct {
	Val BoolAttr `xml:"val,attr"`
}

XBoolValAttr Example: <b val="1" />

func (*XBoolValAttr) Equal 

func (a *XBoolValAttr) Equal(other *XBoolValAttr) bool

func (*XBoolValAttr) Value 

func (a *XBoolValAttr) Value() bool

type XBoolValAttrU 

type XBoolValAttrU struct {
	Val BoolAttr `xml:"val,attr"`
}

XBoolValAttrU fix XML ns for XBoolValAttr

type XBorder 

type XBorder struct {
	DiagonalDown BoolAttr     `xml:"diagonalDown,attr,omitempty"` // A boolean value indicating if the cell's diagonal border includes a diagonal line, starting at the top left corner of the cell and moving down to the bottom right corner of the cell.
	DiagonalUp   BoolAttr     `xml:"diagonalUp,attr,omitempty"`   // A boolean value indicating if the cell's diagonal border includes a diagonal line, starting at the bottom left corner of the cell and moving up to the top right corner of the cell.
	Outline      BoolAttr     `xml:"outline,attr,omitempty"`      // A boolean value indicating if left, right, top, and bottom borders should be applied only to outside borders of a cell range.
	Left         *XBorderInfo `xml:"left,omitempty"`
	Right        *XBorderInfo `xml:"right,omitempty"`
	Top          *XBorderInfo `xml:"top,omitempty"`
	Bottom       *XBorderInfo `xml:"bottom,omitempty"`
	Diagonal     *XBorderInfo `xml:"diagonal,omitempty"`
}

XBorder Border type https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.border?view=openxml-2.8.1

func (*XBorder) Equal 

func (b *XBorder) Equal(other *XBorder) bool

type XBorderInfo 

type XBorderInfo struct {
	Style string  `xml:"style,attr,omitempty"`
	Color *XColor `xml:"color,omitempty"`
}

XBorderInfo BorderInfo type

func (*XBorderInfo) Equal 

func (b *XBorderInfo) Equal(other *XBorderInfo) bool

type XBorders 

type XBorders struct {
	Count  int        `xml:"count,attr"`
	Border []*XBorder `xml:"border"`
}

XBorders Borders type

type XBordersU 

type XBordersU struct {
	Count int `xml:"count,attr"`

	Border []*XBorder `xml:"border"`
}

XBordersU fix XML ns for XBorders

type XC 

type XC struct {
	XMLName xml.Name

	R string `xml:"r,attr"`
	S int    `xml:"s,attr,omitempty"`
	T string `xml:"t,attr,omitempty"`
	F *XF    `xml:"f,omitempty"`
	V string `xml:"v,omitempty"`
}

XC This collection represents a cell in the worksheet. Information about the cell's location (reference), value, data type, formatting, and formula is expressed here.

type XCalcPr 

type XCalcPr struct {
	CalcID string `xml:"calcId,attr,omitempty"`
}

XCalcPr CalcPr type

type XCalcPrU 

type XCalcPrU struct {
	CalcID string `xml:"calcId,attr,omitempty"`
}

XCalcPrU fix XML ns

type XCellStyle 

type XCellStyle struct {
	Name          string `xml:"name,attr"`                    // User Defined Cell Style
	XfID          int    `xml:"xfId,attr"`                    // Format Id
	BuiltinID     int    `xml:"builtinId,attr"`               // Built-In Style Id
	CustomBuiltin string `xml:"customBuiltin,attr,omitempty"` // Custom Built In
	Hidden        string `xml:"hidden,attr,omitempty"`        // Hidden Style
	ILevel        string `xml:"iLevel,attr,omitempty"`        // Outline Style
}

XCellStyle CellStyle type

type XCellStyleU 

type XCellStyleU struct {
	Name          string `xml:"name,attr"`
	XfID          int    `xml:"xfId,attr"`
	BuiltinID     int    `xml:"builtinId,attr"`
	CustomBuiltin string `xml:"customBuiltin,attr,omitempty"`
	Hidden        string `xml:"hidden,attr,omitempty"`
	ILevel        string `xml:"iLevel,attr,omitempty"`
}

XCellStyleU fix XML ns for XCellStyle

type XCellStyleXfs 

type XCellStyleXfs struct {
	Count int `xml:"count,attr"`

	Xf []*XXf `xml:"xf"`
}

XCellStyleXfs CellStyleXfs type

type XCellStyleXfsU 

type XCellStyleXfsU struct {
	Count int `xml:"count,attr"`

	Xf []*XXf `xml:"xf"`
}

XCellStyleXfsU fix XML ns for XCellStyleXfs

type XCellStyles 

type XCellStyles struct {
	Count int `xml:"count,attr"` // Style Count

	CellStyle []*XCellStyle `xml:"cellStyle"`
}

XCellStyles This element contains the named cell styles, consisting of a sequence of named style records. A named cell style is a collection of direct or themed formatting (e.g., cell border, cell fill, and font type/size/style) grouped together into a single named style, and can be applied to a cell.

Example: 

For example, "Normal", "Heading 1", "Title", and "20% Accent1" are named cell styles expressed below.
They have builtInId's associated with them, and use xfId to reference the specific formatting elements pertaining to the particular style.
The xfId is a zero-based index, referencing an xf record in the cellStyleXfs collection.

<cellStyles count="4">
  <cellStyle name="20% - Accent1" xfId="3" builtinId="30"/>
  <cellStyle name="Heading 1" xfId="2" builtinId="16"/>
  <cellStyle name="Normal" xfId="0" builtinId="0"/>
  <cellStyle name="Title" xfId="1" builtinId="15"/>
</cellStyles>

type XCellStylesU 

type XCellStylesU struct {
	Count int `xml:"count,attr"`

	CellStyle []*XCellStyleU `xml:"cellStyle"`
}

XCellStylesU fix XML ns for XCellStyles

type XCellXfs 

type XCellXfs struct {
	Count int    `xml:"count,attr"` // Format Count. Count of xf elements.
	Xf    []*XXf `xml:"xf"`         // Formats
}

XCellXfs CellFormats. This element contains the master formatting records (xf) which define the formatting applied to cells in this workbook. These records are the starting point for determining the formatting for a cell. Cells in the Sheet Part reference the xf records by zero-based index.

type XCellXfsU 

type XCellXfsU struct {
	Count int `xml:"count,attr"`

	Xf []*XXf `xml:"xf"`
}

XCellXfsU fix XML ns for XCellXfs

type XClrScheme 

type XClrScheme struct {
	Name     string           `xml:"name,attr"`
	Dk1      *XSysClrElement  `xml:"a:dk1"`
	Lt1      *XSysClrElement  `xml:"a:lt1"`
	Dk2      *XSrgbClrElement `xml:"a:dk2"`
	Lt2      *XSrgbClrElement `xml:"a:lt2"`
	Accent1  *XSrgbClrElement `xml:"a:accent1"`
	Accent2  *XSrgbClrElement `xml:"a:accent2"`
	Accent3  *XSrgbClrElement `xml:"a:accent3"`
	Accent4  *XSrgbClrElement `xml:"a:accent4"`
	Accent5  *XSrgbClrElement `xml:"a:accent5"`
	Accent6  *XSrgbClrElement `xml:"a:accent6"`
	Hlink    *XSrgbClrElement `xml:"a:hlink"`
	FolHlink *XSrgbClrElement `xml:"a:folHlink"`
}

XClrScheme ClrScheme type

type XClrSchemeU 

type XClrSchemeU struct {
	Name     string            `xml:"name,attr"`
	Dk1      *XSysClrElementU  `xml:"dk1"`
	Lt1      *XSysClrElementU  `xml:"lt1"`
	Dk2      *XSrgbClrElementU `xml:"dk2"`
	Lt2      *XSrgbClrElementU `xml:"lt2"`
	Accent1  *XSrgbClrElementU `xml:"accent1"`
	Accent2  *XSrgbClrElementU `xml:"accent2"`
	Accent3  *XSrgbClrElementU `xml:"accent3"`
	Accent4  *XSrgbClrElementU `xml:"accent4"`
	Accent5  *XSrgbClrElementU `xml:"accent5"`
	Accent6  *XSrgbClrElementU `xml:"accent6"`
	Hlink    *XSrgbClrElementU `xml:"hlink"`
	FolHlink *XSrgbClrElementU `xml:"folHlink"`
}

XClrSchemeU fix XML ns

type XCol 

type XCol struct {
	Min          int             `xml:"min,attr"`
	Max          int             `xml:"max,attr"`
	BestFit      BoolAttr        `xml:"bestFit,attr,omitempty"`
	Collapsed    BoolAttr        `xml:"collapsed,attr,omitempty"`
	CustomWidth  BoolAttr        `xml:"customWidth,attr,omitempty"`
	Hidden       BoolAttr        `xml:"hidden,attr,omitempty"`
	OutlineLevel uint8           `xml:"outlineLevel,attr,omitempty"`
	Phonetic     BoolAttr        `xml:"phonetic,attr,omitempty"`
	Style        int             `xml:"style,attr,omitempty"`
	Width        decimal.Decimal `xml:"width,attr"`
}

XCol Col node

type XColor 

type XColor struct {
	// Theme Color. A zero-based index into the <clrScheme> collection (§20.1.6.2), referencing a particular <sysClr> or <srgbClr> value expressed in the Theme part.
	Theme OmitIntAttr `xml:"theme,attr,omitempty"`
	// Alpha Red Green Blue Color Value. Standard Alpha Red Green Blue color value (ARGB).
	RGB string `xml:"rgb,attr,omitempty"`
	// Automatic. A boolean value indicating the color is automatic and system color dependent.
	Auto BoolAttr `xml:"auto,attr,omitempty"`
	// Index. Indexed color value. Only used for backwards compatibility. References a color in indexedColors.
	Indexed OmitIntAttr `xml:"indexed,attr,omitempty"`
	// Tint. Specifies the tint value applied to the color.
	// If tint is supplied, then it is applied to the value of the color to determine the final color applied.
	// The tint value is stored as a double from -1.0 .. 1.0, where -1.0 means 100% darken and 1.0 means 100% lighten. Also, 0.0 means no change.
	Tint string `xml:"tint,attr,omitempty"`
}

XColor Data Bar Color One of the colors associated with the data bar or color scale. The auto attribute shall not be used in the context of data bars.

func (*XColor) Equal 

func (c *XColor) Equal(other *XColor) bool

type XColorU 

type XColorU struct {
	Theme   OmitIntAttr     `xml:"theme,attr"`
	RGB     string          `xml:"rgb,attr,omitempty"`
	Auto    BoolAttr        `xml:"auto,attr,omitempty"`
	Indexed OmitIntAttr     `xml:"indexed,attr,omitempty"`
	Tint    decimal.Decimal `xml:"tint,attr,omitempty"`
}

XColorU fix XML ns for XColor

type XColors 

type XColors struct {
	IndexedColors []any `xml:"x:indexedColors"` // Color Indexes
	MruColors     []any `xml:"x:mruColors"`     // MRU Colors
}

XColors Colors type

type XCols 

type XCols struct {
	Col []*XCol `xml:"col"`
}

XCols Cols node

type XContentTypes 

type XContentTypes struct {
	XMLName xml.Name `xml:"http://schemas.openxmlformats.org/package/2006/content-types Types"`

	Defaults  []*XDefault  `xml:"Default"`
	Overrides []*XOverride `xml:"Override"`
}

XContentTypes directly maps the types element of content types for relationships

func NewXContentTypes 

func NewXContentTypes(worksheetRelations *XRelationships) (contentTypes *XContentTypes)

NewXContentTypes create XContentTypes from WorksheetRelations

type XCoreProperties 

type XCoreProperties struct {
	XMLName       xml.Name `xml:"cp:coreProperties"`
	XmlnsCp       string   `xml:"xmlns:cp,attr"`
	XmlnsDc       string   `xml:"xmlns:dc,attr"`
	XmlnsDcterms  string   `xml:"xmlns:dcterms,attr"`
	XmlnsDcmitype string   `xml:"xmlns:dcmitype,attr"`
	XmlnsXsi      string   `xml:"xmlns:xsi,attr"`

	DcCreator        string           `xml:"dc:creator"`
	CpLastModifiedBy string           `xml:"cp:lastModifiedBy"`
	Created          *XDctermsElement `xml:"dcterms:created"`
	Modified         *XDctermsElement `xml:"dcterms:modified"`
}

XCoreProperties directly maps the root element

func NewDefaultXCoreProperties 

func NewDefaultXCoreProperties() *XCoreProperties

NewDefaultXCoreProperties create *XCoreProperties with default template

type XCorePropertiesU 

type XCorePropertiesU struct {
	XMLName       xml.Name `xml:"coreProperties"`
	XmlnsCp       string   `xml:"cp,attr"`
	XmlnsDc       string   `xml:"dc,attr"`
	XmlnsDcterms  string   `xml:"dcterms,attr"`
	XmlnsDcmitype string   `xml:"dcmitype,attr"`
	XmlnsXsi      string   `xml:"xsi,attr"`

	DcCreator        string            `xml:"creator"`
	CpLastModifiedBy string            `xml:"lastModifiedBy"`
	Created          *XDctermsElementU `xml:"created"`
	Modified         *XDctermsElementU `xml:"modified"`
}

XCorePropertiesU fix XML ns for XCoreProperties

type XDctermsElement 

type XDctermsElement struct {
	Text string `xml:",chardata"`
	Type string `xml:"xsi:type,attr"`
}

XDctermsElement document time element

type XDctermsElementU 

type XDctermsElementU struct {
	Text string `xml:",chardata"`
	Type string `xml:"type,attr"`
}

XDctermsElementU fix XML ns for XDctermsElement

type XDefault 

type XDefault struct {
	Extension   string `xml:",attr"`
	ContentType string `xml:",attr"`
}

XDefault directly maps the override element in the namespace

type XDimension 

type XDimension struct {
	Ref string `xml:"ref,attr"`
}

XDimension Dimension node

type XDxfs 

type XDxfs struct {
	Count int `xml:"count,attr"`
}

XDxfs Dxfs type

type XDxfsU 

type XDxfsU struct {
	Count int `xml:"count,attr"`
}

XDxfsU fix XML ns for XDxfs

type XEffectLst 

type XEffectLst struct {
	OuterShdw *XOuterShdw `xml:"a:outerShdw"`
}

XEffectLst EffectLst type

type XEffectLstU 

type XEffectLstU struct {
	OuterShdw *XOuterShdwU `xml:"outerShdw"`
}

XEffectLstU fix XML ns

type XEffectStyle 

type XEffectStyle struct {
	EffectLst *XEffectLst `xml:"a:effectLst"`
}

XEffectStyle EffectStyle type

type XEffectStyleLst 

type XEffectStyleLst struct {
	EffectStyle []*XEffectStyle `xml:"a:effectStyle"`
}

XEffectStyleLst EffectStyleLst type

type XEffectStyleLstU 

type XEffectStyleLstU struct {
	EffectStyle []*XEffectStyleU `xml:"effectStyle"`
}

XEffectStyleLstU fix XML ns

type XEffectStyleU 

type XEffectStyleU struct {
	EffectLst *XEffectLstU `xml:"effectLst"`
}

XEffectStyleU fix XML ns

type XExt 

type XExt struct {
	URI         string        `xml:"uri,attr"`
	ThemeFamily *XThemeFamily `xml:"thm15:themeFamily"`
}

XExt Ext type

type XExtLst 

type XExtLst struct {
	Ext *XExt `xml:"a:ext"`
}

XExtLst ExtLst type

type XExtLstU 

type XExtLstU struct {
	Ext *XExtU `xml:"ext"`
}

XExtLstU fix XML ns

type XExtU 

type XExtU struct {
	URI         string         `xml:"uri,attr"`
	ThemeFamily *XThemeFamilyU `xml:"themeFamily"`
}

XExtU fix XML ns

type XExtendedProperties 

type XExtendedProperties struct {
	XMLName xml.Name `xml:"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties Properties"`
	XmlnsVt string   `xml:"xmlns:vt,attr"`

	Application       string  `xml:"Application"`
	DocSecurity       string  `xml:"DocSecurity"`
	ScaleCrop         string  `xml:"ScaleCrop"`
	HeadingPairs      *XPairs `xml:"HeadingPairs"`
	TitlesOfParts     *XPairs `xml:"TitlesOfParts"`
	Company           string  `xml:"Company"`
	LinksUpToDate     string  `xml:"LinksUpToDate"`
	SharedDoc         string  `xml:"SharedDoc"`
	HyperlinksChanged string  `xml:"HyperlinksChanged"`
	AppVersion        string  `xml:"AppVersion"`
}

XExtendedProperties Document extended properties

func NewXExtendedProperties 

func NewXExtendedProperties(workbook *XWorkbook) (properties *XExtendedProperties)

NewXExtendedProperties create *XExtendedProperties from Workbook

type XExtendedPropertiesU 

type XExtendedPropertiesU struct {
	XMLName xml.Name `xml:"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties Properties"`
	XmlnsVt string   `xml:"vt,attr"`

	Application       string   `xml:"Application"`
	DocSecurity       string   `xml:"DocSecurity"`
	ScaleCrop         string   `xml:"ScaleCrop"`
	HeadingPairs      *XPairsU `xml:"HeadingPairs"`
	TitlesOfParts     *XPairsU `xml:"TitlesOfParts"`
	Company           string   `xml:"Company"`
	LinksUpToDate     string   `xml:"LinksUpToDate"`
	SharedDoc         string   `xml:"SharedDoc"`
	HyperlinksChanged string   `xml:"HyperlinksChanged"`
	AppVersion        string   `xml:"AppVersion"`
}

XExtendedPropertiesU fix XML ns for XExtendedProperties

type XExtraClrSchemeLst 

type XExtraClrSchemeLst struct {
}

XExtraClrSchemeLst ExtraClrSchemeLst type

type XExtraClrSchemeLstU 

type XExtraClrSchemeLstU struct {
}

XExtraClrSchemeLstU fix XML ns

type XF 

type XF struct {
	Content string      `xml:",chardata"`
	T       OmitIntAttr `xml:"t,attr,omitempty"`   // Formula type
	Ref     string      `xml:"ref,attr,omitempty"` // Shared formula ref
	Si      int         `xml:"si,attr,omitempty"`  // Shared formula index
}

XF F node

type XFile 

type XFile struct {
	ContentTypes          *XContentTypes       // [Content_Types].xml
	Worksheets            []*XWorksheet        // xl/worksheets/sheet?.xml
	Workbook              *XWorkbook           // xl/workbook.xml
	WorkbookRelationships *XRelationships      // xl/_rels/workbook.xml.rels
	RootRelationships     *XRelationships      // _rels/.rels
	ExtendedProperties    *XExtendedProperties // docProps/app.xml
	CoreProperties        *XCoreProperties     // docProps/core.xml
	Themes                []*XTheme            // xl/theme/theme?.xml
	StyleSheet            *XStyleSheet         // xl/styles.xml
	SharedStrings         *XSharedStrings      // xl/sharedStrings.xml
}

XFile Document all Data

func NewDefaultFile 

func NewDefaultFile(defaultFontName string, defaultFontSize int, sheetName string) (file *XFile)

NewDefaultFile create *XFile with default template

type XFileVersion 

type XFileVersion struct {
	AppName      string `xml:"appName,attr,omitempty"`
	LastEdited   string `xml:"lastEdited,attr,omitempty"`
	LowestEdited string `xml:"lowestEdited,attr,omitempty"`
	RupBuild     string `xml:"rupBuild,attr,omitempty"`
}

XFileVersion FileVersion type

type XFileVersionU 

type XFileVersionU struct {
	AppName      string `xml:"appName,attr,omitempty"`
	LastEdited   string `xml:"lastEdited,attr,omitempty"`
	LowestEdited string `xml:"lowestEdited,attr,omitempty"`
	RupBuild     string `xml:"rupBuild,attr,omitempty"`
}

XFileVersionU fix XML ns

type XFill 

type XFill struct {
	PatternFill *XPatternFill `xml:"patternFill"`
}

XFill Fill type

func (*XFill) Equal 

func (f *XFill) Equal(other *XFill) bool

func (*XFill) GetPatternType 

func (f *XFill) GetPatternType() string

type XFillStyleLst 

type XFillStyleLst struct {
	SolidFill *XSolidFill  `xml:"a:solidFill"`
	GradFill  []*XGradFill `xml:"a:gradFill"`
}

XFillStyleLst FillStyleLst type

type XFillStyleLstU 

type XFillStyleLstU struct {
	SolidFill *XSolidFillU  `xml:"solidFill"`
	GradFill  []*XGradFillU `xml:"gradFill"`
}

XFillStyleLstU fix XML ns

type XFillU 

type XFillU struct {
	PatternFill *XPatternFillU `xml:"patternFill"`
}

XFillU fix XML ns for XFill

type XFills 

type XFills struct {
	Count int `xml:"count,attr"`

	Fill []*XFill `xml:"fill"`
}

XFills Fills type

type XFillsU 

type XFillsU struct {
	Count int `xml:"count,attr"`

	Fill []*XFillU `xml:"fill"`
}

XFillsU fix XML ns for XFills

type XFmtScheme 

type XFmtScheme struct {
	Name           string           `xml:"name,attr"`
	FillStyleLst   *XFillStyleLst   `xml:"a:fillStyleLst"`
	LnStyleLst     *XLnStyleLst     `xml:"a:lnStyleLst"`
	EffectStyleLst *XEffectStyleLst `xml:"a:effectStyleLst"`
	BgFillStyleLst *XBgFillStyleLst `xml:"a:bgFillStyleLst"`
}

XFmtScheme FmtScheme type

type XFmtSchemeU 

type XFmtSchemeU struct {
	Name           string            `xml:"name,attr"`
	FillStyleLst   *XFillStyleLstU   `xml:"fillStyleLst"`
	LnStyleLst     *XLnStyleLstU     `xml:"lnStyleLst"`
	EffectStyleLst *XEffectStyleLstU `xml:"effectStyleLst"`
	BgFillStyleLst *XBgFillStyleLstU `xml:"bgFillStyleLst"`
}

XFmtSchemeU fix XML ns

type XFontElement 

type XFontElement struct {
	Latin *XLatin       `xml:"a:latin"`
	Ea    *XTypeface    `xml:"a:ea"`
	Cs    *XTypeface    `xml:"a:cs"`
	Font  []*XThemeFont `xml:"a:font"`
}

XFontElement FontElement type

type XFontElementU 

type XFontElementU struct {
	Latin *XLatinU       `xml:"latin"`
	Ea    *XTypefaceU    `xml:"ea"`
	Cs    *XTypefaceU    `xml:"cs"`
	Font  []*XThemeFontU `xml:"font"`
}

XFontElementU fix XML ns

type XFontScheme 

type XFontScheme struct {
	Name      string        `xml:"name,attr"`
	MajorFont *XFontElement `xml:"a:majorFont"`
	MinorFont *XFontElement `xml:"a:minorFont"`
}

XFontScheme FontScheme type

type XFontSchemeU 

type XFontSchemeU struct {
	Name      string         `xml:"name,attr"`
	MajorFont *XFontElementU `xml:"majorFont"`
	MinorFont *XFontElementU `xml:"minorFont"`
}

XFontSchemeU fix XML ns

type XFonts 

type XFonts struct {
	Count      int    `xml:"count,attr"`
	KnownFonts string `xml:"x14ac:knownFonts,attr"`

	Font []*XStyleSheetFont `xml:"font"`
}

XFonts Fonts type

type XFontsU 

type XFontsU struct {
	Count      int    `xml:"count,attr"`
	KnownFonts string `xml:"knownFonts,attr"`

	Font []*XStyleSheetFontU `xml:"font"`
}

XFontsU fix XML ns for XFonts

type XFormat 

type XFormat struct {
	// Action Format Action. Specifies the formatting behavior for the area indicated in the pivotArea element.
	// The default value for this attribute is "formatting," which indicates that the specified cells have some formatting applied.
	// The format is specified in the dxfId attribute. If the formatting is cleared from the cells, then the value of this attribute becomes "blank."
	Action string `xml:"action,attr"`
	// DxfID Format Id. Specifies the identifier of the format the application is currently using for the PivotTable.
	// Formatting information is written to the styles part. See the Styles section (§18.8) for more information on formats.
	DxfID int `xml:"dxfId,attr"`
}

XFormat PivotTable Format. Represents the format defined in the PivotTable. https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.format?view=openxml-2.8.1

type XGradFill 

type XGradFill struct {
	RotWithShape string  `xml:"rotWithShape,attr"`
	GsLst        *XGsLst `xml:"a:gsLst"`
	Lin          *XLin   `xml:"a:lin"`
}

XGradFill GradFill type

type XGradFillU 

type XGradFillU struct {
	RotWithShape string   `xml:"rotWithShape,attr"`
	GsLst        *XGsLstU `xml:"gsLst"`
	Lin          *XLinU   `xml:"lin"`
}

XGradFillU fix XML ns

type XGs 

type XGs struct {
	Pos       string      `xml:"pos,attr"`
	SchemeClr *XSchemeClr `xml:"a:schemeClr"`
}

XGs Gs type

type XGsLst 

type XGsLst struct {
	Gs []*XGs `xml:"a:gs"`
}

XGsLst GsLst type

type XGsLstU 

type XGsLstU struct {
	Gs []*XGsU `xml:"gs"`
}

XGsLstU fix XML ns

type XGsU 

type XGsU struct {
	Pos       string       `xml:"pos,attr"`
	SchemeClr *XSchemeClrU `xml:"schemeClr"`
}

XGsU fix XML ns

type XIntValAttr 

type XIntValAttr struct {
	Val int `xml:"val,attr"`
}

XIntValAttr Example: <sz val="11" />

func (*XIntValAttr) Equal 

func (a *XIntValAttr) Equal(other *XIntValAttr) bool

func (*XIntValAttr) Value 

func (a *XIntValAttr) Value() int

type XIntValAttrU 

type XIntValAttrU struct {
	Val int `xml:"val,attr"`
}

XIntValAttrU fix XML ns for XIntValAttr

type XLatin 

type XLatin struct {
	Typeface string `xml:"typeface,attr"`
	Panose   string `xml:"panose,attr"`
}

XLatin Latin type

type XLatinU 

type XLatinU struct {
	Typeface string `xml:"typeface,attr"`
	Panose   string `xml:"panose,attr"`
}

XLatinU fix XML ns

type XLin 

type XLin struct {
	Ang    string `xml:"ang,attr"`
	Scaled string `xml:"scaled,attr"`
}

XLin Lin type

type XLinU 

type XLinU struct {
	Ang    string `xml:"ang,attr"`
	Scaled string `xml:"scaled,attr"`
}

XLinU fix XML ns

type XLn 

type XLn struct {
	W         string           `xml:"w,attr"`
	Cap       string           `xml:"cap,attr"`
	Cmpd      string           `xml:"cmpd,attr"`
	Algn      string           `xml:"algn,attr"`
	SolidFill *XSolidFill      `xml:"a:solidFill"`
	PrstDash  *XValAttrElement `xml:"a:prstDash"`
	Miter     *XMiter          `xml:"a:miter"`
}

XLn Ln type

type XLnStyleLst 

type XLnStyleLst struct {
	Ln []*XLn `xml:"a:ln"`
}

XLnStyleLst LnStyleLst type

type XLnStyleLstU 

type XLnStyleLstU struct {
	Ln []*XLnU `xml:"ln"`
}

XLnStyleLstU fix XML ns

type XLnU 

type XLnU struct {
	W         string            `xml:"w,attr"`
	Cap       string            `xml:"cap,attr"`
	Cmpd      string            `xml:"cmpd,attr"`
	Algn      string            `xml:"algn,attr"`
	SolidFill *XSolidFillU      `xml:"solidFill"`
	PrstDash  *XValAttrElementU `xml:"prstDash"`
	Miter     *XMiterU          `xml:"miter"`
}

XLnU fix XML ns

type XMergeCell 

type XMergeCell struct {
	Ref string `xml:"ref,attr,omitempty"`
}

XMergeCell MergeCell node

type XMergeCells 

type XMergeCells struct {
	Count     int           `xml:"count,attr,omitempty"`
	MergeCell []*XMergeCell `xml:"mergeCell,omitempty"`
}

XMergeCells MergeCells node

type XMiter 

type XMiter struct {
	Lim string `xml:"lim,attr"`
}

XMiter Miter type

type XMiterU 

type XMiterU struct {
	Lim string `xml:"lim,attr"`
}

XMiterU fix XML ns

type XNumFmt 

type XNumFmt struct {
	FormatCode string `xml:"formatCode,attr"` // Number Format Code
	NumFmtID   int    `xml:"numFmtId,attr"`   // Number Format Id. Id used by the master style records (xf's) to reference this number format.
}

XNumFmt This element specifies number format properties which indicate how to format and render the numeric value of a cell. https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformat?view=openxml-2.8.1

func (*XNumFmt) Equal 

func (n *XNumFmt) Equal(other *XNumFmt) bool

type XNumFmtU 

type XNumFmtU struct {
	FormatCode string `xml:"formatCode,attr"`
	NumFmtID   int    `xml:"numFmtId,attr"`
}

XNumFmtU fix XML ns for XNumFmt

type XNumFmts 

type XNumFmts struct {
	Count  int        `xml:"count,attr"` // Number Format Count. Count of number format elements.
	NumFmt []*XNumFmt `xml:"numFmt"`
}

XNumFmts This element defines the number formats in this workbook, consisting of a sequence of numFmt records, where each numFmt record defines a particular number format, indicating how to format and render the numeric value of a cell. https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformats?view=openxml-2.8.1

type XNumFmtsU 

type XNumFmtsU struct {
	Count  int         `xml:"count,attr"`
	NumFmt []*XNumFmtU `xml:"numFmt"`
}

XNumFmtsU fix XML ns for XNumFmts

type XObjectDefaults 

type XObjectDefaults struct {
}

XObjectDefaults ObjectDefaults type

type XObjectDefaultsU 

type XObjectDefaultsU struct {
}

XObjectDefaultsU fix XML ns

type XOuterShdw 

type XOuterShdw struct {
	BlurRad      string    `xml:"blurRad,attr"`
	Dist         string    `xml:"dist,attr"`
	Dir          string    `xml:"dir,attr"`
	Algn         string    `xml:"algn,attr"`
	RotWithShape string    `xml:"rotWithShape,attr"`
	SrgbClr      *XSrgbClr `xml:"a:srgbClr"`
}

XOuterShdw OuterShdw type

type XOuterShdwU 

type XOuterShdwU struct {
	BlurRad      string     `xml:"blurRad,attr"`
	Dist         string     `xml:"dist,attr"`
	Dir          string     `xml:"dir,attr"`
	Algn         string     `xml:"algn,attr"`
	RotWithShape string     `xml:"rotWithShape,attr"`
	SrgbClr      *XSrgbClrU `xml:"srgbClr"`
}

XOuterShdwU fix XML ns

type XOverride 

type XOverride struct {
	PartName    string `xml:",attr"`
	ContentType string `xml:",attr"`
}

XOverride directly maps the default element in the namespace

type XPageMargins 

type XPageMargins struct {
	Left   decimal.Decimal `xml:"left,attr"`
	Right  decimal.Decimal `xml:"right,attr"`
	Top    decimal.Decimal `xml:"top,attr"`
	Bottom decimal.Decimal `xml:"bottom,attr"`
	Header decimal.Decimal `xml:"header,attr"`
	Footer decimal.Decimal `xml:"footer,attr"`
}

XPageMargins PageMargins node

type XPairs 

type XPairs struct {
	Vector *XVector `xml:"vt:vector"`
}

XPairs Pairs Type

type XPairsU 

type XPairsU struct {
	Vector *XVectorU `xml:"vector"`
}

XPairsU fix XML ns for XPairs

type XPatternFill 

type XPatternFill struct {
	PatternType     string  `xml:"patternType,attr"`
	BackgroundColor *XColor `xml:"bgColor,omitempty"`
	ForegroundColor *XColor `xml:"fgColor,omitempty"`
}

XPatternFill PatternFill type

type XPatternFillU 

type XPatternFillU struct {
	PatternType     string  `xml:"patternType,attr"`
	BackgroundColor *XColor `xml:"bgColor,omitempty"`
	ForegroundColor *XColor `xml:"fgColor,omitempty"`
}

XPatternFillU fix XML ns for XPatternFill

type XPhoneticPr 

type XPhoneticPr struct {
	FontID string `xml:"fontId,attr"`
	Type   string `xml:"type,attr"`
}

XPhoneticPr PhoneticPr node

type XRelationship 

type XRelationship struct {
	ID     string `xml:"Id,attr"`
	Type   string `xml:"Type,attr"`
	Target string `xml:"Target,attr"`
	Index  int    `xml:"-"`
}

XRelationship Relationship type

type XRelationships 

type XRelationships struct {
	XMLName xml.Name `xml:"http://schemas.openxmlformats.org/package/2006/relationships Relationships"`

	Relationships []*XRelationship `xml:"Relationship"`
}

XRelationships .rels XMLDocument type

func NewDefaultRootXRelationships 

func NewDefaultRootXRelationships() *XRelationships

NewDefaultRootXRelationships create *XRelationships with default template

func NewWorkbookXRelationships 

func NewWorkbookXRelationships(file *XFile) (workbookRelations *XRelationships)

NewWorkbookXRelationships create *XRelationships from Worksheets and Themes

type XRow 

type XRow struct {
	R              int             `xml:"r,attr"` // row number
	Spans          string          `xml:"spans,attr,omitempty"`
	Hidden         BoolAttr        `xml:"hidden,attr,omitempty"`
	C              []*XC           `xml:"c"`
	Ht             string          `xml:"ht,attr,omitempty"`
	CustomHeight   BoolAttr        `xml:"customHeight,attr,omitempty"`
	OutlineLevel   uint8           `xml:"outlineLevel,attr,omitempty"`
	S              int             `xml:"s,attr,omitempty"`            // row style id
	CustomFormat   BoolAttr        `xml:"customFormat,attr,omitempty"` // enable row custom format
	X14acDyDescent OmitDecimalAttr `xml:"x14ac:dyDescent,attr,omitempty"`
}

XRow Row node

type XSchemeClr 

type XSchemeClr struct {
	Val    string           `xml:"val,attr"`
	LumMod *XValAttrElement `xml:"a:lumMod,omitempty"`
	SatMod *XValAttrElement `xml:"a:satMod,omitempty"`
	Tint   *XValAttrElement `xml:"a:tint,omitempty"`
	Shade  *XValAttrElement `xml:"a:shade,omitempty"`
}

XSchemeClr SchemeClr type

type XSchemeClrU 

type XSchemeClrU struct {
	Val    string            `xml:"val,attr"`
	LumMod *XValAttrElementU `xml:"lumMod,omitempty"`
	SatMod *XValAttrElementU `xml:"satMod,omitempty"`
	Tint   *XValAttrElementU `xml:"tint,omitempty"`
	Shade  *XValAttrElementU `xml:"shade,omitempty"`
}

XSchemeClrU fix XML ns

type XSharedStrings 

type XSharedStrings struct {
	XMLName     xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main sst"`
	Count       int      `xml:"count,attr"`
	UniqueCount int      `xml:"uniqueCount,attr"`

	Si []*XSi `xml:"si,omitempty"`
}

XSharedStrings XML document

func NewDefaultXSharedStrings 

func NewDefaultXSharedStrings() *XSharedStrings

NewDefaultXSharedStrings create *XSharedStrings with default template

type XSheet 

type XSheet struct {
	Name    string `xml:"name,attr,omitempty"`
	SheetID int    `xml:"sheetId,attr,omitempty"`
	Rid     string `xml:"r:id,attr,omitempty"`
}

XSheet Sheet type

type XSheetData 

type XSheetData struct {
	XMLName xml.Name `xml:"sheetData"`
	Row     []*XRow  `xml:"row"`
}

XSheetData SheetData node

type XSheetFormatPr 

type XSheetFormatPr struct {
	DefaultRowHeight decimal.Decimal `xml:"defaultRowHeight,attr"` // Default Row Height. Default row height measured in point size. Optimization so we don't have to write the height on all rows. This can be written out if most rows have custom height, to achieve the optimization.
	// X14acDyDescent   decimal.Decimal `xml:"x14ac:dyDescent,attr"`
	DefaultColWidth OmitDecimalAttr `xml:"defaultColWidth,attr,omitempty"` // Default Column Width. Default column width measured as the number of characters of the maximum digit width of the normal style's font.
	BaseColWidth    OmitUIntAttr    `xml:"baseColWidth,attr,omitempty"`    // Base Column Width. Specifies the number of characters of the maximum digit width of the normal style's font. This value does not include margin padding or extra padding for gridlines. It is only the number of characters.
	CustomHeight    BoolAttr        `xml:"customHeight,attr,omitempty"`    // Custom Height. 'True' if defaultRowHeight value has been manually set, or is different from the default value.
	ZeroHeight      BoolAttr        `xml:"zeroHeight,attr,omitempty"`      // Hidden By Default. 'True' if rows are hidden by default. This setting is an optimization used when most rows of the sheet are hidden. In this case, instead of writing out every row and specifying hidden, it is much shorter to only write out the rows that are not hidden, and specify here that rows are hidden by default, and only not hidden if specified.
	ThickTop        BoolAttr        `xml:"thickTop,attr,omitempty"`        // Thick Top Border. 'True' if rows have a thick top border by default.
	ThickBottom     BoolAttr        `xml:"thickBottom,attr,omitempty"`     // Thick Bottom Border. 'True' if rows have a thick bottom border by default.
	OutlineLevelRow OmitUByteAttr   `xml:"outlineLevelRow,attr,omitempty"` // Maximum Outline Row. Highest number of outline level for rows in this sheet. These values shall be in synch with the actual sheet outline levels.
	OutlineLevelCol OmitUByteAttr   `xml:"outlineLevelCol,attr,omitempty"` // Maximum Outline Column. Highest number of outline levels for columns in this sheet. These values shall be in synch with the actual sheet outline levels.
}

XSheetFormatPr SheetFormatPr node https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetformatproperties?view=openxml-3.0.1

type XSheetU 

type XSheetU struct {
	Name    string `xml:"name,attr,omitempty"`
	SheetID int    `xml:"sheetId,attr,omitempty"`
	Rid     string `xml:"id,attr,omitempty"`
}

XSheetU fix XML ns

type XSheetView 

type XSheetView struct {
	TabSelected    int `xml:"tabSelected,attr,omitempty"`
	WorkbookViewID int `xml:"workbookViewId,attr"`
}

XSheetView SheetView node

type XSheetViews 

type XSheetViews struct {
	SheetView *XSheetView `xml:"sheetView"`
}

XSheetViews SheetViews node

type XSheets 

type XSheets struct {
	Sheet []*XSheet `xml:"sheet"`
}

XSheets Sheets type

type XSheetsU 

type XSheetsU struct {
	Sheet []*XSheetU `xml:"sheet"`
}

XSheetsU fix XML ns

type XSi 

type XSi struct {
	T          string       `xml:"t"`
	PhoneticPr *XPhoneticPr `xml:"phoneticPr"`
}

XSi Si node

type XSlicerStyles 

type XSlicerStyles struct {
	DefaultSlicerStyle string `xml:"defaultSlicerStyle,attr"`
}

XSlicerStyles SlicerStyles type

type XSlicerStylesU 

type XSlicerStylesU struct {
	DefaultSlicerStyle string `xml:"defaultSlicerStyle,attr"`
}

XSlicerStylesU fix XML ns for XSlicerStyles

type XSolidFill 

type XSolidFill struct {
	SchemeClr *XSchemeClr      `xml:"a:schemeClr"`
	Tint      *XValAttrElement `xml:"a:tint,omitempty"`
	SatMod    *XValAttrElement `xml:"a:satMod,omitempty"`
}

XSolidFill SolidFill type

type XSolidFillU 

type XSolidFillU struct {
	SchemeClr *XSchemeClrU      `xml:"schemeClr"`
	Tint      *XValAttrElementU `xml:"tint,omitempty"`
	SatMod    *XValAttrElementU `xml:"satMod,omitempty"`
}

XSolidFillU fix XML ns

type XSrgbClr 

type XSrgbClr struct {
	Val   string           `xml:"val,attr"`
	Alpha *XValAttrElement `xml:"a:alpha,omitempty"`
}

XSrgbClr SrgbClr type

type XSrgbClrElement 

type XSrgbClrElement struct {
	SrgbClr *XSrgbClr `xml:"a:srgbClr"`
}

XSrgbClrElement SrgbClrElement type

type XSrgbClrElementU 

type XSrgbClrElementU struct {
	SrgbClr *XSrgbClrU `xml:"srgbClr"`
}

XSrgbClrElementU fix XML ns

type XSrgbClrU 

type XSrgbClrU struct {
	Val   string            `xml:"val,attr"`
	Alpha *XValAttrElementU `xml:"alpha,omitempty"`
}

XSrgbClrU fix XML ns

type XStyleSheet 

type XStyleSheet struct {
	XMLName     xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main styleSheet"`
	XmlnsMc     string   `xml:"xmlns:mc,attr"`
	McIgnorable string   `xml:"mc:Ignorable,attr"`
	XmlnsX14ac  string   `xml:"xmlns:x14ac,attr"`
	XmlnsX16r2  string   `xml:"xmlns:x16r2,attr"`

	NumFmts      *XNumFmts          `xml:"numFmts,omitempty"` // Number Formats
	Fonts        *XFonts            `xml:"fonts"`             // Fonts
	Fills        *XFills            `xml:"fills"`             // Fills
	Borders      *XBorders          `xml:"borders"`           // Borders
	CellStyleXfs *XCellStyleXfs     `xml:"cellStyleXfs"`      // Formatting Records
	CellXfs      *XCellXfs          `xml:"cellXfs"`           // Cell Formats
	CellStyles   *XCellStyles       `xml:"cellStyles"`        // Cell Styles
	Dxfs         *XDxfs             `xml:"dxfs"`              // Formats
	TableStyles  *XTableStyles      `xml:"tableStyles"`       // Table Styles
	ExtLst       *XStyleSheetExtLst `xml:"extLst"`            // Future Feature Data Storage Area

}

XStyleSheet StyleSheet XML document

func NewDefaultXStyleSheet 

func NewDefaultXStyleSheet(defaultFontName string, defaultFontSize int) *XStyleSheet

NewDefaultXStyleSheet create *XStyleSheet with default template

type XStyleSheetExt 

type XStyleSheetExt struct {
	URI            string           `xml:"uri,attr"`
	XmlnsX14       string           `xml:"xmlns:x14,attr,omitempty"`
	XmlnsX15       string           `xml:"xmlns:x15,attr,omitempty"`
	SlicerStyles   *XSlicerStyles   `xml:"x14:slicerStyles,omitempty"`
	TimelineStyles *XTimelineStyles `xml:"x15:timelineStyles,omitempty"`
}

XStyleSheetExt StyleSheetExt type

type XStyleSheetExtLst 

type XStyleSheetExtLst struct {
	Ext []*XStyleSheetExt `xml:"ext"`
}

XStyleSheetExtLst StyleSheetExtLst type

type XStyleSheetExtLstU 

type XStyleSheetExtLstU struct {
	Ext []*XStyleSheetExtU `xml:"ext"`
}

XStyleSheetExtLstU fix XML ns for XStyleSheetExtLst

type XStyleSheetExtU 

type XStyleSheetExtU struct {
	URI            string            `xml:"uri,attr"`
	XmlnsX14       string            `xml:"x14,attr,omitempty"`
	XmlnsX15       string            `xml:"x15,attr,omitempty"`
	SlicerStyles   *XSlicerStylesU   `xml:"slicerStyles,omitempty"`
	TimelineStyles *XTimelineStylesU `xml:"timelineStyles,omitempty"`
}

XStyleSheetExtU fix XML ns for XStyleSheetExt

type XStyleSheetFont 

type XStyleSheetFont struct {
	B         *XBoolValAttr    `xml:"b,omitempty"`         // Bold
	Charset   *XIntValAttr     `xml:"charset,omitempty"`   // Character Set
	Color     *XColor          `xml:"color,omitempty"`     // Text Color
	Condense  *XBoolValAttr    `xml:"condense,omitempty"`  // Condense
	Extend    *XBoolValAttr    `xml:"extend,omitempty"`    // Extend
	Family    *XIntValAttr     `xml:"family"`              // Font Family
	I         *XBoolValAttr    `xml:"i,omitempty"`         // Italic
	Name      *XValAttrElement `xml:"name"`                // Font Name
	Outline   *XBoolValAttr    `xml:"outline,omitempty"`   // Outline
	Scheme    *XValAttrElement `xml:"scheme,omitempty"`    // Scheme
	Shadow    *XBoolValAttr    `xml:"shadow,omitempty"`    // Shadow
	Strike    *XBoolValAttr    `xml:"strike,omitempty"`    // Strike Through. TextStrikeValues
	Sz        *XIntValAttr     `xml:"sz"`                  // Font Size
	U         *XValAttrElement `xml:"u,omitempty"`         // Underline. TextUnderlineValues
	VertAlign *XValAttrElement `xml:"vertAlign,omitempty"` // Vertical Alignment
}

XStyleSheetFont This element defines the properties for one of the fonts used in this workbook. https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.font?view=openxml-2.8.1

func (*XStyleSheetFont) Equal 

func (f *XStyleSheetFont) Equal(other *XStyleSheetFont) bool

type XStyleSheetFontU 

type XStyleSheetFontU struct {
	B         *XBoolValAttr    `xml:"b,omitempty"`         // Bold
	Charset   *XIntValAttr     `xml:"charset,omitempty"`   // Character Set
	Color     *XColor          `xml:"color,omitempty"`     // Text Color
	Condense  *XBoolValAttr    `xml:"condense,omitempty"`  // Condense
	Extend    *XBoolValAttr    `xml:"extend,omitempty"`    // Extend
	Family    *XIntValAttr     `xml:"family"`              // Font Family
	I         *XBoolValAttr    `xml:"i,omitempty"`         // Italic
	Name      *XValAttrElement `xml:"name"`                // Font Name
	Outline   *XBoolValAttr    `xml:"outline,omitempty"`   // Outline
	Scheme    *XValAttrElement `xml:"scheme,omitempty"`    // Scheme
	Shadow    *XBoolValAttr    `xml:"shadow,omitempty"`    // Shadow
	Strike    *XBoolValAttr    `xml:"strike,omitempty"`    // Strike Through. TextStrikeValues
	Sz        *XIntValAttr     `xml:"sz"`                  // Font Size
	U         *XValAttrElement `xml:"u,omitempty"`         // Underline. TextUnderlineValues
	VertAlign *XValAttrElement `xml:"vertAlign,omitempty"` // Vertical Alignment
}

XStyleSheetFontU fix XML ns for XStyleSheetFont

type XStyleSheetU 

type XStyleSheetU struct {
	XMLName     xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main styleSheet"`
	XmlnsMc     string   `xml:"mc,attr"`
	McIgnorable string   `xml:"Ignorable,attr"`
	XmlnsX14ac  string   `xml:"x14ac,attr"`
	XmlnsX16r2  string   `xml:"x16r2,attr"`

	NumFmts      *XNumFmtsU          `xml:"numFmts,omitempty"`
	Fonts        *XFontsU            `xml:"fonts"`
	Fills        *XFillsU            `xml:"fills"`
	Borders      *XBordersU          `xml:"borders"`
	CellStyleXfs *XCellStyleXfsU     `xml:"cellStyleXfs"`
	CellXfs      *XCellXfsU          `xml:"cellXfs"`
	CellStyles   *XCellStylesU       `xml:"cellStyles"`
	Dxfs         *XDxfsU             `xml:"dxfs"`
	TableStyles  *XTableStylesU      `xml:"tableStyles"`
	ExtLst       *XStyleSheetExtLstU `xml:"extLst"`
}

XStyleSheetU fix XML ns for XStyleSheet

type XSysClr 

type XSysClr struct {
	Val     string `xml:"val,attr"`
	LastClr string `xml:"lastClr,attr"`
}

XSysClr SysClr type

type XSysClrElement 

type XSysClrElement struct {
	SysClr *XSysClr `xml:"a:sysClr"`
}

XSysClrElement SysClrElement type

type XSysClrElementU 

type XSysClrElementU struct {
	SysClr *XSysClrU `xml:"sysClr"`
}

XSysClrElementU fix XML ns

type XSysClrU 

type XSysClrU struct {
	Val     string `xml:"val,attr"`
	LastClr string `xml:"lastClr,attr"`
}

XSysClrU fix XML ns

type XTableStyles 

type XTableStyles struct {
	Count             int    `xml:"count,attr"`
	DefaultTableStyle string `xml:"defaultTableStyle,attr"`
	DefaultPivotStyle string `xml:"defaultPivotStyle,attr"`
}

XTableStyles TableStyles type

type XTableStylesU 

type XTableStylesU struct {
	Count             int    `xml:"count,attr"`
	DefaultTableStyle string `xml:"defaultTableStyle,attr"`
	DefaultPivotStyle string `xml:"defaultPivotStyle,attr"`
}

XTableStylesU fix XML ns for XTableStyles

type XTheme 

type XTheme struct {
	XMLName xml.Name `xml:"a:theme"`
	XmlnsA  string   `xml:"xmlns:a,attr"`
	Name    string   `xml:"name,attr"`

	ThemeElements     *XThemeElements     `xml:"a:themeElements"`
	ObjectDefaults    *XObjectDefaults    `xml:"a:objectDefaults"`
	ExtraClrSchemeLst *XExtraClrSchemeLst `xml:"a:extraClrSchemeLst"`
	ExtLst            *XExtLst            `xml:"a:extLst"`
}

XTheme Theme XML doc

func NewDefaultXTheme 

func NewDefaultXTheme() *XTheme

NewDefaultXTheme create *XTheme with default template

type XThemeElements 

type XThemeElements struct {
	ClrScheme  *XClrScheme  `xml:"a:clrScheme"`
	FontScheme *XFontScheme `xml:"a:fontScheme"`
	FmtScheme  *XFmtScheme  `xml:"a:fmtScheme"`
}

XThemeElements ThemeElements type

type XThemeElementsU 

type XThemeElementsU struct {
	ClrScheme  *XClrSchemeU  `xml:"clrScheme"`
	FontScheme *XFontSchemeU `xml:"fontScheme"`
	FmtScheme  *XFmtSchemeU  `xml:"fmtScheme"`
}

XThemeElementsU fix XML ns

type XThemeFamily 

type XThemeFamily struct {
	XmlnsThm15 string `xml:"xmlns:thm15,attr"`
	Name       string `xml:"name,attr"`
	ID         string `xml:"id,attr"`
	Vid        string `xml:"vid,attr"`
}

XThemeFamily ThemeFamily type

type XThemeFamilyU 

type XThemeFamilyU struct {
	XmlnsThm15 string `xml:"thm15,attr"`
	Name       string `xml:"name,attr"`
	ID         string `xml:"id,attr"`
	Vid        string `xml:"vid,attr"`
}

XThemeFamilyU fix XML ns

type XThemeFont 

type XThemeFont struct {
	Script   string `xml:"script,attr"`
	Typeface string `xml:"typeface,attr"`
}

XThemeFont ThemeFont type

type XThemeFontU 

type XThemeFontU struct {
	Script   string `xml:"script,attr"`
	Typeface string `xml:"typeface,attr"`
}

XThemeFontU fix XML ns

type XThemeU 

type XThemeU struct {
	XMLName xml.Name `xml:"theme"`
	XmlnsA  string   `xml:"a,attr"`
	Name    string   `xml:"name,attr"`

	ThemeElements     *XThemeElementsU     `xml:"themeElements"`
	ObjectDefaults    *XObjectDefaultsU    `xml:"objectDefaults"`
	ExtraClrSchemeLst *XExtraClrSchemeLstU `xml:"extraClrSchemeLst"`
	ExtLst            *XExtLstU            `xml:"extLst"`
}

XThemeU fix XML ns

type XTimelineStyles 

type XTimelineStyles struct {
	DefaultTimelineStyle string `xml:"defaultTimelineStyle,attr"`
}

XTimelineStyles TimelineStyles type

type XTimelineStylesU 

type XTimelineStylesU struct {
	DefaultTimelineStyle string `xml:"defaultTimelineStyle,attr"`
}

XTimelineStylesU fix XML ns for XTimelineStyles

type XTypeface 

type XTypeface struct {
	Typeface string `xml:"typeface,attr"`
}

XTypeface Typeface type

type XTypefaceU 

type XTypefaceU struct {
	Typeface string `xml:"typeface,attr"`
}

XTypefaceU fix XML ns

type XValAttrElement 

type XValAttrElement struct {
	Val string `xml:"val,attr"`
}

XValAttrElement Val type

func (*XValAttrElement) Equal 

func (a *XValAttrElement) Equal(b *XValAttrElement) bool

func (*XValAttrElement) Value 

func (a *XValAttrElement) Value() string

type XValAttrElementU 

type XValAttrElementU struct {
	Val string `xml:"val,attr"`
}

XValAttrElementU fix XML ns

type XVariant 

type XVariant struct {
	Lpstr string `xml:"vt:lpstr,omitempty"`
	I4    int32  `xml:"vt:i4,omitempty"`
}

XVariant Variant Type

type XVariantU 

type XVariantU struct {
	Lpstr string `xml:"lpstr,omitempty"`
	I4    int32  `xml:"i4,omitempty"`
}

XVariantU fix XML ns for XVariant

type XVector 

type XVector struct {
	Size     int    `xml:"size,attr"`
	BaseType string `xml:"baseType,attr"`

	Lpstr   []string    `xml:"vt:lpstr,omitempty"`
	Variant []*XVariant `xml:"vt:variant,omitempty"`
}

XVector Vector Type

type XVectorU 

type XVectorU struct {
	Size     int    `xml:"size,attr"`
	BaseType string `xml:"baseType,attr"`

	Lpstr   []string     `xml:"lpstr,omitempty"`
	Variant []*XVariantU `xml:"variant,omitempty"`
}

XVectorU fix XML ns for XVector

type XWorkBookView 

type XWorkBookView struct {
	XWindow      string `xml:"xWindow,attr,omitempty"`
	YWindow      string `xml:"yWindow,attr,omitempty"`
	WindowWidth  int    `xml:"windowWidth,attr,omitempty"`
	WindowHeight int    `xml:"windowHeight,attr,omitempty"`
}

XWorkBookView WorkBookView type

type XWorkBookViewU 

type XWorkBookViewU struct {
	XWindow      string `xml:"xWindow,attr,omitempty"`
	YWindow      string `xml:"yWindow,attr,omitempty"`
	WindowWidth  int    `xml:"windowWidth,attr,omitempty"`
	WindowHeight int    `xml:"windowHeight,attr,omitempty"`
}

XWorkBookViewU fix XML ns

type XWorkbook 

type XWorkbook struct {
	XMLName     xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main workbook"`
	XmlnsR      string   `xml:"xmlns:r,attr"`
	XmlnsMC     string   `xml:"xmlns:mc,attr"`
	McIgnorable string   `xml:"mc:Ignorable,attr"`
	XmlnsX15    string   `xml:"xmlns:x15,attr"`

	FileVersion *XFileVersion `xml:"fileVersion"`
	WorkbookPr  *XWorkbookPr  `xml:"workbookPr"`
	BookViews   *XBookViews   `xml:"bookViews"`
	Sheets      *XSheets      `xml:"sheets"`
	CalcPr      *XCalcPr      `xml:"calcPr"`
}

XWorkbook Workbook XML struct

func NewXWorkbook 

func NewXWorkbook(worksheetRelations *XRelationships, sheetName string) (workbook *XWorkbook)

NewXWorkbook create *XWorkbook from WorksheetRelationships

type XWorkbookPr 

type XWorkbookPr struct {
	DefaultThemeVersion string `xml:"defaultThemeVersion,attr,omitempty"`
}

XWorkbookPr WorkbookPr type

type XWorkbookPrU 

type XWorkbookPrU struct {
	DefaultThemeVersion string `xml:"defaultThemeVersion,attr,omitempty"`
}

XWorkbookPrU fix XML ns

type XWorkbookU 

type XWorkbookU struct {
	XMLName     xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main workbook"`
	XmlnsR      string   `xml:"r,attr"`
	XmlnsMC     string   `xml:"mc,attr"`
	McIgnorable string   `xml:"Ignorable,attr"`
	XmlnsX15    string   `xml:"x15,attr"`

	FileVersion *XFileVersionU `xml:"fileVersion"`
	WorkbookPr  *XWorkbookPrU  `xml:"workbookPr"`
	BookViews   *XBookViewsU   `xml:"bookViews"`
	Sheets      *XSheetsU      `xml:"sheets"`
	CalcPr      *XCalcPrU      `xml:"calcPr"`
}

XWorkbookU fix XML ns

type XWorksheet 

type XWorksheet struct {
	XMLName     xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main worksheet"`
	XmlnsR      string   `xml:"xmlns:r,attr"`
	XmlnsMc     string   `xml:"xmlns:mc,attr"`
	XmlnsX14ac  string   `xml:"xmlns:x14ac,attr"`
	McIgnorable string   `xml:"mc:Ignorable,attr"`

	Dimension     *XDimension     `xml:"dimension"`
	SheetViews    *XSheetViews    `xml:"sheetViews"`
	SheetFormatPr *XSheetFormatPr `xml:"sheetFormatPr"`
	Cols          *XCols          `xml:"cols,omitempty"`
	SheetData     *XSheetData     `xml:"sheetData"`
	MergeCells    *XMergeCells    `xml:"mergeCells,omitempty"`
	PageMargins   *XPageMargins   `xml:"pageMargins"`
}

XWorksheet Worksheet XML doc

func NewDefaultXWorksheet 

func NewDefaultXWorksheet() *XWorksheet

NewDefaultXWorksheet create *XWorksheet with default template

type XXf 

type XXf struct {
	NumFmtID          int         `xml:"numFmtId,attr"`                    // Number Format Id. Id of the number format (numFmt) record used by this cell format.
	FontID            int         `xml:"fontId,attr"`                      // Font Id. Zero-based index of the font record used by this cell format.
	FillID            int         `xml:"fillId,attr"`                      // Fill Id. Zero-based index of the fill record used by this cell format.
	BorderID          int         `xml:"borderId,attr"`                    // Border Id. Zero-based index of the border record used by this cell format.
	XfID              int         `xml:"xfId,attr,omitempty"`              // Format Id. For xf records contained in cellXfs this is the zero-based index of an xf record contained in cellStyleXfs corresponding to the cell style applied to the cell.
	ApplyAlignment    BoolAttr    `xml:"applyAlignment,attr,omitempty"`    // Apply Alignment. A boolean value indicating whether the alignment formatting specified for this xf should be applied.
	ApplyBorder       BoolAttr    `xml:"applyBorder,attr,omitempty"`       // Apply Border. A boolean value indicating whether the border formatting specified for this xf should be applied.
	ApplyFill         BoolAttr    `xml:"applyFill,attr,omitempty"`         // Apply Fill. A boolean value indicating whether the fill formatting specified for this xf should be applied.
	ApplyFont         BoolAttr    `xml:"applyFont,attr,omitempty"`         // Apply Font. A boolean value indicating whether the font formatting specified for this xf should be applied.
	ApplyNumberFormat BoolAttr    `xml:"applyNumberFormat,attr,omitempty"` // Apply Number Format. A boolean value indicating whether the number formatting specified for this xf should be applied.
	ApplyProtection   BoolAttr    `xml:"applyProtection,attr,omitempty"`   // Apply Protection. A boolean value indicating whether the protection formatting specified for this xf should be applied.
	PivotButton       BoolAttr    `xml:"pivotButton,attr,omitempty"`       // Pivot Button. A boolean value indicating whether the cell rendering includes a pivot table dropdown button.
	QuotePrefix       BoolAttr    `xml:"quotePrefix,attr,omitempty"`       // Quote Prefix. A boolean value indicating whether the text string in a cell should be prefixed by a single quote mark (e.g., 'text). In these cases, the quote is not stored in the Shared Strings Part.
	Alignment         *XAlignment `xml:"alignment,omitempty"`              // Alignment
}

XXf CellFormat. Formatting Elements https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.cellformat?view=openxml-2.8.1

func (*XXf) Equal 

func (f *XXf) Equal(other *XXf) bool

Source Files

View all Source files

Jump to

Keyboard shortcuts

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