diff --git a/chart.go b/chart.go
index 267e0ddc1e..24ad2076eb 100644
--- a/chart.go
+++ b/chart.go
@@ -469,30 +469,30 @@ var (
}
)
-// parseFormatChartSet provides a function to parse the format settings of the
+// parseChartOptions provides a function to parse the format settings of the
// chart with default value.
-func parseFormatChartSet(formatSet string) (*formatChart, error) {
- format := formatChart{
- Dimension: formatChartDimension{
+func parseChartOptions(opts string) (*chartOptions, error) {
+ options := chartOptions{
+ Dimension: chartDimensionOptions{
Width: 480,
Height: 290,
},
- Format: formatPicture{
+ Format: pictureOptions{
FPrintsWithSheet: true,
XScale: 1,
YScale: 1,
},
- Legend: formatChartLegend{
+ Legend: chartLegendOptions{
Position: "bottom",
},
- Title: formatChartTitle{
+ Title: chartTitleOptions{
Name: " ",
},
VaryColors: true,
ShowBlanksAs: "gap",
}
- err := json.Unmarshal([]byte(formatSet), &format)
- return &format, err
+ err := json.Unmarshal([]byte(opts), &options)
+ return &options, err
}
// AddChart provides the method to add chart in a sheet by given chart format
@@ -881,13 +881,13 @@ func parseFormatChartSet(formatSet string) (*formatChart, error) {
// fmt.Println(err)
// }
// }
-func (f *File) AddChart(sheet, cell, format string, combo ...string) error {
+func (f *File) AddChart(sheet, cell, opts string, combo ...string) error {
// Read sheet data.
ws, err := f.workSheetReader(sheet)
if err != nil {
return err
}
- formatSet, comboCharts, err := f.getFormatChart(format, combo)
+ options, comboCharts, err := f.getChartOptions(opts, combo)
if err != nil {
return err
}
@@ -898,11 +898,11 @@ func (f *File) AddChart(sheet, cell, format string, combo ...string) error {
drawingID, drawingXML = f.prepareDrawing(ws, drawingID, sheet, drawingXML)
drawingRels := "xl/drawings/_rels/drawing" + strconv.Itoa(drawingID) + ".xml.rels"
drawingRID := f.addRels(drawingRels, SourceRelationshipChart, "../charts/chart"+strconv.Itoa(chartID)+".xml", "")
- err = f.addDrawingChart(sheet, drawingXML, cell, formatSet.Dimension.Width, formatSet.Dimension.Height, drawingRID, &formatSet.Format)
+ err = f.addDrawingChart(sheet, drawingXML, cell, options.Dimension.Width, options.Dimension.Height, drawingRID, &options.Format)
if err != nil {
return err
}
- f.addChart(formatSet, comboCharts)
+ f.addChart(options, comboCharts)
f.addContentTypePart(chartID, "chart")
f.addContentTypePart(drawingID, "drawings")
f.addSheetNameSpace(sheet, SourceRelationship)
@@ -913,12 +913,12 @@ func (f *File) AddChart(sheet, cell, format string, combo ...string) error {
// format set (such as offset, scale, aspect ratio setting and print settings)
// and properties set. In Excel a chartsheet is a worksheet that only contains
// a chart.
-func (f *File) AddChartSheet(sheet, format string, combo ...string) error {
+func (f *File) AddChartSheet(sheet, opts string, combo ...string) error {
// Check if the worksheet already exists
if f.GetSheetIndex(sheet) != -1 {
return ErrExistsWorksheet
}
- formatSet, comboCharts, err := f.getFormatChart(format, combo)
+ options, comboCharts, err := f.getChartOptions(opts, combo)
if err != nil {
return err
}
@@ -945,8 +945,8 @@ func (f *File) AddChartSheet(sheet, format string, combo ...string) error {
f.prepareChartSheetDrawing(&cs, drawingID, sheet)
drawingRels := "xl/drawings/_rels/drawing" + strconv.Itoa(drawingID) + ".xml.rels"
drawingRID := f.addRels(drawingRels, SourceRelationshipChart, "../charts/chart"+strconv.Itoa(chartID)+".xml", "")
- f.addSheetDrawingChart(drawingXML, drawingRID, &formatSet.Format)
- f.addChart(formatSet, comboCharts)
+ f.addSheetDrawingChart(drawingXML, drawingRID, &options.Format)
+ f.addChart(options, comboCharts)
f.addContentTypePart(chartID, "chart")
f.addContentTypePart(sheetID, "chartsheet")
f.addContentTypePart(drawingID, "drawings")
@@ -960,45 +960,45 @@ func (f *File) AddChartSheet(sheet, format string, combo ...string) error {
return err
}
-// getFormatChart provides a function to check format set of the chart and
+// getChartOptions provides a function to check format set of the chart and
// create chart format.
-func (f *File) getFormatChart(format string, combo []string) (*formatChart, []*formatChart, error) {
- var comboCharts []*formatChart
- formatSet, err := parseFormatChartSet(format)
+func (f *File) getChartOptions(opts string, combo []string) (*chartOptions, []*chartOptions, error) {
+ var comboCharts []*chartOptions
+ options, err := parseChartOptions(opts)
if err != nil {
- return formatSet, comboCharts, err
+ return options, comboCharts, err
}
for _, comboFormat := range combo {
- comboChart, err := parseFormatChartSet(comboFormat)
+ comboChart, err := parseChartOptions(comboFormat)
if err != nil {
- return formatSet, comboCharts, err
+ return options, comboCharts, err
}
if _, ok := chartValAxNumFmtFormatCode[comboChart.Type]; !ok {
- return formatSet, comboCharts, newUnsupportedChartType(comboChart.Type)
+ return options, comboCharts, newUnsupportedChartType(comboChart.Type)
}
comboCharts = append(comboCharts, comboChart)
}
- if _, ok := chartValAxNumFmtFormatCode[formatSet.Type]; !ok {
- return formatSet, comboCharts, newUnsupportedChartType(formatSet.Type)
+ if _, ok := chartValAxNumFmtFormatCode[options.Type]; !ok {
+ return options, comboCharts, newUnsupportedChartType(options.Type)
}
- return formatSet, comboCharts, err
+ return options, comboCharts, err
}
// DeleteChart provides a function to delete chart in spreadsheet by given
// worksheet name and cell reference.
-func (f *File) DeleteChart(sheet, cell string) (err error) {
+func (f *File) DeleteChart(sheet, cell string) error {
col, row, err := CellNameToCoordinates(cell)
if err != nil {
- return
+ return err
}
col--
row--
ws, err := f.workSheetReader(sheet)
if err != nil {
- return
+ return err
}
if ws.Drawing == nil {
- return
+ return err
}
drawingXML := strings.ReplaceAll(f.getSheetRelationshipsTargetByID(sheet, ws.Drawing.RID), "..", "xl")
return f.deleteDrawing(col, row, drawingXML, "Chart")
diff --git a/comment.go b/comment.go
index 41f91bb2bf..3d0832469e 100644
--- a/comment.go
+++ b/comment.go
@@ -23,15 +23,15 @@ import (
"strings"
)
-// parseFormatCommentsSet provides a function to parse the format settings of
+// parseCommentOptions provides a function to parse the format settings of
// the comment with default value.
-func parseFormatCommentsSet(formatSet string) (*formatComment, error) {
- format := formatComment{
+func parseCommentOptions(opts string) (*commentOptions, error) {
+ options := commentOptions{
Author: "Author:",
Text: " ",
}
- err := json.Unmarshal([]byte(formatSet), &format)
- return &format, err
+ err := json.Unmarshal([]byte(opts), &options)
+ return &options, err
}
// GetComments retrieves all comments and returns a map of worksheet name to
@@ -93,8 +93,8 @@ func (f *File) getSheetComments(sheetFile string) string {
// comment in Sheet1!$A$30:
//
// err := f.AddComment("Sheet1", "A30", `{"author":"Excelize: ","text":"This is a comment."}`)
-func (f *File) AddComment(sheet, cell, format string) error {
- formatSet, err := parseFormatCommentsSet(format)
+func (f *File) AddComment(sheet, cell, opts string) error {
+ options, err := parseCommentOptions(opts)
if err != nil {
return err
}
@@ -123,19 +123,19 @@ func (f *File) AddComment(sheet, cell, format string) error {
}
commentsXML := "xl/comments" + strconv.Itoa(commentID) + ".xml"
var colCount int
- for i, l := range strings.Split(formatSet.Text, "\n") {
+ for i, l := range strings.Split(options.Text, "\n") {
if ll := len(l); ll > colCount {
if i == 0 {
- ll += len(formatSet.Author)
+ ll += len(options.Author)
}
colCount = ll
}
}
- err = f.addDrawingVML(commentID, drawingVML, cell, strings.Count(formatSet.Text, "\n")+1, colCount)
+ err = f.addDrawingVML(commentID, drawingVML, cell, strings.Count(options.Text, "\n")+1, colCount)
if err != nil {
return err
}
- f.addComment(commentsXML, cell, formatSet)
+ f.addComment(commentsXML, cell, options)
f.addContentTypePart(commentID, "comments")
return err
}
@@ -144,11 +144,12 @@ func (f *File) AddComment(sheet, cell, format string) error {
// worksheet name. For example, delete the comment in Sheet1!$A$30:
//
// err := f.DeleteComment("Sheet1", "A30")
-func (f *File) DeleteComment(sheet, cell string) (err error) {
+func (f *File) DeleteComment(sheet, cell string) error {
+ var err error
sheetXMLPath, ok := f.getSheetXMLPath(sheet)
if !ok {
err = newNoExistSheetError(sheet)
- return
+ return err
}
commentsXML := f.getSheetComments(filepath.Base(sheetXMLPath))
if !strings.HasPrefix(commentsXML, "/") {
@@ -173,7 +174,7 @@ func (f *File) DeleteComment(sheet, cell string) (err error) {
}
f.Comments[commentsXML] = comments
}
- return
+ return err
}
// addDrawingVML provides a function to create comment as
@@ -279,9 +280,9 @@ func (f *File) addDrawingVML(commentID int, drawingVML, cell string, lineCount,
// addComment provides a function to create chart as xl/comments%d.xml by
// given cell and format sets.
-func (f *File) addComment(commentsXML, cell string, formatSet *formatComment) {
- a := formatSet.Author
- t := formatSet.Text
+func (f *File) addComment(commentsXML, cell string, opts *commentOptions) {
+ a := opts.Author
+ t := opts.Text
if len(a) > MaxFieldLength {
a = a[:MaxFieldLength]
}
@@ -291,10 +292,10 @@ func (f *File) addComment(commentsXML, cell string, formatSet *formatComment) {
comments := f.commentsReader(commentsXML)
authorID := 0
if comments == nil {
- comments = &xlsxComments{Authors: xlsxAuthor{Author: []string{formatSet.Author}}}
+ comments = &xlsxComments{Authors: xlsxAuthor{Author: []string{opts.Author}}}
}
- if inStrSlice(comments.Authors.Author, formatSet.Author, true) == -1 {
- comments.Authors.Author = append(comments.Authors.Author, formatSet.Author)
+ if inStrSlice(comments.Authors.Author, opts.Author, true) == -1 {
+ comments.Authors.Author = append(comments.Authors.Author, opts.Author)
authorID = len(comments.Authors.Author) - 1
}
defaultFont := f.GetDefaultFont()
diff --git a/docProps.go b/docProps.go
index 00ff808bbd..4ee46ad1d0 100644
--- a/docProps.go
+++ b/docProps.go
@@ -64,19 +64,20 @@ import (
// HyperlinksChanged: true,
// AppVersion: "16.0000",
// })
-func (f *File) SetAppProps(appProperties *AppProperties) (err error) {
+func (f *File) SetAppProps(appProperties *AppProperties) error {
var (
app *xlsxProperties
+ err error
+ field string
fields []string
- output []byte
immutable, mutable reflect.Value
- field string
+ output []byte
)
app = new(xlsxProperties)
if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML(defaultXMLPathDocPropsApp)))).
Decode(app); err != nil && err != io.EOF {
err = newDecodeXMLError(err)
- return
+ return err
}
fields = []string{"Application", "ScaleCrop", "DocSecurity", "Company", "LinksUpToDate", "HyperlinksChanged", "AppVersion"}
immutable, mutable = reflect.ValueOf(*appProperties), reflect.ValueOf(app).Elem()
@@ -94,7 +95,7 @@ func (f *File) SetAppProps(appProperties *AppProperties) (err error) {
app.Vt = NameSpaceDocumentPropertiesVariantTypes.Value
output, err = xml.Marshal(app)
f.saveFileList(defaultXMLPathDocPropsApp, output)
- return
+ return err
}
// GetAppProps provides a function to get document application properties.
@@ -167,23 +168,24 @@ func (f *File) GetAppProps() (ret *AppProperties, err error) {
// Language: "en-US",
// Version: "1.0.0",
// })
-func (f *File) SetDocProps(docProperties *DocProperties) (err error) {
+func (f *File) SetDocProps(docProperties *DocProperties) error {
var (
core *decodeCoreProperties
- newProps *xlsxCoreProperties
+ err error
+ field, val string
fields []string
- output []byte
immutable, mutable reflect.Value
- field, val string
+ newProps *xlsxCoreProperties
+ output []byte
)
core = new(decodeCoreProperties)
if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML(defaultXMLPathDocPropsCore)))).
Decode(core); err != nil && err != io.EOF {
err = newDecodeXMLError(err)
- return
+ return err
}
- newProps, err = &xlsxCoreProperties{
+ newProps = &xlsxCoreProperties{
Dc: NameSpaceDublinCore,
Dcterms: NameSpaceDublinCoreTerms,
Dcmitype: NameSpaceDublinCoreMetadataInitiative,
@@ -200,7 +202,7 @@ func (f *File) SetDocProps(docProperties *DocProperties) (err error) {
ContentStatus: core.ContentStatus,
Category: core.Category,
Version: core.Version,
- }, nil
+ }
if core.Created != nil {
newProps.Created = &xlsxDcTerms{Type: core.Created.Type, Text: core.Created.Text}
}
@@ -226,7 +228,7 @@ func (f *File) SetDocProps(docProperties *DocProperties) (err error) {
output, err = xml.Marshal(newProps)
f.saveFileList(defaultXMLPathDocPropsCore, output)
- return
+ return err
}
// GetDocProps provides a function to get document core properties.
diff --git a/drawing.go b/drawing.go
index e05c9beb8f..3ef58212b3 100644
--- a/drawing.go
+++ b/drawing.go
@@ -56,7 +56,7 @@ func (f *File) prepareChartSheetDrawing(cs *xlsxChartsheet, drawingID int, sheet
// addChart provides a function to create chart as xl/charts/chart%d.xml by
// given format sets.
-func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
+func (f *File) addChart(opts *chartOptions, comboCharts []*chartOptions) {
count := f.countCharts()
xlsxChartSpace := xlsxChartSpace{
XMLNSa: NameSpaceDrawingML.Value,
@@ -101,7 +101,7 @@ func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
Lang: "en-US",
AltLang: "en-US",
},
- T: formatSet.Title.Name,
+ T: opts.Title.Name,
},
},
},
@@ -124,10 +124,10 @@ func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
Overlay: &attrValBool{Val: boolPtr(false)},
},
View3D: &cView3D{
- RotX: &attrValInt{Val: intPtr(chartView3DRotX[formatSet.Type])},
- RotY: &attrValInt{Val: intPtr(chartView3DRotY[formatSet.Type])},
- Perspective: &attrValInt{Val: intPtr(chartView3DPerspective[formatSet.Type])},
- RAngAx: &attrValInt{Val: intPtr(chartView3DRAngAx[formatSet.Type])},
+ RotX: &attrValInt{Val: intPtr(chartView3DRotX[opts.Type])},
+ RotY: &attrValInt{Val: intPtr(chartView3DRotY[opts.Type])},
+ Perspective: &attrValInt{Val: intPtr(chartView3DPerspective[opts.Type])},
+ RAngAx: &attrValInt{Val: intPtr(chartView3DRAngAx[opts.Type])},
},
Floor: &cThicknessSpPr{
Thickness: &attrValInt{Val: intPtr(0)},
@@ -140,12 +140,12 @@ func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
},
PlotArea: &cPlotArea{},
Legend: &cLegend{
- LegendPos: &attrValString{Val: stringPtr(chartLegendPosition[formatSet.Legend.Position])},
+ LegendPos: &attrValString{Val: stringPtr(chartLegendPosition[opts.Legend.Position])},
Overlay: &attrValBool{Val: boolPtr(false)},
},
PlotVisOnly: &attrValBool{Val: boolPtr(false)},
- DispBlanksAs: &attrValString{Val: stringPtr(formatSet.ShowBlanksAs)},
+ DispBlanksAs: &attrValString{Val: stringPtr(opts.ShowBlanksAs)},
ShowDLblsOverMax: &attrValBool{Val: boolPtr(false)},
},
SpPr: &cSpPr{
@@ -181,7 +181,7 @@ func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
},
},
}
- plotAreaFunc := map[string]func(*formatChart) *cPlotArea{
+ plotAreaFunc := map[string]func(*chartOptions) *cPlotArea{
Area: f.drawBaseChart,
AreaStacked: f.drawBaseChart,
AreaPercentStacked: f.drawBaseChart,
@@ -237,7 +237,7 @@ func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
Bubble: f.drawBaseChart,
Bubble3D: f.drawBaseChart,
}
- if formatSet.Legend.None {
+ if opts.Legend.None {
xlsxChartSpace.Chart.Legend = nil
}
addChart := func(c, p *cPlotArea) {
@@ -250,8 +250,8 @@ func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
immutable.FieldByName(mutable.Type().Field(i).Name).Set(field)
}
}
- addChart(xlsxChartSpace.Chart.PlotArea, plotAreaFunc[formatSet.Type](formatSet))
- order := len(formatSet.Series)
+ addChart(xlsxChartSpace.Chart.PlotArea, plotAreaFunc[opts.Type](opts))
+ order := len(opts.Series)
for idx := range comboCharts {
comboCharts[idx].order = order
addChart(xlsxChartSpace.Chart.PlotArea, plotAreaFunc[comboCharts[idx].Type](comboCharts[idx]))
@@ -264,7 +264,7 @@ func (f *File) addChart(formatSet *formatChart, comboCharts []*formatChart) {
// drawBaseChart provides a function to draw the c:plotArea element for bar,
// and column series charts by given format sets.
-func (f *File) drawBaseChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawBaseChart(opts *chartOptions) *cPlotArea {
c := cCharts{
BarDir: &attrValString{
Val: stringPtr("col"),
@@ -273,11 +273,11 @@ func (f *File) drawBaseChart(formatSet *formatChart) *cPlotArea {
Val: stringPtr("clustered"),
},
VaryColors: &attrValBool{
- Val: boolPtr(formatSet.VaryColors),
+ Val: boolPtr(opts.VaryColors),
},
- Ser: f.drawChartSeries(formatSet),
- Shape: f.drawChartShape(formatSet),
- DLbls: f.drawChartDLbls(formatSet),
+ Ser: f.drawChartSeries(opts),
+ Shape: f.drawChartShape(opts),
+ DLbls: f.drawChartDLbls(opts),
AxID: []*attrValInt{
{Val: intPtr(754001152)},
{Val: intPtr(753999904)},
@@ -285,17 +285,17 @@ func (f *File) drawBaseChart(formatSet *formatChart) *cPlotArea {
Overlap: &attrValInt{Val: intPtr(100)},
}
var ok bool
- if *c.BarDir.Val, ok = plotAreaChartBarDir[formatSet.Type]; !ok {
+ if *c.BarDir.Val, ok = plotAreaChartBarDir[opts.Type]; !ok {
c.BarDir = nil
}
- if *c.Grouping.Val, ok = plotAreaChartGrouping[formatSet.Type]; !ok {
+ if *c.Grouping.Val, ok = plotAreaChartGrouping[opts.Type]; !ok {
c.Grouping = nil
}
- if *c.Overlap.Val, ok = plotAreaChartOverlap[formatSet.Type]; !ok {
+ if *c.Overlap.Val, ok = plotAreaChartOverlap[opts.Type]; !ok {
c.Overlap = nil
}
- catAx := f.drawPlotAreaCatAx(formatSet)
- valAx := f.drawPlotAreaValAx(formatSet)
+ catAx := f.drawPlotAreaCatAx(opts)
+ valAx := f.drawPlotAreaValAx(opts)
charts := map[string]*cPlotArea{
"area": {
AreaChart: &c,
@@ -508,23 +508,23 @@ func (f *File) drawBaseChart(formatSet *formatChart) *cPlotArea {
ValAx: valAx,
},
}
- return charts[formatSet.Type]
+ return charts[opts.Type]
}
// drawDoughnutChart provides a function to draw the c:plotArea element for
// doughnut chart by given format sets.
-func (f *File) drawDoughnutChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawDoughnutChart(opts *chartOptions) *cPlotArea {
holeSize := 75
- if formatSet.HoleSize > 0 && formatSet.HoleSize <= 90 {
- holeSize = formatSet.HoleSize
+ if opts.HoleSize > 0 && opts.HoleSize <= 90 {
+ holeSize = opts.HoleSize
}
return &cPlotArea{
DoughnutChart: &cCharts{
VaryColors: &attrValBool{
- Val: boolPtr(formatSet.VaryColors),
+ Val: boolPtr(opts.VaryColors),
},
- Ser: f.drawChartSeries(formatSet),
+ Ser: f.drawChartSeries(opts),
HoleSize: &attrValInt{Val: intPtr(holeSize)},
},
}
@@ -532,65 +532,65 @@ func (f *File) drawDoughnutChart(formatSet *formatChart) *cPlotArea {
// drawLineChart provides a function to draw the c:plotArea element for line
// chart by given format sets.
-func (f *File) drawLineChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawLineChart(opts *chartOptions) *cPlotArea {
return &cPlotArea{
LineChart: &cCharts{
Grouping: &attrValString{
- Val: stringPtr(plotAreaChartGrouping[formatSet.Type]),
+ Val: stringPtr(plotAreaChartGrouping[opts.Type]),
},
VaryColors: &attrValBool{
Val: boolPtr(false),
},
- Ser: f.drawChartSeries(formatSet),
- DLbls: f.drawChartDLbls(formatSet),
+ Ser: f.drawChartSeries(opts),
+ DLbls: f.drawChartDLbls(opts),
AxID: []*attrValInt{
{Val: intPtr(754001152)},
{Val: intPtr(753999904)},
},
},
- CatAx: f.drawPlotAreaCatAx(formatSet),
- ValAx: f.drawPlotAreaValAx(formatSet),
+ CatAx: f.drawPlotAreaCatAx(opts),
+ ValAx: f.drawPlotAreaValAx(opts),
}
}
// drawPieChart provides a function to draw the c:plotArea element for pie
// chart by given format sets.
-func (f *File) drawPieChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawPieChart(opts *chartOptions) *cPlotArea {
return &cPlotArea{
PieChart: &cCharts{
VaryColors: &attrValBool{
- Val: boolPtr(formatSet.VaryColors),
+ Val: boolPtr(opts.VaryColors),
},
- Ser: f.drawChartSeries(formatSet),
+ Ser: f.drawChartSeries(opts),
},
}
}
// drawPie3DChart provides a function to draw the c:plotArea element for 3D
// pie chart by given format sets.
-func (f *File) drawPie3DChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawPie3DChart(opts *chartOptions) *cPlotArea {
return &cPlotArea{
Pie3DChart: &cCharts{
VaryColors: &attrValBool{
- Val: boolPtr(formatSet.VaryColors),
+ Val: boolPtr(opts.VaryColors),
},
- Ser: f.drawChartSeries(formatSet),
+ Ser: f.drawChartSeries(opts),
},
}
}
// drawPieOfPieChart provides a function to draw the c:plotArea element for
// pie chart by given format sets.
-func (f *File) drawPieOfPieChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawPieOfPieChart(opts *chartOptions) *cPlotArea {
return &cPlotArea{
OfPieChart: &cCharts{
OfPieType: &attrValString{
Val: stringPtr("pie"),
},
VaryColors: &attrValBool{
- Val: boolPtr(formatSet.VaryColors),
+ Val: boolPtr(opts.VaryColors),
},
- Ser: f.drawChartSeries(formatSet),
+ Ser: f.drawChartSeries(opts),
SerLines: &attrValString{},
},
}
@@ -598,16 +598,16 @@ func (f *File) drawPieOfPieChart(formatSet *formatChart) *cPlotArea {
// drawBarOfPieChart provides a function to draw the c:plotArea element for
// pie chart by given format sets.
-func (f *File) drawBarOfPieChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawBarOfPieChart(opts *chartOptions) *cPlotArea {
return &cPlotArea{
OfPieChart: &cCharts{
OfPieType: &attrValString{
Val: stringPtr("bar"),
},
VaryColors: &attrValBool{
- Val: boolPtr(formatSet.VaryColors),
+ Val: boolPtr(opts.VaryColors),
},
- Ser: f.drawChartSeries(formatSet),
+ Ser: f.drawChartSeries(opts),
SerLines: &attrValString{},
},
}
@@ -615,7 +615,7 @@ func (f *File) drawBarOfPieChart(formatSet *formatChart) *cPlotArea {
// drawRadarChart provides a function to draw the c:plotArea element for radar
// chart by given format sets.
-func (f *File) drawRadarChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawRadarChart(opts *chartOptions) *cPlotArea {
return &cPlotArea{
RadarChart: &cCharts{
RadarStyle: &attrValString{
@@ -624,21 +624,21 @@ func (f *File) drawRadarChart(formatSet *formatChart) *cPlotArea {
VaryColors: &attrValBool{
Val: boolPtr(false),
},
- Ser: f.drawChartSeries(formatSet),
- DLbls: f.drawChartDLbls(formatSet),
+ Ser: f.drawChartSeries(opts),
+ DLbls: f.drawChartDLbls(opts),
AxID: []*attrValInt{
{Val: intPtr(754001152)},
{Val: intPtr(753999904)},
},
},
- CatAx: f.drawPlotAreaCatAx(formatSet),
- ValAx: f.drawPlotAreaValAx(formatSet),
+ CatAx: f.drawPlotAreaCatAx(opts),
+ ValAx: f.drawPlotAreaValAx(opts),
}
}
// drawScatterChart provides a function to draw the c:plotArea element for
// scatter chart by given format sets.
-func (f *File) drawScatterChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawScatterChart(opts *chartOptions) *cPlotArea {
return &cPlotArea{
ScatterChart: &cCharts{
ScatterStyle: &attrValString{
@@ -647,35 +647,35 @@ func (f *File) drawScatterChart(formatSet *formatChart) *cPlotArea {
VaryColors: &attrValBool{
Val: boolPtr(false),
},
- Ser: f.drawChartSeries(formatSet),
- DLbls: f.drawChartDLbls(formatSet),
+ Ser: f.drawChartSeries(opts),
+ DLbls: f.drawChartDLbls(opts),
AxID: []*attrValInt{
{Val: intPtr(754001152)},
{Val: intPtr(753999904)},
},
},
- CatAx: f.drawPlotAreaCatAx(formatSet),
- ValAx: f.drawPlotAreaValAx(formatSet),
+ CatAx: f.drawPlotAreaCatAx(opts),
+ ValAx: f.drawPlotAreaValAx(opts),
}
}
// drawSurface3DChart provides a function to draw the c:surface3DChart element by
// given format sets.
-func (f *File) drawSurface3DChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawSurface3DChart(opts *chartOptions) *cPlotArea {
plotArea := &cPlotArea{
Surface3DChart: &cCharts{
- Ser: f.drawChartSeries(formatSet),
+ Ser: f.drawChartSeries(opts),
AxID: []*attrValInt{
{Val: intPtr(754001152)},
{Val: intPtr(753999904)},
{Val: intPtr(832256642)},
},
},
- CatAx: f.drawPlotAreaCatAx(formatSet),
- ValAx: f.drawPlotAreaValAx(formatSet),
- SerAx: f.drawPlotAreaSerAx(formatSet),
+ CatAx: f.drawPlotAreaCatAx(opts),
+ ValAx: f.drawPlotAreaValAx(opts),
+ SerAx: f.drawPlotAreaSerAx(opts),
}
- if formatSet.Type == WireframeSurface3D {
+ if opts.Type == WireframeSurface3D {
plotArea.Surface3DChart.Wireframe = &attrValBool{Val: boolPtr(true)}
}
return plotArea
@@ -683,21 +683,21 @@ func (f *File) drawSurface3DChart(formatSet *formatChart) *cPlotArea {
// drawSurfaceChart provides a function to draw the c:surfaceChart element by
// given format sets.
-func (f *File) drawSurfaceChart(formatSet *formatChart) *cPlotArea {
+func (f *File) drawSurfaceChart(opts *chartOptions) *cPlotArea {
plotArea := &cPlotArea{
SurfaceChart: &cCharts{
- Ser: f.drawChartSeries(formatSet),
+ Ser: f.drawChartSeries(opts),
AxID: []*attrValInt{
{Val: intPtr(754001152)},
{Val: intPtr(753999904)},
{Val: intPtr(832256642)},
},
},
- CatAx: f.drawPlotAreaCatAx(formatSet),
- ValAx: f.drawPlotAreaValAx(formatSet),
- SerAx: f.drawPlotAreaSerAx(formatSet),
+ CatAx: f.drawPlotAreaCatAx(opts),
+ ValAx: f.drawPlotAreaValAx(opts),
+ SerAx: f.drawPlotAreaSerAx(opts),
}
- if formatSet.Type == WireframeContour {
+ if opts.Type == WireframeContour {
plotArea.SurfaceChart.Wireframe = &attrValBool{Val: boolPtr(true)}
}
return plotArea
@@ -705,7 +705,7 @@ func (f *File) drawSurfaceChart(formatSet *formatChart) *cPlotArea {
// drawChartShape provides a function to draw the c:shape element by given
// format sets.
-func (f *File) drawChartShape(formatSet *formatChart) *attrValString {
+func (f *File) drawChartShape(opts *chartOptions) *attrValString {
shapes := map[string]string{
Bar3DConeClustered: "cone",
Bar3DConeStacked: "cone",
@@ -729,7 +729,7 @@ func (f *File) drawChartShape(formatSet *formatChart) *attrValString {
Col3DCylinderStacked: "cylinder",
Col3DCylinderPercentStacked: "cylinder",
}
- if shape, ok := shapes[formatSet.Type]; ok {
+ if shape, ok := shapes[opts.Type]; ok {
return &attrValString{Val: stringPtr(shape)}
}
return nil
@@ -737,29 +737,29 @@ func (f *File) drawChartShape(formatSet *formatChart) *attrValString {
// drawChartSeries provides a function to draw the c:ser element by given
// format sets.
-func (f *File) drawChartSeries(formatSet *formatChart) *[]cSer {
+func (f *File) drawChartSeries(opts *chartOptions) *[]cSer {
var ser []cSer
- for k := range formatSet.Series {
+ for k := range opts.Series {
ser = append(ser, cSer{
- IDx: &attrValInt{Val: intPtr(k + formatSet.order)},
- Order: &attrValInt{Val: intPtr(k + formatSet.order)},
+ IDx: &attrValInt{Val: intPtr(k + opts.order)},
+ Order: &attrValInt{Val: intPtr(k + opts.order)},
Tx: &cTx{
StrRef: &cStrRef{
- F: formatSet.Series[k].Name,
+ F: opts.Series[k].Name,
},
},
- SpPr: f.drawChartSeriesSpPr(k, formatSet),
- Marker: f.drawChartSeriesMarker(k, formatSet),
- DPt: f.drawChartSeriesDPt(k, formatSet),
- DLbls: f.drawChartSeriesDLbls(formatSet),
+ SpPr: f.drawChartSeriesSpPr(k, opts),
+ Marker: f.drawChartSeriesMarker(k, opts),
+ DPt: f.drawChartSeriesDPt(k, opts),
+ DLbls: f.drawChartSeriesDLbls(opts),
InvertIfNegative: &attrValBool{Val: boolPtr(false)},
- Cat: f.drawChartSeriesCat(formatSet.Series[k], formatSet),
- Smooth: &attrValBool{Val: boolPtr(formatSet.Series[k].Line.Smooth)},
- Val: f.drawChartSeriesVal(formatSet.Series[k], formatSet),
- XVal: f.drawChartSeriesXVal(formatSet.Series[k], formatSet),
- YVal: f.drawChartSeriesYVal(formatSet.Series[k], formatSet),
- BubbleSize: f.drawCharSeriesBubbleSize(formatSet.Series[k], formatSet),
- Bubble3D: f.drawCharSeriesBubble3D(formatSet),
+ Cat: f.drawChartSeriesCat(opts.Series[k], opts),
+ Smooth: &attrValBool{Val: boolPtr(opts.Series[k].Line.Smooth)},
+ Val: f.drawChartSeriesVal(opts.Series[k], opts),
+ XVal: f.drawChartSeriesXVal(opts.Series[k], opts),
+ YVal: f.drawChartSeriesYVal(opts.Series[k], opts),
+ BubbleSize: f.drawCharSeriesBubbleSize(opts.Series[k], opts),
+ Bubble3D: f.drawCharSeriesBubble3D(opts),
})
}
return &ser
@@ -767,15 +767,15 @@ func (f *File) drawChartSeries(formatSet *formatChart) *[]cSer {
// drawChartSeriesSpPr provides a function to draw the c:spPr element by given
// format sets.
-func (f *File) drawChartSeriesSpPr(i int, formatSet *formatChart) *cSpPr {
+func (f *File) drawChartSeriesSpPr(i int, opts *chartOptions) *cSpPr {
var srgbClr *attrValString
var schemeClr *aSchemeClr
- if color := stringPtr(formatSet.Series[i].Line.Color); *color != "" {
+ if color := stringPtr(opts.Series[i].Line.Color); *color != "" {
*color = strings.TrimPrefix(*color, "#")
srgbClr = &attrValString{Val: color}
} else {
- schemeClr = &aSchemeClr{Val: "accent" + strconv.Itoa((formatSet.order+i)%6+1)}
+ schemeClr = &aSchemeClr{Val: "accent" + strconv.Itoa((opts.order+i)%6+1)}
}
spPrScatter := &cSpPr{
@@ -786,7 +786,7 @@ func (f *File) drawChartSeriesSpPr(i int, formatSet *formatChart) *cSpPr {
}
spPrLine := &cSpPr{
Ln: &aLn{
- W: f.ptToEMUs(formatSet.Series[i].Line.Width),
+ W: f.ptToEMUs(opts.Series[i].Line.Width),
Cap: "rnd", // rnd, sq, flat
SolidFill: &aSolidFill{
SchemeClr: schemeClr,
@@ -795,12 +795,12 @@ func (f *File) drawChartSeriesSpPr(i int, formatSet *formatChart) *cSpPr {
},
}
chartSeriesSpPr := map[string]*cSpPr{Line: spPrLine, Scatter: spPrScatter}
- return chartSeriesSpPr[formatSet.Type]
+ return chartSeriesSpPr[opts.Type]
}
// drawChartSeriesDPt provides a function to draw the c:dPt element by given
// data index and format sets.
-func (f *File) drawChartSeriesDPt(i int, formatSet *formatChart) []*cDPt {
+func (f *File) drawChartSeriesDPt(i int, opts *chartOptions) []*cDPt {
dpt := []*cDPt{{
IDx: &attrValInt{Val: intPtr(i)},
Bubble3D: &attrValBool{Val: boolPtr(false)},
@@ -824,19 +824,19 @@ func (f *File) drawChartSeriesDPt(i int, formatSet *formatChart) []*cDPt {
},
}}
chartSeriesDPt := map[string][]*cDPt{Pie: dpt, Pie3D: dpt}
- return chartSeriesDPt[formatSet.Type]
+ return chartSeriesDPt[opts.Type]
}
// drawChartSeriesCat provides a function to draw the c:cat element by given
// chart series and format sets.
-func (f *File) drawChartSeriesCat(v formatChartSeries, formatSet *formatChart) *cCat {
+func (f *File) drawChartSeriesCat(v chartSeriesOptions, opts *chartOptions) *cCat {
cat := &cCat{
StrRef: &cStrRef{
F: v.Categories,
},
}
chartSeriesCat := map[string]*cCat{Scatter: nil, Bubble: nil, Bubble3D: nil}
- if _, ok := chartSeriesCat[formatSet.Type]; ok || v.Categories == "" {
+ if _, ok := chartSeriesCat[opts.Type]; ok || v.Categories == "" {
return nil
}
return cat
@@ -844,14 +844,14 @@ func (f *File) drawChartSeriesCat(v formatChartSeries, formatSet *formatChart) *
// drawChartSeriesVal provides a function to draw the c:val element by given
// chart series and format sets.
-func (f *File) drawChartSeriesVal(v formatChartSeries, formatSet *formatChart) *cVal {
+func (f *File) drawChartSeriesVal(v chartSeriesOptions, opts *chartOptions) *cVal {
val := &cVal{
NumRef: &cNumRef{
F: v.Values,
},
}
chartSeriesVal := map[string]*cVal{Scatter: nil, Bubble: nil, Bubble3D: nil}
- if _, ok := chartSeriesVal[formatSet.Type]; ok {
+ if _, ok := chartSeriesVal[opts.Type]; ok {
return nil
}
return val
@@ -859,16 +859,16 @@ func (f *File) drawChartSeriesVal(v formatChartSeries, formatSet *formatChart) *
// drawChartSeriesMarker provides a function to draw the c:marker element by
// given data index and format sets.
-func (f *File) drawChartSeriesMarker(i int, formatSet *formatChart) *cMarker {
+func (f *File) drawChartSeriesMarker(i int, opts *chartOptions) *cMarker {
defaultSymbol := map[string]*attrValString{Scatter: {Val: stringPtr("circle")}}
marker := &cMarker{
- Symbol: defaultSymbol[formatSet.Type],
+ Symbol: defaultSymbol[opts.Type],
Size: &attrValInt{Val: intPtr(5)},
}
- if symbol := stringPtr(formatSet.Series[i].Marker.Symbol); *symbol != "" {
+ if symbol := stringPtr(opts.Series[i].Marker.Symbol); *symbol != "" {
marker.Symbol = &attrValString{Val: symbol}
}
- if size := intPtr(formatSet.Series[i].Marker.Size); *size != 0 {
+ if size := intPtr(opts.Series[i].Marker.Size); *size != 0 {
marker.Size = &attrValInt{Val: size}
}
if i < 6 {
@@ -889,37 +889,37 @@ func (f *File) drawChartSeriesMarker(i int, formatSet *formatChart) *cMarker {
}
}
chartSeriesMarker := map[string]*cMarker{Scatter: marker, Line: marker}
- return chartSeriesMarker[formatSet.Type]
+ return chartSeriesMarker[opts.Type]
}
// drawChartSeriesXVal provides a function to draw the c:xVal element by given
// chart series and format sets.
-func (f *File) drawChartSeriesXVal(v formatChartSeries, formatSet *formatChart) *cCat {
+func (f *File) drawChartSeriesXVal(v chartSeriesOptions, opts *chartOptions) *cCat {
cat := &cCat{
StrRef: &cStrRef{
F: v.Categories,
},
}
chartSeriesXVal := map[string]*cCat{Scatter: cat}
- return chartSeriesXVal[formatSet.Type]
+ return chartSeriesXVal[opts.Type]
}
// drawChartSeriesYVal provides a function to draw the c:yVal element by given
// chart series and format sets.
-func (f *File) drawChartSeriesYVal(v formatChartSeries, formatSet *formatChart) *cVal {
+func (f *File) drawChartSeriesYVal(v chartSeriesOptions, opts *chartOptions) *cVal {
val := &cVal{
NumRef: &cNumRef{
F: v.Values,
},
}
chartSeriesYVal := map[string]*cVal{Scatter: val, Bubble: val, Bubble3D: val}
- return chartSeriesYVal[formatSet.Type]
+ return chartSeriesYVal[opts.Type]
}
// drawCharSeriesBubbleSize provides a function to draw the c:bubbleSize
// element by given chart series and format sets.
-func (f *File) drawCharSeriesBubbleSize(v formatChartSeries, formatSet *formatChart) *cVal {
- if _, ok := map[string]bool{Bubble: true, Bubble3D: true}[formatSet.Type]; !ok {
+func (f *File) drawCharSeriesBubbleSize(v chartSeriesOptions, opts *chartOptions) *cVal {
+ if _, ok := map[string]bool{Bubble: true, Bubble3D: true}[opts.Type]; !ok {
return nil
}
return &cVal{
@@ -931,8 +931,8 @@ func (f *File) drawCharSeriesBubbleSize(v formatChartSeries, formatSet *formatCh
// drawCharSeriesBubble3D provides a function to draw the c:bubble3D element
// by given format sets.
-func (f *File) drawCharSeriesBubble3D(formatSet *formatChart) *attrValBool {
- if _, ok := map[string]bool{Bubble3D: true}[formatSet.Type]; !ok {
+func (f *File) drawCharSeriesBubble3D(opts *chartOptions) *attrValBool {
+ if _, ok := map[string]bool{Bubble3D: true}[opts.Type]; !ok {
return nil
}
return &attrValBool{Val: boolPtr(true)}
@@ -940,51 +940,51 @@ func (f *File) drawCharSeriesBubble3D(formatSet *formatChart) *attrValBool {
// drawChartDLbls provides a function to draw the c:dLbls element by given
// format sets.
-func (f *File) drawChartDLbls(formatSet *formatChart) *cDLbls {
+func (f *File) drawChartDLbls(opts *chartOptions) *cDLbls {
return &cDLbls{
- ShowLegendKey: &attrValBool{Val: boolPtr(formatSet.Legend.ShowLegendKey)},
- ShowVal: &attrValBool{Val: boolPtr(formatSet.Plotarea.ShowVal)},
- ShowCatName: &attrValBool{Val: boolPtr(formatSet.Plotarea.ShowCatName)},
- ShowSerName: &attrValBool{Val: boolPtr(formatSet.Plotarea.ShowSerName)},
- ShowBubbleSize: &attrValBool{Val: boolPtr(formatSet.Plotarea.ShowBubbleSize)},
- ShowPercent: &attrValBool{Val: boolPtr(formatSet.Plotarea.ShowPercent)},
- ShowLeaderLines: &attrValBool{Val: boolPtr(formatSet.Plotarea.ShowLeaderLines)},
+ ShowLegendKey: &attrValBool{Val: boolPtr(opts.Legend.ShowLegendKey)},
+ ShowVal: &attrValBool{Val: boolPtr(opts.Plotarea.ShowVal)},
+ ShowCatName: &attrValBool{Val: boolPtr(opts.Plotarea.ShowCatName)},
+ ShowSerName: &attrValBool{Val: boolPtr(opts.Plotarea.ShowSerName)},
+ ShowBubbleSize: &attrValBool{Val: boolPtr(opts.Plotarea.ShowBubbleSize)},
+ ShowPercent: &attrValBool{Val: boolPtr(opts.Plotarea.ShowPercent)},
+ ShowLeaderLines: &attrValBool{Val: boolPtr(opts.Plotarea.ShowLeaderLines)},
}
}
// drawChartSeriesDLbls provides a function to draw the c:dLbls element by
// given format sets.
-func (f *File) drawChartSeriesDLbls(formatSet *formatChart) *cDLbls {
- dLbls := f.drawChartDLbls(formatSet)
+func (f *File) drawChartSeriesDLbls(opts *chartOptions) *cDLbls {
+ dLbls := f.drawChartDLbls(opts)
chartSeriesDLbls := map[string]*cDLbls{
Scatter: nil, Surface3D: nil, WireframeSurface3D: nil, Contour: nil, WireframeContour: nil, Bubble: nil, Bubble3D: nil,
}
- if _, ok := chartSeriesDLbls[formatSet.Type]; ok {
+ if _, ok := chartSeriesDLbls[opts.Type]; ok {
return nil
}
return dLbls
}
// drawPlotAreaCatAx provides a function to draw the c:catAx element.
-func (f *File) drawPlotAreaCatAx(formatSet *formatChart) []*cAxs {
- max := &attrValFloat{Val: formatSet.XAxis.Maximum}
- min := &attrValFloat{Val: formatSet.XAxis.Minimum}
- if formatSet.XAxis.Maximum == nil {
+func (f *File) drawPlotAreaCatAx(opts *chartOptions) []*cAxs {
+ max := &attrValFloat{Val: opts.XAxis.Maximum}
+ min := &attrValFloat{Val: opts.XAxis.Minimum}
+ if opts.XAxis.Maximum == nil {
max = nil
}
- if formatSet.XAxis.Minimum == nil {
+ if opts.XAxis.Minimum == nil {
min = nil
}
axs := []*cAxs{
{
AxID: &attrValInt{Val: intPtr(754001152)},
Scaling: &cScaling{
- Orientation: &attrValString{Val: stringPtr(orientation[formatSet.XAxis.ReverseOrder])},
+ Orientation: &attrValString{Val: stringPtr(orientation[opts.XAxis.ReverseOrder])},
Max: max,
Min: min,
},
- Delete: &attrValBool{Val: boolPtr(formatSet.XAxis.None)},
- AxPos: &attrValString{Val: stringPtr(catAxPos[formatSet.XAxis.ReverseOrder])},
+ Delete: &attrValBool{Val: boolPtr(opts.XAxis.None)},
+ AxPos: &attrValString{Val: stringPtr(catAxPos[opts.XAxis.ReverseOrder])},
NumFmt: &cNumFmt{
FormatCode: "General",
SourceLinked: true,
@@ -1002,45 +1002,45 @@ func (f *File) drawPlotAreaCatAx(formatSet *formatChart) []*cAxs {
NoMultiLvlLbl: &attrValBool{Val: boolPtr(false)},
},
}
- if formatSet.XAxis.MajorGridlines {
+ if opts.XAxis.MajorGridlines {
axs[0].MajorGridlines = &cChartLines{SpPr: f.drawPlotAreaSpPr()}
}
- if formatSet.XAxis.MinorGridlines {
+ if opts.XAxis.MinorGridlines {
axs[0].MinorGridlines = &cChartLines{SpPr: f.drawPlotAreaSpPr()}
}
- if formatSet.XAxis.TickLabelSkip != 0 {
- axs[0].TickLblSkip = &attrValInt{Val: intPtr(formatSet.XAxis.TickLabelSkip)}
+ if opts.XAxis.TickLabelSkip != 0 {
+ axs[0].TickLblSkip = &attrValInt{Val: intPtr(opts.XAxis.TickLabelSkip)}
}
return axs
}
// drawPlotAreaValAx provides a function to draw the c:valAx element.
-func (f *File) drawPlotAreaValAx(formatSet *formatChart) []*cAxs {
- max := &attrValFloat{Val: formatSet.YAxis.Maximum}
- min := &attrValFloat{Val: formatSet.YAxis.Minimum}
- if formatSet.YAxis.Maximum == nil {
+func (f *File) drawPlotAreaValAx(opts *chartOptions) []*cAxs {
+ max := &attrValFloat{Val: opts.YAxis.Maximum}
+ min := &attrValFloat{Val: opts.YAxis.Minimum}
+ if opts.YAxis.Maximum == nil {
max = nil
}
- if formatSet.YAxis.Minimum == nil {
+ if opts.YAxis.Minimum == nil {
min = nil
}
var logBase *attrValFloat
- if formatSet.YAxis.LogBase >= 2 && formatSet.YAxis.LogBase <= 1000 {
- logBase = &attrValFloat{Val: float64Ptr(formatSet.YAxis.LogBase)}
+ if opts.YAxis.LogBase >= 2 && opts.YAxis.LogBase <= 1000 {
+ logBase = &attrValFloat{Val: float64Ptr(opts.YAxis.LogBase)}
}
axs := []*cAxs{
{
AxID: &attrValInt{Val: intPtr(753999904)},
Scaling: &cScaling{
LogBase: logBase,
- Orientation: &attrValString{Val: stringPtr(orientation[formatSet.YAxis.ReverseOrder])},
+ Orientation: &attrValString{Val: stringPtr(orientation[opts.YAxis.ReverseOrder])},
Max: max,
Min: min,
},
- Delete: &attrValBool{Val: boolPtr(formatSet.YAxis.None)},
- AxPos: &attrValString{Val: stringPtr(valAxPos[formatSet.YAxis.ReverseOrder])},
+ Delete: &attrValBool{Val: boolPtr(opts.YAxis.None)},
+ AxPos: &attrValString{Val: stringPtr(valAxPos[opts.YAxis.ReverseOrder])},
NumFmt: &cNumFmt{
- FormatCode: chartValAxNumFmtFormatCode[formatSet.Type],
+ FormatCode: chartValAxNumFmtFormatCode[opts.Type],
SourceLinked: true,
},
MajorTickMark: &attrValString{Val: stringPtr("none")},
@@ -1050,44 +1050,44 @@ func (f *File) drawPlotAreaValAx(formatSet *formatChart) []*cAxs {
TxPr: f.drawPlotAreaTxPr(),
CrossAx: &attrValInt{Val: intPtr(754001152)},
Crosses: &attrValString{Val: stringPtr("autoZero")},
- CrossBetween: &attrValString{Val: stringPtr(chartValAxCrossBetween[formatSet.Type])},
+ CrossBetween: &attrValString{Val: stringPtr(chartValAxCrossBetween[opts.Type])},
},
}
- if formatSet.YAxis.MajorGridlines {
+ if opts.YAxis.MajorGridlines {
axs[0].MajorGridlines = &cChartLines{SpPr: f.drawPlotAreaSpPr()}
}
- if formatSet.YAxis.MinorGridlines {
+ if opts.YAxis.MinorGridlines {
axs[0].MinorGridlines = &cChartLines{SpPr: f.drawPlotAreaSpPr()}
}
- if pos, ok := valTickLblPos[formatSet.Type]; ok {
+ if pos, ok := valTickLblPos[opts.Type]; ok {
axs[0].TickLblPos.Val = stringPtr(pos)
}
- if formatSet.YAxis.MajorUnit != 0 {
- axs[0].MajorUnit = &attrValFloat{Val: float64Ptr(formatSet.YAxis.MajorUnit)}
+ if opts.YAxis.MajorUnit != 0 {
+ axs[0].MajorUnit = &attrValFloat{Val: float64Ptr(opts.YAxis.MajorUnit)}
}
return axs
}
// drawPlotAreaSerAx provides a function to draw the c:serAx element.
-func (f *File) drawPlotAreaSerAx(formatSet *formatChart) []*cAxs {
- max := &attrValFloat{Val: formatSet.YAxis.Maximum}
- min := &attrValFloat{Val: formatSet.YAxis.Minimum}
- if formatSet.YAxis.Maximum == nil {
+func (f *File) drawPlotAreaSerAx(opts *chartOptions) []*cAxs {
+ max := &attrValFloat{Val: opts.YAxis.Maximum}
+ min := &attrValFloat{Val: opts.YAxis.Minimum}
+ if opts.YAxis.Maximum == nil {
max = nil
}
- if formatSet.YAxis.Minimum == nil {
+ if opts.YAxis.Minimum == nil {
min = nil
}
return []*cAxs{
{
AxID: &attrValInt{Val: intPtr(832256642)},
Scaling: &cScaling{
- Orientation: &attrValString{Val: stringPtr(orientation[formatSet.YAxis.ReverseOrder])},
+ Orientation: &attrValString{Val: stringPtr(orientation[opts.YAxis.ReverseOrder])},
Max: max,
Min: min,
},
- Delete: &attrValBool{Val: boolPtr(formatSet.YAxis.None)},
- AxPos: &attrValString{Val: stringPtr(catAxPos[formatSet.XAxis.ReverseOrder])},
+ Delete: &attrValBool{Val: boolPtr(opts.YAxis.None)},
+ AxPos: &attrValString{Val: stringPtr(catAxPos[opts.XAxis.ReverseOrder])},
TickLblPos: &attrValString{Val: stringPtr("nextTo")},
SpPr: f.drawPlotAreaSpPr(),
TxPr: f.drawPlotAreaTxPr(),
@@ -1207,7 +1207,7 @@ func (f *File) drawingParser(path string) (*xlsxWsDr, int) {
// addDrawingChart provides a function to add chart graphic frame by given
// sheet, drawingXML, cell, width, height, relationship index and format sets.
-func (f *File) addDrawingChart(sheet, drawingXML, cell string, width, height, rID int, formatSet *formatPicture) error {
+func (f *File) addDrawingChart(sheet, drawingXML, cell string, width, height, rID int, opts *pictureOptions) error {
col, row, err := CellNameToCoordinates(cell)
if err != nil {
return err
@@ -1215,17 +1215,17 @@ func (f *File) addDrawingChart(sheet, drawingXML, cell string, width, height, rI
colIdx := col - 1
rowIdx := row - 1
- width = int(float64(width) * formatSet.XScale)
- height = int(float64(height) * formatSet.YScale)
- colStart, rowStart, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, colIdx, rowIdx, formatSet.OffsetX, formatSet.OffsetY, width, height)
+ width = int(float64(width) * opts.XScale)
+ height = int(float64(height) * opts.YScale)
+ colStart, rowStart, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, colIdx, rowIdx, opts.OffsetX, opts.OffsetY, width, height)
content, cNvPrID := f.drawingParser(drawingXML)
twoCellAnchor := xdrCellAnchor{}
- twoCellAnchor.EditAs = formatSet.Positioning
+ twoCellAnchor.EditAs = opts.Positioning
from := xlsxFrom{}
from.Col = colStart
- from.ColOff = formatSet.OffsetX * EMU
+ from.ColOff = opts.OffsetX * EMU
from.Row = rowStart
- from.RowOff = formatSet.OffsetY * EMU
+ from.RowOff = opts.OffsetY * EMU
to := xlsxTo{}
to.Col = colEnd
to.ColOff = x2 * EMU
@@ -1255,8 +1255,8 @@ func (f *File) addDrawingChart(sheet, drawingXML, cell string, width, height, rI
graphic, _ := xml.Marshal(graphicFrame)
twoCellAnchor.GraphicFrame = string(graphic)
twoCellAnchor.ClientData = &xdrClientData{
- FLocksWithSheet: formatSet.FLocksWithSheet,
- FPrintsWithSheet: formatSet.FPrintsWithSheet,
+ FLocksWithSheet: opts.FLocksWithSheet,
+ FPrintsWithSheet: opts.FPrintsWithSheet,
}
content.TwoCellAnchor = append(content.TwoCellAnchor, &twoCellAnchor)
f.Drawings.Store(drawingXML, content)
@@ -1266,10 +1266,10 @@ func (f *File) addDrawingChart(sheet, drawingXML, cell string, width, height, rI
// addSheetDrawingChart provides a function to add chart graphic frame for
// chartsheet by given sheet, drawingXML, width, height, relationship index
// and format sets.
-func (f *File) addSheetDrawingChart(drawingXML string, rID int, formatSet *formatPicture) {
+func (f *File) addSheetDrawingChart(drawingXML string, rID int, opts *pictureOptions) {
content, cNvPrID := f.drawingParser(drawingXML)
absoluteAnchor := xdrCellAnchor{
- EditAs: formatSet.Positioning,
+ EditAs: opts.Positioning,
Pos: &xlsxPoint2D{},
Ext: &xlsxExt{},
}
@@ -1295,8 +1295,8 @@ func (f *File) addSheetDrawingChart(drawingXML string, rID int, formatSet *forma
graphic, _ := xml.Marshal(graphicFrame)
absoluteAnchor.GraphicFrame = string(graphic)
absoluteAnchor.ClientData = &xdrClientData{
- FLocksWithSheet: formatSet.FLocksWithSheet,
- FPrintsWithSheet: formatSet.FPrintsWithSheet,
+ FLocksWithSheet: opts.FLocksWithSheet,
+ FPrintsWithSheet: opts.FPrintsWithSheet,
}
content.AbsoluteAnchor = append(content.AbsoluteAnchor, &absoluteAnchor)
f.Drawings.Store(drawingXML, content)
@@ -1304,8 +1304,9 @@ func (f *File) addSheetDrawingChart(drawingXML string, rID int, formatSet *forma
// deleteDrawing provides a function to delete chart graphic frame by given by
// given coordinates and graphic type.
-func (f *File) deleteDrawing(col, row int, drawingXML, drawingType string) (err error) {
+func (f *File) deleteDrawing(col, row int, drawingXML, drawingType string) error {
var (
+ err error
wsDr *xlsxWsDr
deTwoCellAnchor *decodeTwoCellAnchor
)
@@ -1331,7 +1332,7 @@ func (f *File) deleteDrawing(col, row int, drawingXML, drawingType string) (err
if err = f.xmlNewDecoder(strings.NewReader("" + wsDr.TwoCellAnchor[idx].GraphicFrame + "")).
Decode(deTwoCellAnchor); err != nil && err != io.EOF {
err = newDecodeXMLError(err)
- return
+ return err
}
if err = nil; deTwoCellAnchor.From != nil && decodeTwoCellAnchorFuncs[drawingType](deTwoCellAnchor) {
if deTwoCellAnchor.From.Col == col && deTwoCellAnchor.From.Row == row {
diff --git a/excelize_test.go b/excelize_test.go
index 9bb6fa83ae..e685b669ee 100644
--- a/excelize_test.go
+++ b/excelize_test.go
@@ -319,13 +319,13 @@ func TestNewFile(t *testing.T) {
t.FailNow()
}
- // Test add picture to worksheet without formatset.
+ // Test add picture to worksheet without options.
err = f.AddPicture("Sheet1", "C2", filepath.Join("test", "images", "excel.png"), "")
if !assert.NoError(t, err) {
t.FailNow()
}
- // Test add picture to worksheet with invalid formatset.
+ // Test add picture to worksheet with invalid options.
err = f.AddPicture("Sheet1", "C2", filepath.Join("test", "images", "excel.png"), `{`)
if !assert.Error(t, err) {
t.FailNow()
@@ -1021,12 +1021,6 @@ func TestRelsWriter(t *testing.T) {
f.relsWriter()
}
-func TestGetSheetView(t *testing.T) {
- f := NewFile()
- _, err := f.getSheetView("SheetN", 0)
- assert.EqualError(t, err, "sheet SheetN does not exist")
-}
-
func TestConditionalFormat(t *testing.T) {
f := NewFile()
sheet1 := f.GetSheetName(0)
@@ -1228,7 +1222,7 @@ func TestProtectSheet(t *testing.T) {
sheetName := f.GetSheetName(0)
assert.NoError(t, f.ProtectSheet(sheetName, nil))
// Test protect worksheet with XOR hash algorithm
- assert.NoError(t, f.ProtectSheet(sheetName, &FormatSheetProtection{
+ assert.NoError(t, f.ProtectSheet(sheetName, &SheetProtectionOptions{
Password: "password",
EditScenarios: false,
}))
@@ -1237,7 +1231,7 @@ func TestProtectSheet(t *testing.T) {
assert.Equal(t, "83AF", ws.SheetProtection.Password)
assert.NoError(t, f.SaveAs(filepath.Join("test", "TestProtectSheet.xlsx")))
// Test protect worksheet with SHA-512 hash algorithm
- assert.NoError(t, f.ProtectSheet(sheetName, &FormatSheetProtection{
+ assert.NoError(t, f.ProtectSheet(sheetName, &SheetProtectionOptions{
AlgorithmName: "SHA-512",
Password: "password",
}))
@@ -1251,15 +1245,15 @@ func TestProtectSheet(t *testing.T) {
// Test remove sheet protection with password verification
assert.NoError(t, f.UnprotectSheet(sheetName, "password"))
// Test protect worksheet with empty password
- assert.NoError(t, f.ProtectSheet(sheetName, &FormatSheetProtection{}))
+ assert.NoError(t, f.ProtectSheet(sheetName, &SheetProtectionOptions{}))
assert.Equal(t, "", ws.SheetProtection.Password)
// Test protect worksheet with password exceeds the limit length
- assert.EqualError(t, f.ProtectSheet(sheetName, &FormatSheetProtection{
+ assert.EqualError(t, f.ProtectSheet(sheetName, &SheetProtectionOptions{
AlgorithmName: "MD4",
Password: strings.Repeat("s", MaxFieldLength+1),
}), ErrPasswordLengthInvalid.Error())
// Test protect worksheet with unsupported hash algorithm
- assert.EqualError(t, f.ProtectSheet(sheetName, &FormatSheetProtection{
+ assert.EqualError(t, f.ProtectSheet(sheetName, &SheetProtectionOptions{
AlgorithmName: "RIPEMD-160",
Password: "password",
}), ErrUnsupportedHashAlgorithm.Error())
@@ -1282,13 +1276,13 @@ func TestUnprotectSheet(t *testing.T) {
f = NewFile()
sheetName := f.GetSheetName(0)
- assert.NoError(t, f.ProtectSheet(sheetName, &FormatSheetProtection{Password: "password"}))
+ assert.NoError(t, f.ProtectSheet(sheetName, &SheetProtectionOptions{Password: "password"}))
// Test remove sheet protection with an incorrect password
assert.EqualError(t, f.UnprotectSheet(sheetName, "wrongPassword"), ErrUnprotectSheetPassword.Error())
// Test remove sheet protection with password verification
assert.NoError(t, f.UnprotectSheet(sheetName, "password"))
// Test with invalid salt value
- assert.NoError(t, f.ProtectSheet(sheetName, &FormatSheetProtection{
+ assert.NoError(t, f.ProtectSheet(sheetName, &SheetProtectionOptions{
AlgorithmName: "SHA-512",
Password: "password",
}))
@@ -1309,7 +1303,7 @@ func TestSetDefaultTimeStyle(t *testing.T) {
func TestAddVBAProject(t *testing.T) {
f := NewFile()
- assert.NoError(t, f.SetSheetPrOptions("Sheet1", CodeName("Sheet1")))
+ assert.NoError(t, f.SetSheetProps("Sheet1", &SheetPropsOptions{CodeName: stringPtr("Sheet1")}))
assert.EqualError(t, f.AddVBAProject("macros.bin"), "stat macros.bin: no such file or directory")
assert.EqualError(t, f.AddVBAProject(filepath.Join("test", "Book1.xlsx")), ErrAddVBAProject.Error())
assert.NoError(t, f.AddVBAProject(filepath.Join("test", "vbaProject.bin")))
diff --git a/lib.go b/lib.go
index 21ce7d2ca3..945c6f0f9c 100644
--- a/lib.go
+++ b/lib.go
@@ -422,20 +422,15 @@ func boolPtr(b bool) *bool { return &b }
// intPtr returns a pointer to an int with the given value.
func intPtr(i int) *int { return &i }
+// uintPtr returns a pointer to an int with the given value.
+func uintPtr(i uint) *uint { return &i }
+
// float64Ptr returns a pointer to a float64 with the given value.
func float64Ptr(f float64) *float64 { return &f }
// stringPtr returns a pointer to a string with the given value.
func stringPtr(s string) *string { return &s }
-// defaultTrue returns true if b is nil, or the pointed value.
-func defaultTrue(b *bool) bool {
- if b == nil {
- return true
- }
- return *b
-}
-
// MarshalXML convert the boolean data type to literal values 0 or 1 on
// serialization.
func (avb attrValBool) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
@@ -499,11 +494,11 @@ func (avb *attrValBool) UnmarshalXML(d *xml.Decoder, start xml.StartElement) err
return nil
}
-// parseFormatSet provides a method to convert format string to []byte and
+// fallbackOptions provides a method to convert format string to []byte and
// handle empty string.
-func parseFormatSet(formatSet string) []byte {
- if formatSet != "" {
- return []byte(formatSet)
+func fallbackOptions(opts string) []byte {
+ if opts != "" {
+ return []byte(opts)
}
return []byte("{}")
}
diff --git a/picture.go b/picture.go
index e1c62f2e52..aceb3f43bd 100644
--- a/picture.go
+++ b/picture.go
@@ -25,15 +25,15 @@ import (
"strings"
)
-// parseFormatPictureSet provides a function to parse the format settings of
+// parsePictureOptions provides a function to parse the format settings of
// the picture with default value.
-func parseFormatPictureSet(formatSet string) (*formatPicture, error) {
- format := formatPicture{
+func parsePictureOptions(opts string) (*pictureOptions, error) {
+ format := pictureOptions{
FPrintsWithSheet: true,
XScale: 1,
YScale: 1,
}
- err := json.Unmarshal(parseFormatSet(formatSet), &format)
+ err := json.Unmarshal(fallbackOptions(opts), &format)
return &format, err
}
@@ -148,14 +148,14 @@ func (f *File) AddPicture(sheet, cell, picture, format string) error {
// fmt.Println(err)
// }
// }
-func (f *File) AddPictureFromBytes(sheet, cell, format, name, extension string, file []byte) error {
+func (f *File) AddPictureFromBytes(sheet, cell, opts, name, extension string, file []byte) error {
var drawingHyperlinkRID int
var hyperlinkType string
ext, ok := supportedImageTypes[extension]
if !ok {
return ErrImgExt
}
- formatSet, err := parseFormatPictureSet(format)
+ options, err := parsePictureOptions(opts)
if err != nil {
return err
}
@@ -177,14 +177,14 @@ func (f *File) AddPictureFromBytes(sheet, cell, format, name, extension string,
mediaStr := ".." + strings.TrimPrefix(f.addMedia(file, ext), "xl")
drawingRID := f.addRels(drawingRels, SourceRelationshipImage, mediaStr, hyperlinkType)
// Add picture with hyperlink.
- if formatSet.Hyperlink != "" && formatSet.HyperlinkType != "" {
- if formatSet.HyperlinkType == "External" {
- hyperlinkType = formatSet.HyperlinkType
+ if options.Hyperlink != "" && options.HyperlinkType != "" {
+ if options.HyperlinkType == "External" {
+ hyperlinkType = options.HyperlinkType
}
- drawingHyperlinkRID = f.addRels(drawingRels, SourceRelationshipHyperLink, formatSet.Hyperlink, hyperlinkType)
+ drawingHyperlinkRID = f.addRels(drawingRels, SourceRelationshipHyperLink, options.Hyperlink, hyperlinkType)
}
ws.Unlock()
- err = f.addDrawingPicture(sheet, drawingXML, cell, name, img.Width, img.Height, drawingRID, drawingHyperlinkRID, formatSet)
+ err = f.addDrawingPicture(sheet, drawingXML, cell, name, img.Width, img.Height, drawingRID, drawingHyperlinkRID, options)
if err != nil {
return err
}
@@ -264,31 +264,31 @@ func (f *File) countDrawings() (count int) {
// addDrawingPicture provides a function to add picture by given sheet,
// drawingXML, cell, file name, width, height relationship index and format
// sets.
-func (f *File) addDrawingPicture(sheet, drawingXML, cell, file string, width, height, rID, hyperlinkRID int, formatSet *formatPicture) error {
+func (f *File) addDrawingPicture(sheet, drawingXML, cell, file string, width, height, rID, hyperlinkRID int, opts *pictureOptions) error {
col, row, err := CellNameToCoordinates(cell)
if err != nil {
return err
}
- if formatSet.Autofit {
- width, height, col, row, err = f.drawingResize(sheet, cell, float64(width), float64(height), formatSet)
+ if opts.Autofit {
+ width, height, col, row, err = f.drawingResize(sheet, cell, float64(width), float64(height), opts)
if err != nil {
return err
}
} else {
- width = int(float64(width) * formatSet.XScale)
- height = int(float64(height) * formatSet.YScale)
+ width = int(float64(width) * opts.XScale)
+ height = int(float64(height) * opts.YScale)
}
col--
row--
- colStart, rowStart, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, col, row, formatSet.OffsetX, formatSet.OffsetY, width, height)
+ colStart, rowStart, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, col, row, opts.OffsetX, opts.OffsetY, width, height)
content, cNvPrID := f.drawingParser(drawingXML)
twoCellAnchor := xdrCellAnchor{}
- twoCellAnchor.EditAs = formatSet.Positioning
+ twoCellAnchor.EditAs = opts.Positioning
from := xlsxFrom{}
from.Col = colStart
- from.ColOff = formatSet.OffsetX * EMU
+ from.ColOff = opts.OffsetX * EMU
from.Row = rowStart
- from.RowOff = formatSet.OffsetY * EMU
+ from.RowOff = opts.OffsetY * EMU
to := xlsxTo{}
to.Col = colEnd
to.ColOff = x2 * EMU
@@ -297,7 +297,7 @@ func (f *File) addDrawingPicture(sheet, drawingXML, cell, file string, width, he
twoCellAnchor.From = &from
twoCellAnchor.To = &to
pic := xlsxPic{}
- pic.NvPicPr.CNvPicPr.PicLocks.NoChangeAspect = formatSet.NoChangeAspect
+ pic.NvPicPr.CNvPicPr.PicLocks.NoChangeAspect = opts.NoChangeAspect
pic.NvPicPr.CNvPr.ID = cNvPrID
pic.NvPicPr.CNvPr.Descr = file
pic.NvPicPr.CNvPr.Name = "Picture " + strconv.Itoa(cNvPrID)
@@ -313,8 +313,8 @@ func (f *File) addDrawingPicture(sheet, drawingXML, cell, file string, width, he
twoCellAnchor.Pic = &pic
twoCellAnchor.ClientData = &xdrClientData{
- FLocksWithSheet: formatSet.FLocksWithSheet,
- FPrintsWithSheet: formatSet.FPrintsWithSheet,
+ FLocksWithSheet: opts.FLocksWithSheet,
+ FPrintsWithSheet: opts.FPrintsWithSheet,
}
content.Lock()
defer content.Unlock()
@@ -514,19 +514,19 @@ func (f *File) GetPicture(sheet, cell string) (string, []byte, error) {
// DeletePicture provides a function to delete charts in spreadsheet by given
// worksheet name and cell reference. Note that the image file won't be deleted
// from the document currently.
-func (f *File) DeletePicture(sheet, cell string) (err error) {
+func (f *File) DeletePicture(sheet, cell string) error {
col, row, err := CellNameToCoordinates(cell)
if err != nil {
- return
+ return err
}
col--
row--
ws, err := f.workSheetReader(sheet)
if err != nil {
- return
+ return err
}
if ws.Drawing == nil {
- return
+ return err
}
drawingXML := strings.ReplaceAll(f.getSheetRelationshipsTargetByID(sheet, ws.Drawing.RID), "..", "xl")
return f.deleteDrawing(col, row, drawingXML, "Pic")
@@ -636,7 +636,7 @@ func (f *File) drawingsWriter() {
}
// drawingResize calculate the height and width after resizing.
-func (f *File) drawingResize(sheet, cell string, width, height float64, formatSet *formatPicture) (w, h, c, r int, err error) {
+func (f *File) drawingResize(sheet, cell string, width, height float64, opts *pictureOptions) (w, h, c, r int, err error) {
var mergeCells []MergeCell
mergeCells, err = f.GetMergeCells(sheet)
if err != nil {
@@ -678,7 +678,7 @@ func (f *File) drawingResize(sheet, cell string, width, height float64, formatSe
asp := float64(cellHeight) / height
height, width = float64(cellHeight), width*asp
}
- width, height = width-float64(formatSet.OffsetX), height-float64(formatSet.OffsetY)
- w, h = int(width*formatSet.XScale), int(height*formatSet.YScale)
+ width, height = width-float64(opts.OffsetX), height-float64(opts.OffsetY)
+ w, h = int(width*opts.XScale), int(height*opts.YScale)
return
}
diff --git a/pivotTable.go b/pivotTable.go
index 8e16e0689a..8266c8e67f 100644
--- a/pivotTable.go
+++ b/pivotTable.go
@@ -18,14 +18,14 @@ import (
"strings"
)
-// PivotTableOption directly maps the format settings of the pivot table.
+// PivotTableOptions directly maps the format settings of the pivot table.
//
// PivotTableStyleName: The built-in pivot table style names
//
// PivotStyleLight1 - PivotStyleLight28
// PivotStyleMedium1 - PivotStyleMedium28
// PivotStyleDark1 - PivotStyleDark28
-type PivotTableOption struct {
+type PivotTableOptions struct {
pivotTableSheetName string
DataRange string `json:"data_range"`
PivotTableRange string `json:"pivot_table_range"`
@@ -81,9 +81,9 @@ type PivotTableField struct {
// options. Note that the same fields can not in Columns, Rows and Filter
// fields at the same time.
//
-// For example, create a pivot table on the Sheet1!$G$2:$M$34 range reference
-// with the region Sheet1!$A$1:$E$31 as the data source, summarize by sum for
-// sales:
+// For example, create a pivot table on the range reference Sheet1!$G$2:$M$34
+// with the range reference Sheet1!$A$1:$E$31 as the data source, summarize by
+// sum for sales:
//
// package main
//
@@ -129,7 +129,7 @@ type PivotTableField struct {
// fmt.Println(err)
// }
// }
-func (f *File) AddPivotTable(opts *PivotTableOption) error {
+func (f *File) AddPivotTable(opts *PivotTableOptions) error {
// parameter validation
_, pivotTableSheetPath, err := f.parseFormatPivotTableSet(opts)
if err != nil {
@@ -168,7 +168,7 @@ func (f *File) AddPivotTable(opts *PivotTableOption) error {
// parseFormatPivotTableSet provides a function to validate pivot table
// properties.
-func (f *File) parseFormatPivotTableSet(opts *PivotTableOption) (*xlsxWorksheet, string, error) {
+func (f *File) parseFormatPivotTableSet(opts *PivotTableOptions) (*xlsxWorksheet, string, error) {
if opts == nil {
return nil, "", ErrParameterRequired
}
@@ -228,7 +228,7 @@ func (f *File) adjustRange(rangeStr string) (string, []int, error) {
// getPivotFieldsOrder provides a function to get order list of pivot table
// fields.
-func (f *File) getPivotFieldsOrder(opts *PivotTableOption) ([]string, error) {
+func (f *File) getPivotFieldsOrder(opts *PivotTableOptions) ([]string, error) {
var order []string
dataRange := f.getDefinedNameRefTo(opts.DataRange, opts.pivotTableSheetName)
if dataRange == "" {
@@ -250,7 +250,7 @@ func (f *File) getPivotFieldsOrder(opts *PivotTableOption) ([]string, error) {
}
// addPivotCache provides a function to create a pivot cache by given properties.
-func (f *File) addPivotCache(pivotCacheXML string, opts *PivotTableOption) error {
+func (f *File) addPivotCache(pivotCacheXML string, opts *PivotTableOptions) error {
// validate data range
definedNameRef := true
dataRange := f.getDefinedNameRefTo(opts.DataRange, opts.pivotTableSheetName)
@@ -312,7 +312,7 @@ func (f *File) addPivotCache(pivotCacheXML string, opts *PivotTableOption) error
// addPivotTable provides a function to create a pivot table by given pivot
// table ID and properties.
-func (f *File) addPivotTable(cacheID, pivotTableID int, pivotTableXML string, opts *PivotTableOption) error {
+func (f *File) addPivotTable(cacheID, pivotTableID int, pivotTableXML string, opts *PivotTableOptions) error {
// validate pivot table range
_, coordinates, err := f.adjustRange(opts.PivotTableRange)
if err != nil {
@@ -391,7 +391,7 @@ func (f *File) addPivotTable(cacheID, pivotTableID int, pivotTableXML string, op
// addPivotRowFields provides a method to add row fields for pivot table by
// given pivot table options.
-func (f *File) addPivotRowFields(pt *xlsxPivotTableDefinition, opts *PivotTableOption) error {
+func (f *File) addPivotRowFields(pt *xlsxPivotTableDefinition, opts *PivotTableOptions) error {
// row fields
rowFieldsIndex, err := f.getPivotFieldsIndex(opts.Rows, opts)
if err != nil {
@@ -415,7 +415,7 @@ func (f *File) addPivotRowFields(pt *xlsxPivotTableDefinition, opts *PivotTableO
// addPivotPageFields provides a method to add page fields for pivot table by
// given pivot table options.
-func (f *File) addPivotPageFields(pt *xlsxPivotTableDefinition, opts *PivotTableOption) error {
+func (f *File) addPivotPageFields(pt *xlsxPivotTableDefinition, opts *PivotTableOptions) error {
// page fields
pageFieldsIndex, err := f.getPivotFieldsIndex(opts.Filter, opts)
if err != nil {
@@ -441,7 +441,7 @@ func (f *File) addPivotPageFields(pt *xlsxPivotTableDefinition, opts *PivotTable
// addPivotDataFields provides a method to add data fields for pivot table by
// given pivot table options.
-func (f *File) addPivotDataFields(pt *xlsxPivotTableDefinition, opts *PivotTableOption) error {
+func (f *File) addPivotDataFields(pt *xlsxPivotTableDefinition, opts *PivotTableOptions) error {
// data fields
dataFieldsIndex, err := f.getPivotFieldsIndex(opts.Data, opts)
if err != nil {
@@ -481,7 +481,7 @@ func inPivotTableField(a []PivotTableField, x string) int {
// addPivotColFields create pivot column fields by given pivot table
// definition and option.
-func (f *File) addPivotColFields(pt *xlsxPivotTableDefinition, opts *PivotTableOption) error {
+func (f *File) addPivotColFields(pt *xlsxPivotTableDefinition, opts *PivotTableOptions) error {
if len(opts.Columns) == 0 {
if len(opts.Data) <= 1 {
return nil
@@ -522,7 +522,7 @@ func (f *File) addPivotColFields(pt *xlsxPivotTableDefinition, opts *PivotTableO
// addPivotFields create pivot fields based on the column order of the first
// row in the data region by given pivot table definition and option.
-func (f *File) addPivotFields(pt *xlsxPivotTableDefinition, opts *PivotTableOption) error {
+func (f *File) addPivotFields(pt *xlsxPivotTableDefinition, opts *PivotTableOptions) error {
order, err := f.getPivotFieldsOrder(opts)
if err != nil {
return err
@@ -627,7 +627,7 @@ func (f *File) countPivotCache() int {
// getPivotFieldsIndex convert the column of the first row in the data region
// to a sequential index by given fields and pivot option.
-func (f *File) getPivotFieldsIndex(fields []PivotTableField, opts *PivotTableOption) ([]int, error) {
+func (f *File) getPivotFieldsIndex(fields []PivotTableField, opts *PivotTableOptions) ([]int, error) {
var pivotFieldsIndex []int
orders, err := f.getPivotFieldsOrder(opts)
if err != nil {
diff --git a/pivotTable_test.go b/pivotTable_test.go
index ed79298322..5d2e537853 100644
--- a/pivotTable_test.go
+++ b/pivotTable_test.go
@@ -25,7 +25,7 @@ func TestAddPivotTable(t *testing.T) {
assert.NoError(t, f.SetCellValue("Sheet1", fmt.Sprintf("D%d", row), rand.Intn(5000)))
assert.NoError(t, f.SetCellValue("Sheet1", fmt.Sprintf("E%d", row), region[rand.Intn(4)]))
}
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet1!$G$2:$M$34",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -41,7 +41,7 @@ func TestAddPivotTable(t *testing.T) {
ShowError: true,
}))
// Use different order of coordinate tests
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -55,7 +55,7 @@ func TestAddPivotTable(t *testing.T) {
ShowLastColumn: true,
}))
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet1!$W$2:$AC$34",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -68,7 +68,7 @@ func TestAddPivotTable(t *testing.T) {
ShowColHeaders: true,
ShowLastColumn: true,
}))
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet1!$G$37:$W$50",
Rows: []PivotTableField{{Data: "Month"}},
@@ -81,7 +81,7 @@ func TestAddPivotTable(t *testing.T) {
ShowColHeaders: true,
ShowLastColumn: true,
}))
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet1!$AE$2:$AG$33",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -94,7 +94,7 @@ func TestAddPivotTable(t *testing.T) {
ShowLastColumn: true,
}))
// Create pivot table with empty subtotal field name and specified style
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet1!$AJ$2:$AP1$35",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -110,7 +110,7 @@ func TestAddPivotTable(t *testing.T) {
PivotTableStyleName: "PivotStyleLight19",
}))
f.NewSheet("Sheet2")
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet2!$A$1:$AR$15",
Rows: []PivotTableField{{Data: "Month"}},
@@ -123,7 +123,7 @@ func TestAddPivotTable(t *testing.T) {
ShowColHeaders: true,
ShowLastColumn: true,
}))
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet2!$A$18:$AR$54",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Type"}},
@@ -143,7 +143,7 @@ func TestAddPivotTable(t *testing.T) {
Comment: "Pivot Table Data Range",
Scope: "Sheet2",
}))
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "dataRange",
PivotTableRange: "Sheet2!$A$57:$AJ$91",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -160,7 +160,7 @@ func TestAddPivotTable(t *testing.T) {
// Test empty pivot table options
assert.EqualError(t, f.AddPivotTable(nil), ErrParameterRequired.Error())
// Test invalid data range
- assert.EqualError(t, f.AddPivotTable(&PivotTableOption{
+ assert.EqualError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$A$1",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -168,7 +168,7 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), `parameter 'DataRange' parsing error: parameter is invalid`)
// Test the data range of the worksheet that is not declared
- assert.EqualError(t, f.AddPivotTable(&PivotTableOption{
+ assert.EqualError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "$A$1:$E$31",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -176,7 +176,7 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), `parameter 'DataRange' parsing error: parameter is invalid`)
// Test the worksheet declared in the data range does not exist
- assert.EqualError(t, f.AddPivotTable(&PivotTableOption{
+ assert.EqualError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "SheetN!$A$1:$E$31",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -184,7 +184,7 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), "sheet SheetN does not exist")
// Test the pivot table range of the worksheet that is not declared
- assert.EqualError(t, f.AddPivotTable(&PivotTableOption{
+ assert.EqualError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -192,7 +192,7 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), `parameter 'PivotTableRange' parsing error: parameter is invalid`)
// Test the worksheet declared in the pivot table range does not exist
- assert.EqualError(t, f.AddPivotTable(&PivotTableOption{
+ assert.EqualError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "SheetN!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -200,7 +200,7 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), "sheet SheetN does not exist")
// Test not exists worksheet in data range
- assert.EqualError(t, f.AddPivotTable(&PivotTableOption{
+ assert.EqualError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "SheetN!$A$1:$E$31",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -208,7 +208,7 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), "sheet SheetN does not exist")
// Test invalid row number in data range
- assert.EqualError(t, f.AddPivotTable(&PivotTableOption{
+ assert.EqualError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$0:$E$31",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -217,7 +217,7 @@ func TestAddPivotTable(t *testing.T) {
}), `parameter 'DataRange' parsing error: cannot convert cell "A0" to coordinates: invalid cell name "A0"`)
assert.NoError(t, f.SaveAs(filepath.Join("test", "TestAddPivotTable1.xlsx")))
// Test with field names that exceed the length limit and invalid subtotal
- assert.NoError(t, f.AddPivotTable(&PivotTableOption{
+ assert.NoError(t, f.AddPivotTable(&PivotTableOptions{
DataRange: "Sheet1!$A$1:$E$31",
PivotTableRange: "Sheet1!$G$2:$M$34",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -232,12 +232,12 @@ func TestAddPivotTable(t *testing.T) {
_, _, err = f.adjustRange("sheet1!")
assert.EqualError(t, err, "parameter is invalid")
// Test get pivot fields order with empty data range
- _, err = f.getPivotFieldsOrder(&PivotTableOption{})
+ _, err = f.getPivotFieldsOrder(&PivotTableOptions{})
assert.EqualError(t, err, `parameter 'DataRange' parsing error: parameter is required`)
// Test add pivot cache with empty data range
- assert.EqualError(t, f.addPivotCache("", &PivotTableOption{}), "parameter 'DataRange' parsing error: parameter is required")
+ assert.EqualError(t, f.addPivotCache("", &PivotTableOptions{}), "parameter 'DataRange' parsing error: parameter is required")
// Test add pivot cache with invalid data range
- assert.EqualError(t, f.addPivotCache("", &PivotTableOption{
+ assert.EqualError(t, f.addPivotCache("", &PivotTableOptions{
DataRange: "$A$1:$E$31",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -245,11 +245,11 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), "parameter 'DataRange' parsing error: parameter is invalid")
// Test add pivot table with empty options
- assert.EqualError(t, f.addPivotTable(0, 0, "", &PivotTableOption{}), "parameter 'PivotTableRange' parsing error: parameter is required")
+ assert.EqualError(t, f.addPivotTable(0, 0, "", &PivotTableOptions{}), "parameter 'PivotTableRange' parsing error: parameter is required")
// Test add pivot table with invalid data range
- assert.EqualError(t, f.addPivotTable(0, 0, "", &PivotTableOption{}), "parameter 'PivotTableRange' parsing error: parameter is required")
+ assert.EqualError(t, f.addPivotTable(0, 0, "", &PivotTableOptions{}), "parameter 'PivotTableRange' parsing error: parameter is required")
// Test add pivot fields with empty data range
- assert.EqualError(t, f.addPivotFields(nil, &PivotTableOption{
+ assert.EqualError(t, f.addPivotFields(nil, &PivotTableOptions{
DataRange: "$A$1:$E$31",
PivotTableRange: "Sheet1!$U$34:$O$2",
Rows: []PivotTableField{{Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
@@ -257,14 +257,14 @@ func TestAddPivotTable(t *testing.T) {
Data: []PivotTableField{{Data: "Sales"}},
}), `parameter 'DataRange' parsing error: parameter is invalid`)
// Test get pivot fields index with empty data range
- _, err = f.getPivotFieldsIndex([]PivotTableField{}, &PivotTableOption{})
+ _, err = f.getPivotFieldsIndex([]PivotTableField{}, &PivotTableOptions{})
assert.EqualError(t, err, `parameter 'DataRange' parsing error: parameter is required`)
}
func TestAddPivotRowFields(t *testing.T) {
f := NewFile()
// Test invalid data range
- assert.EqualError(t, f.addPivotRowFields(&xlsxPivotTableDefinition{}, &PivotTableOption{
+ assert.EqualError(t, f.addPivotRowFields(&xlsxPivotTableDefinition{}, &PivotTableOptions{
DataRange: "Sheet1!$A$1:$A$1",
}), `parameter 'DataRange' parsing error: parameter is invalid`)
}
@@ -272,7 +272,7 @@ func TestAddPivotRowFields(t *testing.T) {
func TestAddPivotPageFields(t *testing.T) {
f := NewFile()
// Test invalid data range
- assert.EqualError(t, f.addPivotPageFields(&xlsxPivotTableDefinition{}, &PivotTableOption{
+ assert.EqualError(t, f.addPivotPageFields(&xlsxPivotTableDefinition{}, &PivotTableOptions{
DataRange: "Sheet1!$A$1:$A$1",
}), `parameter 'DataRange' parsing error: parameter is invalid`)
}
@@ -280,7 +280,7 @@ func TestAddPivotPageFields(t *testing.T) {
func TestAddPivotDataFields(t *testing.T) {
f := NewFile()
// Test invalid data range
- assert.EqualError(t, f.addPivotDataFields(&xlsxPivotTableDefinition{}, &PivotTableOption{
+ assert.EqualError(t, f.addPivotDataFields(&xlsxPivotTableDefinition{}, &PivotTableOptions{
DataRange: "Sheet1!$A$1:$A$1",
}), `parameter 'DataRange' parsing error: parameter is invalid`)
}
@@ -288,7 +288,7 @@ func TestAddPivotDataFields(t *testing.T) {
func TestAddPivotColFields(t *testing.T) {
f := NewFile()
// Test invalid data range
- assert.EqualError(t, f.addPivotColFields(&xlsxPivotTableDefinition{}, &PivotTableOption{
+ assert.EqualError(t, f.addPivotColFields(&xlsxPivotTableDefinition{}, &PivotTableOptions{
DataRange: "Sheet1!$A$1:$A$1",
Columns: []PivotTableField{{Data: "Type", DefaultSubtotal: true}},
}), `parameter 'DataRange' parsing error: parameter is invalid`)
@@ -297,7 +297,7 @@ func TestAddPivotColFields(t *testing.T) {
func TestGetPivotFieldsOrder(t *testing.T) {
f := NewFile()
// Test get pivot fields order with not exist worksheet
- _, err := f.getPivotFieldsOrder(&PivotTableOption{DataRange: "SheetN!$A$1:$E$31"})
+ _, err := f.getPivotFieldsOrder(&PivotTableOptions{DataRange: "SheetN!$A$1:$E$31"})
assert.EqualError(t, err, "sheet SheetN does not exist")
}
diff --git a/rows_test.go b/rows_test.go
index 8ce007ff85..74c4d25ffd 100644
--- a/rows_test.go
+++ b/rows_test.go
@@ -165,10 +165,10 @@ func TestRowHeight(t *testing.T) {
assert.EqualError(t, err, "sheet SheetN does not exist")
// Test get row height with custom default row height.
- assert.NoError(t, f.SetSheetFormatPr(sheet1,
- DefaultRowHeight(30.0),
- CustomHeight(true),
- ))
+ assert.NoError(t, f.SetSheetProps(sheet1, &SheetPropsOptions{
+ DefaultRowHeight: float64Ptr(30.0),
+ CustomHeight: boolPtr(true),
+ }))
height, err = f.GetRowHeight(sheet1, 100)
assert.NoError(t, err)
assert.Equal(t, 30.0, height)
diff --git a/shape.go b/shape.go
index 4fca348128..eca354f50d 100644
--- a/shape.go
+++ b/shape.go
@@ -17,21 +17,21 @@ import (
"strings"
)
-// parseFormatShapeSet provides a function to parse the format settings of the
+// parseShapeOptions provides a function to parse the format settings of the
// shape with default value.
-func parseFormatShapeSet(formatSet string) (*formatShape, error) {
- format := formatShape{
+func parseShapeOptions(opts string) (*shapeOptions, error) {
+ options := shapeOptions{
Width: 160,
Height: 160,
- Format: formatPicture{
+ Format: pictureOptions{
FPrintsWithSheet: true,
XScale: 1,
YScale: 1,
},
- Line: formatLine{Width: 1},
+ Line: lineOptions{Width: 1},
}
- err := json.Unmarshal([]byte(formatSet), &format)
- return &format, err
+ err := json.Unmarshal([]byte(opts), &options)
+ return &options, err
}
// AddShape provides the method to add shape in a sheet by given worksheet
@@ -277,8 +277,8 @@ func parseFormatShapeSet(formatSet string) (*formatShape, error) {
// wavy
// wavyHeavy
// wavyDbl
-func (f *File) AddShape(sheet, cell, format string) error {
- formatSet, err := parseFormatShapeSet(format)
+func (f *File) AddShape(sheet, cell, opts string) error {
+ options, err := parseShapeOptions(opts)
if err != nil {
return err
}
@@ -305,7 +305,7 @@ func (f *File) AddShape(sheet, cell, format string) error {
f.addSheetDrawing(sheet, rID)
f.addSheetNameSpace(sheet, SourceRelationship)
}
- err = f.addDrawingShape(sheet, drawingXML, cell, formatSet)
+ err = f.addDrawingShape(sheet, drawingXML, cell, options)
if err != nil {
return err
}
@@ -315,7 +315,7 @@ func (f *File) AddShape(sheet, cell, format string) error {
// addDrawingShape provides a function to add preset geometry by given sheet,
// drawingXMLand format sets.
-func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *formatShape) error {
+func (f *File) addDrawingShape(sheet, drawingXML, cell string, opts *shapeOptions) error {
fromCol, fromRow, err := CellNameToCoordinates(cell)
if err != nil {
return err
@@ -344,19 +344,19 @@ func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *format
"wavyDbl": true,
}
- width := int(float64(formatSet.Width) * formatSet.Format.XScale)
- height := int(float64(formatSet.Height) * formatSet.Format.YScale)
+ width := int(float64(opts.Width) * opts.Format.XScale)
+ height := int(float64(opts.Height) * opts.Format.YScale)
- colStart, rowStart, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, colIdx, rowIdx, formatSet.Format.OffsetX, formatSet.Format.OffsetY,
+ colStart, rowStart, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, colIdx, rowIdx, opts.Format.OffsetX, opts.Format.OffsetY,
width, height)
content, cNvPrID := f.drawingParser(drawingXML)
twoCellAnchor := xdrCellAnchor{}
- twoCellAnchor.EditAs = formatSet.Format.Positioning
+ twoCellAnchor.EditAs = opts.Format.Positioning
from := xlsxFrom{}
from.Col = colStart
- from.ColOff = formatSet.Format.OffsetX * EMU
+ from.ColOff = opts.Format.OffsetX * EMU
from.Row = rowStart
- from.RowOff = formatSet.Format.OffsetY * EMU
+ from.RowOff = opts.Format.OffsetY * EMU
to := xlsxTo{}
to.Col = colEnd
to.ColOff = x2 * EMU
@@ -365,7 +365,7 @@ func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *format
twoCellAnchor.From = &from
twoCellAnchor.To = &to
shape := xdrSp{
- Macro: formatSet.Macro,
+ Macro: opts.Macro,
NvSpPr: &xdrNvSpPr{
CNvPr: &xlsxCNvPr{
ID: cNvPrID,
@@ -377,13 +377,13 @@ func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *format
},
SpPr: &xlsxSpPr{
PrstGeom: xlsxPrstGeom{
- Prst: formatSet.Type,
+ Prst: opts.Type,
},
},
Style: &xdrStyle{
- LnRef: setShapeRef(formatSet.Color.Line, 2),
- FillRef: setShapeRef(formatSet.Color.Fill, 1),
- EffectRef: setShapeRef(formatSet.Color.Effect, 0),
+ LnRef: setShapeRef(opts.Color.Line, 2),
+ FillRef: setShapeRef(opts.Color.Fill, 1),
+ EffectRef: setShapeRef(opts.Color.Effect, 0),
FontRef: &aFontRef{
Idx: "minor",
SchemeClr: &attrValString{
@@ -401,13 +401,13 @@ func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *format
},
},
}
- if formatSet.Line.Width != 1 {
+ if opts.Line.Width != 1 {
shape.SpPr.Ln = xlsxLineProperties{
- W: f.ptToEMUs(formatSet.Line.Width),
+ W: f.ptToEMUs(opts.Line.Width),
}
}
- if len(formatSet.Paragraph) < 1 {
- formatSet.Paragraph = []formatShapeParagraph{
+ if len(opts.Paragraph) < 1 {
+ opts.Paragraph = []shapeParagraphOptions{
{
Font: Font{
Bold: false,
@@ -421,7 +421,7 @@ func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *format
},
}
}
- for _, p := range formatSet.Paragraph {
+ for _, p := range opts.Paragraph {
u := p.Font.Underline
_, ok := textUnderlineType[u]
if !ok {
@@ -460,8 +460,8 @@ func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *format
}
twoCellAnchor.Sp = &shape
twoCellAnchor.ClientData = &xdrClientData{
- FLocksWithSheet: formatSet.Format.FLocksWithSheet,
- FPrintsWithSheet: formatSet.Format.FPrintsWithSheet,
+ FLocksWithSheet: opts.Format.FLocksWithSheet,
+ FPrintsWithSheet: opts.Format.FPrintsWithSheet,
}
content.TwoCellAnchor = append(content.TwoCellAnchor, &twoCellAnchor)
f.Drawings.Store(drawingXML, content)
diff --git a/sheet.go b/sheet.go
index fe24b18c90..73e7501f27 100644
--- a/sheet.go
+++ b/sheet.go
@@ -38,10 +38,10 @@ import (
// Note that when creating a new workbook, the default worksheet named
// `Sheet1` will be created.
func (f *File) NewSheet(sheet string) int {
- // Check if the worksheet already exists
if trimSheetName(sheet) == "" {
return -1
}
+ // Check if the worksheet already exists
index := f.GetSheetIndex(sheet)
if index != -1 {
return index
@@ -675,10 +675,10 @@ func (f *File) SetSheetVisible(sheet string, visible bool) error {
return nil
}
-// parseFormatPanesSet provides a function to parse the panes settings.
-func parseFormatPanesSet(formatSet string) (*formatPanes, error) {
- format := formatPanes{}
- err := json.Unmarshal([]byte(formatSet), &format)
+// parsePanesOptions provides a function to parse the panes settings.
+func parsePanesOptions(opts string) (*panesOptions, error) {
+ format := panesOptions{}
+ err := json.Unmarshal([]byte(opts), &format)
return &format, err
}
@@ -767,7 +767,7 @@ func parseFormatPanesSet(formatSet string) (*formatPanes, error) {
//
// f.SetPanes("Sheet1", `{"freeze":false,"split":false}`)
func (f *File) SetPanes(sheet, panes string) error {
- fs, _ := parseFormatPanesSet(panes)
+ fs, _ := parsePanesOptions(panes)
ws, err := f.workSheetReader(sheet)
if err != nil {
return err
@@ -1021,7 +1021,7 @@ func attrValToBool(name string, attrs []xml.Attr) (val bool, err error) {
// |
// &R | Right section
// |
-// &S | Strikethrough text format
+// &S | Strike through text format
// |
// &T | Current time
// |
@@ -1068,7 +1068,7 @@ func attrValToBool(name string, attrs []xml.Attr) (val bool, err error) {
// that same page
//
// - No footer on the first page
-func (f *File) SetHeaderFooter(sheet string, settings *FormatHeaderFooter) error {
+func (f *File) SetHeaderFooter(sheet string, settings *HeaderFooterOptions) error {
ws, err := f.workSheetReader(sheet)
if err != nil {
return err
@@ -1113,13 +1113,13 @@ func (f *File) SetHeaderFooter(sheet string, settings *FormatHeaderFooter) error
// Password: "password",
// EditScenarios: false,
// })
-func (f *File) ProtectSheet(sheet string, settings *FormatSheetProtection) error {
+func (f *File) ProtectSheet(sheet string, settings *SheetProtectionOptions) error {
ws, err := f.workSheetReader(sheet)
if err != nil {
return err
}
if settings == nil {
- settings = &FormatSheetProtection{
+ settings = &SheetProtectionOptions{
EditObjects: true,
EditScenarios: true,
SelectLockedCells: true,
@@ -1213,173 +1213,8 @@ func trimSheetName(name string) string {
return name
}
-// PageLayoutOption is an option of a page layout of a worksheet. See
-// SetPageLayout().
-type PageLayoutOption interface {
- setPageLayout(layout *xlsxPageSetUp)
-}
-
-// PageLayoutOptionPtr is a writable PageLayoutOption. See GetPageLayout().
-type PageLayoutOptionPtr interface {
- PageLayoutOption
- getPageLayout(layout *xlsxPageSetUp)
-}
-
-type (
- // BlackAndWhite specified print black and white.
- BlackAndWhite bool
- // FirstPageNumber specified the first printed page number. If no value is
- // specified, then 'automatic' is assumed.
- FirstPageNumber uint
- // PageLayoutOrientation defines the orientation of page layout for a
- // worksheet.
- PageLayoutOrientation string
- // PageLayoutPaperSize defines the paper size of the worksheet.
- PageLayoutPaperSize int
- // FitToHeight specified the number of vertical pages to fit on.
- FitToHeight int
- // FitToWidth specified the number of horizontal pages to fit on.
- FitToWidth int
- // PageLayoutScale defines the print scaling. This attribute is restricted
- // to value ranging from 10 (10%) to 400 (400%). This setting is
- // overridden when fitToWidth and/or fitToHeight are in use.
- PageLayoutScale uint
-)
-
-const (
- // OrientationPortrait indicates page layout orientation id portrait.
- OrientationPortrait = "portrait"
- // OrientationLandscape indicates page layout orientation id landscape.
- OrientationLandscape = "landscape"
-)
-
-// setPageLayout provides a method to set the print black and white for the
-// worksheet.
-func (p BlackAndWhite) setPageLayout(ps *xlsxPageSetUp) {
- ps.BlackAndWhite = bool(p)
-}
-
-// getPageLayout provides a method to get the print black and white for the
-// worksheet.
-func (p *BlackAndWhite) getPageLayout(ps *xlsxPageSetUp) {
- if ps == nil {
- *p = false
- return
- }
- *p = BlackAndWhite(ps.BlackAndWhite)
-}
-
-// setPageLayout provides a method to set the first printed page number for
-// the worksheet.
-func (p FirstPageNumber) setPageLayout(ps *xlsxPageSetUp) {
- if 0 < int(p) {
- ps.FirstPageNumber = strconv.Itoa(int(p))
- ps.UseFirstPageNumber = true
- }
-}
-
-// getPageLayout provides a method to get the first printed page number for
-// the worksheet.
-func (p *FirstPageNumber) getPageLayout(ps *xlsxPageSetUp) {
- if ps != nil && ps.UseFirstPageNumber {
- if number, _ := strconv.Atoi(ps.FirstPageNumber); number != 0 {
- *p = FirstPageNumber(number)
- return
- }
- }
- *p = 1
-}
-
-// setPageLayout provides a method to set the orientation for the worksheet.
-func (o PageLayoutOrientation) setPageLayout(ps *xlsxPageSetUp) {
- ps.Orientation = string(o)
-}
-
-// getPageLayout provides a method to get the orientation for the worksheet.
-func (o *PageLayoutOrientation) getPageLayout(ps *xlsxPageSetUp) {
- // Excel default: portrait
- if ps == nil || ps.Orientation == "" {
- *o = OrientationPortrait
- return
- }
- *o = PageLayoutOrientation(ps.Orientation)
-}
-
-// setPageLayout provides a method to set the paper size for the worksheet.
-func (p PageLayoutPaperSize) setPageLayout(ps *xlsxPageSetUp) {
- ps.PaperSize = intPtr(int(p))
-}
-
-// getPageLayout provides a method to get the paper size for the worksheet.
-func (p *PageLayoutPaperSize) getPageLayout(ps *xlsxPageSetUp) {
- // Excel default: 1
- if ps == nil || ps.PaperSize == nil {
- *p = 1
- return
- }
- *p = PageLayoutPaperSize(*ps.PaperSize)
-}
-
-// setPageLayout provides a method to set the fit to height for the worksheet.
-func (p FitToHeight) setPageLayout(ps *xlsxPageSetUp) {
- if int(p) > 0 {
- ps.FitToHeight = intPtr(int(p))
- }
-}
-
-// getPageLayout provides a method to get the fit to height for the worksheet.
-func (p *FitToHeight) getPageLayout(ps *xlsxPageSetUp) {
- if ps == nil || ps.FitToHeight == nil {
- *p = 1
- return
- }
- *p = FitToHeight(*ps.FitToHeight)
-}
-
-// setPageLayout provides a method to set the fit to width for the worksheet.
-func (p FitToWidth) setPageLayout(ps *xlsxPageSetUp) {
- if int(p) > 0 {
- ps.FitToWidth = intPtr(int(p))
- }
-}
-
-// getPageLayout provides a method to get the fit to width for the worksheet.
-func (p *FitToWidth) getPageLayout(ps *xlsxPageSetUp) {
- if ps == nil || ps.FitToWidth == nil {
- *p = 1
- return
- }
- *p = FitToWidth(*ps.FitToWidth)
-}
-
-// setPageLayout provides a method to set the scale for the worksheet.
-func (p PageLayoutScale) setPageLayout(ps *xlsxPageSetUp) {
- if 10 <= int(p) && int(p) <= 400 {
- ps.Scale = int(p)
- }
-}
-
-// getPageLayout provides a method to get the scale for the worksheet.
-func (p *PageLayoutScale) getPageLayout(ps *xlsxPageSetUp) {
- if ps == nil || ps.Scale < 10 || ps.Scale > 400 {
- *p = 100
- return
- }
- *p = PageLayoutScale(ps.Scale)
-}
-
// SetPageLayout provides a function to sets worksheet page layout.
//
-// Available options:
-//
-// BlackAndWhite(bool)
-// FirstPageNumber(uint)
-// PageLayoutOrientation(string)
-// PageLayoutPaperSize(int)
-// FitToHeight(int)
-// FitToWidth(int)
-// PageLayoutScale(uint)
-//
// The following shows the paper size sorted by excelize index number:
//
// Index | Paper Size
@@ -1500,42 +1335,93 @@ func (p *PageLayoutScale) getPageLayout(ps *xlsxPageSetUp) {
// 116 | PRC Envelope #8 Rotated (309 mm x 120 mm)
// 117 | PRC Envelope #9 Rotated (324 mm x 229 mm)
// 118 | PRC Envelope #10 Rotated (458 mm x 324 mm)
-func (f *File) SetPageLayout(sheet string, opts ...PageLayoutOption) error {
- s, err := f.workSheetReader(sheet)
+func (f *File) SetPageLayout(sheet string, opts *PageLayoutOptions) error {
+ ws, err := f.workSheetReader(sheet)
if err != nil {
return err
}
- ps := s.PageSetUp
- if ps == nil {
- ps = new(xlsxPageSetUp)
- s.PageSetUp = ps
+ if opts == nil {
+ return err
+ }
+ ws.setPageSetUp(opts)
+ return err
+}
+
+// newPageSetUp initialize page setup settings for the worksheet if which not
+// exist.
+func (ws *xlsxWorksheet) newPageSetUp() {
+ if ws.PageSetUp == nil {
+ ws.PageSetUp = new(xlsxPageSetUp)
}
+}
- for _, opt := range opts {
- opt.setPageLayout(ps)
+// setPageSetUp set page setup settings for the worksheet by given options.
+func (ws *xlsxWorksheet) setPageSetUp(opts *PageLayoutOptions) {
+ if opts.Size != nil {
+ ws.newPageSetUp()
+ ws.PageSetUp.PaperSize = opts.Size
+ }
+ if opts.Orientation != nil && (*opts.Orientation == "portrait" || *opts.Orientation == "landscape") {
+ ws.newPageSetUp()
+ ws.PageSetUp.Orientation = *opts.Orientation
+ }
+ if opts.FirstPageNumber != nil && *opts.FirstPageNumber > 0 {
+ ws.newPageSetUp()
+ ws.PageSetUp.FirstPageNumber = strconv.Itoa(int(*opts.FirstPageNumber))
+ ws.PageSetUp.UseFirstPageNumber = true
+ }
+ if opts.AdjustTo != nil && 10 <= *opts.AdjustTo && *opts.AdjustTo <= 400 {
+ ws.newPageSetUp()
+ ws.PageSetUp.Scale = int(*opts.AdjustTo)
+ }
+ if opts.FitToHeight != nil {
+ ws.newPageSetUp()
+ ws.PageSetUp.FitToHeight = opts.FitToHeight
+ }
+ if opts.FitToWidth != nil {
+ ws.newPageSetUp()
+ ws.PageSetUp.FitToWidth = opts.FitToWidth
+ }
+ if opts.BlackAndWhite != nil {
+ ws.newPageSetUp()
+ ws.PageSetUp.BlackAndWhite = *opts.BlackAndWhite
}
- return err
}
// GetPageLayout provides a function to gets worksheet page layout.
-//
-// Available options:
-//
-// PageLayoutOrientation(string)
-// PageLayoutPaperSize(int)
-// FitToHeight(int)
-// FitToWidth(int)
-func (f *File) GetPageLayout(sheet string, opts ...PageLayoutOptionPtr) error {
- s, err := f.workSheetReader(sheet)
+func (f *File) GetPageLayout(sheet string) (PageLayoutOptions, error) {
+ opts := PageLayoutOptions{
+ Size: intPtr(0),
+ Orientation: stringPtr("portrait"),
+ FirstPageNumber: uintPtr(1),
+ AdjustTo: uintPtr(100),
+ }
+ ws, err := f.workSheetReader(sheet)
if err != nil {
- return err
+ return opts, err
}
- ps := s.PageSetUp
-
- for _, opt := range opts {
- opt.getPageLayout(ps)
+ if ws.PageSetUp != nil {
+ if ws.PageSetUp.PaperSize != nil {
+ opts.Size = ws.PageSetUp.PaperSize
+ }
+ if ws.PageSetUp.Orientation != "" {
+ opts.Orientation = stringPtr(ws.PageSetUp.Orientation)
+ }
+ if num, _ := strconv.Atoi(ws.PageSetUp.FirstPageNumber); num != 0 {
+ opts.FirstPageNumber = uintPtr(uint(num))
+ }
+ if ws.PageSetUp.Scale >= 10 && ws.PageSetUp.Scale <= 400 {
+ opts.AdjustTo = uintPtr(uint(ws.PageSetUp.Scale))
+ }
+ if ws.PageSetUp.FitToHeight != nil {
+ opts.FitToHeight = ws.PageSetUp.FitToHeight
+ }
+ if ws.PageSetUp.FitToWidth != nil {
+ opts.FitToWidth = ws.PageSetUp.FitToWidth
+ }
+ opts.BlackAndWhite = boolPtr(ws.PageSetUp.BlackAndWhite)
}
- return err
+ return opts, err
}
// SetDefinedName provides a function to set the defined names of the workbook
@@ -1690,20 +1576,23 @@ func (f *File) UngroupSheets() error {
// ends and where begins the next one by given worksheet name and cell reference, so the
// content before the page break will be printed on one page and after the
// page break on another.
-func (f *File) InsertPageBreak(sheet, cell string) (err error) {
- var ws *xlsxWorksheet
- var row, col int
+func (f *File) InsertPageBreak(sheet, cell string) error {
+ var (
+ ws *xlsxWorksheet
+ row, col int
+ err error
+ )
rowBrk, colBrk := -1, -1
if ws, err = f.workSheetReader(sheet); err != nil {
- return
+ return err
}
if col, row, err = CellNameToCoordinates(cell); err != nil {
- return
+ return err
}
col--
row--
if col == row && col == 0 {
- return
+ return err
}
if ws.RowBreaks == nil {
ws.RowBreaks = &xlsxBreaks{}
@@ -1741,24 +1630,27 @@ func (f *File) InsertPageBreak(sheet, cell string) (err error) {
}
ws.RowBreaks.Count = len(ws.RowBreaks.Brk)
ws.ColBreaks.Count = len(ws.ColBreaks.Brk)
- return
+ return err
}
// RemovePageBreak remove a page break by given worksheet name and cell
// reference.
-func (f *File) RemovePageBreak(sheet, cell string) (err error) {
- var ws *xlsxWorksheet
- var row, col int
+func (f *File) RemovePageBreak(sheet, cell string) error {
+ var (
+ ws *xlsxWorksheet
+ row, col int
+ err error
+ )
if ws, err = f.workSheetReader(sheet); err != nil {
- return
+ return err
}
if col, row, err = CellNameToCoordinates(cell); err != nil {
- return
+ return err
}
col--
row--
if col == row && col == 0 {
- return
+ return err
}
removeBrk := func(ID int, brks []*xlsxBrk) []*xlsxBrk {
for i, brk := range brks {
@@ -1769,7 +1661,7 @@ func (f *File) RemovePageBreak(sheet, cell string) (err error) {
return brks
}
if ws.RowBreaks == nil || ws.ColBreaks == nil {
- return
+ return err
}
rowBrks := len(ws.RowBreaks.Brk)
colBrks := len(ws.ColBreaks.Brk)
@@ -1780,20 +1672,20 @@ func (f *File) RemovePageBreak(sheet, cell string) (err error) {
ws.ColBreaks.Count = len(ws.ColBreaks.Brk)
ws.RowBreaks.ManualBreakCount--
ws.ColBreaks.ManualBreakCount--
- return
+ return err
}
if rowBrks > 0 && rowBrks > colBrks {
ws.RowBreaks.Brk = removeBrk(row, ws.RowBreaks.Brk)
ws.RowBreaks.Count = len(ws.RowBreaks.Brk)
ws.RowBreaks.ManualBreakCount--
- return
+ return err
}
if colBrks > 0 && colBrks > rowBrks {
ws.ColBreaks.Brk = removeBrk(col, ws.ColBreaks.Brk)
ws.ColBreaks.Count = len(ws.ColBreaks.Brk)
ws.ColBreaks.ManualBreakCount--
}
- return
+ return err
}
// relsReader provides a function to get the pointer to the structure
diff --git a/sheet_test.go b/sheet_test.go
index 87c36d469f..74ca02c1b3 100644
--- a/sheet_test.go
+++ b/sheet_test.go
@@ -8,78 +8,9 @@ import (
"strings"
"testing"
- "github.com/mohae/deepcopy"
"github.com/stretchr/testify/assert"
)
-func ExampleFile_SetPageLayout() {
- f := NewFile()
- if err := f.SetPageLayout(
- "Sheet1",
- BlackAndWhite(true),
- FirstPageNumber(2),
- PageLayoutOrientation(OrientationLandscape),
- PageLayoutPaperSize(10),
- FitToHeight(2),
- FitToWidth(2),
- PageLayoutScale(50),
- ); err != nil {
- fmt.Println(err)
- }
- // Output:
-}
-
-func ExampleFile_GetPageLayout() {
- f := NewFile()
- var (
- blackAndWhite BlackAndWhite
- firstPageNumber FirstPageNumber
- orientation PageLayoutOrientation
- paperSize PageLayoutPaperSize
- fitToHeight FitToHeight
- fitToWidth FitToWidth
- scale PageLayoutScale
- )
- if err := f.GetPageLayout("Sheet1", &blackAndWhite); err != nil {
- fmt.Println(err)
- }
- if err := f.GetPageLayout("Sheet1", &firstPageNumber); err != nil {
- fmt.Println(err)
- }
- if err := f.GetPageLayout("Sheet1", &orientation); err != nil {
- fmt.Println(err)
- }
- if err := f.GetPageLayout("Sheet1", &paperSize); err != nil {
- fmt.Println(err)
- }
- if err := f.GetPageLayout("Sheet1", &fitToHeight); err != nil {
- fmt.Println(err)
- }
- if err := f.GetPageLayout("Sheet1", &fitToWidth); err != nil {
- fmt.Println(err)
- }
- if err := f.GetPageLayout("Sheet1", &scale); err != nil {
- fmt.Println(err)
- }
- fmt.Println("Defaults:")
- fmt.Printf("- print black and white: %t\n", blackAndWhite)
- fmt.Printf("- page number for first printed page: %d\n", firstPageNumber)
- fmt.Printf("- orientation: %q\n", orientation)
- fmt.Printf("- paper size: %d\n", paperSize)
- fmt.Printf("- fit to height: %d\n", fitToHeight)
- fmt.Printf("- fit to width: %d\n", fitToWidth)
- fmt.Printf("- scale: %d\n", scale)
- // Output:
- // Defaults:
- // - print black and white: false
- // - page number for first printed page: 1
- // - orientation: "portrait"
- // - paper size: 1
- // - fit to height: 1
- // - fit to width: 1
- // - scale: 100
-}
-
func TestNewSheet(t *testing.T) {
f := NewFile()
f.NewSheet("Sheet2")
@@ -114,68 +45,6 @@ func TestSetPane(t *testing.T) {
assert.NoError(t, f.SetPanes("Sheet1", `{"freeze":true,"split":false,"x_split":1,"y_split":0,"top_left_cell":"B1","active_pane":"topRight","panes":[{"sqref":"K16","active_cell":"K16","pane":"topRight"}]}`))
}
-func TestPageLayoutOption(t *testing.T) {
- const sheet = "Sheet1"
-
- testData := []struct {
- container PageLayoutOptionPtr
- nonDefault PageLayoutOption
- }{
- {new(BlackAndWhite), BlackAndWhite(true)},
- {new(FirstPageNumber), FirstPageNumber(2)},
- {new(PageLayoutOrientation), PageLayoutOrientation(OrientationLandscape)},
- {new(PageLayoutPaperSize), PageLayoutPaperSize(10)},
- {new(FitToHeight), FitToHeight(2)},
- {new(FitToWidth), FitToWidth(2)},
- {new(PageLayoutScale), PageLayoutScale(50)},
- }
-
- for i, test := range testData {
- t.Run(fmt.Sprintf("TestData%d", i), func(t *testing.T) {
- opts := test.nonDefault
- t.Logf("option %T", opts)
-
- def := deepcopy.Copy(test.container).(PageLayoutOptionPtr)
- val1 := deepcopy.Copy(def).(PageLayoutOptionPtr)
- val2 := deepcopy.Copy(def).(PageLayoutOptionPtr)
-
- f := NewFile()
- // Get the default value
- assert.NoError(t, f.GetPageLayout(sheet, def), opts)
- // Get again and check
- assert.NoError(t, f.GetPageLayout(sheet, val1), opts)
- if !assert.Equal(t, val1, def, opts) {
- t.FailNow()
- }
- // Set the same value
- assert.NoError(t, f.SetPageLayout(sheet, val1), opts)
- // Get again and check
- assert.NoError(t, f.GetPageLayout(sheet, val1), opts)
- if !assert.Equal(t, val1, def, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Set a different value
- assert.NoError(t, f.SetPageLayout(sheet, test.nonDefault), opts)
- assert.NoError(t, f.GetPageLayout(sheet, val1), opts)
- // Get again and compare
- assert.NoError(t, f.GetPageLayout(sheet, val2), opts)
- if !assert.Equal(t, val1, val2, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Value should not be the same as the default
- if !assert.NotEqual(t, def, val1, "%T: value should have changed from default", opts) {
- t.FailNow()
- }
- // Restore the default value
- assert.NoError(t, f.SetPageLayout(sheet, def), opts)
- assert.NoError(t, f.GetPageLayout(sheet, val1), opts)
- if !assert.Equal(t, def, val1) {
- t.FailNow()
- }
- })
- }
-}
-
func TestSearchSheet(t *testing.T) {
f, err := OpenFile(filepath.Join("test", "SharedStrings.xlsx"))
if !assert.NoError(t, err) {
@@ -226,14 +95,32 @@ func TestSearchSheet(t *testing.T) {
func TestSetPageLayout(t *testing.T) {
f := NewFile()
+ assert.NoError(t, f.SetPageLayout("Sheet1", nil))
+ ws, ok := f.Sheet.Load("xl/worksheets/sheet1.xml")
+ assert.True(t, ok)
+ ws.(*xlsxWorksheet).PageSetUp = nil
+ expected := PageLayoutOptions{
+ Size: intPtr(1),
+ Orientation: stringPtr("landscape"),
+ FirstPageNumber: uintPtr(1),
+ AdjustTo: uintPtr(120),
+ FitToHeight: intPtr(2),
+ FitToWidth: intPtr(2),
+ BlackAndWhite: boolPtr(true),
+ }
+ assert.NoError(t, f.SetPageLayout("Sheet1", &expected))
+ opts, err := f.GetPageLayout("Sheet1")
+ assert.NoError(t, err)
+ assert.Equal(t, expected, opts)
// Test set page layout on not exists worksheet.
- assert.EqualError(t, f.SetPageLayout("SheetN"), "sheet SheetN does not exist")
+ assert.EqualError(t, f.SetPageLayout("SheetN", nil), "sheet SheetN does not exist")
}
func TestGetPageLayout(t *testing.T) {
f := NewFile()
// Test get page layout on not exists worksheet.
- assert.EqualError(t, f.GetPageLayout("SheetN"), "sheet SheetN does not exist")
+ _, err := f.GetPageLayout("SheetN")
+ assert.EqualError(t, err, "sheet SheetN does not exist")
}
func TestSetHeaderFooter(t *testing.T) {
@@ -242,20 +129,20 @@ func TestSetHeaderFooter(t *testing.T) {
// Test set header and footer on not exists worksheet.
assert.EqualError(t, f.SetHeaderFooter("SheetN", nil), "sheet SheetN does not exist")
// Test set header and footer with illegal setting.
- assert.EqualError(t, f.SetHeaderFooter("Sheet1", &FormatHeaderFooter{
+ assert.EqualError(t, f.SetHeaderFooter("Sheet1", &HeaderFooterOptions{
OddHeader: strings.Repeat("c", MaxFieldLength+1),
}), newFieldLengthError("OddHeader").Error())
assert.NoError(t, f.SetHeaderFooter("Sheet1", nil))
text := strings.Repeat("一", MaxFieldLength)
- assert.NoError(t, f.SetHeaderFooter("Sheet1", &FormatHeaderFooter{
+ assert.NoError(t, f.SetHeaderFooter("Sheet1", &HeaderFooterOptions{
OddHeader: text,
OddFooter: text,
EvenHeader: text,
EvenFooter: text,
FirstHeader: text,
}))
- assert.NoError(t, f.SetHeaderFooter("Sheet1", &FormatHeaderFooter{
+ assert.NoError(t, f.SetHeaderFooter("Sheet1", &HeaderFooterOptions{
DifferentFirst: true,
DifferentOddEven: true,
OddHeader: "&R&P",
diff --git a/sheetpr.go b/sheetpr.go
index 8675c7548a..a246e9ef5a 100644
--- a/sheetpr.go
+++ b/sheetpr.go
@@ -11,647 +11,249 @@
package excelize
-import "strings"
-
-// SheetPrOption is an option of a view of a worksheet. See SetSheetPrOptions().
-type SheetPrOption interface {
- setSheetPrOption(view *xlsxSheetPr)
-}
-
-// SheetPrOptionPtr is a writable SheetPrOption. See GetSheetPrOptions().
-type SheetPrOptionPtr interface {
- SheetPrOption
- getSheetPrOption(view *xlsxSheetPr)
-}
-
-type (
- // CodeName is an option used for SheetPrOption and WorkbookPrOption
- CodeName string
- // EnableFormatConditionsCalculation is a SheetPrOption
- EnableFormatConditionsCalculation bool
- // Published is a SheetPrOption
- Published bool
- // FitToPage is a SheetPrOption
- FitToPage bool
- // TabColorIndexed is a TabColor option, within SheetPrOption
- TabColorIndexed int
- // TabColorRGB is a TabColor option, within SheetPrOption
- TabColorRGB string
- // TabColorTheme is a TabColor option, within SheetPrOption
- TabColorTheme int
- // TabColorTint is a TabColor option, within SheetPrOption
- TabColorTint float64
- // AutoPageBreaks is a SheetPrOption
- AutoPageBreaks bool
- // OutlineSummaryBelow is an outlinePr, within SheetPr option
- OutlineSummaryBelow bool
-)
-
-// setSheetPrOption implements the SheetPrOption interface.
-func (o OutlineSummaryBelow) setSheetPrOption(pr *xlsxSheetPr) {
- if pr.OutlinePr == nil {
- pr.OutlinePr = new(xlsxOutlinePr)
+// SetPageMargins provides a function to set worksheet page margins.
+func (f *File) SetPageMargins(sheet string, opts *PageLayoutMarginsOptions) error {
+ ws, err := f.workSheetReader(sheet)
+ if err != nil {
+ return err
}
- pr.OutlinePr.SummaryBelow = bool(o)
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface.
-func (o *OutlineSummaryBelow) getSheetPrOption(pr *xlsxSheetPr) {
- // Excel default: true
- if pr == nil || pr.OutlinePr == nil {
- *o = true
- return
- }
- *o = OutlineSummaryBelow(defaultTrue(&pr.OutlinePr.SummaryBelow))
-}
-
-// setSheetPrOption implements the SheetPrOption interface and specifies a
-// stable name of the sheet.
-func (o CodeName) setSheetPrOption(pr *xlsxSheetPr) {
- pr.CodeName = string(o)
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface and get the
-// stable name of the sheet.
-func (o *CodeName) getSheetPrOption(pr *xlsxSheetPr) {
- if pr == nil {
- *o = ""
- return
- }
- *o = CodeName(pr.CodeName)
-}
-
-// setSheetPrOption implements the SheetPrOption interface and flag indicating
-// whether the conditional formatting calculations shall be evaluated.
-func (o EnableFormatConditionsCalculation) setSheetPrOption(pr *xlsxSheetPr) {
- pr.EnableFormatConditionsCalculation = boolPtr(bool(o))
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface and get the
-// settings of whether the conditional formatting calculations shall be
-// evaluated.
-func (o *EnableFormatConditionsCalculation) getSheetPrOption(pr *xlsxSheetPr) {
- if pr == nil {
- *o = true
- return
- }
- *o = EnableFormatConditionsCalculation(defaultTrue(pr.EnableFormatConditionsCalculation))
-}
-
-// setSheetPrOption implements the SheetPrOption interface and flag indicating
-// whether the worksheet is published.
-func (o Published) setSheetPrOption(pr *xlsxSheetPr) {
- pr.Published = boolPtr(bool(o))
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface and get the
-// settings of whether the worksheet is published.
-func (o *Published) getSheetPrOption(pr *xlsxSheetPr) {
- if pr == nil {
- *o = true
- return
- }
- *o = Published(defaultTrue(pr.Published))
-}
-
-// setSheetPrOption implements the SheetPrOption interface.
-func (o FitToPage) setSheetPrOption(pr *xlsxSheetPr) {
- if pr.PageSetUpPr == nil {
- if !o {
- return
- }
- pr.PageSetUpPr = new(xlsxPageSetUpPr)
+ if opts == nil {
+ return err
}
- pr.PageSetUpPr.FitToPage = bool(o)
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface.
-func (o *FitToPage) getSheetPrOption(pr *xlsxSheetPr) {
- // Excel default: false
- if pr == nil || pr.PageSetUpPr == nil {
- *o = false
- return
- }
- *o = FitToPage(pr.PageSetUpPr.FitToPage)
-}
-
-// setSheetPrOption implements the SheetPrOption interface and sets the
-// TabColor Indexed.
-func (o TabColorIndexed) setSheetPrOption(pr *xlsxSheetPr) {
- if pr.TabColor == nil {
- pr.TabColor = new(xlsxTabColor)
+ preparePageMargins := func(ws *xlsxWorksheet) {
+ if ws.PageMargins == nil {
+ ws.PageMargins = new(xlsxPageMargins)
+ }
}
- pr.TabColor.Indexed = int(o)
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface and gets the
-// TabColor Indexed. Defaults to -1 if no indexed has been set.
-func (o *TabColorIndexed) getSheetPrOption(pr *xlsxSheetPr) {
- if pr == nil || pr.TabColor == nil {
- *o = TabColorIndexed(ColorMappingTypeUnset)
- return
- }
- *o = TabColorIndexed(pr.TabColor.Indexed)
-}
-
-// setSheetPrOption implements the SheetPrOption interface and specifies a
-// stable name of the sheet.
-func (o TabColorRGB) setSheetPrOption(pr *xlsxSheetPr) {
- if pr.TabColor == nil {
- if string(o) == "" {
- return
+ preparePrintOptions := func(ws *xlsxWorksheet) {
+ if ws.PrintOptions == nil {
+ ws.PrintOptions = new(xlsxPrintOptions)
}
- pr.TabColor = new(xlsxTabColor)
}
- pr.TabColor.RGB = getPaletteColor(string(o))
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface and get the
-// stable name of the sheet.
-func (o *TabColorRGB) getSheetPrOption(pr *xlsxSheetPr) {
- if pr == nil || pr.TabColor == nil {
- *o = ""
- return
- }
- *o = TabColorRGB(strings.TrimPrefix(pr.TabColor.RGB, "FF"))
-}
-
-// setSheetPrOption implements the SheetPrOption interface and sets the
-// TabColor Theme. Warning: it does not create a clrScheme!
-func (o TabColorTheme) setSheetPrOption(pr *xlsxSheetPr) {
- if pr.TabColor == nil {
- pr.TabColor = new(xlsxTabColor)
+ if opts.Bottom != nil {
+ preparePageMargins(ws)
+ ws.PageMargins.Bottom = *opts.Bottom
}
- pr.TabColor.Theme = int(o)
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface and gets the
-// TabColor Theme. Defaults to -1 if no theme has been set.
-func (o *TabColorTheme) getSheetPrOption(pr *xlsxSheetPr) {
- if pr == nil || pr.TabColor == nil {
- *o = TabColorTheme(ColorMappingTypeUnset)
- return
- }
- *o = TabColorTheme(pr.TabColor.Theme)
-}
-
-// setSheetPrOption implements the SheetPrOption interface and sets the
-// TabColor Tint.
-func (o TabColorTint) setSheetPrOption(pr *xlsxSheetPr) {
- if pr.TabColor == nil {
- pr.TabColor = new(xlsxTabColor)
+ if opts.Footer != nil {
+ preparePageMargins(ws)
+ ws.PageMargins.Footer = *opts.Footer
}
- pr.TabColor.Tint = float64(o)
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface and gets the
-// TabColor Tint. Defaults to 0.0 if no tint has been set.
-func (o *TabColorTint) getSheetPrOption(pr *xlsxSheetPr) {
- if pr == nil || pr.TabColor == nil {
- *o = 0.0
- return
- }
- *o = TabColorTint(pr.TabColor.Tint)
-}
-
-// setSheetPrOption implements the SheetPrOption interface.
-func (o AutoPageBreaks) setSheetPrOption(pr *xlsxSheetPr) {
- if pr.PageSetUpPr == nil {
- if !o {
- return
- }
- pr.PageSetUpPr = new(xlsxPageSetUpPr)
+ if opts.Header != nil {
+ preparePageMargins(ws)
+ ws.PageMargins.Header = *opts.Header
}
- pr.PageSetUpPr.AutoPageBreaks = bool(o)
-}
-
-// getSheetPrOption implements the SheetPrOptionPtr interface.
-func (o *AutoPageBreaks) getSheetPrOption(pr *xlsxSheetPr) {
- // Excel default: false
- if pr == nil || pr.PageSetUpPr == nil {
- *o = false
- return
- }
- *o = AutoPageBreaks(pr.PageSetUpPr.AutoPageBreaks)
-}
-
-// SetSheetPrOptions provides a function to sets worksheet properties.
-//
-// Available options:
-//
-// CodeName(string)
-// EnableFormatConditionsCalculation(bool)
-// Published(bool)
-// FitToPage(bool)
-// TabColorIndexed(int)
-// TabColorRGB(string)
-// TabColorTheme(int)
-// TabColorTint(float64)
-// AutoPageBreaks(bool)
-// OutlineSummaryBelow(bool)
-func (f *File) SetSheetPrOptions(sheet string, opts ...SheetPrOption) error {
- ws, err := f.workSheetReader(sheet)
- if err != nil {
- return err
+ if opts.Left != nil {
+ preparePageMargins(ws)
+ ws.PageMargins.Left = *opts.Left
}
- pr := ws.SheetPr
- if pr == nil {
- pr = new(xlsxSheetPr)
- ws.SheetPr = pr
+ if opts.Right != nil {
+ preparePageMargins(ws)
+ ws.PageMargins.Right = *opts.Right
}
-
- for _, opt := range opts {
- opt.setSheetPrOption(pr)
+ if opts.Top != nil {
+ preparePageMargins(ws)
+ ws.PageMargins.Top = *opts.Top
+ }
+ if opts.Horizontally != nil {
+ preparePrintOptions(ws)
+ ws.PrintOptions.HorizontalCentered = *opts.Horizontally
+ }
+ if opts.Vertically != nil {
+ preparePrintOptions(ws)
+ ws.PrintOptions.VerticalCentered = *opts.Vertically
}
return err
}
-// GetSheetPrOptions provides a function to gets worksheet properties.
-//
-// Available options:
-//
-// CodeName(string)
-// EnableFormatConditionsCalculation(bool)
-// Published(bool)
-// FitToPage(bool)
-// TabColorIndexed(int)
-// TabColorRGB(string)
-// TabColorTheme(int)
-// TabColorTint(float64)
-// AutoPageBreaks(bool)
-// OutlineSummaryBelow(bool)
-func (f *File) GetSheetPrOptions(sheet string, opts ...SheetPrOptionPtr) error {
+// GetPageMargins provides a function to get worksheet page margins.
+func (f *File) GetPageMargins(sheet string) (PageLayoutMarginsOptions, error) {
+ opts := PageLayoutMarginsOptions{
+ Bottom: float64Ptr(0.75),
+ Footer: float64Ptr(0.3),
+ Header: float64Ptr(0.3),
+ Left: float64Ptr(0.7),
+ Right: float64Ptr(0.7),
+ Top: float64Ptr(0.75),
+ }
ws, err := f.workSheetReader(sheet)
if err != nil {
- return err
+ return opts, err
}
- pr := ws.SheetPr
-
- for _, opt := range opts {
- opt.getSheetPrOption(pr)
+ if ws.PageMargins != nil {
+ if ws.PageMargins.Bottom != 0 {
+ opts.Bottom = float64Ptr(ws.PageMargins.Bottom)
+ }
+ if ws.PageMargins.Footer != 0 {
+ opts.Footer = float64Ptr(ws.PageMargins.Footer)
+ }
+ if ws.PageMargins.Header != 0 {
+ opts.Header = float64Ptr(ws.PageMargins.Header)
+ }
+ if ws.PageMargins.Left != 0 {
+ opts.Left = float64Ptr(ws.PageMargins.Left)
+ }
+ if ws.PageMargins.Right != 0 {
+ opts.Right = float64Ptr(ws.PageMargins.Right)
+ }
+ if ws.PageMargins.Top != 0 {
+ opts.Top = float64Ptr(ws.PageMargins.Top)
+ }
}
- return err
-}
-
-type (
- // PageMarginBottom specifies the bottom margin for the page.
- PageMarginBottom float64
- // PageMarginFooter specifies the footer margin for the page.
- PageMarginFooter float64
- // PageMarginHeader specifies the header margin for the page.
- PageMarginHeader float64
- // PageMarginLeft specifies the left margin for the page.
- PageMarginLeft float64
- // PageMarginRight specifies the right margin for the page.
- PageMarginRight float64
- // PageMarginTop specifies the top margin for the page.
- PageMarginTop float64
-)
-
-// setPageMargins provides a method to set the bottom margin for the worksheet.
-func (p PageMarginBottom) setPageMargins(pm *xlsxPageMargins) {
- pm.Bottom = float64(p)
-}
-
-// setPageMargins provides a method to get the bottom margin for the worksheet.
-func (p *PageMarginBottom) getPageMargins(pm *xlsxPageMargins) {
- // Excel default: 0.75
- if pm == nil || pm.Bottom == 0 {
- *p = 0.75
- return
- }
- *p = PageMarginBottom(pm.Bottom)
-}
-
-// setPageMargins provides a method to set the footer margin for the worksheet.
-func (p PageMarginFooter) setPageMargins(pm *xlsxPageMargins) {
- pm.Footer = float64(p)
-}
-
-// setPageMargins provides a method to get the footer margin for the worksheet.
-func (p *PageMarginFooter) getPageMargins(pm *xlsxPageMargins) {
- // Excel default: 0.3
- if pm == nil || pm.Footer == 0 {
- *p = 0.3
- return
- }
- *p = PageMarginFooter(pm.Footer)
-}
-
-// setPageMargins provides a method to set the header margin for the worksheet.
-func (p PageMarginHeader) setPageMargins(pm *xlsxPageMargins) {
- pm.Header = float64(p)
-}
-
-// setPageMargins provides a method to get the header margin for the worksheet.
-func (p *PageMarginHeader) getPageMargins(pm *xlsxPageMargins) {
- // Excel default: 0.3
- if pm == nil || pm.Header == 0 {
- *p = 0.3
- return
- }
- *p = PageMarginHeader(pm.Header)
-}
-
-// setPageMargins provides a method to set the left margin for the worksheet.
-func (p PageMarginLeft) setPageMargins(pm *xlsxPageMargins) {
- pm.Left = float64(p)
-}
-
-// setPageMargins provides a method to get the left margin for the worksheet.
-func (p *PageMarginLeft) getPageMargins(pm *xlsxPageMargins) {
- // Excel default: 0.7
- if pm == nil || pm.Left == 0 {
- *p = 0.7
- return
- }
- *p = PageMarginLeft(pm.Left)
-}
-
-// setPageMargins provides a method to set the right margin for the worksheet.
-func (p PageMarginRight) setPageMargins(pm *xlsxPageMargins) {
- pm.Right = float64(p)
-}
-
-// setPageMargins provides a method to get the right margin for the worksheet.
-func (p *PageMarginRight) getPageMargins(pm *xlsxPageMargins) {
- // Excel default: 0.7
- if pm == nil || pm.Right == 0 {
- *p = 0.7
- return
- }
- *p = PageMarginRight(pm.Right)
-}
-
-// setPageMargins provides a method to set the top margin for the worksheet.
-func (p PageMarginTop) setPageMargins(pm *xlsxPageMargins) {
- pm.Top = float64(p)
-}
-
-// setPageMargins provides a method to get the top margin for the worksheet.
-func (p *PageMarginTop) getPageMargins(pm *xlsxPageMargins) {
- // Excel default: 0.75
- if pm == nil || pm.Top == 0 {
- *p = 0.75
- return
- }
- *p = PageMarginTop(pm.Top)
-}
-
-// PageMarginsOptions is an option of a page margin of a worksheet. See
-// SetPageMargins().
-type PageMarginsOptions interface {
- setPageMargins(layout *xlsxPageMargins)
-}
-
-// PageMarginsOptionsPtr is a writable PageMarginsOptions. See
-// GetPageMargins().
-type PageMarginsOptionsPtr interface {
- PageMarginsOptions
- getPageMargins(layout *xlsxPageMargins)
+ if ws.PrintOptions != nil {
+ opts.Horizontally = boolPtr(ws.PrintOptions.HorizontalCentered)
+ opts.Vertically = boolPtr(ws.PrintOptions.VerticalCentered)
+ }
+ return opts, err
}
-// SetPageMargins provides a function to set worksheet page margins.
-//
-// Available options:
-//
-// PageMarginBottom(float64)
-// PageMarginFooter(float64)
-// PageMarginHeader(float64)
-// PageMarginLeft(float64)
-// PageMarginRight(float64)
-// PageMarginTop(float64)
-func (f *File) SetPageMargins(sheet string, opts ...PageMarginsOptions) error {
- s, err := f.workSheetReader(sheet)
- if err != nil {
- return err
+// setSheetProps set worksheet format properties by given options.
+func (ws *xlsxWorksheet) setSheetProps(opts *SheetPropsOptions) {
+ prepareSheetPr := func(ws *xlsxWorksheet) {
+ if ws.SheetPr == nil {
+ ws.SheetPr = new(xlsxSheetPr)
+ }
}
- pm := s.PageMargins
- if pm == nil {
- pm = new(xlsxPageMargins)
- s.PageMargins = pm
+ preparePageSetUpPr := func(ws *xlsxWorksheet) {
+ prepareSheetPr(ws)
+ if ws.SheetPr.PageSetUpPr == nil {
+ ws.SheetPr.PageSetUpPr = new(xlsxPageSetUpPr)
+ }
}
-
- for _, opt := range opts {
- opt.setPageMargins(pm)
+ prepareOutlinePr := func(ws *xlsxWorksheet) {
+ prepareSheetPr(ws)
+ if ws.SheetPr.OutlinePr == nil {
+ ws.SheetPr.OutlinePr = new(xlsxOutlinePr)
+ }
}
- return err
-}
-
-// GetPageMargins provides a function to get worksheet page margins.
-//
-// Available options:
-//
-// PageMarginBottom(float64)
-// PageMarginFooter(float64)
-// PageMarginHeader(float64)
-// PageMarginLeft(float64)
-// PageMarginRight(float64)
-// PageMarginTop(float64)
-func (f *File) GetPageMargins(sheet string, opts ...PageMarginsOptionsPtr) error {
- s, err := f.workSheetReader(sheet)
- if err != nil {
- return err
+ prepareTabColor := func(ws *xlsxWorksheet) {
+ prepareSheetPr(ws)
+ if ws.SheetPr.TabColor == nil {
+ ws.SheetPr.TabColor = new(xlsxTabColor)
+ }
}
- pm := s.PageMargins
-
- for _, opt := range opts {
- opt.getPageMargins(pm)
+ if opts.CodeName != nil {
+ prepareSheetPr(ws)
+ ws.SheetPr.CodeName = *opts.CodeName
}
- return err
-}
-
-// SheetFormatPrOptions is an option of the formatting properties of a
-// worksheet. See SetSheetFormatPr().
-type SheetFormatPrOptions interface {
- setSheetFormatPr(formatPr *xlsxSheetFormatPr)
-}
-
-// SheetFormatPrOptionsPtr is a writable SheetFormatPrOptions. See
-// GetSheetFormatPr().
-type SheetFormatPrOptionsPtr interface {
- SheetFormatPrOptions
- getSheetFormatPr(formatPr *xlsxSheetFormatPr)
-}
-
-type (
- // BaseColWidth specifies the number of characters of the maximum digit width
- // of the normal style's font. This value does not include margin padding or
- // extra padding for gridlines. It is only the number of characters.
- BaseColWidth uint8
- // DefaultColWidth specifies the default column width measured as the number
- // of characters of the maximum digit width of the normal style's font.
- DefaultColWidth float64
- // DefaultRowHeight specifies the default row height measured in point size.
- // Optimization so we don't have to write the height on all rows. This can be
- // written out if most rows have custom height, to achieve the optimization.
- DefaultRowHeight float64
- // CustomHeight specifies the custom height.
- CustomHeight bool
- // ZeroHeight specifies if rows are hidden.
- ZeroHeight bool
- // ThickTop specifies if rows have a thick top border by default.
- ThickTop bool
- // ThickBottom specifies if rows have a thick bottom border by default.
- ThickBottom bool
-)
-
-// setSheetFormatPr provides a method to set the number of characters of the
-// maximum digit width of the normal style's font.
-func (p BaseColWidth) setSheetFormatPr(fp *xlsxSheetFormatPr) {
- fp.BaseColWidth = uint8(p)
-}
-
-// setSheetFormatPr provides a method to set the number of characters of the
-// maximum digit width of the normal style's font.
-func (p *BaseColWidth) getSheetFormatPr(fp *xlsxSheetFormatPr) {
- if fp == nil {
- *p = 0
- return
- }
- *p = BaseColWidth(fp.BaseColWidth)
-}
-
-// setSheetFormatPr provides a method to set the default column width measured
-// as the number of characters of the maximum digit width of the normal
-// style's font.
-func (p DefaultColWidth) setSheetFormatPr(fp *xlsxSheetFormatPr) {
- fp.DefaultColWidth = float64(p)
-}
-
-// getSheetFormatPr provides a method to get the default column width measured
-// as the number of characters of the maximum digit width of the normal
-// style's font.
-func (p *DefaultColWidth) getSheetFormatPr(fp *xlsxSheetFormatPr) {
- if fp == nil {
- *p = 0
- return
- }
- *p = DefaultColWidth(fp.DefaultColWidth)
-}
-
-// setSheetFormatPr provides a method to set the default row height measured
-// in point size.
-func (p DefaultRowHeight) setSheetFormatPr(fp *xlsxSheetFormatPr) {
- fp.DefaultRowHeight = float64(p)
-}
-
-// getSheetFormatPr provides a method to get the default row height measured
-// in point size.
-func (p *DefaultRowHeight) getSheetFormatPr(fp *xlsxSheetFormatPr) {
- if fp == nil {
- *p = 15
- return
- }
- *p = DefaultRowHeight(fp.DefaultRowHeight)
-}
-
-// setSheetFormatPr provides a method to set the custom height.
-func (p CustomHeight) setSheetFormatPr(fp *xlsxSheetFormatPr) {
- fp.CustomHeight = bool(p)
-}
-
-// getSheetFormatPr provides a method to get the custom height.
-func (p *CustomHeight) getSheetFormatPr(fp *xlsxSheetFormatPr) {
- if fp == nil {
- *p = false
- return
+ if opts.EnableFormatConditionsCalculation != nil {
+ prepareSheetPr(ws)
+ ws.SheetPr.EnableFormatConditionsCalculation = opts.EnableFormatConditionsCalculation
}
- *p = CustomHeight(fp.CustomHeight)
-}
-
-// setSheetFormatPr provides a method to set if rows are hidden.
-func (p ZeroHeight) setSheetFormatPr(fp *xlsxSheetFormatPr) {
- fp.ZeroHeight = bool(p)
-}
-
-// getSheetFormatPr provides a method to get if rows are hidden.
-func (p *ZeroHeight) getSheetFormatPr(fp *xlsxSheetFormatPr) {
- if fp == nil {
- *p = false
- return
+ if opts.Published != nil {
+ prepareSheetPr(ws)
+ ws.SheetPr.Published = opts.Published
+ }
+ if opts.AutoPageBreaks != nil {
+ preparePageSetUpPr(ws)
+ ws.SheetPr.PageSetUpPr.AutoPageBreaks = *opts.AutoPageBreaks
+ }
+ if opts.FitToPage != nil {
+ preparePageSetUpPr(ws)
+ ws.SheetPr.PageSetUpPr.FitToPage = *opts.FitToPage
+ }
+ if opts.OutlineSummaryBelow != nil {
+ prepareOutlinePr(ws)
+ ws.SheetPr.OutlinePr.SummaryBelow = *opts.OutlineSummaryBelow
+ }
+ if opts.TabColorIndexed != nil {
+ prepareTabColor(ws)
+ ws.SheetPr.TabColor.Indexed = *opts.TabColorIndexed
+ }
+ if opts.TabColorRGB != nil {
+ prepareTabColor(ws)
+ ws.SheetPr.TabColor.RGB = *opts.TabColorRGB
+ }
+ if opts.TabColorTheme != nil {
+ prepareTabColor(ws)
+ ws.SheetPr.TabColor.Theme = *opts.TabColorTheme
+ }
+ if opts.TabColorTint != nil {
+ prepareTabColor(ws)
+ ws.SheetPr.TabColor.Tint = *opts.TabColorTint
}
- *p = ZeroHeight(fp.ZeroHeight)
-}
-
-// setSheetFormatPr provides a method to set if rows have a thick top border
-// by default.
-func (p ThickTop) setSheetFormatPr(fp *xlsxSheetFormatPr) {
- fp.ThickTop = bool(p)
-}
-
-// getSheetFormatPr provides a method to get if rows have a thick top border
-// by default.
-func (p *ThickTop) getSheetFormatPr(fp *xlsxSheetFormatPr) {
- if fp == nil {
- *p = false
- return
- }
- *p = ThickTop(fp.ThickTop)
-}
-
-// setSheetFormatPr provides a method to set if rows have a thick bottom
-// border by default.
-func (p ThickBottom) setSheetFormatPr(fp *xlsxSheetFormatPr) {
- fp.ThickBottom = bool(p)
-}
-
-// setSheetFormatPr provides a method to set if rows have a thick bottom
-// border by default.
-func (p *ThickBottom) getSheetFormatPr(fp *xlsxSheetFormatPr) {
- if fp == nil {
- *p = false
- return
- }
- *p = ThickBottom(fp.ThickBottom)
}
-// SetSheetFormatPr provides a function to set worksheet formatting properties.
-//
-// Available options:
-//
-// BaseColWidth(uint8)
-// DefaultColWidth(float64)
-// DefaultRowHeight(float64)
-// CustomHeight(bool)
-// ZeroHeight(bool)
-// ThickTop(bool)
-// ThickBottom(bool)
-func (f *File) SetSheetFormatPr(sheet string, opts ...SheetFormatPrOptions) error {
- s, err := f.workSheetReader(sheet)
+// SetSheetProps provides a function to set worksheet properties.
+func (f *File) SetSheetProps(sheet string, opts *SheetPropsOptions) error {
+ ws, err := f.workSheetReader(sheet)
if err != nil {
return err
}
- fp := s.SheetFormatPr
- if fp == nil {
- fp = new(xlsxSheetFormatPr)
- s.SheetFormatPr = fp
+ if opts == nil {
+ return err
+ }
+ ws.setSheetProps(opts)
+ if ws.SheetFormatPr == nil {
+ ws.SheetFormatPr = &xlsxSheetFormatPr{DefaultRowHeight: defaultRowHeight}
+ }
+ if opts.BaseColWidth != nil {
+ ws.SheetFormatPr.BaseColWidth = *opts.BaseColWidth
}
- for _, opt := range opts {
- opt.setSheetFormatPr(fp)
+ if opts.DefaultColWidth != nil {
+ ws.SheetFormatPr.DefaultColWidth = *opts.DefaultColWidth
+ }
+ if opts.DefaultRowHeight != nil {
+ ws.SheetFormatPr.DefaultRowHeight = *opts.DefaultRowHeight
+ }
+ if opts.CustomHeight != nil {
+ ws.SheetFormatPr.CustomHeight = *opts.CustomHeight
+ }
+ if opts.ZeroHeight != nil {
+ ws.SheetFormatPr.ZeroHeight = *opts.ZeroHeight
+ }
+ if opts.ThickTop != nil {
+ ws.SheetFormatPr.ThickTop = *opts.ThickTop
+ }
+ if opts.ThickBottom != nil {
+ ws.SheetFormatPr.ThickBottom = *opts.ThickBottom
}
return err
}
-// GetSheetFormatPr provides a function to get worksheet formatting properties.
-//
-// Available options:
-//
-// BaseColWidth(uint8)
-// DefaultColWidth(float64)
-// DefaultRowHeight(float64)
-// CustomHeight(bool)
-// ZeroHeight(bool)
-// ThickTop(bool)
-// ThickBottom(bool)
-func (f *File) GetSheetFormatPr(sheet string, opts ...SheetFormatPrOptionsPtr) error {
- s, err := f.workSheetReader(sheet)
+// GetSheetProps provides a function to get worksheet properties.
+func (f *File) GetSheetProps(sheet string) (SheetPropsOptions, error) {
+ baseColWidth := uint8(8)
+ opts := SheetPropsOptions{
+ EnableFormatConditionsCalculation: boolPtr(true),
+ Published: boolPtr(true),
+ AutoPageBreaks: boolPtr(true),
+ OutlineSummaryBelow: boolPtr(true),
+ BaseColWidth: &baseColWidth,
+ }
+ ws, err := f.workSheetReader(sheet)
if err != nil {
- return err
+ return opts, err
}
- fp := s.SheetFormatPr
- for _, opt := range opts {
- opt.getSheetFormatPr(fp)
+ if ws.SheetPr != nil {
+ opts.CodeName = stringPtr(ws.SheetPr.CodeName)
+ if ws.SheetPr.EnableFormatConditionsCalculation != nil {
+ opts.EnableFormatConditionsCalculation = ws.SheetPr.EnableFormatConditionsCalculation
+ }
+ if ws.SheetPr.Published != nil {
+ opts.Published = ws.SheetPr.Published
+ }
+ if ws.SheetPr.PageSetUpPr != nil {
+ opts.AutoPageBreaks = boolPtr(ws.SheetPr.PageSetUpPr.AutoPageBreaks)
+ opts.FitToPage = boolPtr(ws.SheetPr.PageSetUpPr.FitToPage)
+ }
+ if ws.SheetPr.OutlinePr != nil {
+ opts.OutlineSummaryBelow = boolPtr(ws.SheetPr.OutlinePr.SummaryBelow)
+ }
+ if ws.SheetPr.TabColor != nil {
+ opts.TabColorIndexed = intPtr(ws.SheetPr.TabColor.Indexed)
+ opts.TabColorRGB = stringPtr(ws.SheetPr.TabColor.RGB)
+ opts.TabColorTheme = intPtr(ws.SheetPr.TabColor.Theme)
+ opts.TabColorTint = float64Ptr(ws.SheetPr.TabColor.Tint)
+ }
}
- return err
+ if ws.SheetFormatPr != nil {
+ opts.BaseColWidth = &ws.SheetFormatPr.BaseColWidth
+ opts.DefaultColWidth = float64Ptr(ws.SheetFormatPr.DefaultColWidth)
+ opts.DefaultRowHeight = float64Ptr(ws.SheetFormatPr.DefaultRowHeight)
+ opts.CustomHeight = boolPtr(ws.SheetFormatPr.CustomHeight)
+ opts.ZeroHeight = boolPtr(ws.SheetFormatPr.ZeroHeight)
+ opts.ThickTop = boolPtr(ws.SheetFormatPr.ThickTop)
+ opts.ThickBottom = boolPtr(ws.SheetFormatPr.ThickBottom)
+ }
+ return opts, err
}
diff --git a/sheetpr_test.go b/sheetpr_test.go
index 291866806e..ccadbefcb2 100644
--- a/sheetpr_test.go
+++ b/sheetpr_test.go
@@ -1,501 +1,107 @@
package excelize
import (
- "fmt"
+ "path/filepath"
"testing"
- "github.com/mohae/deepcopy"
"github.com/stretchr/testify/assert"
)
-var _ = []SheetPrOption{
- CodeName("hello"),
- EnableFormatConditionsCalculation(false),
- Published(false),
- FitToPage(true),
- TabColorIndexed(42),
- TabColorRGB("#FFFF00"),
- TabColorTheme(ColorMappingTypeLight2),
- TabColorTint(0.5),
- AutoPageBreaks(true),
- OutlineSummaryBelow(true),
-}
-
-var _ = []SheetPrOptionPtr{
- (*CodeName)(nil),
- (*EnableFormatConditionsCalculation)(nil),
- (*Published)(nil),
- (*FitToPage)(nil),
- (*TabColorIndexed)(nil),
- (*TabColorRGB)(nil),
- (*TabColorTheme)(nil),
- (*TabColorTint)(nil),
- (*AutoPageBreaks)(nil),
- (*OutlineSummaryBelow)(nil),
-}
-
-func ExampleFile_SetSheetPrOptions() {
- f := NewFile()
- const sheet = "Sheet1"
-
- if err := f.SetSheetPrOptions(sheet,
- CodeName("code"),
- EnableFormatConditionsCalculation(false),
- Published(false),
- FitToPage(true),
- TabColorIndexed(42),
- TabColorRGB("#FFFF00"),
- TabColorTheme(ColorMappingTypeLight2),
- TabColorTint(0.5),
- AutoPageBreaks(true),
- OutlineSummaryBelow(false),
- ); err != nil {
- fmt.Println(err)
- }
- // Output:
-}
-
-func ExampleFile_GetSheetPrOptions() {
- f := NewFile()
- const sheet = "Sheet1"
-
- var (
- codeName CodeName
- enableFormatConditionsCalculation EnableFormatConditionsCalculation
- published Published
- fitToPage FitToPage
- tabColorIndexed TabColorIndexed
- tabColorRGB TabColorRGB
- tabColorTheme TabColorTheme
- tabColorTint TabColorTint
- autoPageBreaks AutoPageBreaks
- outlineSummaryBelow OutlineSummaryBelow
- )
-
- if err := f.GetSheetPrOptions(sheet,
- &codeName,
- &enableFormatConditionsCalculation,
- &published,
- &fitToPage,
- &tabColorIndexed,
- &tabColorRGB,
- &tabColorTheme,
- &tabColorTint,
- &autoPageBreaks,
- &outlineSummaryBelow,
- ); err != nil {
- fmt.Println(err)
- }
- fmt.Println("Defaults:")
- fmt.Printf("- codeName: %q\n", codeName)
- fmt.Println("- enableFormatConditionsCalculation:", enableFormatConditionsCalculation)
- fmt.Println("- published:", published)
- fmt.Println("- fitToPage:", fitToPage)
- fmt.Printf("- tabColorIndexed: %d\n", tabColorIndexed)
- fmt.Printf("- tabColorRGB: %q\n", tabColorRGB)
- fmt.Printf("- tabColorTheme: %d\n", tabColorTheme)
- fmt.Printf("- tabColorTint: %f\n", tabColorTint)
- fmt.Println("- autoPageBreaks:", autoPageBreaks)
- fmt.Println("- outlineSummaryBelow:", outlineSummaryBelow)
- // Output:
- // Defaults:
- // - codeName: ""
- // - enableFormatConditionsCalculation: true
- // - published: true
- // - fitToPage: false
- // - tabColorIndexed: -1
- // - tabColorRGB: ""
- // - tabColorTheme: -1
- // - tabColorTint: 0.000000
- // - autoPageBreaks: false
- // - outlineSummaryBelow: true
-}
-
-func TestSheetPrOptions(t *testing.T) {
- const sheet = "Sheet1"
-
- testData := []struct {
- container SheetPrOptionPtr
- nonDefault SheetPrOption
- }{
- {new(CodeName), CodeName("xx")},
- {new(EnableFormatConditionsCalculation), EnableFormatConditionsCalculation(false)},
- {new(Published), Published(false)},
- {new(FitToPage), FitToPage(true)},
- {new(TabColorIndexed), TabColorIndexed(42)},
- {new(TabColorRGB), TabColorRGB("FFFF00")},
- {new(TabColorTheme), TabColorTheme(ColorMappingTypeLight2)},
- {new(TabColorTint), TabColorTint(0.5)},
- {new(AutoPageBreaks), AutoPageBreaks(true)},
- {new(OutlineSummaryBelow), OutlineSummaryBelow(false)},
- }
-
- for i, test := range testData {
- t.Run(fmt.Sprintf("TestData%d", i), func(t *testing.T) {
- opts := test.nonDefault
- t.Logf("option %T", opts)
-
- def := deepcopy.Copy(test.container).(SheetPrOptionPtr)
- val1 := deepcopy.Copy(def).(SheetPrOptionPtr)
- val2 := deepcopy.Copy(def).(SheetPrOptionPtr)
-
- f := NewFile()
- // Get the default value
- assert.NoError(t, f.GetSheetPrOptions(sheet, def), opts)
- // Get again and check
- assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opts)
- if !assert.Equal(t, val1, def, opts) {
- t.FailNow()
- }
- // Set the same value
- assert.NoError(t, f.SetSheetPrOptions(sheet, val1), opts)
- // Get again and check
- assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opts)
- if !assert.Equal(t, val1, def, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Set a different value
- assert.NoError(t, f.SetSheetPrOptions(sheet, test.nonDefault), opts)
- assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opts)
- // Get again and compare
- assert.NoError(t, f.GetSheetPrOptions(sheet, val2), opts)
- if !assert.Equal(t, val1, val2, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Value should not be the same as the default
- if !assert.NotEqual(t, def, val1, "%T: value should have changed from default", opts) {
- t.FailNow()
- }
- // Restore the default value
- assert.NoError(t, f.SetSheetPrOptions(sheet, def), opts)
- assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opts)
- if !assert.Equal(t, def, val1) {
- t.FailNow()
- }
- })
- }
-}
-
-func TestSetSheetPrOptions(t *testing.T) {
- f := NewFile()
- assert.NoError(t, f.SetSheetPrOptions("Sheet1", TabColorRGB("")))
- // Test SetSheetPrOptions on not exists worksheet.
- assert.EqualError(t, f.SetSheetPrOptions("SheetN"), "sheet SheetN does not exist")
-}
-
-func TestGetSheetPrOptions(t *testing.T) {
- f := NewFile()
- // Test GetSheetPrOptions on not exists worksheet.
- assert.EqualError(t, f.GetSheetPrOptions("SheetN"), "sheet SheetN does not exist")
-}
-
-var _ = []PageMarginsOptions{
- PageMarginBottom(1.0),
- PageMarginFooter(1.0),
- PageMarginHeader(1.0),
- PageMarginLeft(1.0),
- PageMarginRight(1.0),
- PageMarginTop(1.0),
-}
-
-var _ = []PageMarginsOptionsPtr{
- (*PageMarginBottom)(nil),
- (*PageMarginFooter)(nil),
- (*PageMarginHeader)(nil),
- (*PageMarginLeft)(nil),
- (*PageMarginRight)(nil),
- (*PageMarginTop)(nil),
-}
-
-func ExampleFile_SetPageMargins() {
- f := NewFile()
- const sheet = "Sheet1"
-
- if err := f.SetPageMargins(sheet,
- PageMarginBottom(1.0),
- PageMarginFooter(1.0),
- PageMarginHeader(1.0),
- PageMarginLeft(1.0),
- PageMarginRight(1.0),
- PageMarginTop(1.0),
- ); err != nil {
- fmt.Println(err)
- }
- // Output:
-}
-
-func ExampleFile_GetPageMargins() {
- f := NewFile()
- const sheet = "Sheet1"
-
- var (
- marginBottom PageMarginBottom
- marginFooter PageMarginFooter
- marginHeader PageMarginHeader
- marginLeft PageMarginLeft
- marginRight PageMarginRight
- marginTop PageMarginTop
- )
-
- if err := f.GetPageMargins(sheet,
- &marginBottom,
- &marginFooter,
- &marginHeader,
- &marginLeft,
- &marginRight,
- &marginTop,
- ); err != nil {
- fmt.Println(err)
- }
- fmt.Println("Defaults:")
- fmt.Println("- marginBottom:", marginBottom)
- fmt.Println("- marginFooter:", marginFooter)
- fmt.Println("- marginHeader:", marginHeader)
- fmt.Println("- marginLeft:", marginLeft)
- fmt.Println("- marginRight:", marginRight)
- fmt.Println("- marginTop:", marginTop)
- // Output:
- // Defaults:
- // - marginBottom: 0.75
- // - marginFooter: 0.3
- // - marginHeader: 0.3
- // - marginLeft: 0.7
- // - marginRight: 0.7
- // - marginTop: 0.75
-}
-
-func TestPageMarginsOption(t *testing.T) {
- const sheet = "Sheet1"
-
- testData := []struct {
- container PageMarginsOptionsPtr
- nonDefault PageMarginsOptions
- }{
- {new(PageMarginTop), PageMarginTop(1.0)},
- {new(PageMarginBottom), PageMarginBottom(1.0)},
- {new(PageMarginLeft), PageMarginLeft(1.0)},
- {new(PageMarginRight), PageMarginRight(1.0)},
- {new(PageMarginHeader), PageMarginHeader(1.0)},
- {new(PageMarginFooter), PageMarginFooter(1.0)},
- }
-
- for i, test := range testData {
- t.Run(fmt.Sprintf("TestData%d", i), func(t *testing.T) {
- opts := test.nonDefault
- t.Logf("option %T", opts)
-
- def := deepcopy.Copy(test.container).(PageMarginsOptionsPtr)
- val1 := deepcopy.Copy(def).(PageMarginsOptionsPtr)
- val2 := deepcopy.Copy(def).(PageMarginsOptionsPtr)
-
- f := NewFile()
- // Get the default value
- assert.NoError(t, f.GetPageMargins(sheet, def), opts)
- // Get again and check
- assert.NoError(t, f.GetPageMargins(sheet, val1), opts)
- if !assert.Equal(t, val1, def, opts) {
- t.FailNow()
- }
- // Set the same value
- assert.NoError(t, f.SetPageMargins(sheet, val1), opts)
- // Get again and check
- assert.NoError(t, f.GetPageMargins(sheet, val1), opts)
- if !assert.Equal(t, val1, def, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Set a different value
- assert.NoError(t, f.SetPageMargins(sheet, test.nonDefault), opts)
- assert.NoError(t, f.GetPageMargins(sheet, val1), opts)
- // Get again and compare
- assert.NoError(t, f.GetPageMargins(sheet, val2), opts)
- if !assert.Equal(t, val1, val2, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Value should not be the same as the default
- if !assert.NotEqual(t, def, val1, "%T: value should have changed from default", opts) {
- t.FailNow()
- }
- // Restore the default value
- assert.NoError(t, f.SetPageMargins(sheet, def), opts)
- assert.NoError(t, f.GetPageMargins(sheet, val1), opts)
- if !assert.Equal(t, def, val1) {
- t.FailNow()
- }
- })
- }
-}
-
func TestSetPageMargins(t *testing.T) {
f := NewFile()
+ assert.NoError(t, f.SetPageMargins("Sheet1", nil))
+ ws, ok := f.Sheet.Load("xl/worksheets/sheet1.xml")
+ assert.True(t, ok)
+ ws.(*xlsxWorksheet).PageMargins = nil
+ ws.(*xlsxWorksheet).PrintOptions = nil
+ expected := PageLayoutMarginsOptions{
+ Bottom: float64Ptr(1.0),
+ Footer: float64Ptr(1.0),
+ Header: float64Ptr(1.0),
+ Left: float64Ptr(1.0),
+ Right: float64Ptr(1.0),
+ Top: float64Ptr(1.0),
+ Horizontally: boolPtr(true),
+ Vertically: boolPtr(true),
+ }
+ assert.NoError(t, f.SetPageMargins("Sheet1", &expected))
+ opts, err := f.GetPageMargins("Sheet1")
+ assert.NoError(t, err)
+ assert.Equal(t, expected, opts)
// Test set page margins on not exists worksheet.
- assert.EqualError(t, f.SetPageMargins("SheetN"), "sheet SheetN does not exist")
+ assert.EqualError(t, f.SetPageMargins("SheetN", nil), "sheet SheetN does not exist")
}
func TestGetPageMargins(t *testing.T) {
f := NewFile()
// Test get page margins on not exists worksheet.
- assert.EqualError(t, f.GetPageMargins("SheetN"), "sheet SheetN does not exist")
-}
-
-func ExampleFile_SetSheetFormatPr() {
- f := NewFile()
- const sheet = "Sheet1"
-
- if err := f.SetSheetFormatPr(sheet,
- BaseColWidth(1.0),
- DefaultColWidth(1.0),
- DefaultRowHeight(1.0),
- CustomHeight(true),
- ZeroHeight(true),
- ThickTop(true),
- ThickBottom(true),
- ); err != nil {
- fmt.Println(err)
- }
- // Output:
+ _, err := f.GetPageMargins("SheetN")
+ assert.EqualError(t, err, "sheet SheetN does not exist")
}
-func ExampleFile_GetSheetFormatPr() {
+func TestDebug(t *testing.T) {
f := NewFile()
- const sheet = "Sheet1"
-
- var (
- baseColWidth BaseColWidth
- defaultColWidth DefaultColWidth
- defaultRowHeight DefaultRowHeight
- customHeight CustomHeight
- zeroHeight ZeroHeight
- thickTop ThickTop
- thickBottom ThickBottom
- )
-
- if err := f.GetSheetFormatPr(sheet,
- &baseColWidth,
- &defaultColWidth,
- &defaultRowHeight,
- &customHeight,
- &zeroHeight,
- &thickTop,
- &thickBottom,
- ); err != nil {
- fmt.Println(err)
- }
- fmt.Println("Defaults:")
- fmt.Println("- baseColWidth:", baseColWidth)
- fmt.Println("- defaultColWidth:", defaultColWidth)
- fmt.Println("- defaultRowHeight:", defaultRowHeight)
- fmt.Println("- customHeight:", customHeight)
- fmt.Println("- zeroHeight:", zeroHeight)
- fmt.Println("- thickTop:", thickTop)
- fmt.Println("- thickBottom:", thickBottom)
- // Output:
- // Defaults:
- // - baseColWidth: 0
- // - defaultColWidth: 0
- // - defaultRowHeight: 15
- // - customHeight: false
- // - zeroHeight: false
- // - thickTop: false
- // - thickBottom: false
-}
-
-func TestSheetFormatPrOptions(t *testing.T) {
- const sheet = "Sheet1"
-
- testData := []struct {
- container SheetFormatPrOptionsPtr
- nonDefault SheetFormatPrOptions
- }{
- {new(BaseColWidth), BaseColWidth(1.0)},
- {new(DefaultColWidth), DefaultColWidth(1.0)},
- {new(DefaultRowHeight), DefaultRowHeight(1.0)},
- {new(CustomHeight), CustomHeight(true)},
- {new(ZeroHeight), ZeroHeight(true)},
- {new(ThickTop), ThickTop(true)},
- {new(ThickBottom), ThickBottom(true)},
- }
-
- for i, test := range testData {
- t.Run(fmt.Sprintf("TestData%d", i), func(t *testing.T) {
- opts := test.nonDefault
- t.Logf("option %T", opts)
-
- def := deepcopy.Copy(test.container).(SheetFormatPrOptionsPtr)
- val1 := deepcopy.Copy(def).(SheetFormatPrOptionsPtr)
- val2 := deepcopy.Copy(def).(SheetFormatPrOptionsPtr)
-
- f := NewFile()
- // Get the default value
- assert.NoError(t, f.GetSheetFormatPr(sheet, def), opts)
- // Get again and check
- assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opts)
- if !assert.Equal(t, val1, def, opts) {
- t.FailNow()
- }
- // Set the same value
- assert.NoError(t, f.SetSheetFormatPr(sheet, val1), opts)
- // Get again and check
- assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opts)
- if !assert.Equal(t, val1, def, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Set a different value
- assert.NoError(t, f.SetSheetFormatPr(sheet, test.nonDefault), opts)
- assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opts)
- // Get again and compare
- assert.NoError(t, f.GetSheetFormatPr(sheet, val2), opts)
- if !assert.Equal(t, val1, val2, "%T: value should not have changed", opts) {
- t.FailNow()
- }
- // Value should not be the same as the default
- if !assert.NotEqual(t, def, val1, "%T: value should have changed from default", opts) {
- t.FailNow()
- }
- // Restore the default value
- assert.NoError(t, f.SetSheetFormatPr(sheet, def), opts)
- assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opts)
- if !assert.Equal(t, def, val1) {
- t.FailNow()
- }
- })
- }
-}
-
-func TestSetSheetFormatPr(t *testing.T) {
- f := NewFile()
- assert.NoError(t, f.GetSheetFormatPr("Sheet1"))
+ assert.NoError(t, f.SetSheetProps("Sheet1", nil))
ws, ok := f.Sheet.Load("xl/worksheets/sheet1.xml")
assert.True(t, ok)
+ ws.(*xlsxWorksheet).PageMargins = nil
+ ws.(*xlsxWorksheet).PrintOptions = nil
+ ws.(*xlsxWorksheet).SheetPr = nil
ws.(*xlsxWorksheet).SheetFormatPr = nil
- assert.NoError(t, f.SetSheetFormatPr("Sheet1", BaseColWidth(1.0)))
- // Test set formatting properties on not exists worksheet.
- assert.EqualError(t, f.SetSheetFormatPr("SheetN"), "sheet SheetN does not exist")
+ // w := uint8(10)
+ // f.SetSheetProps("Sheet1", &SheetPropsOptions{BaseColWidth: &w})
+ f.SetPageMargins("Sheet1", &PageLayoutMarginsOptions{Horizontally: boolPtr(true)})
+ assert.NoError(t, f.SaveAs(filepath.Join("test", "TestDebug.xlsx")))
}
-func TestGetSheetFormatPr(t *testing.T) {
+func TestSetSheetProps(t *testing.T) {
f := NewFile()
- assert.NoError(t, f.GetSheetFormatPr("Sheet1"))
+ assert.NoError(t, f.SetSheetProps("Sheet1", nil))
ws, ok := f.Sheet.Load("xl/worksheets/sheet1.xml")
assert.True(t, ok)
+ ws.(*xlsxWorksheet).SheetPr = nil
ws.(*xlsxWorksheet).SheetFormatPr = nil
- var (
- baseColWidth BaseColWidth
- defaultColWidth DefaultColWidth
- defaultRowHeight DefaultRowHeight
- customHeight CustomHeight
- zeroHeight ZeroHeight
- thickTop ThickTop
- thickBottom ThickBottom
- )
- assert.NoError(t, f.GetSheetFormatPr("Sheet1",
- &baseColWidth,
- &defaultColWidth,
- &defaultRowHeight,
- &customHeight,
- &zeroHeight,
- &thickTop,
- &thickBottom,
- ))
- // Test get formatting properties on not exists worksheet.
- assert.EqualError(t, f.GetSheetFormatPr("SheetN"), "sheet SheetN does not exist")
+ baseColWidth := uint8(8)
+ expected := SheetPropsOptions{
+ CodeName: stringPtr("code"),
+ EnableFormatConditionsCalculation: boolPtr(true),
+ Published: boolPtr(true),
+ AutoPageBreaks: boolPtr(true),
+ FitToPage: boolPtr(true),
+ TabColorIndexed: intPtr(1),
+ TabColorRGB: stringPtr("#FFFF00"),
+ TabColorTheme: intPtr(1),
+ TabColorTint: float64Ptr(1),
+ OutlineSummaryBelow: boolPtr(true),
+ BaseColWidth: &baseColWidth,
+ DefaultColWidth: float64Ptr(10),
+ DefaultRowHeight: float64Ptr(10),
+ CustomHeight: boolPtr(true),
+ ZeroHeight: boolPtr(true),
+ ThickTop: boolPtr(true),
+ ThickBottom: boolPtr(true),
+ }
+ assert.NoError(t, f.SetSheetProps("Sheet1", &expected))
+ opts, err := f.GetSheetProps("Sheet1")
+ assert.NoError(t, err)
+ assert.Equal(t, expected, opts)
+
+ ws.(*xlsxWorksheet).SheetPr = nil
+ assert.NoError(t, f.SetSheetProps("Sheet1", &SheetPropsOptions{FitToPage: boolPtr(true)}))
+ ws.(*xlsxWorksheet).SheetPr = nil
+ assert.NoError(t, f.SetSheetProps("Sheet1", &SheetPropsOptions{TabColorRGB: stringPtr("#FFFF00")}))
+ ws.(*xlsxWorksheet).SheetPr = nil
+ assert.NoError(t, f.SetSheetProps("Sheet1", &SheetPropsOptions{TabColorTheme: intPtr(1)}))
+ ws.(*xlsxWorksheet).SheetPr = nil
+ assert.NoError(t, f.SetSheetProps("Sheet1", &SheetPropsOptions{TabColorTint: float64Ptr(1)}))
+
+ // Test SetSheetProps on not exists worksheet.
+ assert.EqualError(t, f.SetSheetProps("SheetN", nil), "sheet SheetN does not exist")
+}
+
+func TestGetSheetProps(t *testing.T) {
+ f := NewFile()
+ // Test GetSheetProps on not exists worksheet.
+ _, err := f.GetSheetProps("SheetN")
+ assert.EqualError(t, err, "sheet SheetN does not exist")
}
diff --git a/sheetview.go b/sheetview.go
index 373658844c..a47d5100e5 100644
--- a/sheetview.go
+++ b/sheetview.go
@@ -13,150 +13,6 @@ package excelize
import "fmt"
-// SheetViewOption is an option of a view of a worksheet. See
-// SetSheetViewOptions().
-type SheetViewOption interface {
- setSheetViewOption(view *xlsxSheetView)
-}
-
-// SheetViewOptionPtr is a writable SheetViewOption. See
-// GetSheetViewOptions().
-type SheetViewOptionPtr interface {
- SheetViewOption
- getSheetViewOption(view *xlsxSheetView)
-}
-
-type (
- // DefaultGridColor is a SheetViewOption. It specifies a flag indicating
- // that the consuming application should use the default grid lines color
- // (system dependent). Overrides any color specified in colorId.
- DefaultGridColor bool
- // ShowFormulas is a SheetViewOption. It specifies a flag indicating
- // whether this sheet should display formulas.
- ShowFormulas bool
- // ShowGridLines is a SheetViewOption. It specifies a flag indicating
- // whether this sheet should display gridlines.
- ShowGridLines bool
- // ShowRowColHeaders is a SheetViewOption. It specifies a flag indicating
- // whether the sheet should display row and column headings.
- ShowRowColHeaders bool
- // ShowZeros is a SheetViewOption. It specifies a flag indicating whether
- // to "show a zero in cells that have zero value". When using a formula to
- // reference another cell which is empty, the referenced value becomes 0
- // when the flag is true. (Default setting is true.)
- ShowZeros bool
- // RightToLeft is a SheetViewOption. It specifies a flag indicating whether
- // the sheet is in 'right to left' display mode. When in this mode, Column
- // A is on the far right, Column B ;is one column left of Column A, and so
- // on. Also, information in cells is displayed in the Right to Left format.
- RightToLeft bool
- // ShowRuler is a SheetViewOption. It specifies a flag indicating this
- // sheet should display ruler.
- ShowRuler bool
- // View is a SheetViewOption. It specifies a flag indicating how sheet is
- // displayed, by default it uses empty string available options: normal,
- // pageLayout, pageBreakPreview
- View string
- // TopLeftCell is a SheetViewOption. It specifies a location of the top
- // left visible cell Location of the top left visible cell in the bottom
- // right pane (when in Left-to-Right mode).
- TopLeftCell string
- // ZoomScale is a SheetViewOption. It specifies a window zoom magnification
- // for current view representing percent values. This attribute is
- // restricted to values ranging from 10 to 400. Horizontal & Vertical
- // scale together.
- ZoomScale float64
-)
-
-// Defaults for each option are described in XML schema for CT_SheetView
-
-func (o DefaultGridColor) setSheetViewOption(view *xlsxSheetView) {
- view.DefaultGridColor = boolPtr(bool(o))
-}
-
-func (o *DefaultGridColor) getSheetViewOption(view *xlsxSheetView) {
- *o = DefaultGridColor(defaultTrue(view.DefaultGridColor)) // Excel default: true
-}
-
-func (o ShowFormulas) setSheetViewOption(view *xlsxSheetView) {
- view.ShowFormulas = bool(o) // Excel default: false
-}
-
-func (o *ShowFormulas) getSheetViewOption(view *xlsxSheetView) {
- *o = ShowFormulas(view.ShowFormulas) // Excel default: false
-}
-
-func (o ShowGridLines) setSheetViewOption(view *xlsxSheetView) {
- view.ShowGridLines = boolPtr(bool(o))
-}
-
-func (o *ShowGridLines) getSheetViewOption(view *xlsxSheetView) {
- *o = ShowGridLines(defaultTrue(view.ShowGridLines)) // Excel default: true
-}
-
-func (o ShowRowColHeaders) setSheetViewOption(view *xlsxSheetView) {
- view.ShowRowColHeaders = boolPtr(bool(o))
-}
-
-func (o *ShowRowColHeaders) getSheetViewOption(view *xlsxSheetView) {
- *o = ShowRowColHeaders(defaultTrue(view.ShowRowColHeaders)) // Excel default: true
-}
-
-func (o ShowZeros) setSheetViewOption(view *xlsxSheetView) {
- view.ShowZeros = boolPtr(bool(o))
-}
-
-func (o *ShowZeros) getSheetViewOption(view *xlsxSheetView) {
- *o = ShowZeros(defaultTrue(view.ShowZeros)) // Excel default: true
-}
-
-func (o RightToLeft) setSheetViewOption(view *xlsxSheetView) {
- view.RightToLeft = bool(o) // Excel default: false
-}
-
-func (o *RightToLeft) getSheetViewOption(view *xlsxSheetView) {
- *o = RightToLeft(view.RightToLeft)
-}
-
-func (o ShowRuler) setSheetViewOption(view *xlsxSheetView) {
- view.ShowRuler = boolPtr(bool(o))
-}
-
-func (o *ShowRuler) getSheetViewOption(view *xlsxSheetView) {
- *o = ShowRuler(defaultTrue(view.ShowRuler)) // Excel default: true
-}
-
-func (o View) setSheetViewOption(view *xlsxSheetView) {
- view.View = string(o)
-}
-
-func (o *View) getSheetViewOption(view *xlsxSheetView) {
- if view.View != "" {
- *o = View(view.View)
- return
- }
- *o = "normal"
-}
-
-func (o TopLeftCell) setSheetViewOption(view *xlsxSheetView) {
- view.TopLeftCell = string(o)
-}
-
-func (o *TopLeftCell) getSheetViewOption(view *xlsxSheetView) {
- *o = TopLeftCell(view.TopLeftCell)
-}
-
-func (o ZoomScale) setSheetViewOption(view *xlsxSheetView) {
- // This attribute is restricted to values ranging from 10 to 400.
- if float64(o) >= 10 && float64(o) <= 400 {
- view.ZoomScale = float64(o)
- }
-}
-
-func (o *ZoomScale) getSheetViewOption(view *xlsxSheetView) {
- *o = ZoomScale(view.ZoomScale)
-}
-
// getSheetView returns the SheetView object
func (f *File) getSheetView(sheet string, viewIndex int) (*xlsxSheetView, error) {
ws, err := f.workSheetReader(sheet)
@@ -180,65 +36,100 @@ func (f *File) getSheetView(sheet string, viewIndex int) (*xlsxSheetView, error)
return &(ws.SheetViews.SheetView[viewIndex]), err
}
-// SetSheetViewOptions sets sheet view options. The viewIndex may be negative
-// and if so is counted backward (-1 is the last view).
-//
-// Available options:
-//
-// DefaultGridColor(bool)
-// ShowFormulas(bool)
-// ShowGridLines(bool)
-// ShowRowColHeaders(bool)
-// ShowZeros(bool)
-// RightToLeft(bool)
-// ShowRuler(bool)
-// View(string)
-// TopLeftCell(string)
-// ZoomScale(float64)
-//
-// Example:
-//
-// err = f.SetSheetViewOptions("Sheet1", -1, ShowGridLines(false))
-func (f *File) SetSheetViewOptions(sheet string, viewIndex int, opts ...SheetViewOption) error {
+// setSheetView set sheet view by given options.
+func (view *xlsxSheetView) setSheetView(opts *ViewOptions) {
+ if opts.DefaultGridColor != nil {
+ view.DefaultGridColor = opts.DefaultGridColor
+ }
+ if opts.RightToLeft != nil {
+ view.RightToLeft = *opts.RightToLeft
+ }
+ if opts.ShowFormulas != nil {
+ view.ShowFormulas = *opts.ShowFormulas
+ }
+ if opts.ShowGridLines != nil {
+ view.ShowGridLines = opts.ShowGridLines
+ }
+ if opts.ShowRowColHeaders != nil {
+ view.ShowRowColHeaders = opts.ShowRowColHeaders
+ }
+ if opts.ShowRuler != nil {
+ view.ShowRuler = opts.ShowRuler
+ }
+ if opts.ShowZeros != nil {
+ view.ShowZeros = opts.ShowZeros
+ }
+ if opts.TopLeftCell != nil {
+ view.TopLeftCell = *opts.TopLeftCell
+ }
+ if opts.View != nil {
+ if _, ok := map[string]interface{}{
+ "normal": nil,
+ "pageLayout": nil,
+ "pageBreakPreview": nil,
+ }[*opts.View]; ok {
+ view.View = *opts.View
+ }
+ }
+ if opts.ZoomScale != nil && *opts.ZoomScale >= 10 && *opts.ZoomScale <= 400 {
+ view.ZoomScale = *opts.ZoomScale
+ }
+}
+
+// SetSheetView sets sheet view options. The viewIndex may be negative and if
+// so is counted backward (-1 is the last view).
+func (f *File) SetSheetView(sheet string, viewIndex int, opts *ViewOptions) error {
view, err := f.getSheetView(sheet, viewIndex)
if err != nil {
return err
}
-
- for _, opt := range opts {
- opt.setSheetViewOption(view)
+ if opts == nil {
+ return err
}
+ view.setSheetView(opts)
return nil
}
-// GetSheetViewOptions gets the value of sheet view options. The viewIndex may
-// be negative and if so is counted backward (-1 is the last view).
-//
-// Available options:
-//
-// DefaultGridColor(bool)
-// ShowFormulas(bool)
-// ShowGridLines(bool)
-// ShowRowColHeaders(bool)
-// ShowZeros(bool)
-// RightToLeft(bool)
-// ShowRuler(bool)
-// View(string)
-// TopLeftCell(string)
-// ZoomScale(float64)
-//
-// Example:
-//
-// var showGridLines excelize.ShowGridLines
-// err = f.GetSheetViewOptions("Sheet1", -1, &showGridLines)
-func (f *File) GetSheetViewOptions(sheet string, viewIndex int, opts ...SheetViewOptionPtr) error {
+// GetSheetView gets the value of sheet view options. The viewIndex may be
+// negative and if so is counted backward (-1 is the last view).
+func (f *File) GetSheetView(sheet string, viewIndex int) (ViewOptions, error) {
+ opts := ViewOptions{
+ DefaultGridColor: boolPtr(true),
+ ShowFormulas: boolPtr(true),
+ ShowGridLines: boolPtr(true),
+ ShowRowColHeaders: boolPtr(true),
+ ShowRuler: boolPtr(true),
+ ShowZeros: boolPtr(true),
+ View: stringPtr("normal"),
+ ZoomScale: float64Ptr(100),
+ }
view, err := f.getSheetView(sheet, viewIndex)
if err != nil {
- return err
+ return opts, err
}
-
- for _, opt := range opts {
- opt.getSheetViewOption(view)
+ if view.DefaultGridColor != nil {
+ opts.DefaultGridColor = view.DefaultGridColor
}
- return nil
+ opts.RightToLeft = boolPtr(view.RightToLeft)
+ opts.ShowFormulas = boolPtr(view.ShowFormulas)
+ if view.ShowGridLines != nil {
+ opts.ShowGridLines = view.ShowGridLines
+ }
+ if view.ShowRowColHeaders != nil {
+ opts.ShowRowColHeaders = view.ShowRowColHeaders
+ }
+ if view.ShowRuler != nil {
+ opts.ShowRuler = view.ShowRuler
+ }
+ if view.ShowZeros != nil {
+ opts.ShowZeros = view.ShowZeros
+ }
+ opts.TopLeftCell = stringPtr(view.TopLeftCell)
+ if view.View != "" {
+ opts.View = stringPtr(view.View)
+ }
+ if view.ZoomScale >= 10 && view.ZoomScale <= 400 {
+ opts.ZoomScale = float64Ptr(view.ZoomScale)
+ }
+ return opts, err
}
diff --git a/sheetview_test.go b/sheetview_test.go
index 65c4f5120b..8d022a2e0f 100644
--- a/sheetview_test.go
+++ b/sheetview_test.go
@@ -1,218 +1,50 @@
package excelize
import (
- "fmt"
"testing"
"github.com/stretchr/testify/assert"
)
-var _ = []SheetViewOption{
- DefaultGridColor(true),
- ShowFormulas(false),
- ShowGridLines(true),
- ShowRowColHeaders(true),
- ShowZeros(true),
- RightToLeft(false),
- ShowRuler(false),
- View("pageLayout"),
- TopLeftCell("B2"),
- ZoomScale(100),
- // SheetViewOptionPtr are also SheetViewOption
- new(DefaultGridColor),
- new(ShowFormulas),
- new(ShowGridLines),
- new(ShowRowColHeaders),
- new(ShowZeros),
- new(RightToLeft),
- new(ShowRuler),
- new(View),
- new(TopLeftCell),
- new(ZoomScale),
-}
-
-var _ = []SheetViewOptionPtr{
- (*DefaultGridColor)(nil),
- (*ShowFormulas)(nil),
- (*ShowGridLines)(nil),
- (*ShowRowColHeaders)(nil),
- (*ShowZeros)(nil),
- (*RightToLeft)(nil),
- (*ShowRuler)(nil),
- (*View)(nil),
- (*TopLeftCell)(nil),
- (*ZoomScale)(nil),
-}
-
-func ExampleFile_SetSheetViewOptions() {
- f := NewFile()
- const sheet = "Sheet1"
-
- if err := f.SetSheetViewOptions(sheet, 0,
- DefaultGridColor(false),
- ShowFormulas(true),
- ShowGridLines(true),
- ShowRowColHeaders(true),
- RightToLeft(false),
- ShowRuler(false),
- View("pageLayout"),
- TopLeftCell("C3"),
- ZoomScale(80),
- ); err != nil {
- fmt.Println(err)
- }
-
- var zoomScale ZoomScale
- fmt.Println("Default:")
- fmt.Println("- zoomScale: 80")
-
- if err := f.SetSheetViewOptions(sheet, 0, ZoomScale(500)); err != nil {
- fmt.Println(err)
- }
-
- if err := f.GetSheetViewOptions(sheet, 0, &zoomScale); err != nil {
- fmt.Println(err)
- }
-
- fmt.Println("Used out of range value:")
- fmt.Println("- zoomScale:", zoomScale)
-
- if err := f.SetSheetViewOptions(sheet, 0, ZoomScale(123)); err != nil {
- fmt.Println(err)
- }
-
- if err := f.GetSheetViewOptions(sheet, 0, &zoomScale); err != nil {
- fmt.Println(err)
- }
-
- fmt.Println("Used correct value:")
- fmt.Println("- zoomScale:", zoomScale)
-
- // Output:
- // Default:
- // - zoomScale: 80
- // Used out of range value:
- // - zoomScale: 80
- // Used correct value:
- // - zoomScale: 123
-}
-
-func ExampleFile_GetSheetViewOptions() {
+func TestSetView(t *testing.T) {
f := NewFile()
- const sheet = "Sheet1"
-
- var (
- defaultGridColor DefaultGridColor
- showFormulas ShowFormulas
- showGridLines ShowGridLines
- showRowColHeaders ShowRowColHeaders
- showZeros ShowZeros
- rightToLeft RightToLeft
- showRuler ShowRuler
- view View
- topLeftCell TopLeftCell
- zoomScale ZoomScale
- )
-
- if err := f.GetSheetViewOptions(sheet, 0,
- &defaultGridColor,
- &showFormulas,
- &showGridLines,
- &showRowColHeaders,
- &showZeros,
- &rightToLeft,
- &showRuler,
- &view,
- &topLeftCell,
- &zoomScale,
- ); err != nil {
- fmt.Println(err)
- }
-
- fmt.Println("Default:")
- fmt.Println("- defaultGridColor:", defaultGridColor)
- fmt.Println("- showFormulas:", showFormulas)
- fmt.Println("- showGridLines:", showGridLines)
- fmt.Println("- showRowColHeaders:", showRowColHeaders)
- fmt.Println("- showZeros:", showZeros)
- fmt.Println("- rightToLeft:", rightToLeft)
- fmt.Println("- showRuler:", showRuler)
- fmt.Println("- view:", view)
- fmt.Println("- topLeftCell:", `"`+topLeftCell+`"`)
- fmt.Println("- zoomScale:", zoomScale)
-
- if err := f.SetSheetViewOptions(sheet, 0, ShowGridLines(false)); err != nil {
- fmt.Println(err)
- }
-
- if err := f.GetSheetViewOptions(sheet, 0, &showGridLines); err != nil {
- fmt.Println(err)
- }
-
- if err := f.SetSheetViewOptions(sheet, 0, ShowZeros(false)); err != nil {
- fmt.Println(err)
- }
-
- if err := f.GetSheetViewOptions(sheet, 0, &showZeros); err != nil {
- fmt.Println(err)
- }
-
- if err := f.SetSheetViewOptions(sheet, 0, View("pageLayout")); err != nil {
- fmt.Println(err)
- }
-
- if err := f.GetSheetViewOptions(sheet, 0, &view); err != nil {
- fmt.Println(err)
- }
-
- if err := f.SetSheetViewOptions(sheet, 0, TopLeftCell("B2")); err != nil {
- fmt.Println(err)
- }
-
- if err := f.GetSheetViewOptions(sheet, 0, &topLeftCell); err != nil {
- fmt.Println(err)
- }
-
- fmt.Println("After change:")
- fmt.Println("- showGridLines:", showGridLines)
- fmt.Println("- showZeros:", showZeros)
- fmt.Println("- view:", view)
- fmt.Println("- topLeftCell:", topLeftCell)
-
- // Output:
- // Default:
- // - defaultGridColor: true
- // - showFormulas: false
- // - showGridLines: true
- // - showRowColHeaders: true
- // - showZeros: true
- // - rightToLeft: false
- // - showRuler: true
- // - view: normal
- // - topLeftCell: ""
- // - zoomScale: 0
- // After change:
- // - showGridLines: false
- // - showZeros: false
- // - view: pageLayout
- // - topLeftCell: B2
-}
-
-func TestSheetViewOptionsErrors(t *testing.T) {
- f := NewFile()
- const sheet = "Sheet1"
-
- assert.NoError(t, f.GetSheetViewOptions(sheet, 0))
- assert.NoError(t, f.GetSheetViewOptions(sheet, -1))
- assert.Error(t, f.GetSheetViewOptions(sheet, 1))
- assert.Error(t, f.GetSheetViewOptions(sheet, -2))
- assert.NoError(t, f.SetSheetViewOptions(sheet, 0))
- assert.NoError(t, f.SetSheetViewOptions(sheet, -1))
- assert.Error(t, f.SetSheetViewOptions(sheet, 1))
- assert.Error(t, f.SetSheetViewOptions(sheet, -2))
-
+ assert.NoError(t, f.SetSheetView("Sheet1", -1, nil))
ws, ok := f.Sheet.Load("xl/worksheets/sheet1.xml")
assert.True(t, ok)
ws.(*xlsxWorksheet).SheetViews = nil
- assert.NoError(t, f.GetSheetViewOptions(sheet, 0))
+ expected := ViewOptions{
+ DefaultGridColor: boolPtr(false),
+ RightToLeft: boolPtr(false),
+ ShowFormulas: boolPtr(false),
+ ShowGridLines: boolPtr(false),
+ ShowRowColHeaders: boolPtr(false),
+ ShowRuler: boolPtr(false),
+ ShowZeros: boolPtr(false),
+ TopLeftCell: stringPtr("A1"),
+ View: stringPtr("normal"),
+ ZoomScale: float64Ptr(120),
+ }
+ assert.NoError(t, f.SetSheetView("Sheet1", 0, &expected))
+ opts, err := f.GetSheetView("Sheet1", 0)
+ assert.NoError(t, err)
+ assert.Equal(t, expected, opts)
+ // Test set sheet view options with invalid view index.
+ assert.EqualError(t, f.SetSheetView("Sheet1", 1, nil), "view index 1 out of range")
+ assert.EqualError(t, f.SetSheetView("Sheet1", -2, nil), "view index -2 out of range")
+ // Test set sheet view options on not exists worksheet.
+ assert.EqualError(t, f.SetSheetView("SheetN", 0, nil), "sheet SheetN does not exist")
+}
+
+func TestGetView(t *testing.T) {
+ f := NewFile()
+ _, err := f.getSheetView("SheetN", 0)
+ assert.EqualError(t, err, "sheet SheetN does not exist")
+ // Test get sheet view options with invalid view index.
+ _, err = f.GetSheetView("Sheet1", 1)
+ assert.EqualError(t, err, "view index 1 out of range")
+ _, err = f.GetSheetView("Sheet1", -2)
+ assert.EqualError(t, err, "view index -2 out of range")
+ // Test get sheet view options on not exists worksheet.
+ _, err = f.GetSheetView("SheetN", 0)
+ assert.EqualError(t, err, "sheet SheetN does not exist")
}
diff --git a/sparkline.go b/sparkline.go
index 79cb1f2b71..f2e0d7a455 100644
--- a/sparkline.go
+++ b/sparkline.go
@@ -387,8 +387,9 @@ func (f *File) addSparklineGroupByStyle(ID int) *xlsxX14SparklineGroup {
// Markers | Toggle sparkline markers
// ColorAxis | An RGB Color is specified as RRGGBB
// Axis | Show sparkline axis
-func (f *File) AddSparkline(sheet string, opts *SparklineOption) (err error) {
+func (f *File) AddSparkline(sheet string, opts *SparklineOptions) error {
var (
+ err error
ws *xlsxWorksheet
sparkType string
sparkTypes map[string]string
@@ -401,7 +402,7 @@ func (f *File) AddSparkline(sheet string, opts *SparklineOption) (err error) {
// parameter validation
if ws, err = f.parseFormatAddSparklineSet(sheet, opts); err != nil {
- return
+ return err
}
// Handle the sparkline type
sparkType = "line"
@@ -409,7 +410,7 @@ func (f *File) AddSparkline(sheet string, opts *SparklineOption) (err error) {
if opts.Type != "" {
if specifiedSparkTypes, ok = sparkTypes[opts.Type]; !ok {
err = ErrSparklineType
- return
+ return err
}
sparkType = specifiedSparkTypes
}
@@ -435,7 +436,7 @@ func (f *File) AddSparkline(sheet string, opts *SparklineOption) (err error) {
f.addSparkline(opts, group)
if ws.ExtLst.Ext != "" { // append mode ext
if err = f.appendSparkline(ws, group, groups); err != nil {
- return
+ return err
}
} else {
groups = &xlsxX14SparklineGroups{
@@ -443,23 +444,23 @@ func (f *File) AddSparkline(sheet string, opts *SparklineOption) (err error) {
SparklineGroups: []*xlsxX14SparklineGroup{group},
}
if sparklineGroupsBytes, err = xml.Marshal(groups); err != nil {
- return
+ return err
}
if extBytes, err = xml.Marshal(&xlsxWorksheetExt{
URI: ExtURISparklineGroups,
Content: string(sparklineGroupsBytes),
}); err != nil {
- return
+ return err
}
ws.ExtLst.Ext = string(extBytes)
}
f.addSheetNameSpace(sheet, NameSpaceSpreadSheetX14)
- return
+ return err
}
// parseFormatAddSparklineSet provides a function to validate sparkline
// properties.
-func (f *File) parseFormatAddSparklineSet(sheet string, opts *SparklineOption) (*xlsxWorksheet, error) {
+func (f *File) parseFormatAddSparklineSet(sheet string, opts *SparklineOptions) (*xlsxWorksheet, error) {
ws, err := f.workSheetReader(sheet)
if err != nil {
return ws, err
@@ -488,7 +489,7 @@ func (f *File) parseFormatAddSparklineSet(sheet string, opts *SparklineOption) (
// addSparkline provides a function to create a sparkline in a sparkline group
// by given properties.
-func (f *File) addSparkline(opts *SparklineOption, group *xlsxX14SparklineGroup) {
+func (f *File) addSparkline(opts *SparklineOptions, group *xlsxX14SparklineGroup) {
for idx, location := range opts.Location {
group.Sparklines.Sparkline = append(group.Sparklines.Sparkline, &xlsxX14Sparkline{
F: opts.Range[idx],
@@ -499,8 +500,9 @@ func (f *File) addSparkline(opts *SparklineOption, group *xlsxX14SparklineGroup)
// appendSparkline provides a function to append sparkline to sparkline
// groups.
-func (f *File) appendSparkline(ws *xlsxWorksheet, group *xlsxX14SparklineGroup, groups *xlsxX14SparklineGroups) (err error) {
+func (f *File) appendSparkline(ws *xlsxWorksheet, group *xlsxX14SparklineGroup, groups *xlsxX14SparklineGroups) error {
var (
+ err error
idx int
decodeExtLst *decodeWorksheetExt
decodeSparklineGroups *decodeX14SparklineGroups
@@ -510,17 +512,17 @@ func (f *File) appendSparkline(ws *xlsxWorksheet, group *xlsxX14SparklineGroup,
decodeExtLst = new(decodeWorksheetExt)
if err = f.xmlNewDecoder(strings.NewReader("" + ws.ExtLst.Ext + "")).
Decode(decodeExtLst); err != nil && err != io.EOF {
- return
+ return err
}
for idx, ext = range decodeExtLst.Ext {
if ext.URI == ExtURISparklineGroups {
decodeSparklineGroups = new(decodeX14SparklineGroups)
if err = f.xmlNewDecoder(strings.NewReader(ext.Content)).
Decode(decodeSparklineGroups); err != nil && err != io.EOF {
- return
+ return err
}
if sparklineGroupBytes, err = xml.Marshal(group); err != nil {
- return
+ return err
}
if groups == nil {
groups = &xlsxX14SparklineGroups{}
@@ -528,16 +530,16 @@ func (f *File) appendSparkline(ws *xlsxWorksheet, group *xlsxX14SparklineGroup,
groups.XMLNSXM = NameSpaceSpreadSheetExcel2006Main.Value
groups.Content = decodeSparklineGroups.Content + string(sparklineGroupBytes)
if sparklineGroupsBytes, err = xml.Marshal(groups); err != nil {
- return
+ return err
}
decodeExtLst.Ext[idx].Content = string(sparklineGroupsBytes)
}
}
if extLstBytes, err = xml.Marshal(decodeExtLst); err != nil {
- return
+ return err
}
ws.ExtLst = &xlsxExtLst{
Ext: strings.TrimSuffix(strings.TrimPrefix(string(extLstBytes), ""), ""),
}
- return
+ return err
}
diff --git a/sparkline_test.go b/sparkline_test.go
index 4703c859d6..e20dfdc811 100644
--- a/sparkline_test.go
+++ b/sparkline_test.go
@@ -15,7 +15,10 @@ func TestAddSparkline(t *testing.T) {
style, err := f.NewStyle(`{"font":{"bold":true}}`)
assert.NoError(t, err)
assert.NoError(t, f.SetCellStyle("Sheet1", "A1", "B1", style))
- assert.NoError(t, f.SetSheetViewOptions("Sheet1", 0, ZoomScale(150)))
+ viewOpts, err := f.GetSheetView("Sheet1", 0)
+ assert.NoError(t, err)
+ viewOpts.ZoomScale = float64Ptr(150)
+ assert.NoError(t, f.SetSheetView("Sheet1", 0, &viewOpts))
assert.NoError(t, f.SetColWidth("Sheet1", "A", "A", 14))
assert.NoError(t, f.SetColWidth("Sheet1", "B", "B", 50))
@@ -24,34 +27,34 @@ func TestAddSparkline(t *testing.T) {
assert.NoError(t, f.SetCellValue("Sheet1", "B1", "Description"))
assert.NoError(t, f.SetCellValue("Sheet1", "B2", `A default "line" sparkline.`))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A2"},
Range: []string{"Sheet3!A1:J1"},
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B3", `A default "column" sparkline.`))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A3"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B4", `A default "win/loss" sparkline.`))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A4"},
Range: []string{"Sheet3!A3:J3"},
Type: "win_loss",
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B6", "Line with markers."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A6"},
Range: []string{"Sheet3!A1:J1"},
Markers: true,
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B7", "Line with high and low points."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A7"},
Range: []string{"Sheet3!A1:J1"},
High: true,
@@ -59,7 +62,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B8", "Line with first and last point markers."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A8"},
Range: []string{"Sheet3!A1:J1"},
First: true,
@@ -67,28 +70,28 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B9", "Line with negative point markers."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A9"},
Range: []string{"Sheet3!A1:J1"},
Negative: true,
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B10", "Line with axis."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A10"},
Range: []string{"Sheet3!A1:J1"},
Axis: true,
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B12", "Column with default style (1)."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A12"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B13", "Column with style 2."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A13"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
@@ -96,7 +99,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B14", "Column with style 3."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A14"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
@@ -104,7 +107,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B15", "Column with style 4."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A15"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
@@ -112,7 +115,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B16", "Column with style 5."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A16"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
@@ -120,7 +123,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B17", "Column with style 6."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A17"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
@@ -128,7 +131,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B18", "Column with a user defined color."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A18"},
Range: []string{"Sheet3!A2:J2"},
Type: "column",
@@ -136,14 +139,14 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B20", "A win/loss sparkline."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A20"},
Range: []string{"Sheet3!A3:J3"},
Type: "win_loss",
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B21", "A win/loss sparkline with negative points highlighted."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A21"},
Range: []string{"Sheet3!A3:J3"},
Type: "win_loss",
@@ -151,7 +154,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B23", "A left to right column (the default)."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A23"},
Range: []string{"Sheet3!A4:J4"},
Type: "column",
@@ -159,7 +162,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B24", "A right to left column."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A24"},
Range: []string{"Sheet3!A4:J4"},
Type: "column",
@@ -168,7 +171,7 @@ func TestAddSparkline(t *testing.T) {
}))
assert.NoError(t, f.SetCellValue("Sheet1", "B25", "Sparkline and text in one cell."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A25"},
Range: []string{"Sheet3!A4:J4"},
Type: "column",
@@ -177,34 +180,34 @@ func TestAddSparkline(t *testing.T) {
assert.NoError(t, f.SetCellValue("Sheet1", "A25", "Growth"))
assert.NoError(t, f.SetCellValue("Sheet1", "B27", "A grouped sparkline. Changes are applied to all three."))
- assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A27", "A28", "A29"},
Range: []string{"Sheet3!A5:J5", "Sheet3!A6:J6", "Sheet3!A7:J7"},
Markers: true,
}))
// Sheet2 sections
- assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOptions{
Location: []string{"F3"},
Range: []string{"Sheet2!A3:E3"},
Type: "win_loss",
Negative: true,
}))
- assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOptions{
Location: []string{"F1"},
Range: []string{"Sheet2!A1:E1"},
Markers: true,
}))
- assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOptions{
Location: []string{"F2"},
Range: []string{"Sheet2!A2:E2"},
Type: "column",
Style: 12,
}))
- assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOption{
+ assert.NoError(t, f.AddSparkline("Sheet2", &SparklineOptions{
Location: []string{"F3"},
Range: []string{"Sheet2!A3:E3"},
Type: "win_loss",
@@ -215,39 +218,39 @@ func TestAddSparkline(t *testing.T) {
assert.NoError(t, f.SaveAs(filepath.Join("test", "TestAddSparkline.xlsx")))
// Test error exceptions
- assert.EqualError(t, f.AddSparkline("SheetN", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("SheetN", &SparklineOptions{
Location: []string{"F3"},
Range: []string{"Sheet2!A3:E3"},
}), "sheet SheetN does not exist")
assert.EqualError(t, f.AddSparkline("Sheet1", nil), ErrParameterRequired.Error())
- assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Range: []string{"Sheet2!A3:E3"},
}), ErrSparklineLocation.Error())
- assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"F3"},
}), ErrSparklineRange.Error())
- assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"F2", "F3"},
Range: []string{"Sheet2!A3:E3"},
}), ErrSparkline.Error())
- assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"F3"},
Range: []string{"Sheet2!A3:E3"},
Type: "unknown_type",
}), ErrSparklineType.Error())
- assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"F3"},
Range: []string{"Sheet2!A3:E3"},
Style: -1,
}), ErrSparklineStyle.Error())
- assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"F3"},
Range: []string{"Sheet2!A3:E3"},
Style: -1,
@@ -265,7 +268,7 @@ func TestAddSparkline(t *testing.T) {
`
- assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOption{
+ assert.EqualError(t, f.AddSparkline("Sheet1", &SparklineOptions{
Location: []string{"A2"},
Range: []string{"Sheet3!A1:J1"},
}), "XML syntax error on line 6: element closed by ")
diff --git a/stream.go b/stream.go
index 019731f92c..3d06790276 100644
--- a/stream.go
+++ b/stream.go
@@ -139,8 +139,8 @@ func (f *File) NewStreamWriter(sheet string) (*StreamWriter, error) {
// called after the rows are written but before Flush.
//
// See File.AddTable for details on the table format.
-func (sw *StreamWriter) AddTable(hCell, vCell, format string) error {
- formatSet, err := parseFormatTableSet(format)
+func (sw *StreamWriter) AddTable(hCell, vCell, opts string) error {
+ options, err := parseTableOptions(opts)
if err != nil {
return err
}
@@ -177,7 +177,7 @@ func (sw *StreamWriter) AddTable(hCell, vCell, format string) error {
tableID := sw.File.countTables() + 1
- name := formatSet.TableName
+ name := options.TableName
if name == "" {
name = "Table" + strconv.Itoa(tableID)
}
@@ -196,11 +196,11 @@ func (sw *StreamWriter) AddTable(hCell, vCell, format string) error {
TableColumn: tableColumn,
},
TableStyleInfo: &xlsxTableStyleInfo{
- Name: formatSet.TableStyle,
- ShowFirstColumn: formatSet.ShowFirstColumn,
- ShowLastColumn: formatSet.ShowLastColumn,
- ShowRowStripes: formatSet.ShowRowStripes,
- ShowColumnStripes: formatSet.ShowColumnStripes,
+ Name: options.TableStyle,
+ ShowFirstColumn: options.ShowFirstColumn,
+ ShowLastColumn: options.ShowLastColumn,
+ ShowRowStripes: options.ShowRowStripes,
+ ShowColumnStripes: options.ShowColumnStripes,
},
}
diff --git a/stream_test.go b/stream_test.go
index 1026cb3492..80875c79a6 100644
--- a/stream_test.go
+++ b/stream_test.go
@@ -173,7 +173,7 @@ func TestStreamTable(t *testing.T) {
assert.NoError(t, streamWriter.AddTable("A1", "C1", ``))
- // Test add table with illegal formatset.
+ // Test add table with illegal options.
assert.EqualError(t, streamWriter.AddTable("B26", "A21", `{x}`), "invalid character 'x' looking for beginning of object key string")
// Test add table with illegal cell reference.
assert.EqualError(t, streamWriter.AddTable("A", "B1", `{}`), newCellNameToCoordinatesError("A", newInvalidCellNameError("A")).Error())
diff --git a/styles.go b/styles.go
index a4f5dc48dc..6d90a9ec3a 100644
--- a/styles.go
+++ b/styles.go
@@ -2859,13 +2859,13 @@ func (f *File) SetCellStyle(sheet, hCell, vCell string, styleID int) error {
// max_color - Same as min_color, see above.
//
// bar_color - Used for data_bar. Same as min_color, see above.
-func (f *File) SetConditionalFormat(sheet, reference, formatSet string) error {
- var format []*formatConditional
- err := json.Unmarshal([]byte(formatSet), &format)
+func (f *File) SetConditionalFormat(sheet, reference, opts string) error {
+ var format []*conditionalOptions
+ err := json.Unmarshal([]byte(opts), &format)
if err != nil {
return err
}
- drawContFmtFunc := map[string]func(p int, ct string, fmtCond *formatConditional) *xlsxCfRule{
+ drawContFmtFunc := map[string]func(p int, ct string, fmtCond *conditionalOptions) *xlsxCfRule{
"cellIs": drawCondFmtCellIs,
"top10": drawCondFmtTop10,
"aboveAverage": drawCondFmtAboveAverage,
@@ -2909,8 +2909,8 @@ func (f *File) SetConditionalFormat(sheet, reference, formatSet string) error {
// extractCondFmtCellIs provides a function to extract conditional format
// settings for cell value (include between, not between, equal, not equal,
// greater than and less than) by given conditional formatting rule.
-func extractCondFmtCellIs(c *xlsxCfRule) *formatConditional {
- format := formatConditional{Type: "cell", Criteria: operatorType[c.Operator], Format: *c.DxfID}
+func extractCondFmtCellIs(c *xlsxCfRule) *conditionalOptions {
+ format := conditionalOptions{Type: "cell", Criteria: operatorType[c.Operator], Format: *c.DxfID}
if len(c.Formula) == 2 {
format.Minimum, format.Maximum = c.Formula[0], c.Formula[1]
return &format
@@ -2922,8 +2922,8 @@ func extractCondFmtCellIs(c *xlsxCfRule) *formatConditional {
// extractCondFmtTop10 provides a function to extract conditional format
// settings for top N (default is top 10) by given conditional formatting
// rule.
-func extractCondFmtTop10(c *xlsxCfRule) *formatConditional {
- format := formatConditional{
+func extractCondFmtTop10(c *xlsxCfRule) *conditionalOptions {
+ format := conditionalOptions{
Type: "top",
Criteria: "=",
Format: *c.DxfID,
@@ -2939,8 +2939,8 @@ func extractCondFmtTop10(c *xlsxCfRule) *formatConditional {
// extractCondFmtAboveAverage provides a function to extract conditional format
// settings for above average and below average by given conditional formatting
// rule.
-func extractCondFmtAboveAverage(c *xlsxCfRule) *formatConditional {
- return &formatConditional{
+func extractCondFmtAboveAverage(c *xlsxCfRule) *conditionalOptions {
+ return &conditionalOptions{
Type: "average",
Criteria: "=",
Format: *c.DxfID,
@@ -2951,8 +2951,8 @@ func extractCondFmtAboveAverage(c *xlsxCfRule) *formatConditional {
// extractCondFmtDuplicateUniqueValues provides a function to extract
// conditional format settings for duplicate and unique values by given
// conditional formatting rule.
-func extractCondFmtDuplicateUniqueValues(c *xlsxCfRule) *formatConditional {
- return &formatConditional{
+func extractCondFmtDuplicateUniqueValues(c *xlsxCfRule) *conditionalOptions {
+ return &conditionalOptions{
Type: map[string]string{
"duplicateValues": "duplicate",
"uniqueValues": "unique",
@@ -2965,8 +2965,8 @@ func extractCondFmtDuplicateUniqueValues(c *xlsxCfRule) *formatConditional {
// extractCondFmtColorScale provides a function to extract conditional format
// settings for color scale (include 2 color scale and 3 color scale) by given
// conditional formatting rule.
-func extractCondFmtColorScale(c *xlsxCfRule) *formatConditional {
- var format formatConditional
+func extractCondFmtColorScale(c *xlsxCfRule) *conditionalOptions {
+ var format conditionalOptions
format.Type, format.Criteria = "2_color_scale", "="
values := len(c.ColorScale.Cfvo)
colors := len(c.ColorScale.Color)
@@ -3000,8 +3000,8 @@ func extractCondFmtColorScale(c *xlsxCfRule) *formatConditional {
// extractCondFmtDataBar provides a function to extract conditional format
// settings for data bar by given conditional formatting rule.
-func extractCondFmtDataBar(c *xlsxCfRule) *formatConditional {
- format := formatConditional{Type: "data_bar", Criteria: "="}
+func extractCondFmtDataBar(c *xlsxCfRule) *conditionalOptions {
+ format := conditionalOptions{Type: "data_bar", Criteria: "="}
if c.DataBar != nil {
format.MinType = c.DataBar.Cfvo[0].Type
format.MaxType = c.DataBar.Cfvo[1].Type
@@ -3012,8 +3012,8 @@ func extractCondFmtDataBar(c *xlsxCfRule) *formatConditional {
// extractCondFmtExp provides a function to extract conditional format settings
// for expression by given conditional formatting rule.
-func extractCondFmtExp(c *xlsxCfRule) *formatConditional {
- format := formatConditional{Type: "formula", Format: *c.DxfID}
+func extractCondFmtExp(c *xlsxCfRule) *conditionalOptions {
+ format := conditionalOptions{Type: "formula", Format: *c.DxfID}
if len(c.Formula) > 0 {
format.Criteria = c.Formula[0]
}
@@ -3023,7 +3023,7 @@ func extractCondFmtExp(c *xlsxCfRule) *formatConditional {
// GetConditionalFormats returns conditional format settings by given worksheet
// name.
func (f *File) GetConditionalFormats(sheet string) (map[string]string, error) {
- extractContFmtFunc := map[string]func(c *xlsxCfRule) *formatConditional{
+ extractContFmtFunc := map[string]func(c *xlsxCfRule) *conditionalOptions{
"cellIs": extractCondFmtCellIs,
"top10": extractCondFmtTop10,
"aboveAverage": extractCondFmtAboveAverage,
@@ -3040,14 +3040,14 @@ func (f *File) GetConditionalFormats(sheet string) (map[string]string, error) {
return conditionalFormats, err
}
for _, cf := range ws.ConditionalFormatting {
- var format []*formatConditional
+ var opts []*conditionalOptions
for _, cr := range cf.CfRule {
if extractFunc, ok := extractContFmtFunc[cr.Type]; ok {
- format = append(format, extractFunc(cr))
+ opts = append(opts, extractFunc(cr))
}
}
- formatSet, _ := json.Marshal(format)
- conditionalFormats[cf.SQRef] = string(formatSet)
+ options, _ := json.Marshal(opts)
+ conditionalFormats[cf.SQRef] = string(options)
}
return conditionalFormats, err
}
@@ -3071,7 +3071,7 @@ func (f *File) UnsetConditionalFormat(sheet, reference string) error {
// drawCondFmtCellIs provides a function to create conditional formatting rule
// for cell value (include between, not between, equal, not equal, greater
// than and less than) by given priority, criteria type and format settings.
-func drawCondFmtCellIs(p int, ct string, format *formatConditional) *xlsxCfRule {
+func drawCondFmtCellIs(p int, ct string, format *conditionalOptions) *xlsxCfRule {
c := &xlsxCfRule{
Priority: p + 1,
Type: validType[format.Type],
@@ -3094,7 +3094,7 @@ func drawCondFmtCellIs(p int, ct string, format *formatConditional) *xlsxCfRule
// drawCondFmtTop10 provides a function to create conditional formatting rule
// for top N (default is top 10) by given priority, criteria type and format
// settings.
-func drawCondFmtTop10(p int, ct string, format *formatConditional) *xlsxCfRule {
+func drawCondFmtTop10(p int, ct string, format *conditionalOptions) *xlsxCfRule {
c := &xlsxCfRule{
Priority: p + 1,
Bottom: format.Type == "bottom",
@@ -3113,7 +3113,7 @@ func drawCondFmtTop10(p int, ct string, format *formatConditional) *xlsxCfRule {
// drawCondFmtAboveAverage provides a function to create conditional
// formatting rule for above average and below average by given priority,
// criteria type and format settings.
-func drawCondFmtAboveAverage(p int, ct string, format *formatConditional) *xlsxCfRule {
+func drawCondFmtAboveAverage(p int, ct string, format *conditionalOptions) *xlsxCfRule {
return &xlsxCfRule{
Priority: p + 1,
Type: validType[format.Type],
@@ -3125,7 +3125,7 @@ func drawCondFmtAboveAverage(p int, ct string, format *formatConditional) *xlsxC
// drawCondFmtDuplicateUniqueValues provides a function to create conditional
// formatting rule for duplicate and unique values by given priority, criteria
// type and format settings.
-func drawCondFmtDuplicateUniqueValues(p int, ct string, format *formatConditional) *xlsxCfRule {
+func drawCondFmtDuplicateUniqueValues(p int, ct string, format *conditionalOptions) *xlsxCfRule {
return &xlsxCfRule{
Priority: p + 1,
Type: validType[format.Type],
@@ -3136,7 +3136,7 @@ func drawCondFmtDuplicateUniqueValues(p int, ct string, format *formatConditiona
// drawCondFmtColorScale provides a function to create conditional formatting
// rule for color scale (include 2 color scale and 3 color scale) by given
// priority, criteria type and format settings.
-func drawCondFmtColorScale(p int, ct string, format *formatConditional) *xlsxCfRule {
+func drawCondFmtColorScale(p int, ct string, format *conditionalOptions) *xlsxCfRule {
minValue := format.MinValue
if minValue == "" {
minValue = "0"
@@ -3173,7 +3173,7 @@ func drawCondFmtColorScale(p int, ct string, format *formatConditional) *xlsxCfR
// drawCondFmtDataBar provides a function to create conditional formatting
// rule for data bar by given priority, criteria type and format settings.
-func drawCondFmtDataBar(p int, ct string, format *formatConditional) *xlsxCfRule {
+func drawCondFmtDataBar(p int, ct string, format *conditionalOptions) *xlsxCfRule {
return &xlsxCfRule{
Priority: p + 1,
Type: validType[format.Type],
@@ -3186,7 +3186,7 @@ func drawCondFmtDataBar(p int, ct string, format *formatConditional) *xlsxCfRule
// drawCondFmtExp provides a function to create conditional formatting rule
// for expression by given priority, criteria type and format settings.
-func drawCondFmtExp(p int, ct string, format *formatConditional) *xlsxCfRule {
+func drawCondFmtExp(p int, ct string, format *conditionalOptions) *xlsxCfRule {
return &xlsxCfRule{
Priority: p + 1,
Type: validType[format.Type],
diff --git a/styles_test.go b/styles_test.go
index 47aee5b802..f27c9a20e2 100644
--- a/styles_test.go
+++ b/styles_test.go
@@ -192,9 +192,9 @@ func TestGetConditionalFormats(t *testing.T) {
f := NewFile()
err := f.SetConditionalFormat("Sheet1", "A1:A2", format)
assert.NoError(t, err)
- formatSet, err := f.GetConditionalFormats("Sheet1")
+ opts, err := f.GetConditionalFormats("Sheet1")
assert.NoError(t, err)
- assert.Equal(t, format, formatSet["A1:A2"])
+ assert.Equal(t, format, opts["A1:A2"])
}
// Test get conditional formats on no exists worksheet
f := NewFile()
diff --git a/table.go b/table.go
index 7ef75625b3..f7cac2097a 100644
--- a/table.go
+++ b/table.go
@@ -20,12 +20,12 @@ import (
"strings"
)
-// parseFormatTableSet provides a function to parse the format settings of the
+// parseTableOptions provides a function to parse the format settings of the
// table with default value.
-func parseFormatTableSet(formatSet string) (*formatTable, error) {
- format := formatTable{ShowRowStripes: true}
- err := json.Unmarshal(parseFormatSet(formatSet), &format)
- return &format, err
+func parseTableOptions(opts string) (*tableOptions, error) {
+ options := tableOptions{ShowRowStripes: true}
+ err := json.Unmarshal(fallbackOptions(opts), &options)
+ return &options, err
}
// AddTable provides the method to add table in a worksheet by given worksheet
@@ -57,8 +57,8 @@ func parseFormatTableSet(formatSet string) (*formatTable, error) {
// TableStyleLight1 - TableStyleLight21
// TableStyleMedium1 - TableStyleMedium28
// TableStyleDark1 - TableStyleDark11
-func (f *File) AddTable(sheet, hCell, vCell, format string) error {
- formatSet, err := parseFormatTableSet(format)
+func (f *File) AddTable(sheet, hCell, vCell, opts string) error {
+ options, err := parseTableOptions(opts)
if err != nil {
return err
}
@@ -91,7 +91,7 @@ func (f *File) AddTable(sheet, hCell, vCell, format string) error {
return err
}
f.addSheetNameSpace(sheet, SourceRelationship)
- if err = f.addTable(sheet, tableXML, hCol, hRow, vCol, vRow, tableID, formatSet); err != nil {
+ if err = f.addTable(sheet, tableXML, hCol, hRow, vCol, vRow, tableID, options); err != nil {
return err
}
f.addContentTypePart(tableID, "table")
@@ -160,7 +160,7 @@ func (f *File) setTableHeader(sheet string, x1, y1, x2 int) ([]*xlsxTableColumn,
// addTable provides a function to add table by given worksheet name,
// range reference and format set.
-func (f *File) addTable(sheet, tableXML string, x1, y1, x2, y2, i int, formatSet *formatTable) error {
+func (f *File) addTable(sheet, tableXML string, x1, y1, x2, y2, i int, opts *tableOptions) error {
// Correct the minimum number of rows, the table at least two lines.
if y1 == y2 {
y2++
@@ -172,7 +172,7 @@ func (f *File) addTable(sheet, tableXML string, x1, y1, x2, y2, i int, formatSet
return err
}
tableColumns, _ := f.setTableHeader(sheet, x1, y1, x2)
- name := formatSet.TableName
+ name := opts.TableName
if name == "" {
name = "Table" + strconv.Itoa(i)
}
@@ -190,11 +190,11 @@ func (f *File) addTable(sheet, tableXML string, x1, y1, x2, y2, i int, formatSet
TableColumn: tableColumns,
},
TableStyleInfo: &xlsxTableStyleInfo{
- Name: formatSet.TableStyle,
- ShowFirstColumn: formatSet.ShowFirstColumn,
- ShowLastColumn: formatSet.ShowLastColumn,
- ShowRowStripes: formatSet.ShowRowStripes,
- ShowColumnStripes: formatSet.ShowColumnStripes,
+ Name: opts.TableStyle,
+ ShowFirstColumn: opts.ShowFirstColumn,
+ ShowLastColumn: opts.ShowLastColumn,
+ ShowRowStripes: opts.ShowRowStripes,
+ ShowColumnStripes: opts.ShowColumnStripes,
},
}
table, _ := xml.Marshal(t)
@@ -202,12 +202,12 @@ func (f *File) addTable(sheet, tableXML string, x1, y1, x2, y2, i int, formatSet
return nil
}
-// parseAutoFilterSet provides a function to parse the settings of the auto
+// parseAutoFilterOptions provides a function to parse the settings of the auto
// filter.
-func parseAutoFilterSet(formatSet string) (*formatAutoFilter, error) {
- format := formatAutoFilter{}
- err := json.Unmarshal([]byte(formatSet), &format)
- return &format, err
+func parseAutoFilterOptions(opts string) (*autoFilterOptions, error) {
+ options := autoFilterOptions{}
+ err := json.Unmarshal([]byte(opts), &options)
+ return &options, err
}
// AutoFilter provides the method to add auto filter in a worksheet by given
@@ -279,7 +279,7 @@ func parseAutoFilterSet(formatSet string) (*formatAutoFilter, error) {
// x < 2000
// col < 2000
// Price < 2000
-func (f *File) AutoFilter(sheet, hCell, vCell, format string) error {
+func (f *File) AutoFilter(sheet, hCell, vCell, opts string) error {
hCol, hRow, err := CellNameToCoordinates(hCell)
if err != nil {
return err
@@ -297,7 +297,7 @@ func (f *File) AutoFilter(sheet, hCell, vCell, format string) error {
vRow, hRow = hRow, vRow
}
- formatSet, _ := parseAutoFilterSet(format)
+ options, _ := parseAutoFilterOptions(opts)
cellStart, _ := CoordinatesToCellName(hCol, hRow, true)
cellEnd, _ := CoordinatesToCellName(vCol, vRow, true)
ref, filterDB := cellStart+":"+cellEnd, "_xlnm._FilterDatabase"
@@ -328,12 +328,12 @@ func (f *File) AutoFilter(sheet, hCell, vCell, format string) error {
}
}
refRange := vCol - hCol
- return f.autoFilter(sheet, ref, refRange, hCol, formatSet)
+ return f.autoFilter(sheet, ref, refRange, hCol, options)
}
// autoFilter provides a function to extract the tokens from the filter
// expression. The tokens are mainly non-whitespace groups.
-func (f *File) autoFilter(sheet, ref string, refRange, col int, formatSet *formatAutoFilter) error {
+func (f *File) autoFilter(sheet, ref string, refRange, col int, opts *autoFilterOptions) error {
ws, err := f.workSheetReader(sheet)
if err != nil {
return err
@@ -346,28 +346,28 @@ func (f *File) autoFilter(sheet, ref string, refRange, col int, formatSet *forma
Ref: ref,
}
ws.AutoFilter = filter
- if formatSet.Column == "" || formatSet.Expression == "" {
+ if opts.Column == "" || opts.Expression == "" {
return nil
}
- fsCol, err := ColumnNameToNumber(formatSet.Column)
+ fsCol, err := ColumnNameToNumber(opts.Column)
if err != nil {
return err
}
offset := fsCol - col
if offset < 0 || offset > refRange {
- return fmt.Errorf("incorrect index of column '%s'", formatSet.Column)
+ return fmt.Errorf("incorrect index of column '%s'", opts.Column)
}
filter.FilterColumn = append(filter.FilterColumn, &xlsxFilterColumn{
ColID: offset,
})
re := regexp.MustCompile(`"(?:[^"]|"")*"|\S+`)
- token := re.FindAllString(formatSet.Expression, -1)
+ token := re.FindAllString(opts.Expression, -1)
if len(token) != 3 && len(token) != 7 {
- return fmt.Errorf("incorrect number of tokens in criteria '%s'", formatSet.Expression)
+ return fmt.Errorf("incorrect number of tokens in criteria '%s'", opts.Expression)
}
- expressions, tokens, err := f.parseFilterExpression(formatSet.Expression, token)
+ expressions, tokens, err := f.parseFilterExpression(opts.Expression, token)
if err != nil {
return err
}
diff --git a/table_test.go b/table_test.go
index c997ad243b..409b49fb5d 100644
--- a/table_test.go
+++ b/table_test.go
@@ -31,7 +31,7 @@ func TestAddTable(t *testing.T) {
// Test add table in not exist worksheet.
assert.EqualError(t, f.AddTable("SheetN", "B26", "A21", `{}`), "sheet SheetN does not exist")
- // Test add table with illegal formatset.
+ // Test add table with illegal options.
assert.EqualError(t, f.AddTable("Sheet1", "B26", "A21", `{x}`), "invalid character 'x' looking for beginning of object key string")
// Test add table with illegal cell reference.
assert.EqualError(t, f.AddTable("Sheet1", "A", "B1", `{}`), newCellNameToCoordinatesError("A", newInvalidCellNameError("A")).Error())
@@ -108,19 +108,19 @@ func TestAutoFilterError(t *testing.T) {
})
}
- assert.EqualError(t, f.autoFilter("SheetN", "A1", 1, 1, &formatAutoFilter{
+ assert.EqualError(t, f.autoFilter("SheetN", "A1", 1, 1, &autoFilterOptions{
Column: "A",
Expression: "",
}), "sheet SheetN does not exist")
- assert.EqualError(t, f.autoFilter("Sheet1", "A1", 1, 1, &formatAutoFilter{
+ assert.EqualError(t, f.autoFilter("Sheet1", "A1", 1, 1, &autoFilterOptions{
Column: "-",
Expression: "-",
}), newInvalidColumnNameError("-").Error())
- assert.EqualError(t, f.autoFilter("Sheet1", "A1", 1, 100, &formatAutoFilter{
+ assert.EqualError(t, f.autoFilter("Sheet1", "A1", 1, 100, &autoFilterOptions{
Column: "A",
Expression: "-",
}), `incorrect index of column 'A'`)
- assert.EqualError(t, f.autoFilter("Sheet1", "A1", 1, 1, &formatAutoFilter{
+ assert.EqualError(t, f.autoFilter("Sheet1", "A1", 1, 1, &autoFilterOptions{
Column: "A",
Expression: "-",
}), `incorrect number of tokens in criteria '-'`)
diff --git a/workbook.go b/workbook.go
index dbe212acca..937c9caf4e 100644
--- a/workbook.go
+++ b/workbook.go
@@ -21,26 +21,38 @@ import (
"strings"
)
-// WorkbookPrOption is an option of a view of a workbook. See SetWorkbookPrOptions().
-type WorkbookPrOption interface {
- setWorkbookPrOption(pr *xlsxWorkbookPr)
+// SetWorkbookProps provides a function to sets workbook properties.
+func (f *File) SetWorkbookProps(opts *WorkbookPropsOptions) error {
+ wb := f.workbookReader()
+ if wb.WorkbookPr == nil {
+ wb.WorkbookPr = new(xlsxWorkbookPr)
+ }
+ if opts == nil {
+ return nil
+ }
+ if opts.Date1904 != nil {
+ wb.WorkbookPr.Date1904 = *opts.Date1904
+ }
+ if opts.FilterPrivacy != nil {
+ wb.WorkbookPr.FilterPrivacy = *opts.FilterPrivacy
+ }
+ if opts.CodeName != nil {
+ wb.WorkbookPr.CodeName = *opts.CodeName
+ }
+ return nil
}
-// WorkbookPrOptionPtr is a writable WorkbookPrOption. See GetWorkbookPrOptions().
-type WorkbookPrOptionPtr interface {
- WorkbookPrOption
- getWorkbookPrOption(pr *xlsxWorkbookPr)
+// GetWorkbookProps provides a function to gets workbook properties.
+func (f *File) GetWorkbookProps() (WorkbookPropsOptions, error) {
+ wb, opts := f.workbookReader(), WorkbookPropsOptions{}
+ if wb.WorkbookPr != nil {
+ opts.Date1904 = boolPtr(wb.WorkbookPr.Date1904)
+ opts.FilterPrivacy = boolPtr(wb.WorkbookPr.FilterPrivacy)
+ opts.CodeName = stringPtr(wb.WorkbookPr.CodeName)
+ }
+ return opts, nil
}
-type (
- // Date1904 is an option used for WorkbookPrOption, that indicates whether
- // to use a 1900 or 1904 date system when converting serial date-times in
- // the workbook to dates
- Date1904 bool
- // FilterPrivacy is an option used for WorkbookPrOption
- FilterPrivacy bool
-)
-
// setWorkbook update workbook property of the spreadsheet. Maximum 31
// characters are allowed in sheet title.
func (f *File) setWorkbook(name string, sheetID, rid int) {
@@ -116,84 +128,3 @@ func (f *File) workBookWriter() {
f.saveFileList(f.getWorkbookPath(), replaceRelationshipsBytes(f.replaceNameSpaceBytes(f.getWorkbookPath(), output)))
}
}
-
-// SetWorkbookPrOptions provides a function to sets workbook properties.
-//
-// Available options:
-//
-// Date1904(bool)
-// FilterPrivacy(bool)
-// CodeName(string)
-func (f *File) SetWorkbookPrOptions(opts ...WorkbookPrOption) error {
- wb := f.workbookReader()
- pr := wb.WorkbookPr
- if pr == nil {
- pr = new(xlsxWorkbookPr)
- wb.WorkbookPr = pr
- }
- for _, opt := range opts {
- opt.setWorkbookPrOption(pr)
- }
- return nil
-}
-
-// setWorkbookPrOption implements the WorkbookPrOption interface.
-func (o Date1904) setWorkbookPrOption(pr *xlsxWorkbookPr) {
- pr.Date1904 = bool(o)
-}
-
-// setWorkbookPrOption implements the WorkbookPrOption interface.
-func (o FilterPrivacy) setWorkbookPrOption(pr *xlsxWorkbookPr) {
- pr.FilterPrivacy = bool(o)
-}
-
-// setWorkbookPrOption implements the WorkbookPrOption interface.
-func (o CodeName) setWorkbookPrOption(pr *xlsxWorkbookPr) {
- pr.CodeName = string(o)
-}
-
-// GetWorkbookPrOptions provides a function to gets workbook properties.
-//
-// Available options:
-//
-// Date1904(bool)
-// FilterPrivacy(bool)
-// CodeName(string)
-func (f *File) GetWorkbookPrOptions(opts ...WorkbookPrOptionPtr) error {
- wb := f.workbookReader()
- pr := wb.WorkbookPr
- for _, opt := range opts {
- opt.getWorkbookPrOption(pr)
- }
- return nil
-}
-
-// getWorkbookPrOption implements the WorkbookPrOption interface and get the
-// date1904 of the workbook.
-func (o *Date1904) getWorkbookPrOption(pr *xlsxWorkbookPr) {
- if pr == nil {
- *o = false
- return
- }
- *o = Date1904(pr.Date1904)
-}
-
-// getWorkbookPrOption implements the WorkbookPrOption interface and get the
-// filter privacy of the workbook.
-func (o *FilterPrivacy) getWorkbookPrOption(pr *xlsxWorkbookPr) {
- if pr == nil {
- *o = false
- return
- }
- *o = FilterPrivacy(pr.FilterPrivacy)
-}
-
-// getWorkbookPrOption implements the WorkbookPrOption interface and get the
-// code name of the workbook.
-func (o *CodeName) getWorkbookPrOption(pr *xlsxWorkbookPr) {
- if pr == nil {
- *o = ""
- return
- }
- *o = CodeName(pr.CodeName)
-}
diff --git a/workbook_test.go b/workbook_test.go
index 18b222c00f..29571fab45 100644
--- a/workbook_test.go
+++ b/workbook_test.go
@@ -1,69 +1,23 @@
package excelize
import (
- "fmt"
"testing"
"github.com/stretchr/testify/assert"
)
-func ExampleFile_SetWorkbookPrOptions() {
- f := NewFile()
- if err := f.SetWorkbookPrOptions(
- Date1904(false),
- FilterPrivacy(false),
- CodeName("code"),
- ); err != nil {
- fmt.Println(err)
- }
- // Output:
-}
-
-func ExampleFile_GetWorkbookPrOptions() {
- f := NewFile()
- var (
- date1904 Date1904
- filterPrivacy FilterPrivacy
- codeName CodeName
- )
- if err := f.GetWorkbookPrOptions(&date1904); err != nil {
- fmt.Println(err)
- }
- if err := f.GetWorkbookPrOptions(&filterPrivacy); err != nil {
- fmt.Println(err)
- }
- if err := f.GetWorkbookPrOptions(&codeName); err != nil {
- fmt.Println(err)
- }
- fmt.Println("Defaults:")
- fmt.Printf("- date1904: %t\n", date1904)
- fmt.Printf("- filterPrivacy: %t\n", filterPrivacy)
- fmt.Printf("- codeName: %q\n", codeName)
- // Output:
- // Defaults:
- // - date1904: false
- // - filterPrivacy: true
- // - codeName: ""
-}
-
-func TestWorkbookPr(t *testing.T) {
+func TestWorkbookProps(t *testing.T) {
f := NewFile()
+ assert.NoError(t, f.SetWorkbookProps(nil))
wb := f.workbookReader()
wb.WorkbookPr = nil
- var date1904 Date1904
- assert.NoError(t, f.GetWorkbookPrOptions(&date1904))
- assert.Equal(t, false, bool(date1904))
-
- wb.WorkbookPr = nil
- var codeName CodeName
- assert.NoError(t, f.GetWorkbookPrOptions(&codeName))
- assert.Equal(t, "", string(codeName))
- assert.NoError(t, f.SetWorkbookPrOptions(CodeName("code")))
- assert.NoError(t, f.GetWorkbookPrOptions(&codeName))
- assert.Equal(t, "code", string(codeName))
-
- wb.WorkbookPr = nil
- var filterPrivacy FilterPrivacy
- assert.NoError(t, f.GetWorkbookPrOptions(&filterPrivacy))
- assert.Equal(t, false, bool(filterPrivacy))
+ expected := WorkbookPropsOptions{
+ Date1904: boolPtr(true),
+ FilterPrivacy: boolPtr(true),
+ CodeName: stringPtr("code"),
+ }
+ assert.NoError(t, f.SetWorkbookProps(&expected))
+ opts, err := f.GetWorkbookProps()
+ assert.NoError(t, err)
+ assert.Equal(t, expected, opts)
}
diff --git a/xmlChart.go b/xmlChart.go
index dcd33e4a4b..53755f37ad 100644
--- a/xmlChart.go
+++ b/xmlChart.go
@@ -518,8 +518,8 @@ type cPageMargins struct {
T float64 `xml:"t,attr"`
}
-// formatChartAxis directly maps the format settings of the chart axis.
-type formatChartAxis struct {
+// chartAxisOptions directly maps the format settings of the chart axis.
+type chartAxisOptions struct {
None bool `json:"none"`
Crossing string `json:"crossing"`
MajorGridlines bool `json:"major_grid_lines"`
@@ -543,26 +543,27 @@ type formatChartAxis struct {
Italic bool `json:"italic"`
Underline bool `json:"underline"`
} `json:"num_font"`
- LogBase float64 `json:"logbase"`
- NameLayout formatLayout `json:"name_layout"`
+ LogBase float64 `json:"logbase"`
+ NameLayout layoutOptions `json:"name_layout"`
}
-type formatChartDimension struct {
+// chartDimensionOptions directly maps the dimension of the chart.
+type chartDimensionOptions struct {
Width int `json:"width"`
Height int `json:"height"`
}
-// formatChart directly maps the format settings of the chart.
-type formatChart struct {
- Type string `json:"type"`
- Series []formatChartSeries `json:"series"`
- Format formatPicture `json:"format"`
- Dimension formatChartDimension `json:"dimension"`
- Legend formatChartLegend `json:"legend"`
- Title formatChartTitle `json:"title"`
- VaryColors bool `json:"vary_colors"`
- XAxis formatChartAxis `json:"x_axis"`
- YAxis formatChartAxis `json:"y_axis"`
+// chartOptions directly maps the format settings of the chart.
+type chartOptions struct {
+ Type string `json:"type"`
+ Series []chartSeriesOptions `json:"series"`
+ Format pictureOptions `json:"format"`
+ Dimension chartDimensionOptions `json:"dimension"`
+ Legend chartLegendOptions `json:"legend"`
+ Title chartTitleOptions `json:"title"`
+ VaryColors bool `json:"vary_colors"`
+ XAxis chartAxisOptions `json:"x_axis"`
+ YAxis chartAxisOptions `json:"y_axis"`
Chartarea struct {
Border struct {
None bool `json:"none"`
@@ -594,7 +595,7 @@ type formatChart struct {
Fill struct {
Color string `json:"color"`
} `json:"fill"`
- Layout formatLayout `json:"layout"`
+ Layout layoutOptions `json:"layout"`
} `json:"plotarea"`
ShowBlanksAs string `json:"show_blanks_as"`
ShowHiddenData bool `json:"show_hidden_data"`
@@ -603,19 +604,19 @@ type formatChart struct {
order int
}
-// formatChartLegend directly maps the format settings of the chart legend.
-type formatChartLegend struct {
- None bool `json:"none"`
- DeleteSeries []int `json:"delete_series"`
- Font Font `json:"font"`
- Layout formatLayout `json:"layout"`
- Position string `json:"position"`
- ShowLegendEntry bool `json:"show_legend_entry"`
- ShowLegendKey bool `json:"show_legend_key"`
+// chartLegendOptions directly maps the format settings of the chart legend.
+type chartLegendOptions struct {
+ None bool `json:"none"`
+ DeleteSeries []int `json:"delete_series"`
+ Font Font `json:"font"`
+ Layout layoutOptions `json:"layout"`
+ Position string `json:"position"`
+ ShowLegendEntry bool `json:"show_legend_entry"`
+ ShowLegendKey bool `json:"show_legend_key"`
}
-// formatChartSeries directly maps the format settings of the chart series.
-type formatChartSeries struct {
+// chartSeriesOptions directly maps the format settings of the chart series.
+type chartSeriesOptions struct {
Name string `json:"name"`
Categories string `json:"categories"`
Values string `json:"values"`
@@ -640,16 +641,16 @@ type formatChartSeries struct {
} `json:"marker"`
}
-// formatChartTitle directly maps the format settings of the chart title.
-type formatChartTitle struct {
- None bool `json:"none"`
- Name string `json:"name"`
- Overlay bool `json:"overlay"`
- Layout formatLayout `json:"layout"`
+// chartTitleOptions directly maps the format settings of the chart title.
+type chartTitleOptions struct {
+ None bool `json:"none"`
+ Name string `json:"name"`
+ Overlay bool `json:"overlay"`
+ Layout layoutOptions `json:"layout"`
}
-// formatLayout directly maps the format settings of the element layout.
-type formatLayout struct {
+// layoutOptions directly maps the format settings of the element layout.
+type layoutOptions struct {
X float64 `json:"x"`
Y float64 `json:"y"`
Width float64 `json:"width"`
diff --git a/xmlComments.go b/xmlComments.go
index b4602fc928..731f416aaa 100644
--- a/xmlComments.go
+++ b/xmlComments.go
@@ -72,8 +72,8 @@ type xlsxPhoneticRun struct {
T string `xml:"t"`
}
-// formatComment directly maps the format settings of the comment.
-type formatComment struct {
+// commentOptions directly maps the format settings of the comment.
+type commentOptions struct {
Author string `json:"author"`
Text string `json:"text"`
}
diff --git a/xmlDrawing.go b/xmlDrawing.go
index fc8dee5890..6a2f79ddf5 100644
--- a/xmlDrawing.go
+++ b/xmlDrawing.go
@@ -493,8 +493,8 @@ type xdrTxBody struct {
P []*aP `xml:"a:p"`
}
-// formatPicture directly maps the format settings of the picture.
-type formatPicture struct {
+// pictureOptions directly maps the format settings of the picture.
+type pictureOptions struct {
FPrintsWithSheet bool `json:"print_obj"`
FLocksWithSheet bool `json:"locked"`
NoChangeAspect bool `json:"lock_aspect_ratio"`
@@ -508,33 +508,33 @@ type formatPicture struct {
Positioning string `json:"positioning"`
}
-// formatShape directly maps the format settings of the shape.
-type formatShape struct {
- Macro string `json:"macro"`
- Type string `json:"type"`
- Width int `json:"width"`
- Height int `json:"height"`
- Format formatPicture `json:"format"`
- Color formatShapeColor `json:"color"`
- Line formatLine `json:"line"`
- Paragraph []formatShapeParagraph `json:"paragraph"`
+// shapeOptions directly maps the format settings of the shape.
+type shapeOptions struct {
+ Macro string `json:"macro"`
+ Type string `json:"type"`
+ Width int `json:"width"`
+ Height int `json:"height"`
+ Format pictureOptions `json:"format"`
+ Color shapeColorOptions `json:"color"`
+ Line lineOptions `json:"line"`
+ Paragraph []shapeParagraphOptions `json:"paragraph"`
}
-// formatShapeParagraph directly maps the format settings of the paragraph in
+// shapeParagraphOptions directly maps the format settings of the paragraph in
// the shape.
-type formatShapeParagraph struct {
+type shapeParagraphOptions struct {
Font Font `json:"font"`
Text string `json:"text"`
}
-// formatShapeColor directly maps the color settings of the shape.
-type formatShapeColor struct {
+// shapeColorOptions directly maps the color settings of the shape.
+type shapeColorOptions struct {
Line string `json:"line"`
Fill string `json:"fill"`
Effect string `json:"effect"`
}
-// formatLine directly maps the line settings of the shape.
-type formatLine struct {
+// lineOptions directly maps the line settings of the shape.
+type lineOptions struct {
Width float64 `json:"width"`
}
diff --git a/xmlTable.go b/xmlTable.go
index 5a56a8330d..758e0ea27c 100644
--- a/xmlTable.go
+++ b/xmlTable.go
@@ -196,8 +196,8 @@ type xlsxTableStyleInfo struct {
ShowColumnStripes bool `xml:"showColumnStripes,attr"`
}
-// formatTable directly maps the format settings of the table.
-type formatTable struct {
+// tableOptions directly maps the format settings of the table.
+type tableOptions struct {
TableName string `json:"table_name"`
TableStyle string `json:"table_style"`
ShowFirstColumn bool `json:"show_first_column"`
@@ -206,8 +206,8 @@ type formatTable struct {
ShowColumnStripes bool `json:"show_column_stripes"`
}
-// formatAutoFilter directly maps the auto filter settings.
-type formatAutoFilter struct {
+// autoFilterOptions directly maps the auto filter settings.
+type autoFilterOptions struct {
Column string `json:"column"`
Expression string `json:"expression"`
FilterList []struct {
diff --git a/xmlWorkbook.go b/xmlWorkbook.go
index a0fce15f2e..dcfa6cad15 100644
--- a/xmlWorkbook.go
+++ b/xmlWorkbook.go
@@ -308,8 +308,15 @@ type xlsxCustomWorkbookView struct {
// DefinedName directly maps the name for a cell or cell range on a
// worksheet.
type DefinedName struct {
- Name string
- Comment string
- RefersTo string
- Scope string
+ Name string `json:"name,omitempty"`
+ Comment string `json:"comment,omitempty"`
+ RefersTo string `json:"refers_to,omitempty"`
+ Scope string `json:"scope,omitempty"`
+}
+
+// WorkbookPropsOptions directly maps the settings of workbook proprieties.
+type WorkbookPropsOptions struct {
+ Date1904 *bool `json:"date_1994,omitempty"`
+ FilterPrivacy *bool `json:"filter_privacy,omitempty"`
+ CodeName *string `json:"code_name,omitempty"`
}
diff --git a/xmlWorksheet.go b/xmlWorksheet.go
index af7c4f3be3..28e785f228 100644
--- a/xmlWorksheet.go
+++ b/xmlWorksheet.go
@@ -454,7 +454,11 @@ type DataValidation struct {
// b (Boolean) | Cell containing a boolean.
// d (Date) | Cell contains a date in the ISO 8601 format.
// e (Error) | Cell containing an error.
-// inlineStr (Inline String) | Cell containing an (inline) rich string, i.e., one not in the shared string table. If this cell type is used, then the cell value is in the is element rather than the v element in the cell (c element).
+// inlineStr (Inline String) | Cell containing an (inline) rich string, i.e.,
+// | one not in the shared string table. If this
+// | cell type is used, then the cell value is in
+// | the is element rather than the v element in
+// | the cell (c element).
// n (Number) | Cell containing a number.
// s (Shared String) | Cell containing a shared string.
// str (String) | Cell containing a formula string.
@@ -777,39 +781,39 @@ type xlsxX14Sparkline struct {
Sqref string `xml:"xm:sqref"`
}
-// SparklineOption directly maps the settings of the sparkline.
-type SparklineOption struct {
- Location []string
- Range []string
- Max int
- CustMax int
- Min int
- CustMin int
- Type string
- Weight float64
- DateAxis bool
- Markers bool
- High bool
- Low bool
- First bool
- Last bool
- Negative bool
- Axis bool
- Hidden bool
- Reverse bool
- Style int
- SeriesColor string
- NegativeColor string
- MarkersColor string
- FirstColor string
- LastColor string
- HightColor string
- LowColor string
- EmptyCells string
-}
-
-// formatPanes directly maps the settings of the panes.
-type formatPanes struct {
+// SparklineOptions directly maps the settings of the sparkline.
+type SparklineOptions struct {
+ Location []string `json:"location"`
+ Range []string `json:"range"`
+ Max int `json:"max"`
+ CustMax int `json:"cust_max"`
+ Min int `json:"min"`
+ CustMin int `json:"cust_min"`
+ Type string `json:"hype"`
+ Weight float64 `json:"weight"`
+ DateAxis bool `json:"date_axis"`
+ Markers bool `json:"markers"`
+ High bool `json:"high"`
+ Low bool `json:"low"`
+ First bool `json:"first"`
+ Last bool `json:"last"`
+ Negative bool `json:"negative"`
+ Axis bool `json:"axis"`
+ Hidden bool `json:"hidden"`
+ Reverse bool `json:"reverse"`
+ Style int `json:"style"`
+ SeriesColor string `json:"series_color"`
+ NegativeColor string `json:"negative_color"`
+ MarkersColor string `json:"markers_color"`
+ FirstColor string `json:"first_color"`
+ LastColor string `json:"last_color"`
+ HightColor string `json:"hight_color"`
+ LowColor string `json:"low_color"`
+ EmptyCells string `json:"empty_cells"`
+}
+
+// panesOptions directly maps the settings of the panes.
+type panesOptions struct {
Freeze bool `json:"freeze"`
Split bool `json:"split"`
XSplit int `json:"x_split"`
@@ -823,8 +827,8 @@ type formatPanes struct {
} `json:"panes"`
}
-// formatConditional directly maps the conditional format settings of the cells.
-type formatConditional struct {
+// conditionalOptions directly maps the conditional format settings of the cells.
+type conditionalOptions struct {
Type string `json:"type"`
AboveAverage bool `json:"above_average,omitempty"`
Percent bool `json:"percent,omitempty"`
@@ -848,47 +852,163 @@ type formatConditional struct {
BarColor string `json:"bar_color,omitempty"`
}
-// FormatSheetProtection directly maps the settings of worksheet protection.
-type FormatSheetProtection struct {
- AlgorithmName string
- AutoFilter bool
- DeleteColumns bool
- DeleteRows bool
- EditObjects bool
- EditScenarios bool
- FormatCells bool
- FormatColumns bool
- FormatRows bool
- InsertColumns bool
- InsertHyperlinks bool
- InsertRows bool
- Password string
- PivotTables bool
- SelectLockedCells bool
- SelectUnlockedCells bool
- Sort bool
-}
-
-// FormatHeaderFooter directly maps the settings of header and footer.
-type FormatHeaderFooter struct {
- AlignWithMargins bool
- DifferentFirst bool
- DifferentOddEven bool
- ScaleWithDoc bool
- OddHeader string
- OddFooter string
- EvenHeader string
- EvenFooter string
- FirstHeader string
- FirstFooter string
-}
-
-// FormatPageMargins directly maps the settings of page margins
-type FormatPageMargins struct {
- Bottom string
- Footer string
- Header string
- Left string
- Right string
- Top string
+// SheetProtectionOptions directly maps the settings of worksheet protection.
+type SheetProtectionOptions struct {
+ AlgorithmName string `json:"algorithm_name,omitempty"`
+ AutoFilter bool `json:"auto_filter,omitempty"`
+ DeleteColumns bool `json:"delete_columns,omitempty"`
+ DeleteRows bool `json:"delete_rows,omitempty"`
+ EditObjects bool `json:"edit_objects,omitempty"`
+ EditScenarios bool `json:"edit_scenarios,omitempty"`
+ FormatCells bool `json:"format_cells,omitempty"`
+ FormatColumns bool `json:"format_columns,omitempty"`
+ FormatRows bool `json:"format_rows,omitempty"`
+ InsertColumns bool `json:"insert_columns,omitempty"`
+ InsertHyperlinks bool `json:"insert_hyperlinks,omitempty"`
+ InsertRows bool `json:"insert_rows,omitempty"`
+ Password string `json:"password,omitempty"`
+ PivotTables bool `json:"pivot_tables,omitempty"`
+ SelectLockedCells bool `json:"select_locked_cells,omitempty"`
+ SelectUnlockedCells bool `json:"select_unlocked_cells,omitempty"`
+ Sort bool `json:"sort,omitempty"`
+}
+
+// HeaderFooterOptions directly maps the settings of header and footer.
+type HeaderFooterOptions struct {
+ AlignWithMargins bool `json:"align_with_margins,omitempty"`
+ DifferentFirst bool `json:"different_first,omitempty"`
+ DifferentOddEven bool `json:"different_odd_even,omitempty"`
+ ScaleWithDoc bool `json:"scale_with_doc,omitempty"`
+ OddHeader string `json:"odd_header,omitempty"`
+ OddFooter string `json:"odd_footer,omitempty"`
+ EvenHeader string `json:"even_header,omitempty"`
+ EvenFooter string `json:"even_footer,omitempty"`
+ FirstHeader string `json:"first_header,omitempty"`
+ FirstFooter string `json:"first_footer,omitempty"`
+}
+
+// PageLayoutMarginsOptions directly maps the settings of page layout margins.
+type PageLayoutMarginsOptions struct {
+ Bottom *float64 `json:"bottom,omitempty"`
+ Footer *float64 `json:"footer,omitempty"`
+ Header *float64 `json:"header,omitempty"`
+ Left *float64 `json:"left,omitempty"`
+ Right *float64 `json:"right,omitempty"`
+ Top *float64 `json:"top,omitempty"`
+ Horizontally *bool `json:"horizontally,omitempty"`
+ Vertically *bool `json:"vertically,omitempty"`
+}
+
+// PageLayoutOptions directly maps the settings of page layout.
+type PageLayoutOptions struct {
+ // Size defines the paper size of the worksheet.
+ Size *int `json:"size,omitempty"`
+ // Orientation defines the orientation of page layout for a worksheet.
+ Orientation *string `json:"orientation,omitempty"`
+ // FirstPageNumber specified the first printed page number. If no value is
+ // specified, then 'automatic' is assumed.
+ FirstPageNumber *uint `json:"first_page_number,omitempty"`
+ // AdjustTo defines the print scaling. This attribute is restricted to
+ // value ranging from 10 (10%) to 400 (400%). This setting is overridden
+ // when fitToWidth and/or fitToHeight are in use.
+ AdjustTo *uint `json:"adjust_to,omitempty"`
+ // FitToHeight specified the number of vertical pages to fit on.
+ FitToHeight *int `json:"fit_to_height,omitempty"`
+ // FitToWidth specified the number of horizontal pages to fit on.
+ FitToWidth *int `json:"fit_to_width,omitempty"`
+ // BlackAndWhite specified print black and white.
+ BlackAndWhite *bool `json:"black_and_white,omitempty"`
+}
+
+// ViewOptions directly maps the settings of sheet view.
+type ViewOptions struct {
+ // DefaultGridColor indicating that the consuming application should use
+ // the default grid lines color(system dependent). Overrides any color
+ // specified in colorId.
+ DefaultGridColor *bool `json:"default_grid_color,omitempty"`
+ // RightToLeft indicating whether the sheet is in 'right to left' display
+ // mode. When in this mode, Column A is on the far right, Column B; is one
+ // column left of Column A, and so on. Also, information in cells is
+ // displayed in the Right to Left format.
+ RightToLeft *bool `json:"right_to_left,omitempty"`
+ // ShowFormulas indicating whether this sheet should display formulas.
+ ShowFormulas *bool `json:"show_formulas,omitempty"`
+ // ShowGridLines indicating whether this sheet should display grid lines.
+ ShowGridLines *bool `json:"show_grid_lines,omitempty"`
+ // ShowRowColHeaders indicating whether the sheet should display row and
+ // column headings.
+ ShowRowColHeaders *bool `json:"show_row_col_headers,omitempty"`
+ // ShowRuler indicating this sheet should display ruler.
+ ShowRuler *bool `json:"show_ruler,omitempty"`
+ // ShowZeros indicating whether to "show a zero in cells that have zero
+ // value". When using a formula to reference another cell which is empty,
+ // the referenced value becomes 0 when the flag is true. (Default setting
+ // is true.)
+ ShowZeros *bool `json:"show_zeros,omitempty"`
+ // TopLeftCell specifies a location of the top left visible cell Location
+ // of the top left visible cell in the bottom right pane (when in
+ // Left-to-Right mode).
+ TopLeftCell *string `json:"top_left_cell,omitempty"`
+ // View indicating how sheet is displayed, by default it uses empty string
+ // available options: normal, pageLayout, pageBreakPreview
+ View *string `json:"low_color,omitempty"`
+ // ZoomScale specifies a window zoom magnification for current view
+ // representing percent values. This attribute is restricted to values
+ // ranging from 10 to 400. Horizontal & Vertical scale together.
+ ZoomScale *float64 `json:"zoom_scale,omitempty"`
+}
+
+// SheetPropsOptions directly maps the settings of sheet view.
+type SheetPropsOptions struct {
+ // Specifies a stable name of the sheet, which should not change over time,
+ // and does not change from user input. This name should be used by code
+ // to reference a particular sheet.
+ CodeName *string `json:"code_name,omitempty"`
+ // EnableFormatConditionsCalculation indicating whether the conditional
+ // formatting calculations shall be evaluated. If set to false, then the
+ // min/max values of color scales or data bars or threshold values in Top N
+ // rules shall not be updated. Essentially the conditional
+ // formatting "calc" is off.
+ EnableFormatConditionsCalculation *bool `json:"enable_format_conditions_calculation,omitempty"`
+ // Published indicating whether the worksheet is published.
+ Published *bool `json:"published,omitempty"`
+ // AutoPageBreaks indicating whether the sheet displays Automatic Page
+ // Breaks.
+ AutoPageBreaks *bool `json:"auto_page_breaks,omitempty"`
+ // FitToPage indicating whether the Fit to Page print option is enabled.
+ FitToPage *bool `json:"fit_to_page,omitempty"`
+ // TabColorIndexed represents the indexed color value.
+ TabColorIndexed *int `json:"tab_color_indexed,omitempty"`
+ // TabColorRGB represents the standard Alpha Red Green Blue color value.
+ TabColorRGB *string `json:"tab_color_rgb,omitempty"`
+ // TabColorTheme represents the zero-based index into the collection,
+ // referencing a particular value expressed in the Theme part.
+ TabColorTheme *int `json:"tab_color_theme,omitempty"`
+ // TabColorTint specifies the tint value applied to the color.
+ TabColorTint *float64 `json:"tab_color_tint,omitempty"`
+ // OutlineSummaryBelow indicating whether summary rows appear below detail
+ // in an outline, when applying an outline.
+ OutlineSummaryBelow *bool `json:"outline_summary_below,omitempty"`
+ // BaseColWidth specifies the number of characters of the maximum digit
+ // width of the normal style's font. This value does not include margin
+ // padding or extra padding for grid lines. It is only the number of
+ // characters.
+ BaseColWidth *uint8 `json:"base_col_width,omitempty"`
+ // DefaultColWidth specifies the default column width measured as the
+ // number of characters of the maximum digit width of the normal style's
+ // font.
+ DefaultColWidth *float64 `json:"default_col_width,omitempty"`
+ // DefaultRowHeight specifies the default row height measured in point
+ // size. Optimization so we don't have to write the height on all rows.
+ // This can be written out if most rows have custom height, to achieve the
+ // optimization.
+ DefaultRowHeight *float64 `json:"default_row_height,omitempty"`
+ // CustomHeight specifies the custom height.
+ CustomHeight *bool `json:"custom_height,omitempty"`
+ // ZeroHeight specifies if rows are hidden.
+ ZeroHeight *bool `json:"zero_height,omitempty"`
+ // ThickTop specifies if rows have a thick top border by default.
+ ThickTop *bool `json:"thick_top,omitempty"`
+ // ThickBottom specifies if rows have a thick bottom border by default.
+ ThickBottom *bool `json:"thick_bottom,omitempty"`
}