From 1f73f08185e664d6914c8eb849a9797b26067628 Mon Sep 17 00:00:00 2001
From: Ri Xu <xuri.me@gmail.com>
Date: Mon, 6 Mar 2017 12:05:41 +0800
Subject: - New feature: border setting support (Related issue #21); - Function
parameter code is simplified; - Fix element `Tint` value parsing error in
worksheet; - Update go test
---
cell.go | 8 +-
excelize.go | 10 +--
excelize_test.go | 35 ++++++++
lib.go | 2 +-
picture.go | 6 +-
styles.go | 223 ++++++++++++++++++++++++++++++++++++++++++++++++++
xmlDrawing.go | 4 +-
xmlStyles.go | 243 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
xmlWorksheet.go | 6 +-
9 files changed, 519 insertions(+), 18 deletions(-)
create mode 100644 styles.go
create mode 100644 xmlStyles.go
diff --git a/cell.go b/cell.go
index 3e11298..ce5ba42 100644
--- a/cell.go
+++ b/cell.go
@@ -8,7 +8,7 @@ import (
// GetCellValue provides function to get value from cell by given sheet index
// and axis in XLSX file.
-func (f *File) GetCellValue(sheet string, axis string) string {
+func (f *File) GetCellValue(sheet, axis string) string {
axis = strings.ToUpper(axis)
var xlsx xlsxWorksheet
name := "xl/worksheets/" + strings.ToLower(sheet) + ".xml"
@@ -59,7 +59,7 @@ func (f *File) GetCellValue(sheet string, axis string) string {
// GetCellFormula provides function to get formula from cell by given sheet
// index and axis in XLSX file.
-func (f *File) GetCellFormula(sheet string, axis string) string {
+func (f *File) GetCellFormula(sheet, axis string) string {
axis = strings.ToUpper(axis)
var xlsx xlsxWorksheet
name := "xl/worksheets/" + strings.ToLower(sheet) + ".xml"
@@ -182,8 +182,8 @@ func (f *File) SetCellHyperLink(sheet, axis, link string) {
f.saveFileList(name, replaceWorkSheetsRelationshipsNameSpace(string(output)))
}
-// MergeCell provides function to merge cells by given axis and sheet name.
-// For example create a merged cell of D3:E9 on Sheet1:
+// MergeCell provides function to merge cells by given coordinate area and sheet
+// name. For example create a merged cell of D3:E9 on Sheet1:
//
// xlsx.MergeCell("sheet1", "D3", "E9")
//
diff --git a/excelize.go b/excelize.go
index 58eb092..4079783 100644
--- a/excelize.go
+++ b/excelize.go
@@ -60,7 +60,7 @@ func OpenReader(r io.Reader) (*File, error) {
}
// SetCellValue provides function to set int or string type value of a cell.
-func (f *File) SetCellValue(sheet string, axis string, value interface{}) {
+func (f *File) SetCellValue(sheet, axis string, value interface{}) {
switch t := value.(type) {
case int:
f.SetCellInt(sheet, axis, value.(int))
@@ -86,7 +86,7 @@ func (f *File) SetCellValue(sheet string, axis string, value interface{}) {
}
// SetCellInt provides function to set int type value of a cell.
-func (f *File) SetCellInt(sheet string, axis string, value int) {
+func (f *File) SetCellInt(sheet, axis string, value int) {
axis = strings.ToUpper(axis)
var xlsx xlsxWorksheet
name := "xl/worksheets/" + strings.ToLower(sheet) + ".xml"
@@ -127,7 +127,7 @@ func (f *File) SetCellInt(sheet string, axis string, value int) {
// SetCellStr provides function to set string type value of a cell. Total number
// of characters that a cell can contain 32767 characters.
-func (f *File) SetCellStr(sheet string, axis string, value string) {
+func (f *File) SetCellStr(sheet, axis, value string) {
axis = strings.ToUpper(axis)
var xlsx xlsxWorksheet
name := "xl/worksheets/" + strings.ToLower(sheet) + ".xml"
@@ -170,7 +170,7 @@ func (f *File) SetCellStr(sheet string, axis string, value string) {
// SetCellDefault provides function to set string type value of a cell as
// default format without escaping the cell.
-func (f *File) SetCellDefault(sheet string, axis string, value string) {
+func (f *File) SetCellDefault(sheet, axis, value string) {
axis = strings.ToUpper(axis)
var xlsx xlsxWorksheet
name := "xl/worksheets/" + strings.ToLower(sheet) + ".xml"
@@ -235,7 +235,7 @@ func completeCol(xlsx xlsxWorksheet, row int, cell int) xlsxWorksheet {
}
// Completion row element tags of XML in a sheet.
-func completeRow(xlsx xlsxWorksheet, row int, cell int) xlsxWorksheet {
+func completeRow(xlsx xlsxWorksheet, row, cell int) xlsxWorksheet {
currentRows := len(xlsx.SheetData.Row)
if currentRows > 1 {
lastRow := xlsx.SheetData.Row[currentRows-1].R
diff --git a/excelize_test.go b/excelize_test.go
index 563f0b6..494156b 100644
--- a/excelize_test.go
+++ b/excelize_test.go
@@ -271,3 +271,38 @@ func TestSetRowHeight(t *testing.T) {
t.Log(err)
}
}
+
+func TestSetBorder(t *testing.T) {
+ xlsx, err := OpenFile("./test/Workbook_2.xlsx")
+ if err != nil {
+ t.Log(err)
+ }
+ // Test set border with invalid style parameter.
+ err = xlsx.SetBorder("Sheet1", "J21", "L25", "")
+ if err != nil {
+ t.Log(err)
+ }
+ // Test set border with invalid style index number.
+ err = xlsx.SetBorder("Sheet1", "J21", "L25", "")
+ if err != nil {
+ t.Log(err)
+ }
+ // Test set border on overlapping area.
+ err = xlsx.SetBorder("Sheet1", "J21", "L25", `{"border":[{"type":"left","color":"0000FF","style":-1},{"type":"top","color":"00FF00","style":14},{"type":"bottom","color":"FFFF00","style":5},{"type":"right","color":"FF0000","style":6},{"type":"diagonalDown","color":"A020F0","style":9},{"type":"diagonalUp","color":"A020F0","style":8}]}`)
+ if err != nil {
+ t.Log(err)
+ }
+ err = xlsx.SetBorder("Sheet1", "M28", "K24", `{"border":[{"type":"left","color":"0000FF","style":2},{"type":"top","color":"00FF00","style":3},{"type":"bottom","color":"FFFF00","style":4},{"type":"right","color":"FF0000","style":5},{"type":"diagonalDown","color":"A020F0","style":6},{"type":"diagonalUp","color":"A020F0","style":7}]}`)
+ if err != nil {
+ t.Log(err)
+ }
+ // Test set border for a single cell.
+ err = xlsx.SetBorder("Sheet1", "O22", "O22", `{"border":[{"type":"left","color":"0000FF","style":8},{"type":"top","color":"00FF00","style":9},{"type":"bottom","color":"FFFF00","style":10},{"type":"right","color":"FF0000","style":11},{"type":"diagonalDown","color":"A020F0","style":12},{"type":"diagonalUp","color":"A020F0","style":13}]}`)
+ if err != nil {
+ t.Log(err)
+ }
+ err = xlsx.Save()
+ if err != nil {
+ t.Log(err)
+ }
+}
diff --git a/lib.go b/lib.go
index 8c56f1b..3eda1eb 100644
--- a/lib.go
+++ b/lib.go
@@ -34,7 +34,7 @@ func (f *File) readXML(name string) string {
// saveFileList provides function to update given file content in file list of
// XLSX.
-func (f *File) saveFileList(name string, content string) {
+func (f *File) saveFileList(name, content string) {
f.XLSX[name] = XMLHeader + content
}
diff --git a/picture.go b/picture.go
index 54d820e..fc4eda7 100644
--- a/picture.go
+++ b/picture.go
@@ -17,8 +17,8 @@ import (
// parseFormatPictureSet provides function to parse the format settings of the
// picture with default value.
-func parseFormatPictureSet(formatSet string) *xlsxFormatPicture {
- format := xlsxFormatPicture{
+func parseFormatPictureSet(formatSet string) *formatPicture {
+ format := formatPicture{
FPrintsWithSheet: true,
FLocksWithSheet: false,
NoChangeAspect: false,
@@ -194,7 +194,7 @@ func (f *File) countDrawings() int {
// yAxis, file name and relationship index. In order to solve the problem that
// the label structure is changed after serialization and deserialization, two
// different structures: decodeWsDr and encodeWsDr are defined.
-func (f *File) addDrawing(sheet, drawingXML, cell, file string, width, height, rID int, formatSet *xlsxFormatPicture) {
+func (f *File) addDrawing(sheet, drawingXML, cell, file string, width, height, rID int, formatSet *formatPicture) {
cell = strings.ToUpper(cell)
fromCol := string(strings.Map(letterOnlyMapF, cell))
fromRow, _ := strconv.Atoi(strings.Map(intOnlyMapF, cell))
diff --git a/styles.go b/styles.go
new file mode 100644
index 0000000..0ef5b74
--- /dev/null
+++ b/styles.go
@@ -0,0 +1,223 @@
+package excelize
+
+import (
+ "encoding/json"
+ "encoding/xml"
+ "strconv"
+ "strings"
+)
+
+// parseFormatBordersSet provides function to parse the format settings of the
+// borders.
+func parseFormatBordersSet(bordersSet string) (*formatBorder, error) {
+ var format formatBorder
+ err := json.Unmarshal([]byte(bordersSet), &format)
+ return &format, err
+}
+
+// SetBorder provides function to get value from cell by given sheet index and
+// coordinate area in XLSX file. Note that the color field uses RGB color code
+// and diagonalDown and diagonalUp type border should be use same color in the
+// same coordinate area.
+//
+// For example create a borders of cell H9 on
+// Sheet1:
+//
+// err := xlsx.SetBorder("Sheet1", "H9", "H9", `{"border":[{"type":"left","color":"0000FF","style":3},{"type":"top","color":"00FF00","style":4},{"type":"bottom","color":"FFFF00","style":5},{"type":"right","color":"FF0000","style":6},{"type":"diagonalDown","color":"A020F0","style":7},{"type":"diagonalUp","color":"A020F0","style":8}]}`)
+// if err != nil {
+// fmt.Println(err)
+// }
+//
+// The following shows the border styles sorted by excelize index number:
+//
+// +-------+---------------+--------+-----------------+
+// | Index | Name | Weight | Style |
+// +=======+===============+========+=================+
+// | 0 | None | 0 | |
+// +-------+---------------+--------+-----------------+
+// | 1 | Continuous | 1 | ``-----------`` |
+// +-------+---------------+--------+-----------------+
+// | 2 | Continuous | 2 | ``-----------`` |
+// +-------+---------------+--------+-----------------+
+// | 3 | Dash | 1 | ``- - - - - -`` |
+// +-------+---------------+--------+-----------------+
+// | 4 | Dot | 1 | ``. . . . . .`` |
+// +-------+---------------+--------+-----------------+
+// | 5 | Continuous | 3 | ``-----------`` |
+// +-------+---------------+--------+-----------------+
+// | 6 | Double | 3 | ``===========`` |
+// +-------+---------------+--------+-----------------+
+// | 7 | Continuous | 0 | ``-----------`` |
+// +-------+---------------+--------+-----------------+
+// | 8 | Dash | 2 | ``- - - - - -`` |
+// +-------+---------------+--------+-----------------+
+// | 9 | Dash Dot | 1 | ``- . - . - .`` |
+// +-------+---------------+--------+-----------------+
+// | 10 | Dash Dot | 2 | ``- . - . - .`` |
+// +-------+---------------+--------+-----------------+
+// | 11 | Dash Dot Dot | 1 | ``- . . - . .`` |
+// +-------+---------------+--------+-----------------+
+// | 12 | Dash Dot Dot | 2 | ``- . . - . .`` |
+// +-------+---------------+--------+-----------------+
+// | 13 | SlantDash Dot | 2 | ``/ - . / - .`` |
+// +-------+---------------+--------+-----------------+
+//
+// The following shows the borders in the order shown in the Excel dialog:
+//
+// +-------+-----------------+-------+-----------------+
+// | Index | Style | Index | Style |
+// +=======+=================+=======+=================+
+// | 0 | None | 12 | ``- . . - . .`` |
+// +-------+-----------------+-------+-----------------+
+// | 7 | ``-----------`` | 13 | ``/ - . / - .`` |
+// +-------+-----------------+-------+-----------------+
+// | 4 | ``. . . . . .`` | 10 | ``- . - . - .`` |
+// +-------+-----------------+-------+-----------------+
+// | 11 | ``- . . - . .`` | 8 | ``- - - - - -`` |
+// +-------+-----------------+-------+-----------------+
+// | 9 | ``- . - . - .`` | 2 | ``-----------`` |
+// +-------+-----------------+-------+-----------------+
+// | 3 | ``- - - - - -`` | 5 | ``-----------`` |
+// +-------+-----------------+-------+-----------------+
+// | 1 | ``-----------`` | 6 | ``===========`` |
+// +-------+-----------------+-------+-----------------+
+//
+func (f *File) SetBorder(sheet, hcell, vcell, style string) error {
+ var styleSheet xlsxStyleSheet
+ xml.Unmarshal([]byte(f.readXML("xl/styles.xml")), &styleSheet)
+ formatBorder, err := parseFormatBordersSet(style)
+ if err != nil {
+ return err
+ }
+ borderID := setBorders(&styleSheet, formatBorder)
+ cellXfsID := setCellXfs(&styleSheet, borderID)
+ output, err := xml.Marshal(styleSheet)
+ if err != nil {
+ return err
+ }
+ f.saveFileList("xl/styles.xml", replaceWorkSheetsRelationshipsNameSpace(string(output)))
+ f.setCellStyle(sheet, hcell, vcell, cellXfsID)
+ return err
+}
+
+// setBorders provides function to add border elements in the styles.xml by
+// given borders format settings.
+func setBorders(style *xlsxStyleSheet, formatBorder *formatBorder) int {
+ var styles = []string{
+ "none",
+ "thin",
+ "medium",
+ "dashed",
+ "dotted",
+ "thick",
+ "double",
+ "hair",
+ "mediumDashed",
+ "dashDot",
+ "mediumDashDot",
+ "dashDotDot",
+ "mediumDashDotDot",
+ "slantDashDot",
+ }
+
+ var border xlsxBorder
+ for _, v := range formatBorder.Border {
+ if v.Style > 13 || v.Style < 0 {
+ continue
+ }
+ var color xlsxColor
+ color.RGB = v.Color
+ switch v.Type {
+ case "left":
+ border.Left.Style = styles[v.Style]
+ border.Left.Color = &color
+ case "right":
+ border.Right.Style = styles[v.Style]
+ border.Right.Color = &color
+ case "top":
+ border.Top.Style = styles[v.Style]
+ border.Top.Color = &color
+ case "bottom":
+ border.Bottom.Style = styles[v.Style]
+ border.Bottom.Color = &color
+ case "diagonalUp":
+ border.Diagonal.Style = styles[v.Style]
+ border.Diagonal.Color = &color
+ border.DiagonalUp = true
+ case "diagonalDown":
+ border.Diagonal.Style = styles[v.Style]
+ border.Diagonal.Color = &color
+ border.DiagonalDown = true
+ }
+ }
+ style.Borders.Count++
+ style.Borders.Border = append(style.Borders.Border, &border)
+ return style.Borders.Count - 1
+}
+
+// setCellXfs provides function to set describes all of the formatting for a
+// cell.
+func setCellXfs(style *xlsxStyleSheet, borderID int) int {
+ var xf xlsxXf
+ xf.BorderID = borderID
+ style.CellXfs.Count++
+ style.CellXfs.Xf = append(style.CellXfs.Xf, xf)
+ return style.CellXfs.Count - 1
+}
+
+// setCellStyle provides function to add style attribute for cells by given
+// sheet index, coordinate area and style ID.
+func (f *File) setCellStyle(sheet, hcell, vcell string, styleID int) {
+ hcell = strings.ToUpper(hcell)
+ vcell = strings.ToUpper(vcell)
+
+ // Coordinate conversion, convert C1:B3 to 2,0,1,2.
+ hcol := string(strings.Map(letterOnlyMapF, hcell))
+ hrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, hcell))
+ hyAxis := hrow - 1
+ hxAxis := titleToNumber(hcol)
+
+ vcol := string(strings.Map(letterOnlyMapF, vcell))
+ vrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, vcell))
+ vyAxis := vrow - 1
+ vxAxis := titleToNumber(vcol)
+
+ if vxAxis < hxAxis {
+ hcell, vcell = vcell, hcell
+ vxAxis, hxAxis = hxAxis, vxAxis
+ }
+
+ if vyAxis < hyAxis {
+ hcell, vcell = vcell, hcell
+ vyAxis, hyAxis = hyAxis, vyAxis
+ }
+
+ // Correct the coordinate area, such correct C1:B3 to B1:C3.
+ hcell = toAlphaString(hxAxis+1) + strconv.Itoa(hyAxis+1)
+ vcell = toAlphaString(vxAxis+1) + strconv.Itoa(vyAxis+1)
+
+ var xlsx xlsxWorksheet
+ name := "xl/worksheets/" + strings.ToLower(sheet) + ".xml"
+ xml.Unmarshal([]byte(f.readXML(name)), &xlsx)
+ if f.checked == nil {
+ f.checked = make(map[string]bool)
+ }
+ ok := f.checked[name]
+ if !ok {
+ xlsx = checkRow(xlsx)
+ f.checked[name] = true
+ }
+
+ xlsx = completeRow(xlsx, vxAxis+1, vyAxis+1)
+ xlsx = completeCol(xlsx, vxAxis+1, vyAxis+1)
+
+ for r, row := range xlsx.SheetData.Row {
+ for k, c := range row.C {
+ if checkCellInArea(c.R, hcell+":"+vcell) {
+ xlsx.SheetData.Row[r].C[k].S = styleID
+ }
+ }
+ }
+ output, _ := xml.Marshal(xlsx)
+ f.saveFileList(name, replaceWorkSheetsRelationshipsNameSpace(string(output)))
+}
diff --git a/xmlDrawing.go b/xmlDrawing.go
index a91e7d7..521fe6d 100644
--- a/xmlDrawing.go
+++ b/xmlDrawing.go
@@ -189,8 +189,8 @@ type encodeWsDr struct {
WsDr xlsxWsDr `xml:"xdr:wsDr"`
}
-// xlsxFormatPicture directly maps the format settings of the picture.
-type xlsxFormatPicture struct {
+// formatPicture directly maps the format settings of the picture.
+type formatPicture struct {
FPrintsWithSheet bool `json:"print_obj"`
FLocksWithSheet bool `json:"locked"`
NoChangeAspect bool `json:"lock_aspect_ratio"`
diff --git a/xmlStyles.go b/xmlStyles.go
new file mode 100644
index 0000000..4da8ec9
--- /dev/null
+++ b/xmlStyles.go
@@ -0,0 +1,243 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxStyleSheet directly maps the stylesheet element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxStyleSheet struct {
+ XMLName xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main styleSheet"`
+ NumFmts *xlsxNumFmts `xml:"numFmts,omitempty"`
+ Fonts *xlsxFonts `xml:"fonts,omitempty"`
+ Fills *xlsxFills `xml:"fills,omitempty"`
+ Borders *xlsxBorders `xml:"borders,omitempty"`
+ CellStyleXfs *xlsxCellStyleXfs `xml:"cellStyleXfs,omitempty"`
+ CellXfs *xlsxCellXfs `xml:"cellXfs,omitempty"`
+ CellStyles *xlsxCellStyles `xml:"cellStyles,omitempty"`
+ Dxfs *xlsxDxfs `xml:"dxfs,omitempty"`
+ TableStyles *xlsxTableStyles `xml:"tableStyles,omitempty"`
+ Colors *xlsxStyleColors `xml:"colors,omitempty"`
+ ExtLst *xlsxExtLst `xml:"extLst"`
+}
+
+// xlsxAlignment formatting information pertaining to text alignment in cells.
+// There are a variety of choices for how text is aligned both horizontally and
+// vertically, as well as indentation settings, and so on.
+type xlsxAlignment struct {
+ Horizontal string `xml:"horizontal,attr,omitempty"`
+ Indent int `xml:"indent,attr,omitempty"`
+ JustifyLastLine bool `xml:"justifyLastLine,attr,omitempty"`
+ ReadingOrder uint64 `xml:"readingOrder,attr,omitempty"`
+ RelativeIndent int `xml:"relativeIndent,attr,omitempty"`
+ ShrinkToFit bool `xml:"shrinkToFit,attr,omitempty"`
+ TextRotation int `xml:"textRotation,attr,omitempty"`
+ Vertical string `xml:"vertical,attr,omitempty"`
+ WrapText bool `xml:"wrapText,attr,omitempty"`
+}
+
+// xlsxLine directly maps the line style element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxLine struct {
+ Style string `xml:"style,attr,omitempty"`
+ Color *xlsxColor `xml:"color,omitempty"`
+}
+
+// xlsxColor is a common mapping used for both the fgColor and bgColor elements
+// in the namespace http://schemas.openxmlformats.org/spreadsheetml/2006/main -
+// currently I have not checked it for completeness - it does as much as I need.
+type xlsxColor struct {
+ RGB string `xml:"rgb,attr,omitempty"`
+ Theme *int `xml:"theme,attr,omitempty"`
+ Tint float64 `xml:"tint,attr,omitempty"`
+}
+
+// xlsxFonts directly maps the fonts element. This element contains all font
+// definitions for this workbook.
+type xlsxFonts struct {
+ Count int `xml:"count,attr"`
+ Font []*xlsxFont `xml:"font,omitempty"`
+}
+
+// xlsxFont directly maps the font element. This element defines the properties
+// for one of the fonts used in this workbook.
+type xlsxFont struct {
+ Font string `xml:",innerxml"`
+}
+
+// xlsxFills directly maps the fills element. This element defines the cell
+// fills portion of the Styles part, consisting of a sequence of fill records. A
+// cell fill consists of a background color, foreground color, and pattern to be
+// applied across the cell.
+type xlsxFills struct {
+ Count int `xml:"count,attr"`
+ Fill []xlsxFill `xml:"fill,omitempty"`
+}
+
+// xlsxFill directly maps the fill element. This element specifies fill
+// formatting.
+type xlsxFill struct {
+ Fill string `xml:",innerxml"`
+}
+
+// xlsxBorders directly maps the borders element. This element contains borders
+// formatting information, specifying all border definitions for all cells in
+// the workbook.
+type xlsxBorders struct {
+ Count int `xml:"count,attr"`
+ Border []*xlsxBorder `xml:"border,omitempty"`
+}
+
+// xlsxBorder directly maps the border element. Expresses a single set of cell
+// border formats (left, right, top, bottom, diagonal). Color is optional. When
+// missing, 'automatic' is implied.
+type xlsxBorder struct {
+ DiagonalDown bool `xml:"diagonalDown,attr,omitempty"`
+ DiagonalUp bool `xml:"diagonalUp,attr,omitempty"`
+ Outline bool `xml:"outline,attr,omitempty"`
+ Left xlsxLine `xml:"left,omitempty"`
+ Right xlsxLine `xml:"right,omitempty"`
+ Top xlsxLine `xml:"top,omitempty"`
+ Bottom xlsxLine `xml:"bottom,omitempty"`
+ Diagonal xlsxLine `xml:"diagonal,omitempty"`
+}
+
+// xlsxCellStyles directly maps the cellStyles element. This element contains
+// the named cell styles, consisting of a sequence of named style records. A
+// named cell style is a collection of direct or themed formatting (e.g., cell
+// border, cell fill, and font type/size/style) grouped together into a single
+// named style, and can be applied to a cell.
+type xlsxCellStyles struct {
+ XMLName xml.Name `xml:"cellStyles"`
+ Count int `xml:"count,attr"`
+ CellStyle []*xlsxCellStyle `xml:"cellStyle,omitempty"`
+}
+
+// xlsxCellStyle directly maps the cellStyle element. This element represents
+// the name and related formatting records for a named cell style in this
+// workbook.
+type xlsxCellStyle struct {
+ XMLName xml.Name `xml:"cellStyle"`
+ BuiltInID *int `xml:"builtInId,attr,omitempty"`
+ CustomBuiltIn *bool `xml:"customBuiltIn,attr,omitempty"`
+ Hidden *bool `xml:"hidden,attr,omitempty"`
+ ILevel *bool `xml:"iLevel,attr,omitempty"`
+ Name string `xml:"name,attr"`
+ XfID int `xml:"xfId,attr"`
+}
+
+// xlsxCellStyleXfs directly maps the cellStyleXfs element. This element
+// contains the master formatting records (xf's) which define the formatting for
+// all named cell styles in this workbook. Master formatting records reference
+// individual elements of formatting (e.g., number format, font definitions,
+// cell fills, etc) by specifying a zero-based index into those collections.
+// Master formatting records also specify whether to apply or ignore particular
+// aspects of formatting.
+type xlsxCellStyleXfs struct {
+ Count int `xml:"count,attr"`
+ Xf []xlsxXf `xml:"xf,omitempty"`
+}
+
+// xlsxXf directly maps the xf element. A single xf element describes all of the
+// formatting for a cell.
+type xlsxXf struct {
+ ApplyAlignment bool `xml:"applyAlignment,attr"`
+ ApplyBorder bool `xml:"applyBorder,attr"`
+ ApplyFill bool `xml:"applyFill,attr"`
+ ApplyFont bool `xml:"applyFont,attr"`
+ ApplyNumberFormat bool `xml:"applyNumberFormat,attr"`
+ ApplyProtection bool `xml:"applyProtection,attr"`
+ BorderID int `xml:"borderId,attr"`
+ FillID int `xml:"fillId,attr"`
+ FontID int `xml:"fontId,attr"`
+ NumFmtID int `xml:"numFmtId,attr"`
+ PivotButton bool `xml:"pivotButton,attr,omitempty"`
+ QuotePrefix bool `xml:"quotePrefix,attr,omitempty"`
+ XfID *int `xml:"xfId,attr,omitempty"`
+ Alignment *xlsxAlignment `xml:"alignment"`
+}
+
+// xlsxCellXfs directly maps the cellXfs element. This element contains the
+// master formatting records (xf) which define the formatting applied to cells
+// in this workbook. These records are the starting point for determining the
+// formatting for a cell. Cells in the Sheet Part reference the xf records by
+// zero-based index.
+type xlsxCellXfs struct {
+ Count int `xml:"count,attr"`
+ Xf []xlsxXf `xml:"xf,omitempty"`
+}
+
+// xlsxDxfs directly maps the dxfs element. This element contains the master
+// differential formatting records (dxf's) which define formatting for all non-
+// cell formatting in this workbook. Whereas xf records fully specify a
+// particular aspect of formatting (e.g., cell borders) by referencing those
+// formatting definitions elsewhere in the Styles part, dxf records specify
+// incremental (or differential) aspects of formatting directly inline within
+// the dxf element. The dxf formatting is to be applied on top of or in addition
+// to any formatting already present on the object using the dxf record.
+type xlsxDxfs struct {
+ Count int `xml:"count,attr"`
+ Dxfs []*xlsxDxf `xml:"dxf,omitempty"`
+}
+
+// xlsxDxf directly maps the dxf element. A single dxf record, expressing
+// incremental formatting to be applied.
+type xlsxDxf struct {
+ Dxf string `xml:",innerxml"`
+}
+
+// xlsxTableStyles directly maps the tableStyles element. This element
+// represents a collection of Table style definitions for Table styles and
+// PivotTable styles used in this workbook. It consists of a sequence of
+// tableStyle records, each defining a single Table style.
+type xlsxTableStyles struct {
+ Count int `xml:"count,attr"`
+ DefaultPivotStyle string `xml:"defaultPivotStyle,attr"`
+ DefaultTableStyle string `xml:"defaultTableStyle,attr"`
+ TableStyles []*xlsxTableStyle `xml:"tableStyle,omitempty"`
+}
+
+// xlsxTableStyle directly maps the tableStyle element. This element represents
+// a single table style definition that indicates how a spreadsheet application
+// should format and display a table.
+type xlsxTableStyle struct {
+ Name string `xml:"name,attr,omitempty"`
+ Pivot int `xml:"pivot,attr,omitempty"`
+ Count int `xml:"count,attr,omitempty"`
+ Table bool `xml:"table,attr,omitempty"`
+ TableStyleElement string `xml:",innerxml"`
+}
+
+// xlsxNumFmts directly maps the numFmts element. This element defines the
+// number formats in this workbook, consisting of a sequence of numFmt records,
+// where each numFmt record defines a particular number format, indicating how
+// to format and render the numeric value of a cell.
+type xlsxNumFmts struct {
+ Count int `xml:"count,attr"`
+ NumFmt []*xlsxNumFmt `xml:"numFmt,omitempty"`
+}
+
+// xlsxNumFmt directly maps the numFmt element. This element specifies number
+// format properties which indicate how to format and render the numeric value
+// of a cell.
+type xlsxNumFmt struct {
+ NumFmtID int `xml:"numFmtId,attr,omitempty"`
+ FormatCode string `xml:"formatCode,attr,omitempty"`
+}
+
+// xlsxStyleColors directly maps the colors element. Color information
+// associated with this stylesheet. This collection is written whenever the
+// legacy color palette has been modified (backwards compatibility settings) or
+// a custom color has been selected while using this workbook.
+type xlsxStyleColors struct {
+ Color string `xml:",innerxml"`
+}
+
+// formatBorder directly maps the format settings of the borders.
+type formatBorder struct {
+ Border []struct {
+ Type string `json:"type"`
+ Color string `json:"color"`
+ Style int `json:"style"`
+ } `json:"border"`
+}
diff --git a/xmlWorksheet.go b/xmlWorksheet.go
index 6efb9ea..831bf3d 100644
--- a/xmlWorksheet.go
+++ b/xmlWorksheet.go
@@ -9,7 +9,7 @@ type xlsxWorksheet struct {
XMLName xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main worksheet"`
SheetPr *xlsxSheetPr `xml:"sheetPr"`
Dimension xlsxDimension `xml:"dimension"`
- SheetViews xlsxSheetViews `xml:"sheetViews"`
+ SheetViews xlsxSheetViews `xml:"sheetViews,omitempty"`
SheetFormatPr *xlsxSheetFormatPr `xml:"sheetFormatPr"`
Cols *xlsxCols `xml:"cols,omitempty"`
SheetData xlsxSheetData `xml:"sheetData"`
@@ -207,8 +207,8 @@ type xlsxPageSetUpPr struct {
// xlsxTabColor directly maps the tabColor element in the namespace currently I
// have not checked it for completeness - it does as much as I need.
type xlsxTabColor struct {
- Theme int `xml:"theme,attr,omitempty"`
- Tint uint8 `xml:"tint,attr,omitempty"`
+ Theme int `xml:"theme,attr,omitempty"`
+ Tint float64 `xml:"tint,attr,omitempty"`
}
// xlsxCols directly maps the cols element in the namespace
--
cgit v1.2.1