README

* XLSX

[[https://travis-ci.org/tealeg/xlsx][https://img.shields.io/travis/tealeg/xlsx/master.svg?style=flat-square]]
[[https://codecov.io/gh/tealeg/xlsx][https://codecov.io/gh/tealeg/xlsx/branch/master/graph/badge.svg]]
[[https://godoc.org/github.com/tealeg/xlsx][https://godoc.org/github.com/tealeg/xlsx?status.svg]]
[[https://github.com/tealeg/xlsx#license][https://img.shields.io/badge/license-bsd-orange.svg]]

** Introduction
xlsx is a library to simplify reading and writing the XML format used
by recent version of Microsoft Excel in Go programs.

The support for writing XLSX files is currently extremely minimal.  It
will expand slowly, but in the meantime patches are welcome!

** Full API docs
The full API docs can be viewed using go's built in documentation
tool, or online at [[http://godoc.org/github.com/tealeg/xlsx][godoc.org]].

** Basic Usage
*** Reading XLSX files
Here is a minimal example usage that will dump all cell data in a
given XLSX file.  A more complete example of this kind of
functionality is contained in [[https://github.com/tealeg/xlsx2csv][the XLSX2CSV program]]:

#+BEGIN_SRC go

package main

import (
    "fmt"
    "github.com/tealeg/xlsx"
)

func main() {
    excelFileName := "/home/tealeg/foo.xlsx"
    xlFile, err := xlsx.OpenFile(excelFileName)
    if err != nil {
        ...
    }
    for _, sheet := range xlFile.Sheets {
        for _, row := range sheet.Rows {
            for _, cell := range row.Cells {
                text := cell.String()
                fmt.Printf("%s\n", text)
            }
        }
    }
}

#+END_SRC

Some additional information is available from the cell (for example,
style information).  For more details see the godoc output for this
package.

*** Writing XLSX files
The following constitutes the bare minimum required to write an XLSX document.

#+BEGIN_SRC go

package main

import (
    "fmt"
    "github.com/tealeg/xlsx"
)

func main() {
    var file *xlsx.File
    var sheet *xlsx.Sheet
    var row *xlsx.Row
    var cell *xlsx.Cell
    var err error

    file = xlsx.NewFile()
    sheet, err = file.AddSheet("Sheet1")
    if err != nil {
        fmt.Printf(err.Error())
    }
    row = sheet.AddRow()
    cell = row.AddCell()
    cell.Value = "I am a cell!"
    err = file.Save("MyXLSXFile.xlsx")
    if err != nil {
        fmt.Printf(err.Error())
    }
}

#+END_SRC

** Contributing

We're extremely happy to review pull requests.  Please be patient, maintaining XLSX doesn't pay anyone's salary (to my knowledge).

If you'd like to propose a change please ensure the following:

- All existing tests are passing.
- There are tests in the test suite that cover the changes you're making.
- You have added documentation strings (in English) to (at least) the public functions you've added or modified.
- Your use of, or creation of, XML is compliant with [[http://www.ecma-international.org/publications/standards/Ecma-376.htm][part 1 of the 4th edition of the ECMA-376 Standard for Office Open XML]].

Eat a peach - Geoff

Documentation

Index

Examples

Constants

View Source
const (
	DataValidationTypeCustom
	DataValidationTypeDate
	DataValidationTypeDecimal

	DataValidationTypeTextLeng
	DataValidationTypeTime
	// DataValidationTypeWhole Integer
	DataValidationTypeWhole
)

    Data validation types

    View Source
    const (
    	DataValidationOperatorBetween
    	DataValidationOperatorEqual
    	DataValidationOperatorGreaterThan
    	DataValidationOperatorGreaterThanOrEqual
    	DataValidationOperatorLessThan
    	DataValidationOperatorLessThanOrEqual
    	DataValidationOperatorNotBetween
    	DataValidationOperatorNotEqual
    )

      Data validation operators

      View Source
      const (
      	MJD_0      float64 = 2400000.5
      	MJD_JD2000 float64 = 51544.5
      )
      View Source
      const (
      	GeneralFormat              = 0
      	IntegerFormat              = 1
      	DecimalFormat              = 2
      	DateFormat_dd_mm_yy        = 14
      	DateTimeFormat_d_m_yy_h_mm = 22
      )
      View Source
      const (
      	Helvetica     = "Helvetica"
      	Baskerville   = "Baskerville Old Face"
      	TimesNewRoman = "Times New Roman"
      	Bodoni        = "Bodoni MT"
      	GillSans      = "Gill Sans MT"
      	Courier       = "Courier"
      )

        Several popular font names that can be used to create fonts

        View Source
        const (
        	RGB_Light_Green = "FFC6EFCE"
        	RGB_Dark_Green  = "FF006100"
        	RGB_Light_Red   = "FFFFC7CE"
        	RGB_Dark_Red    = "FF9C0006"
        	RGB_White       = "00000000"
        	RGB_Black       = "FFFFFFFF"
        )
        View Source
        const ColWidth = 9.5

          Default column width in excel

          View Source
          const Excel2006MaxRowCount = 1048576
          View Source
          const Excel2006MaxRowIndex = Excel2006MaxRowCount - 1
          View Source
          const NoRowLimit int = -1
          View Source
          const (
          	Solid_Cell_Fill = "solid"
          )
          View Source
          const TEMPLATE_DOCPROPS_APP = `` /* 308-byte string literal not displayed */
          
          View Source
          const TEMPLATE_DOCPROPS_CORE = `` /* 364-byte string literal not displayed */
          
          View Source
          const TEMPLATE_XL_THEME_THEME = `` /* 10940-byte string literal not displayed */
          
          View Source
          const TEMPLATE__RELS_DOT_RELS = `` /* 580-byte string literal not displayed */
          

          Variables

          View Source
          var (
          	DefaultDateFormat     = builtInNumFmt[14]
          	DefaultDateTimeFormat = builtInNumFmt[22]
          
          	DefaultDateOptions = DateTimeOptions{
          		Location:        timeLocationUTC,
          		ExcelTimeFormat: DefaultDateFormat,
          	}
          
          	DefaultDateTimeOptions = DateTimeOptions{
          		Location:        timeLocationUTC,
          		ExcelTimeFormat: DefaultDateTimeFormat,
          	}
          )
          View Source
          var (
          	NoCurrentSheetError      = errors.New("no Current Sheet")
          	WrongNumberOfRowsError   = errors.New("invalid number of cells passed to Write. All calls to Write on the same sheet must have the same number of cells")
          	AlreadyOnLastSheetError  = errors.New("NextSheet() called, but already on last sheet")
          	UnsupportedCellTypeError = errors.New("the given cell type is not supported")
          )
          View Source
          var BuiltStreamFileBuilderError = errors.New("StreamFileBuilder has already been built, functions may no longer be used")
          View Source
          var HSLModel = color.ModelFunc(hslModel)

            HSLModel converts any color.Color to a HSL color.

            Functions

            func ColIndexToLetters

            func ColIndexToLetters(colRef int) string

              ColIndexToLetters is used to convert a zero based, numeric column indentifier into a character code.

              func ColLettersToIndex

              func ColLettersToIndex(letters string) int

                ColLettersToIndex is used to convert a character based column reference to a zero based numeric column identifier.

                func FileToSlice

                func FileToSlice(path string) ([][][]string, error)

                  A convenient wrapper around File.ToSlice, FileToSlice will return the raw data contained in an Excel XLSX file as three dimensional slice. The first index represents the sheet number, the second the row number, and the third the cell number.

                  For example:

                  var mySlice [][][]string
                  var value string
                  mySlice = xlsx.FileToSlice("myXLSX.xlsx")
                  value = mySlice[0][0][0]
                  

                  Here, value would be set to the raw value of the cell A1 in the first sheet in the XLSX file.

                  func FileToSliceUnmerged

                  func FileToSliceUnmerged(path string) ([][][]string, error)

                    FileToSliceUnmerged is a wrapper around File.ToSliceUnmerged. It returns the raw data contained in an Excel XLSX file as three dimensional slice. Merged cells will be unmerged. Covered cells become the values of theirs origins.

                    func GetCellIDStringFromCoords

                    func GetCellIDStringFromCoords(x, y int) string

                      GetCellIDStringFromCoords returns the Excel format cell name that represents a pair of zero based cartesian coordinates.

                      func GetCellIDStringFromCoordsWithFixed

                      func GetCellIDStringFromCoordsWithFixed(x, y int, xFixed, yFixed bool) string

                        GetCellIDStringFromCoordsWithFixed returns the Excel format cell name that represents a pair of zero based cartesian coordinates. It can specify either value as fixed.

                        func GetCoordsFromCellIDString

                        func GetCoordsFromCellIDString(cellIDString string) (x, y int, error error)

                          GetCoordsFromCellIDString returns the zero based cartesian coordinates from a cell name in Excel format, e.g. the cellIDString "A1" returns 0, 0 and the "B3" return 1, 2.

                          func HSLToRGB

                          func HSLToRGB(h, s, l float64) (r, g, b uint8)

                            HSLToRGB converts an HSL triple to a RGB triple.

                            Ported from http://goo.gl/Vg1h9

                            func MakeDefaultContentTypes

                            func MakeDefaultContentTypes() (types xlsxTypes)

                            func NewXlsxCellDataValidation

                            func NewXlsxCellDataValidation(allowBlank bool) *xlsxCellDataValidation

                              NewXlsxCellDataValidation return data validation struct

                              func RGBToHSL

                              func RGBToHSL(r, g, b uint8) (h, s, l float64)

                                RGBToHSL converts an RGB triple to a HSL triple.

                                Ported from http://goo.gl/Vg1h9

                                func RowIndexToString

                                func RowIndexToString(rowRef int) string

                                  RowIndexToString is used to convert a zero based, numeric row indentifier into its string representation.

                                  func SetDefaultFont

                                  func SetDefaultFont(size int, name string)

                                  func TimeFromExcelTime

                                  func TimeFromExcelTime(excelTime float64, date1904 bool) time.Time

                                    Convert an excelTime representation (stored as a floating point number) to a time.Time.

                                    func TimeToExcelTime

                                    func TimeToExcelTime(t time.Time, date1904 bool) float64

                                      TimeToExcelTime will convert a time.Time into Excel's float representation, in either 1900 or 1904 mode. If you don't know which to use, set date1904 to false. TODO should this should handle Julian dates?

                                      func TimeToUTCTime

                                      func TimeToUTCTime(t time.Time) time.Time

                                      Types

                                      type Alignment

                                      type Alignment struct {
                                      	Horizontal   string
                                      	Indent       int
                                      	ShrinkToFit  bool
                                      	TextRotation int
                                      	Vertical     string
                                      	WrapText     bool
                                      }

                                      func DefaultAlignment

                                      func DefaultAlignment() *Alignment

                                      type AutoFilter

                                      type AutoFilter struct {
                                      	TopLeftCell     string
                                      	BottomRightCell string
                                      }

                                      type Border

                                      type Border struct {
                                      	Left        string
                                      	LeftColor   string
                                      	Right       string
                                      	RightColor  string
                                      	Top         string
                                      	TopColor    string
                                      	Bottom      string
                                      	BottomColor string
                                      }

                                        Border is a high level structure intended to provide user access to the contents of Border Style within an Sheet.

                                        func DefaultBorder

                                        func DefaultBorder() *Border

                                        func NewBorder

                                        func NewBorder(left, right, top, bottom string) *Border

                                        type Cell

                                        type Cell struct {
                                        	Row   *Row
                                        	Value string
                                        
                                        	NumFmt string
                                        
                                        	Hidden bool
                                        	HMerge int
                                        	VMerge int
                                        
                                        	DataValidation *xlsxCellDataValidation
                                        	// contains filtered or unexported fields
                                        }

                                          Cell is a high level structure intended to provide user access to the contents of Cell within an xlsx.Row.

                                          func NewCell

                                          func NewCell(r *Row) *Cell

                                            NewCell creates a cell and adds it to a row.

                                            func (*Cell) Bool

                                            func (c *Cell) Bool() bool

                                              Bool returns a boolean from a cell's value. TODO: Determine if the current return value is appropriate for types other than CellTypeBool.

                                              func (*Cell) Float

                                              func (c *Cell) Float() (float64, error)

                                                Float returns the value of cell as a number.

                                                func (*Cell) FormattedValue

                                                func (c *Cell) FormattedValue() (string, error)

                                                  FormattedValue returns a value, and possibly an error condition from a Cell. If it is possible to apply a format to the cell value, it will do so, if not then an error will be returned, along with the raw value of the Cell.

                                                  func (*Cell) Formula

                                                  func (c *Cell) Formula() string

                                                    Formula returns the formula string for the cell.

                                                    func (*Cell) GeneralNumeric

                                                    func (c *Cell) GeneralNumeric() (string, error)

                                                      GeneralNumeric returns the value of the cell as a string. It is formatted very closely to the the XLSX spec for how to display values when the storage type is Number and the format type is General. It is not 100% identical to the spec but is as close as you can get using the built in Go formatting tools.

                                                      func (*Cell) GeneralNumericWithoutScientific

                                                      func (c *Cell) GeneralNumericWithoutScientific() (string, error)

                                                        GeneralNumericWithoutScientific returns numbers that are always formatted as numbers, but it does not follow the rules for when XLSX should switch to scientific notation, since sometimes scientific notation is not desired, even if that is how the document is supposed to be formatted.

                                                        func (*Cell) GetNumberFormat

                                                        func (c *Cell) GetNumberFormat() string

                                                          GetNumberFormat returns the number format string for a cell.

                                                          func (*Cell) GetStyle

                                                          func (c *Cell) GetStyle() *Style

                                                            GetStyle returns the Style associated with a Cell

                                                            func (*Cell) GetTime

                                                            func (c *Cell) GetTime(date1904 bool) (t time.Time, err error)

                                                              GetTime returns the value of a Cell as a time.Time

                                                              func (*Cell) Int

                                                              func (c *Cell) Int() (int, error)

                                                                Int returns the value of cell as integer. Has max 53 bits of precision See: float64(int64(math.MaxInt))

                                                                func (*Cell) Int64

                                                                func (c *Cell) Int64() (int64, error)

                                                                  Int64 returns the value of cell as 64-bit integer.

                                                                  func (*Cell) IsTime

                                                                  func (c *Cell) IsTime() bool

                                                                    IsTime returns true if the cell stores a time value.

                                                                    func (*Cell) Merge

                                                                    func (c *Cell) Merge(hcells, vcells int)

                                                                      Merge with other cells, horizontally and/or vertically.

                                                                      func (*Cell) SetBool

                                                                      func (c *Cell) SetBool(b bool)

                                                                        SetBool sets a cell's value to a boolean.

                                                                        func (*Cell) SetDataValidation

                                                                        func (c *Cell) SetDataValidation(dd *xlsxCellDataValidation)

                                                                          SetDataValidation set data validation

                                                                          func (*Cell) SetDate

                                                                          func (c *Cell) SetDate(t time.Time)

                                                                            SetDate sets the value of a cell to a float.

                                                                            func (*Cell) SetDateTime

                                                                            func (c *Cell) SetDateTime(t time.Time)

                                                                            func (*Cell) SetDateTimeWithFormat

                                                                            func (c *Cell) SetDateTimeWithFormat(n float64, format string)

                                                                            func (*Cell) SetDateWithOptions

                                                                            func (c *Cell) SetDateWithOptions(t time.Time, options DateTimeOptions)

                                                                              SetDateWithOptions allows for more granular control when exporting dates and times

                                                                              func (*Cell) SetFloat

                                                                              func (c *Cell) SetFloat(n float64)

                                                                                SetFloat sets the value of a cell to a float.

                                                                                func (*Cell) SetFloatWithFormat

                                                                                func (c *Cell) SetFloatWithFormat(n float64, format string)

                                                                                  SetFloatWithFormat sets the value of a cell to a float and applies formatting to the cell.

                                                                                  func (*Cell) SetFormat

                                                                                  func (c *Cell) SetFormat(format string)

                                                                                    SetCellFormat set cell value format

                                                                                    func (*Cell) SetFormula

                                                                                    func (c *Cell) SetFormula(formula string)

                                                                                      SetFormula sets the format string for a cell.

                                                                                      func (*Cell) SetInt

                                                                                      func (c *Cell) SetInt(n int)

                                                                                        SetInt sets a cell's value to an integer.

                                                                                        func (*Cell) SetInt64

                                                                                        func (c *Cell) SetInt64(n int64)

                                                                                          SetInt64 sets a cell's value to a 64-bit integer.

                                                                                          func (*Cell) SetString

                                                                                          func (c *Cell) SetString(s string)

                                                                                            SetString sets the value of a cell to a string.

                                                                                            func (*Cell) SetStringFormula

                                                                                            func (c *Cell) SetStringFormula(formula string)

                                                                                            func (*Cell) SetStyle

                                                                                            func (c *Cell) SetStyle(style *Style)

                                                                                              SetStyle sets the style of a cell.

                                                                                              func (*Cell) SetValue

                                                                                              func (c *Cell) SetValue(n interface{})

                                                                                                SetInt sets a cell's value to an integer.

                                                                                                func (*Cell) String

                                                                                                func (c *Cell) String() string

                                                                                                  String returns the value of a Cell as a string. If you'd like to see errors returned from formatting then please use Cell.FormattedValue() instead.

                                                                                                  func (*Cell) Type

                                                                                                  func (c *Cell) Type() CellType

                                                                                                    Type returns the CellType of a cell. See CellType constants for more details.

                                                                                                    type CellInterface

                                                                                                    type CellInterface interface {
                                                                                                    	String() string
                                                                                                    	FormattedValue() string
                                                                                                    }

                                                                                                      CellInterface defines the public API of the Cell.

                                                                                                      type CellMetadata

                                                                                                      type CellMetadata struct {
                                                                                                      	// contains filtered or unexported fields
                                                                                                      }

                                                                                                        CellMetadata represents anything attributable to a cell except for the cell data itself. For example, it is used in StreamFileBuilder.AddSheetWithDefaultColumnMetadata to associate default attributes for cells in a particular column

                                                                                                        var (
                                                                                                        	DefaultStringCellMetadata  CellMetadata
                                                                                                        	DefaultNumericCellMetadata CellMetadata
                                                                                                        	DefaultDecimalCellMetadata CellMetadata
                                                                                                        	DefaultIntegerCellMetadata CellMetadata
                                                                                                        	DefaultDateCellMetadata    CellMetadata
                                                                                                        )

                                                                                                        func MakeCellMetadata

                                                                                                        func MakeCellMetadata(cellType CellType, streamStyle StreamStyle) CellMetadata

                                                                                                        func (CellMetadata) Ptr

                                                                                                        func (cm CellMetadata) Ptr() *CellMetadata

                                                                                                        type CellType

                                                                                                        type CellType int

                                                                                                          CellType is an int type for storing metadata about the data type in the cell.

                                                                                                          const (
                                                                                                          	CellTypeString CellType = iota
                                                                                                          	// CellTypeStringFormula is a specific format for formulas that return string values. Formulas that return numbers
                                                                                                          	// and booleans are stored as those types.
                                                                                                          	CellTypeStringFormula
                                                                                                          	CellTypeNumeric
                                                                                                          	CellTypeBool
                                                                                                          	// CellTypeInline is not respected on save, all inline string cells will be saved as SharedStrings
                                                                                                          	// when saving to an XLSX file. This the same behavior as that found in Excel.
                                                                                                          	CellTypeInline
                                                                                                          	CellTypeError
                                                                                                          	// d (Date): Cell contains a date in the ISO 8601 format.
                                                                                                          	// That is the only mention of this format in the XLSX spec.
                                                                                                          	// Date seems to be unused by the current version of Excel, it stores dates as Numeric cells with a date format string.
                                                                                                          	// For now these cells will have their value output directly. It is unclear if the value is supposed to be parsed
                                                                                                          	// into a number and then formatted using the formatting or not.
                                                                                                          	CellTypeDate
                                                                                                          )

                                                                                                            These are the cell types from the ST_CellType spec

                                                                                                            func (CellType) Ptr

                                                                                                            func (ct CellType) Ptr() *CellType

                                                                                                            type Col

                                                                                                            type Col struct {
                                                                                                            	Min          int
                                                                                                            	Max          int
                                                                                                            	Hidden       bool
                                                                                                            	Width        float64
                                                                                                            	Collapsed    bool
                                                                                                            	OutlineLevel uint8
                                                                                                            
                                                                                                            	DataValidation []*xlsxCellDataValidation
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                            func (*Col) GetStreamStyle

                                                                                                            func (c *Col) GetStreamStyle() StreamStyle

                                                                                                            func (*Col) GetStyle

                                                                                                            func (c *Col) GetStyle() *Style

                                                                                                              GetStyle returns the Style associated with a Col

                                                                                                              func (*Col) SetCellMetadata

                                                                                                              func (c *Col) SetCellMetadata(cellMetadata CellMetadata)

                                                                                                                SetCellMetadata sets the CellMetadata related attributes of a Col

                                                                                                                func (*Col) SetDataValidation

                                                                                                                func (c *Col) SetDataValidation(dd *xlsxCellDataValidation, start, end int)

                                                                                                                  SetDataValidation set data validation with zero based start and end. Set end to -1 for all rows.

                                                                                                                  func (*Col) SetDataValidationWithStart

                                                                                                                  func (c *Col) SetDataValidationWithStart(dd *xlsxCellDataValidation, start int)

                                                                                                                    SetDataValidationWithStart set data validation with a zero basd start row. This will apply to the rest of the rest of the column.

                                                                                                                    func (*Col) SetStreamStyle

                                                                                                                    func (c *Col) SetStreamStyle(style StreamStyle)

                                                                                                                      SetStreamStyle sets the style and number format id to the ones specified in the given StreamStyle

                                                                                                                      func (*Col) SetStyle

                                                                                                                      func (c *Col) SetStyle(style *Style)

                                                                                                                        SetStyle sets the style of a Col

                                                                                                                        func (*Col) SetType

                                                                                                                        func (c *Col) SetType(cellType CellType)

                                                                                                                          SetType will set the format string of a column based on the type that you want to set it to. This function does not really make a lot of sense.

                                                                                                                          type DataValidationErrorStyle

                                                                                                                          type DataValidationErrorStyle int
                                                                                                                          const (
                                                                                                                          	StyleStop DataValidationErrorStyle
                                                                                                                          	StyleWarning
                                                                                                                          	StyleInformation
                                                                                                                          )

                                                                                                                            Data validation error styles

                                                                                                                            type DataValidationOperator

                                                                                                                            type DataValidationOperator int

                                                                                                                              DataValidationOperator operator enum

                                                                                                                              type DataValidationType

                                                                                                                              type DataValidationType int

                                                                                                                              type DateTimeOptions

                                                                                                                              type DateTimeOptions struct {
                                                                                                                              	// Location allows calculating times in other timezones/locations
                                                                                                                              	Location *time.Location
                                                                                                                              	// ExcelTimeFormat is the string you want excel to use to format the datetime
                                                                                                                              	ExcelTimeFormat string
                                                                                                                              }

                                                                                                                                DateTimeOptions are additional options for exporting times

                                                                                                                                type File

                                                                                                                                type File struct {
                                                                                                                                	Date1904 bool
                                                                                                                                
                                                                                                                                	Sheets []*Sheet
                                                                                                                                	Sheet  map[string]*Sheet
                                                                                                                                
                                                                                                                                	DefinedNames []*xlsxDefinedName
                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                }

                                                                                                                                  File is a high level structure providing a slice of Sheet structs to the user.

                                                                                                                                  func NewFile

                                                                                                                                  func NewFile() *File

                                                                                                                                    Create a new File

                                                                                                                                    func OpenBinary

                                                                                                                                    func OpenBinary(bs []byte) (*File, error)

                                                                                                                                      OpenBinary() take bytes of an XLSX file and returns a populated xlsx.File struct for it.

                                                                                                                                      func OpenBinaryWithRowLimit

                                                                                                                                      func OpenBinaryWithRowLimit(bs []byte, rowLimit int) (*File, error)

                                                                                                                                        OpenBinaryWithRowLimit() take bytes of an XLSX file and returns a populated xlsx.File struct for it.

                                                                                                                                        func OpenFile

                                                                                                                                        func OpenFile(fileName string) (file *File, err error)

                                                                                                                                          OpenFile() take the name of an XLSX file and returns a populated xlsx.File struct for it.

                                                                                                                                          func OpenFileWithRowLimit

                                                                                                                                          func OpenFileWithRowLimit(fileName string, rowLimit int) (file *File, err error)

                                                                                                                                            OpenFileWithRowLimit() will open the file, but will only read the specified number of rows. If you save this file, it will be truncated to the number of rows specified.

                                                                                                                                            func OpenReaderAt

                                                                                                                                            func OpenReaderAt(r io.ReaderAt, size int64) (*File, error)

                                                                                                                                              OpenReaderAt() take io.ReaderAt of an XLSX file and returns a populated xlsx.File struct for it.

                                                                                                                                              func OpenReaderAtWithRowLimit

                                                                                                                                              func OpenReaderAtWithRowLimit(r io.ReaderAt, size int64, rowLimit int) (*File, error)

                                                                                                                                                OpenReaderAtWithRowLimit() take io.ReaderAt of an XLSX file and returns a populated xlsx.File struct for it.

                                                                                                                                                func ReadZip

                                                                                                                                                func ReadZip(f *zip.ReadCloser) (*File, error)

                                                                                                                                                  ReadZip() takes a pointer to a zip.ReadCloser and returns a xlsx.File struct populated with its contents. In most cases ReadZip is not used directly, but is called internally by OpenFile.

                                                                                                                                                  func ReadZipReader

                                                                                                                                                  func ReadZipReader(r *zip.Reader) (*File, error)

                                                                                                                                                    ReadZipReader() can be used to read an XLSX in memory without touching the filesystem.

                                                                                                                                                    func ReadZipReaderWithRowLimit

                                                                                                                                                    func ReadZipReaderWithRowLimit(r *zip.Reader, rowLimit int) (*File, error)

                                                                                                                                                      ReadZipReaderWithRowLimit() can be used to read an XLSX in memory without touching the filesystem. rowLimit is the number of rows that should be read from the file. If rowLimit is -1, no limit is applied. You can specify this with the constant NoRowLimit.

                                                                                                                                                      func ReadZipWithRowLimit

                                                                                                                                                      func ReadZipWithRowLimit(f *zip.ReadCloser, rowLimit int) (*File, error)

                                                                                                                                                        ReadZipWithRowLimit() takes a pointer to a zip.ReadCloser and returns a xlsx.File struct populated with its contents. In most cases ReadZip is not used directly, but is called internally by OpenFile.

                                                                                                                                                        func (*File) AddSheet

                                                                                                                                                        func (f *File) AddSheet(sheetName string) (*Sheet, error)

                                                                                                                                                          AddSheet Add a new Sheet, with the provided name, to a File. The minimum sheet name length is 1 character. If the sheet name length is less an error is thrown. The maximum sheet name length is 31 characters. If the sheet name length is exceeded an error is thrown. These special characters are also not allowed: : \ / ? * [ ]

                                                                                                                                                          func (*File) AppendSheet

                                                                                                                                                          func (f *File) AppendSheet(sheet Sheet, sheetName string) (*Sheet, error)

                                                                                                                                                            Appends an existing Sheet, with the provided name, to a File

                                                                                                                                                            func (*File) MarshallParts

                                                                                                                                                            func (f *File) MarshallParts() (map[string]string, error)

                                                                                                                                                              Construct a map of file name to XML content representing the file in terms of the structure of an XLSX file.

                                                                                                                                                              func (*File) Save

                                                                                                                                                              func (f *File) Save(path string) (err error)

                                                                                                                                                                Save the File to an xlsx file at the provided path.

                                                                                                                                                                func (*File) ToSlice

                                                                                                                                                                func (f *File) ToSlice() (output [][][]string, err error)

                                                                                                                                                                  Return the raw data contained in the File as three dimensional slice. The first index represents the sheet number, the second the row number, and the third the cell number.

                                                                                                                                                                  For example:

                                                                                                                                                                  var mySlice [][][]string
                                                                                                                                                                  var value string
                                                                                                                                                                  mySlice = xlsx.FileToSlice("myXLSX.xlsx")
                                                                                                                                                                  value = mySlice[0][0][0]
                                                                                                                                                                  

                                                                                                                                                                  Here, value would be set to the raw value of the cell A1 in the first sheet in the XLSX file.

                                                                                                                                                                  func (*File) ToSliceUnmerged

                                                                                                                                                                  func (f *File) ToSliceUnmerged() (output [][][]string, err error)

                                                                                                                                                                    ToSliceUnmerged returns the raw data contained in the File as three dimensional slice (s. method ToSlice). A covered cell become the value of its origin cell. Example: table where A1:A2 merged. | 01.01.2011 | Bread | 20 | | | Fish | 70 | This sheet will be converted to the slice: [ [01.01.2011 Bread 20]

                                                                                                                                                                    [01.01.2011 Fish 70] ]
                                                                                                                                                                    

                                                                                                                                                                    func (*File) Write

                                                                                                                                                                    func (f *File) Write(writer io.Writer) (err error)

                                                                                                                                                                      Write the File to io.Writer as xlsx

                                                                                                                                                                      type Fill

                                                                                                                                                                      type Fill struct {
                                                                                                                                                                      	PatternType string
                                                                                                                                                                      	BgColor     string
                                                                                                                                                                      	FgColor     string
                                                                                                                                                                      }

                                                                                                                                                                        Fill is a high level structure intended to provide user access to the contents of background and foreground color index within an Sheet.

                                                                                                                                                                        var (
                                                                                                                                                                        	FillGreen *Fill
                                                                                                                                                                        	FillRed   *Fill
                                                                                                                                                                        	FillWhite *Fill
                                                                                                                                                                        )

                                                                                                                                                                        func DefaultFill

                                                                                                                                                                        func DefaultFill() *Fill

                                                                                                                                                                        func NewFill

                                                                                                                                                                        func NewFill(patternType, fgColor, bgColor string) *Fill

                                                                                                                                                                        type Font

                                                                                                                                                                        type Font struct {
                                                                                                                                                                        	Size      int
                                                                                                                                                                        	Name      string
                                                                                                                                                                        	Family    int
                                                                                                                                                                        	Charset   int
                                                                                                                                                                        	Color     string
                                                                                                                                                                        	Bold      bool
                                                                                                                                                                        	Italic    bool
                                                                                                                                                                        	Underline bool
                                                                                                                                                                        }
                                                                                                                                                                        var (
                                                                                                                                                                        	FontBold       *Font
                                                                                                                                                                        	FontItalic     *Font
                                                                                                                                                                        	FontUnderlined *Font
                                                                                                                                                                        )

                                                                                                                                                                        func DefaultFont

                                                                                                                                                                        func DefaultFont() *Font

                                                                                                                                                                        func NewFont

                                                                                                                                                                        func NewFont(size int, name string) *Font

                                                                                                                                                                        type HSL

                                                                                                                                                                        type HSL struct {
                                                                                                                                                                        	H, S, L float64
                                                                                                                                                                        }

                                                                                                                                                                          HSL represents a cylindrical coordinate of points in an RGB color model.

                                                                                                                                                                          Values are in the range 0 to 1.

                                                                                                                                                                          func (HSL) RGBA

                                                                                                                                                                          func (c HSL) RGBA() (uint32, uint32, uint32, uint32)

                                                                                                                                                                            RGBA returns the alpha-premultiplied red, green, blue and alpha values for the HSL.

                                                                                                                                                                            type Pane

                                                                                                                                                                            type Pane struct {
                                                                                                                                                                            	XSplit      float64
                                                                                                                                                                            	YSplit      float64
                                                                                                                                                                            	TopLeftCell string
                                                                                                                                                                            	ActivePane  string
                                                                                                                                                                            	State       string // Either "split" or "frozen"
                                                                                                                                                                            }

                                                                                                                                                                            type RefTable

                                                                                                                                                                            type RefTable struct {
                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                            }

                                                                                                                                                                            func MakeSharedStringRefTable

                                                                                                                                                                            func MakeSharedStringRefTable(source *xlsxSST) *RefTable

                                                                                                                                                                              MakeSharedStringRefTable() takes an xlsxSST struct and converts it's contents to an slice of strings used to refer to string values by numeric index - this is the model used within XLSX worksheet (a numeric reference is stored to a shared cell value).

                                                                                                                                                                              func NewSharedStringRefTable

                                                                                                                                                                              func NewSharedStringRefTable() *RefTable

                                                                                                                                                                                NewSharedStringRefTable() creates a new, empty RefTable.

                                                                                                                                                                                func (*RefTable) AddString

                                                                                                                                                                                func (rt *RefTable) AddString(str string) int

                                                                                                                                                                                  AddString adds a string to the reference table and return it's numeric index. If the string already exists then it simply returns the existing index.

                                                                                                                                                                                  func (*RefTable) Length

                                                                                                                                                                                  func (rt *RefTable) Length() int

                                                                                                                                                                                  func (*RefTable) ResolveSharedString

                                                                                                                                                                                  func (rt *RefTable) ResolveSharedString(index int) string

                                                                                                                                                                                    Resolvesharedstring() looks up a string value by numeric index from a provided reference table (just a slice of strings in the correct order). This function only exists to provide clarity or purpose via it's name.

                                                                                                                                                                                    type Row

                                                                                                                                                                                    type Row struct {
                                                                                                                                                                                    	Cells        []*Cell
                                                                                                                                                                                    	Hidden       bool
                                                                                                                                                                                    	Sheet        *Sheet
                                                                                                                                                                                    	Height       float64
                                                                                                                                                                                    	OutlineLevel uint8
                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                    }

                                                                                                                                                                                    func (*Row) AddCell

                                                                                                                                                                                    func (r *Row) AddCell() *Cell

                                                                                                                                                                                    func (*Row) ReadStruct

                                                                                                                                                                                    func (r *Row) ReadStruct(ptr interface{}) error

                                                                                                                                                                                      ReadStruct reads a struct from r to ptr. Accepts a ptr to struct. This code expects a tag xlsx:"N", where N is the index of the cell to be used. Basic types like int,string,float64 and bool are supported

                                                                                                                                                                                      Example
                                                                                                                                                                                      Output:
                                                                                                                                                                                      
                                                                                                                                                                                      

                                                                                                                                                                                      func (*Row) SetHeight

                                                                                                                                                                                      func (r *Row) SetHeight(ht float64)

                                                                                                                                                                                      func (*Row) SetHeightCM

                                                                                                                                                                                      func (r *Row) SetHeightCM(ht float64)

                                                                                                                                                                                      func (*Row) WriteSlice

                                                                                                                                                                                      func (r *Row) WriteSlice(e interface{}, cols int) int

                                                                                                                                                                                        Writes an array to row r. Accepts a pointer to array type 'e', and writes the number of columns to write, 'cols'. If 'cols' is < 0, the entire array will be written if possible. Returns -1 if the 'e' doesn't point to an array, otherwise the number of columns written.

                                                                                                                                                                                        func (*Row) WriteStruct

                                                                                                                                                                                        func (r *Row) WriteStruct(e interface{}, cols int) int

                                                                                                                                                                                          Writes a struct to row r. Accepts a pointer to struct type 'e', and the number of columns to write, `cols`. If 'cols' is < 0, the entire struct will be written if possible. Returns -1 if the 'e' doesn't point to a struct, otherwise the number of columns written

                                                                                                                                                                                          type Sheet

                                                                                                                                                                                          type Sheet struct {
                                                                                                                                                                                          	Name        string
                                                                                                                                                                                          	File        *File
                                                                                                                                                                                          	Rows        []*Row
                                                                                                                                                                                          	Cols        []*Col
                                                                                                                                                                                          	MaxRow      int
                                                                                                                                                                                          	MaxCol      int
                                                                                                                                                                                          	Hidden      bool
                                                                                                                                                                                          	Selected    bool
                                                                                                                                                                                          	SheetViews  []SheetView
                                                                                                                                                                                          	SheetFormat SheetFormat
                                                                                                                                                                                          	AutoFilter  *AutoFilter
                                                                                                                                                                                          }

                                                                                                                                                                                            Sheet is a high level structure intended to provide user access to the contents of a particular sheet within an XLSX file.

                                                                                                                                                                                            func (*Sheet) AddRow

                                                                                                                                                                                            func (s *Sheet) AddRow() *Row

                                                                                                                                                                                              Add a new Row to a Sheet

                                                                                                                                                                                              func (*Sheet) AddRowAtIndex

                                                                                                                                                                                              func (s *Sheet) AddRowAtIndex(index int) (*Row, error)

                                                                                                                                                                                                Add a new Row to a Sheet at a specific index

                                                                                                                                                                                                func (*Sheet) Cell

                                                                                                                                                                                                func (sh *Sheet) Cell(row, col int) *Cell

                                                                                                                                                                                                  Get a Cell by passing it's cartesian coordinates (zero based) as row and column integer indexes.

                                                                                                                                                                                                  For example:

                                                                                                                                                                                                  cell := sheet.Cell(0,0)
                                                                                                                                                                                                  

                                                                                                                                                                                                  ... would set the variable "cell" to contain a Cell struct containing the data from the field "A1" on the spreadsheet.

                                                                                                                                                                                                  func (*Sheet) Col

                                                                                                                                                                                                  func (s *Sheet) Col(idx int) *Col

                                                                                                                                                                                                    Make sure we always have as many Cols as we do cells.

                                                                                                                                                                                                    func (*Sheet) RemoveRowAtIndex

                                                                                                                                                                                                    func (s *Sheet) RemoveRowAtIndex(index int) error

                                                                                                                                                                                                      Removes a row at a specific index

                                                                                                                                                                                                      func (*Sheet) Row

                                                                                                                                                                                                      func (s *Sheet) Row(idx int) *Row

                                                                                                                                                                                                        Make sure we always have as many Rows as we do cells.

                                                                                                                                                                                                        func (*Sheet) SetColWidth

                                                                                                                                                                                                        func (s *Sheet) SetColWidth(startcol, endcol int, width float64) error

                                                                                                                                                                                                          Set the width of a single column or multiple columns.

                                                                                                                                                                                                          type SheetFormat

                                                                                                                                                                                                          type SheetFormat struct {
                                                                                                                                                                                                          	DefaultColWidth  float64
                                                                                                                                                                                                          	DefaultRowHeight float64
                                                                                                                                                                                                          	OutlineLevelCol  uint8
                                                                                                                                                                                                          	OutlineLevelRow  uint8
                                                                                                                                                                                                          }

                                                                                                                                                                                                          type SheetView

                                                                                                                                                                                                          type SheetView struct {
                                                                                                                                                                                                          	Pane *Pane
                                                                                                                                                                                                          }

                                                                                                                                                                                                          type StreamCell

                                                                                                                                                                                                          type StreamCell struct {
                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                          }

                                                                                                                                                                                                            StreamCell holds the data, style and type of cell for streaming.

                                                                                                                                                                                                            func NewDateStreamCell

                                                                                                                                                                                                            func NewDateStreamCell(t time.Time) StreamCell

                                                                                                                                                                                                              NewDateStreamCell creates a new cell that holds a date value and is formatted as dd-mm-yyyy and is of type numeric.

                                                                                                                                                                                                              func NewIntegerStreamCell

                                                                                                                                                                                                              func NewIntegerStreamCell(cellData int) StreamCell

                                                                                                                                                                                                                NewIntegerStreamCell creates a new cell that holds an integer value (represented as string), is formatted as a standard integer and is of type numeric.

                                                                                                                                                                                                                func NewStreamCell

                                                                                                                                                                                                                func NewStreamCell(cellData string, cellStyle StreamStyle, cellType CellType) StreamCell

                                                                                                                                                                                                                  NewStreamCell creates a new cell containing the given data with the given style and type.

                                                                                                                                                                                                                  func NewStringStreamCell

                                                                                                                                                                                                                  func NewStringStreamCell(cellData string) StreamCell

                                                                                                                                                                                                                    NewStringStreamCell creates a new cell that holds string data, is of type string and uses general formatting.

                                                                                                                                                                                                                    func NewStyledIntegerStreamCell

                                                                                                                                                                                                                    func NewStyledIntegerStreamCell(cellData int, cellStyle StreamStyle) StreamCell

                                                                                                                                                                                                                      NewStyledIntegerStreamCell creates a new cell that holds an integer value (represented as string) and is styled according to the given style.

                                                                                                                                                                                                                      func NewStyledStringStreamCell

                                                                                                                                                                                                                      func NewStyledStringStreamCell(cellData string, cellStyle StreamStyle) StreamCell

                                                                                                                                                                                                                        NewStyledStringStreamCell creates a new cell that holds a string and is styled according to the given style.

                                                                                                                                                                                                                        type StreamFile

                                                                                                                                                                                                                        type StreamFile struct {
                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                        func (*StreamFile) Close

                                                                                                                                                                                                                        func (sf *StreamFile) Close() error

                                                                                                                                                                                                                          Close closes the Stream File. Any sheets that have not yet been written to will have an empty sheet created for them.

                                                                                                                                                                                                                          func (*StreamFile) Error

                                                                                                                                                                                                                          func (sf *StreamFile) Error() error

                                                                                                                                                                                                                            Error reports any error that has occurred during a previous Write or Flush.

                                                                                                                                                                                                                            func (*StreamFile) Flush

                                                                                                                                                                                                                            func (sf *StreamFile) Flush()

                                                                                                                                                                                                                            func (*StreamFile) NextSheet

                                                                                                                                                                                                                            func (sf *StreamFile) NextSheet() error

                                                                                                                                                                                                                              NextSheet will switch to the next sheet. Sheets are selected in the same order they were added. Once you leave a sheet, you cannot return to it.

                                                                                                                                                                                                                              func (*StreamFile) Write

                                                                                                                                                                                                                              func (sf *StreamFile) Write(cells []string) error

                                                                                                                                                                                                                                Write will write a row of cells to the current sheet. Every call to Write on the same sheet must contain the same number of cells as the header provided when the sheet was created or an error will be returned. This function will always trigger a flush on success. Currently the only supported data type is string data.

                                                                                                                                                                                                                                func (*StreamFile) WriteAll

                                                                                                                                                                                                                                func (sf *StreamFile) WriteAll(records [][]string) error

                                                                                                                                                                                                                                func (*StreamFile) WriteAllS

                                                                                                                                                                                                                                func (sf *StreamFile) WriteAllS(records [][]StreamCell) error

                                                                                                                                                                                                                                  WriteAllS will write all the rows provided in records. All rows must have the same number of cells as the number of columns given when creating the sheet. This function will always trigger a flush on success. WriteAllS supports all data types and styles that are supported by StreamCell.

                                                                                                                                                                                                                                  func (*StreamFile) WriteS

                                                                                                                                                                                                                                  func (sf *StreamFile) WriteS(cells []StreamCell) error

                                                                                                                                                                                                                                    WriteS will write a row of cells to the current sheet. Every call to WriteS on the same sheet must contain the same number of cells as the number of columns provided when the sheet was created or an error will be returned. This function will always trigger a flush on success. WriteS supports all data types and styles that are supported by StreamCell.

                                                                                                                                                                                                                                    func (*StreamFile) WriteWithColumnDefaultMetadata

                                                                                                                                                                                                                                    func (sf *StreamFile) WriteWithColumnDefaultMetadata(cells []string) error

                                                                                                                                                                                                                                      WriteWithColumnDefaultMetadata will write a row of cells to the current sheet. Every call to WriteWithColumnDefaultMetadata on the same sheet must contain the same number of cells as the header provided when the sheet was created or an error will be returned. This function will always trigger a flush on success. Each cell will be encoded with the default CellMetadata of the column that it belongs to. However, if the cell data string cannot be parsed into the cell type in CellMetadata, we fall back on encoding the cell as a string and giving it a default string style

                                                                                                                                                                                                                                      type StreamFileBuilder

                                                                                                                                                                                                                                      type StreamFileBuilder struct {
                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                      func NewStreamFileBuilder

                                                                                                                                                                                                                                      func NewStreamFileBuilder(writer io.Writer) *StreamFileBuilder

                                                                                                                                                                                                                                        NewStreamFileBuilder creates an StreamFileBuilder that will write to the the provided io.writer

                                                                                                                                                                                                                                        func NewStreamFileBuilderForPath

                                                                                                                                                                                                                                        func NewStreamFileBuilderForPath(path string) (*StreamFileBuilder, error)

                                                                                                                                                                                                                                          NewStreamFileBuilderForPath takes the name of an XLSX file and returns a builder for it. The file will be created if it does not exist, or truncated if it does.

                                                                                                                                                                                                                                          func (*StreamFileBuilder) AddSheet

                                                                                                                                                                                                                                          func (sb *StreamFileBuilder) AddSheet(name string, headers []string, cellTypes []*CellType) error

                                                                                                                                                                                                                                            AddSheet will add sheets with the given name with the provided headers. The headers cannot be edited later, and all rows written to the sheet must contain the same number of cells as the header. Sheet names must be unique, or an error will be thrown.

                                                                                                                                                                                                                                            func (*StreamFileBuilder) AddSheetS

                                                                                                                                                                                                                                            func (sb *StreamFileBuilder) AddSheetS(name string, columnStyles []StreamStyle) error

                                                                                                                                                                                                                                              AddSheetS will add a sheet with the given name and column styles. The number of column styles given is the number of columns that will be created, and thus the number of cells each row has to have. columnStyles[0] becomes the style of the first column, columnStyles[1] the style of the second column etc. All the styles in columnStyles have to have been added or an error will be returned. Sheet names must be unique, or an error will be returned.

                                                                                                                                                                                                                                              func (*StreamFileBuilder) AddSheetWithDefaultColumnMetadata

                                                                                                                                                                                                                                              func (sb *StreamFileBuilder) AddSheetWithDefaultColumnMetadata(name string, headers []string, columnsDefaultCellMetadata []*CellMetadata) error

                                                                                                                                                                                                                                              func (*StreamFileBuilder) AddStreamStyle

                                                                                                                                                                                                                                              func (sb *StreamFileBuilder) AddStreamStyle(streamStyle StreamStyle) error

                                                                                                                                                                                                                                                AddStreamStyle adds a new style to the style sheet. Only Styles that have been added through this function will be usable. This function cannot be used after AddSheetS or Build has been called, and if it is called after AddSheetS or Buildit will return an error.

                                                                                                                                                                                                                                                func (*StreamFileBuilder) AddStreamStyleList

                                                                                                                                                                                                                                                func (sb *StreamFileBuilder) AddStreamStyleList(streamStyles []StreamStyle) error

                                                                                                                                                                                                                                                  AddStreamStyleList adds a list of new styles to the style sheet. Only Styles that have been added through either this function or AddStreamStyle will be usable. This function cannot be used after AddSheetS and Build has been called, and if it is called after AddSheetS and Build it will return an error.

                                                                                                                                                                                                                                                  func (*StreamFileBuilder) AddValidation

                                                                                                                                                                                                                                                  func (sb *StreamFileBuilder) AddValidation(sheetIndex, colIndex, rowStartIndex int, validation *xlsxCellDataValidation)

                                                                                                                                                                                                                                                    AddValidation will add a validation to a specific column.

                                                                                                                                                                                                                                                    func (*StreamFileBuilder) Build

                                                                                                                                                                                                                                                    func (sb *StreamFileBuilder) Build() (*StreamFile, error)

                                                                                                                                                                                                                                                      Build begins streaming the XLSX file to the io, by writing all the XLSX metadata. It creates a StreamFile struct that can be used to write the rows to the sheets.

                                                                                                                                                                                                                                                      type StreamStyle

                                                                                                                                                                                                                                                      type StreamStyle struct {
                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        StreamStyle has style and formatting information. Used to store a style for streaming

                                                                                                                                                                                                                                                        var (
                                                                                                                                                                                                                                                        	StreamStyleFromColumn StreamStyle
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	StreamStyleDefaultString    StreamStyle
                                                                                                                                                                                                                                                        	StreamStyleBoldString       StreamStyle
                                                                                                                                                                                                                                                        	StreamStyleItalicString     StreamStyle
                                                                                                                                                                                                                                                        	StreamStyleUnderlinedString StreamStyle
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	StreamStyleDefaultInteger    StreamStyle
                                                                                                                                                                                                                                                        	StreamStyleBoldInteger       StreamStyle
                                                                                                                                                                                                                                                        	StreamStyleItalicInteger     StreamStyle
                                                                                                                                                                                                                                                        	StreamStyleUnderlinedInteger StreamStyle
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	StreamStyleDefaultDate StreamStyle
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	StreamStyleDefaultDecimal StreamStyle
                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                        func MakeDateStyle

                                                                                                                                                                                                                                                        func MakeDateStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle

                                                                                                                                                                                                                                                          MakeDateStyle creates a new style that can be used on cells with Date data. The formatting used is: dd_mm_yy If used on other data the formatting might be wrong.

                                                                                                                                                                                                                                                          func MakeDecimalStyle

                                                                                                                                                                                                                                                          func MakeDecimalStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle

                                                                                                                                                                                                                                                            MakeDecimalStyle creates a new style that can be used on cells with decimal numeric data. If used on other data the formatting might be wrong.

                                                                                                                                                                                                                                                            func MakeIntegerStyle

                                                                                                                                                                                                                                                            func MakeIntegerStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle

                                                                                                                                                                                                                                                              MakeIntegerStyle creates a new style that can be used on cells with integer data. If used on other data the formatting might be wrong.

                                                                                                                                                                                                                                                              func MakeStringStyle

                                                                                                                                                                                                                                                              func MakeStringStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle

                                                                                                                                                                                                                                                                MakeStringStyle creates a new style that can be used on cells with string data. If used on other data the formatting might be wrong.

                                                                                                                                                                                                                                                                func MakeStyle

                                                                                                                                                                                                                                                                func MakeStyle(numFormatId int, font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle

                                                                                                                                                                                                                                                                  MakeStyle creates a new StreamStyle and add it to the styles that will be streamed.

                                                                                                                                                                                                                                                                  type Style

                                                                                                                                                                                                                                                                  type Style struct {
                                                                                                                                                                                                                                                                  	Border          Border
                                                                                                                                                                                                                                                                  	Fill            Fill
                                                                                                                                                                                                                                                                  	Font            Font
                                                                                                                                                                                                                                                                  	ApplyBorder     bool
                                                                                                                                                                                                                                                                  	ApplyFill       bool
                                                                                                                                                                                                                                                                  	ApplyFont       bool
                                                                                                                                                                                                                                                                  	ApplyAlignment  bool
                                                                                                                                                                                                                                                                  	Alignment       Alignment
                                                                                                                                                                                                                                                                  	NamedStyleIndex *int
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    Style is a high level structure intended to provide user access to the contents of Style within an XLSX file.

                                                                                                                                                                                                                                                                    func NewStyle

                                                                                                                                                                                                                                                                    func NewStyle() *Style

                                                                                                                                                                                                                                                                      Return a new Style structure initialised with the default values.

                                                                                                                                                                                                                                                                      type WorkBookRels

                                                                                                                                                                                                                                                                      type WorkBookRels map[string]string

                                                                                                                                                                                                                                                                      func (*WorkBookRels) MakeXLSXWorkbookRels

                                                                                                                                                                                                                                                                      func (w *WorkBookRels) MakeXLSXWorkbookRels() xlsxWorkbookRels

                                                                                                                                                                                                                                                                      type XLSXReaderError

                                                                                                                                                                                                                                                                      type XLSXReaderError struct {
                                                                                                                                                                                                                                                                      	Err string
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        XLSXReaderError is the standard error type for otherwise undefined errors in the XSLX reading process.

                                                                                                                                                                                                                                                                        func (*XLSXReaderError) Error

                                                                                                                                                                                                                                                                        func (e *XLSXReaderError) Error() string

                                                                                                                                                                                                                                                                          Error returns a string value from an XLSXReaderError struct in order that it might comply with the builtin.error interface.

                                                                                                                                                                                                                                                                          type XLSXUnmarshaler

                                                                                                                                                                                                                                                                          type XLSXUnmarshaler interface {
                                                                                                                                                                                                                                                                          	Unmarshal(*Row) error
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            XLSXUnmarshaler is the interface implemented for types that can unmarshal a Row as a representation of themselves.