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