forked from p30928647/excelize
- New feature: border setting support (Related issue #21);
- Function parameter code is simplified; - Fix element `Tint` value parsing error in worksheet; - Update go test
This commit is contained in:
parent
48722e6482
commit
1f73f08185
8
cell.go
8
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")
|
||||
//
|
||||
|
|
|
|||
10
excelize.go
10
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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
2
lib.go
2
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
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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)))
|
||||
}
|
||||
|
|
@ -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"`
|
||||
|
|
|
|||
|
|
@ -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"`
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue