Index: src/java/org/apache/poi/ss/usermodel/BorderFormatting.java =================================================================== --- src/java/org/apache/poi/ss/usermodel/BorderFormatting.java (revision 1737757) +++ src/java/org/apache/poi/ss/usermodel/BorderFormatting.java (working copy) @@ -24,44 +24,86 @@ * of Conditional Formatting settings */ public interface BorderFormatting { - /** No border */ + /** No border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_NONE = 0x0; - /** Thin border */ + + /** Thin border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_THIN = 0x1; - /** Medium border */ + + /** Medium border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_MEDIUM = 0x2; - /** dash border */ + + /** dash border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_DASHED = 0x3; - /** dot border */ - short BORDER_HAIR = 0x4; - /** Thick border */ + + /** dot border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ + short BORDER_DOTTED = 0x4; + + /** Thick border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_THICK = 0x5; - /** double-line border */ + + /** double-line border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_DOUBLE = 0x6; - /** hair-line border */ - short BORDER_DOTTED = 0x7; - /** Medium dashed border */ + + /** hair-line border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ + short BORDER_HAIR = 0x7; + + /** Medium dashed border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_MEDIUM_DASHED = 0x8; - /** dash-dot border */ + + + /** dash-dot border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_DASH_DOT = 0x9; - /** medium dash-dot border */ + + /** medium dash-dot border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_MEDIUM_DASH_DOT = 0xA; - /** dash-dot-dot border */ + + /** dash-dot-dot border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_DASH_DOT_DOT = 0xB; - /** medium dash-dot-dot border */ + + /** medium dash-dot-dot border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_MEDIUM_DASH_DOT_DOT = 0xC; - /** slanted dash-dot border */ + + /** slanted dash-dot border + * @deprecated 3.15 beta 1. Use {@link BorderStyle} + */ short BORDER_SLANTED_DASH_DOT = 0xD; - short getBorderBottom(); + BorderStyle getBorderBottom(); - short getBorderDiagonal(); + BorderStyle getBorderDiagonal(); - short getBorderLeft(); + BorderStyle getBorderLeft(); - short getBorderRight(); + BorderStyle getBorderRight(); - short getBorderTop(); + BorderStyle getBorderTop(); short getBottomBorderColor(); Color getBottomBorderColorColor(); @@ -78,35 +120,80 @@ short getTopBorderColor(); Color getTopBorderColorColor(); + /** + * Set bottom border. + * + * @param border MUST be a BORDER_* constant + * @deprecated 3.15 beta 1 + */ void setBorderBottom(short border); /** + * Set bottom border. + * + * @param border + */ + void setBorderBottom(BorderStyle border); + + /** * Set diagonal border. * * @param border MUST be a BORDER_* constant + * @deprecated 3.15 beta 1 */ void setBorderDiagonal(short border); + + /** + * Set diagonal border. + * + * @param border + */ + void setBorderDiagonal(BorderStyle border); /** * Set left border. * * @param border MUST be a BORDER_* constant + * @deprecated 3.15 beta 1 */ void setBorderLeft(short border); + + /** + * Set left border. + * + * @param border + */ + void setBorderLeft(BorderStyle border); /** * Set right border. * * @param border MUST be a BORDER_* constant + * @deprecated 3.15 beta 1 */ void setBorderRight(short border); + + /** + * Set right border. + * + * @param border + */ + void setBorderRight(BorderStyle border); /** * Set top border. * * @param border MUST be a BORDER_* constant + * @deprecated 3.15 beta 1 */ void setBorderTop(short border); + + /** + * Set top border. + * + * @param border + */ + void setBorderTop(BorderStyle border); void setBottomBorderColor(short color); void setBottomBorderColor(Color color); Index: src/java/org/apache/poi/ss/usermodel/CellStyle.java =================================================================== --- src/java/org/apache/poi/ss/usermodel/CellStyle.java (revision 1737757) +++ src/java/org/apache/poi/ss/usermodel/CellStyle.java (working copy) @@ -87,84 +87,98 @@ /** * No border + * @deprecated Use {@link BorderStyle} */ short BORDER_NONE = 0x0; /** * Thin border + * @deprecated Use {@link BorderStyle} */ short BORDER_THIN = 0x1; /** * Medium border + * @deprecated Use {@link BorderStyle} */ short BORDER_MEDIUM = 0x2; /** * dash border + * @deprecated Use {@link BorderStyle} */ short BORDER_DASHED = 0x3; /** * dot border + * @deprecated Use {@link BorderStyle} */ short BORDER_DOTTED = 0x4; /** * Thick border + * @deprecated Use {@link BorderStyle} */ short BORDER_THICK = 0x5; /** * double-line border + * @deprecated Use {@link BorderStyle} */ short BORDER_DOUBLE = 0x6; /** * hair-line border + * @deprecated Use {@link BorderStyle} */ short BORDER_HAIR = 0x7; /** * Medium dashed border + * @deprecated Use {@link BorderStyle} */ short BORDER_MEDIUM_DASHED = 0x8; /** * dash-dot border + * @deprecated Use {@link BorderStyle} */ short BORDER_DASH_DOT = 0x9; /** * medium dash-dot border + * @deprecated Use {@link BorderStyle} */ short BORDER_MEDIUM_DASH_DOT = 0xA; /** * dash-dot-dot border + * @deprecated Use {@link BorderStyle} */ short BORDER_DASH_DOT_DOT = 0xB; /** * medium dash-dot-dot border + * @deprecated Use {@link BorderStyle} */ short BORDER_MEDIUM_DASH_DOT_DOT = 0xC; /** * slanted dash-dot border + * @deprecated Use {@link BorderStyle} */ short BORDER_SLANTED_DASH_DOT = 0xD; @@ -416,31 +430,22 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ - void setBorderLeft(short border); + + /** + * set the type of border to use for the left border of the cell + * @param border type + */ + void setBorderLeft(BorderStyle border); /** * get the type of border to use for the left border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ + BorderStyle getBorderLeft(); - short getBorderLeft(); - /** * set the type of border to use for the right border of the cell * @param border type @@ -458,31 +463,22 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ - void setBorderRight(short border); + + /** + * set the type of border to use for the right border of the cell + * @param border type + */ + void setBorderRight(BorderStyle border); /** * get the type of border to use for the right border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ + BorderStyle getBorderRight(); - short getBorderRight(); - /** * set the type of border to use for the top border of the cell * @param border type @@ -500,31 +496,22 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ - void setBorderTop(short border); + + /** + * set the type of border to use for the top border of the cell + * @param border type + */ + void setBorderTop(BorderStyle border); /** * get the type of border to use for the top border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ + BorderStyle getBorderTop(); - short getBorderTop(); - /** * set the type of border to use for the bottom border of the cell * @param border type @@ -542,29 +529,21 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ - void setBorderBottom(short border); + + /** + * set the type of border to use for the bottom border of the cell + * @param border type + */ + void setBorderBottom(BorderStyle border); /** * get the type of border to use for the bottom border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ - short getBorderBottom(); + BorderStyle getBorderBottom(); /** * set the color to use for the left border Index: src/java/org/apache/poi/ss/usermodel/BorderStyle.java =================================================================== --- src/java/org/apache/poi/ss/usermodel/BorderStyle.java (revision 1737757) +++ src/java/org/apache/poi/ss/usermodel/BorderStyle.java (working copy) @@ -19,13 +19,13 @@ /** * The enumeration value indicating the line style of a border in a cell, - * i.e., whether it is borded dash dot, dash dot dot, dashed, dotted, double, hair, medium, + * i.e., whether it is bordered dash dot, dash dot dot, dashed, dotted, double, hair, medium, * medium dash dot, medium dash dot dot, medium dashed, none, slant dash dot, thick or thin. */ public enum BorderStyle { /** - * No border + * No border (default) */ NONE(0x0), @@ -88,22 +88,36 @@ * medium dash-dot-dot border * @deprecated POI 3.15 beta 1. Use {@link MEDIUM_DASH_DOT_DOT} instead. */ - MEDIUM_DASH_DOT_DOTC(0xC), + //MEDIUM_DASH_DOT_DOTC(0xC), + + /** + * medium dash-dot-dot border + */ MEDIUM_DASH_DOT_DOT(0xC), /** * slanted dash-dot border */ SLANTED_DASH_DOT(0xD); - - + private final short code; - BorderStyle(int code) { + private BorderStyle(int code) { this.code = (short)code; } public short getCode() { return code; } + + private static final BorderStyle[] _table = new BorderStyle[0xD + 1]; + static { + for (BorderStyle c : values()) { + _table[c.getCode()] = c; + } + } + + public static BorderStyle valueOf(short code) { + return _table[code]; + } } Index: src/java/org/apache/poi/ss/util/CellUtil.java =================================================================== --- src/java/org/apache/poi/ss/util/CellUtil.java (revision 1737757) +++ src/java/org/apache/poi/ss/util/CellUtil.java (working copy) @@ -22,6 +22,7 @@ import java.util.Locale; import java.util.Map; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.Font; @@ -277,10 +278,10 @@ private static Map getFormatProperties(CellStyle style) { Map properties = new HashMap(); putShort(properties, ALIGNMENT, style.getAlignment()); - putShort(properties, BORDER_BOTTOM, style.getBorderBottom()); - putShort(properties, BORDER_LEFT, style.getBorderLeft()); - putShort(properties, BORDER_RIGHT, style.getBorderRight()); - putShort(properties, BORDER_TOP, style.getBorderTop()); + putBorderStyle(properties, BORDER_BOTTOM, style.getBorderBottom()); + putBorderStyle(properties, BORDER_LEFT, style.getBorderLeft()); + putBorderStyle(properties, BORDER_RIGHT, style.getBorderRight()); + putBorderStyle(properties, BORDER_TOP, style.getBorderTop()); putShort(properties, BOTTOM_BORDER_COLOR, style.getBottomBorderColor()); putShort(properties, DATA_FORMAT, style.getDataFormat()); putShort(properties, FILL_BACKGROUND_COLOR, style.getFillBackgroundColor()); @@ -309,10 +310,10 @@ */ private static void setFormatProperties(CellStyle style, Workbook workbook, Map properties) { style.setAlignment(getShort(properties, ALIGNMENT)); - style.setBorderBottom(getShort(properties, BORDER_BOTTOM)); - style.setBorderLeft(getShort(properties, BORDER_LEFT)); - style.setBorderRight(getShort(properties, BORDER_RIGHT)); - style.setBorderTop(getShort(properties, BORDER_TOP)); + style.setBorderBottom(getBorderStyle(properties, BORDER_BOTTOM)); + style.setBorderLeft(getBorderStyle(properties, BORDER_LEFT)); + style.setBorderRight(getBorderStyle(properties, BORDER_RIGHT)); + style.setBorderTop(getBorderStyle(properties, BORDER_TOP)); style.setBottomBorderColor(getShort(properties, BOTTOM_BORDER_COLOR)); style.setDataFormat(getShort(properties, DATA_FORMAT)); style.setFillBackgroundColor(getShort(properties, FILL_BACKGROUND_COLOR)); @@ -345,6 +346,18 @@ } return 0; } + + /** + * Utility method that returns the named BorderStyle value form the given map. + * + * @param properties map of named properties (String -> Object) + * @param name property name + * @return Border style if set, otherwise {@link BorderStyle#NONE} + */ + private static BorderStyle getBorderStyle(Map properties, String name) { + BorderStyle value = (BorderStyle) properties.get(name); + return (value != null) ? value : BorderStyle.NONE; + } /** * Utility method that returns the named boolean value form the given map. @@ -373,6 +386,17 @@ private static void putShort(Map properties, String name, short value) { properties.put(name, Short.valueOf(value)); } + + /** + * Utility method that puts the named short value to the given map. + * + * @param properties map of properties (String -> Object) + * @param name property name + * @param value property value + */ + private static void putBorderStyle(Map properties, String name, BorderStyle border) { + properties.put(name, border); + } /** * Utility method that puts the named boolean value to the given map. Index: src/java/org/apache/poi/hssf/usermodel/HSSFCellStyle.java =================================================================== --- src/java/org/apache/poi/hssf/usermodel/HSSFCellStyle.java (revision 1737757) +++ src/java/org/apache/poi/hssf/usermodel/HSSFCellStyle.java (working copy) @@ -26,6 +26,7 @@ import org.apache.poi.hssf.record.FormatRecord; import org.apache.poi.hssf.record.StyleRecord; import org.apache.poi.hssf.util.HSSFColor; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.Font; @@ -410,6 +411,7 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ @Override public void setBorderLeft(short border) @@ -417,29 +419,25 @@ _format.setIndentNotParentBorder(true); _format.setBorderLeft(border); } + + /** + * set the type of border to use for the left border of the cell + * @param border type + */ + @Override + public void setBorderLeft(BorderStyle border) + { + setBorderLeft(border.getCode()); + } /** * get the type of border to use for the left border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ @Override - public short getBorderLeft() + public BorderStyle getBorderLeft() { - return _format.getBorderLeft(); + return BorderStyle.valueOf(_format.getBorderLeft()); } /** @@ -459,6 +457,7 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ @Override public void setBorderRight(short border) @@ -466,29 +465,25 @@ _format.setIndentNotParentBorder(true); _format.setBorderRight(border); } + + /** + * set the type of border to use for the right border of the cell + * @param border type + */ + @Override + public void setBorderRight(BorderStyle border) + { + setBorderRight(border.getCode()); + } /** * get the type of border to use for the right border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ @Override - public short getBorderRight() + public BorderStyle getBorderRight() { - return _format.getBorderRight(); + return BorderStyle.valueOf(_format.getBorderRight()); } /** @@ -508,6 +503,7 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ @Override public void setBorderTop(short border) @@ -515,29 +511,25 @@ _format.setIndentNotParentBorder(true); _format.setBorderTop(border); } + + /** + * set the type of border to use for the top border of the cell + * @param border type + */ + @Override + public void setBorderTop(BorderStyle border) + { + setBorderTop(border.getCode()); + } /** * get the type of border to use for the top border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ @Override - public short getBorderTop() + public BorderStyle getBorderTop() { - return _format.getBorderTop(); + return BorderStyle.valueOf(_format.getBorderTop()); } /** @@ -557,6 +549,7 @@ * @see #BORDER_DASH_DOT_DOT * @see #BORDER_MEDIUM_DASH_DOT_DOT * @see #BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ @Override public void setBorderBottom(short border) @@ -564,29 +557,25 @@ _format.setIndentNotParentBorder(true); _format.setBorderBottom(border); } + + /** + * set the type of border to use for the bottom border of the cell + * @param border type + */ + @Override + public void setBorderBottom(BorderStyle border) + { + setBorderBottom(border.getCode()); + } /** * get the type of border to use for the bottom border of the cell * @return border type - * @see #BORDER_NONE - * @see #BORDER_THIN - * @see #BORDER_MEDIUM - * @see #BORDER_DASHED - * @see #BORDER_DOTTED - * @see #BORDER_THICK - * @see #BORDER_DOUBLE - * @see #BORDER_HAIR - * @see #BORDER_MEDIUM_DASHED - * @see #BORDER_DASH_DOT - * @see #BORDER_MEDIUM_DASH_DOT - * @see #BORDER_DASH_DOT_DOT - * @see #BORDER_MEDIUM_DASH_DOT_DOT - * @see #BORDER_SLANTED_DASH_DOT */ @Override - public short getBorderBottom() + public BorderStyle getBorderBottom() { - return _format.getBorderBottom(); + return BorderStyle.valueOf(_format.getBorderBottom()); } /** Index: src/java/org/apache/poi/hssf/usermodel/HSSFBorderFormatting.java =================================================================== --- src/java/org/apache/poi/hssf/usermodel/HSSFBorderFormatting.java (revision 1737757) +++ src/java/org/apache/poi/hssf/usermodel/HSSFBorderFormatting.java (working copy) @@ -20,6 +20,7 @@ import org.apache.poi.hssf.record.CFRuleBase; import org.apache.poi.hssf.record.cf.BorderFormatting; import org.apache.poi.hssf.util.HSSFColor; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.Color; /** @@ -41,65 +42,80 @@ return borderFormatting; } - public short getBorderBottom() { - return (short)borderFormatting.getBorderBottom(); + @Override + public BorderStyle getBorderBottom() { + return BorderStyle.valueOf((short)borderFormatting.getBorderBottom()); } - public short getBorderDiagonal() { - return (short)borderFormatting.getBorderDiagonal(); + @Override + public BorderStyle getBorderDiagonal() { + return BorderStyle.valueOf((short)borderFormatting.getBorderDiagonal()); } - public short getBorderLeft() { - return (short)borderFormatting.getBorderLeft(); + @Override + public BorderStyle getBorderLeft() { + return BorderStyle.valueOf((short)borderFormatting.getBorderLeft()); } - public short getBorderRight() { - return (short)borderFormatting.getBorderRight(); + @Override + public BorderStyle getBorderRight() { + return BorderStyle.valueOf((short)borderFormatting.getBorderRight()); } - public short getBorderTop() { - return (short)borderFormatting.getBorderTop(); + @Override + public BorderStyle getBorderTop() { + return BorderStyle.valueOf((short)borderFormatting.getBorderTop()); } + @Override public short getBottomBorderColor() { return (short)borderFormatting.getBottomBorderColor(); } + @Override public HSSFColor getBottomBorderColorColor() { return workbook.getCustomPalette().getColor( borderFormatting.getBottomBorderColor() ); } + @Override public short getDiagonalBorderColor() { return (short)borderFormatting.getDiagonalBorderColor(); } + @Override public HSSFColor getDiagonalBorderColorColor() { return workbook.getCustomPalette().getColor( borderFormatting.getDiagonalBorderColor() ); } + @Override public short getLeftBorderColor() { return (short)borderFormatting.getLeftBorderColor(); } + @Override public HSSFColor getLeftBorderColorColor() { return workbook.getCustomPalette().getColor( borderFormatting.getLeftBorderColor() ); } + @Override public short getRightBorderColor() { return (short)borderFormatting.getRightBorderColor(); } + @Override public HSSFColor getRightBorderColorColor() { return workbook.getCustomPalette().getColor( borderFormatting.getRightBorderColor() ); } + @Override public short getTopBorderColor() { return (short)borderFormatting.getTopBorderColor(); } + @Override public HSSFColor getTopBorderColorColor() { return workbook.getCustomPalette().getColor( borderFormatting.getTopBorderColor() @@ -126,6 +142,7 @@ } } + @Override public void setBorderBottom(short border) { borderFormatting.setBorderBottom(border); if (border != 0) { @@ -134,7 +151,12 @@ cfRuleRecord.setBottomBorderModified(false); } } + @Override + public void setBorderBottom(BorderStyle border) { + setBorderBottom(border.getCode()); + } + @Override public void setBorderDiagonal(short border) { borderFormatting.setBorderDiagonal(border); if (border != 0) { @@ -145,7 +167,12 @@ cfRuleRecord.setTopLeftBottomRightBorderModified(false); } } + @Override + public void setBorderDiagonal(BorderStyle border) { + setBorderDiagonal(border.getCode()); + } + @Override public void setBorderLeft(short border) { borderFormatting.setBorderLeft(border); if (border != 0) { @@ -154,7 +181,12 @@ cfRuleRecord.setLeftBorderModified(false); } } + @Override + public void setBorderLeft(BorderStyle border) { + setBorderLeft(border.getCode()); + } + @Override public void setBorderRight(short border) { borderFormatting.setBorderRight(border); if (border != 0) { @@ -163,7 +195,12 @@ cfRuleRecord.setRightBorderModified(false); } } + @Override + public void setBorderRight(BorderStyle border) { + setBorderRight(border.getCode()); + } + @Override public void setBorderTop(short border) { borderFormatting.setBorderTop(border); if (border != 0) { @@ -172,7 +209,12 @@ cfRuleRecord.setTopBorderModified(false); } } + @Override + public void setBorderTop(BorderStyle border) { + setBorderTop(border.getCode()); + } + @Override public void setBottomBorderColor(short color) { borderFormatting.setBottomBorderColor(color); if (color != 0) { @@ -190,6 +232,7 @@ } } + @Override public void setDiagonalBorderColor(short color) { borderFormatting.setDiagonalBorderColor(color); if (color != 0) { @@ -200,6 +243,7 @@ cfRuleRecord.setTopLeftBottomRightBorderModified(false); } } + @Override public void setDiagonalBorderColor(Color color) { HSSFColor hcolor = HSSFColor.toHSSFColor(color); if (hcolor == null) { @@ -209,6 +253,7 @@ } } + @Override public void setLeftBorderColor(short color) { borderFormatting.setLeftBorderColor(color); if (color != 0) { @@ -217,6 +262,7 @@ cfRuleRecord.setLeftBorderModified(false); } } + @Override public void setLeftBorderColor(Color color) { HSSFColor hcolor = HSSFColor.toHSSFColor(color); if (hcolor == null) { @@ -226,6 +272,7 @@ } } + @Override public void setRightBorderColor(short color) { borderFormatting.setRightBorderColor(color); if (color != 0) { @@ -234,6 +281,7 @@ cfRuleRecord.setRightBorderModified(false); } } + @Override public void setRightBorderColor(Color color) { HSSFColor hcolor = HSSFColor.toHSSFColor(color); if (hcolor == null) { @@ -243,6 +291,7 @@ } } + @Override public void setTopBorderColor(short color) { borderFormatting.setTopBorderColor(color); if (color != 0) { @@ -251,6 +300,7 @@ cfRuleRecord.setTopBorderModified(false); } } + @Override public void setTopBorderColor(Color color) { HSSFColor hcolor = HSSFColor.toHSSFColor(color); if (hcolor == null) { Index: src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFBorderFormatting.java =================================================================== --- src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFBorderFormatting.java (revision 1737757) +++ src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFBorderFormatting.java (working copy) @@ -17,6 +17,7 @@ package org.apache.poi.xssf.usermodel; import org.apache.poi.ss.usermodel.BorderFormatting; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.Color; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorder; import org.openxmlformats.schemas.spreadsheetml.x2006.main.STBorderStyle; @@ -34,126 +35,183 @@ _border = border; } - public short getBorderBottom() { + @Override + public BorderStyle getBorderBottom() { STBorderStyle.Enum ptrn = _border.isSetBottom() ? _border.getBottom().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } - public short getBorderDiagonal() { + @Override + public BorderStyle getBorderDiagonal() { STBorderStyle.Enum ptrn = _border.isSetDiagonal() ? _border.getDiagonal().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } - public short getBorderLeft() { + @Override + public BorderStyle getBorderLeft() { STBorderStyle.Enum ptrn = _border.isSetLeft() ? _border.getLeft().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } - public short getBorderRight() { + @Override + public BorderStyle getBorderRight() { STBorderStyle.Enum ptrn = _border.isSetRight() ? _border.getRight().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } - public short getBorderTop() { + @Override + public BorderStyle getBorderTop() { STBorderStyle.Enum ptrn = _border.isSetTop() ? _border.getTop().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } + @Override public XSSFColor getBottomBorderColorColor() { if(!_border.isSetBottom()) return null; CTBorderPr pr = _border.getBottom(); return new XSSFColor(pr.getColor()); } + @Override public short getBottomBorderColor() { XSSFColor color = getBottomBorderColorColor(); if (color == null) return 0; return color.getIndexed(); } + @Override public XSSFColor getDiagonalBorderColorColor() { if(!_border.isSetDiagonal()) return null; CTBorderPr pr = _border.getDiagonal(); return new XSSFColor(pr.getColor()); } + @Override public short getDiagonalBorderColor() { XSSFColor color = getDiagonalBorderColorColor(); if (color == null) return 0; return color.getIndexed(); } + @Override public XSSFColor getLeftBorderColorColor() { if(!_border.isSetLeft()) return null; CTBorderPr pr = _border.getLeft(); return new XSSFColor(pr.getColor()); } + @Override public short getLeftBorderColor() { XSSFColor color = getLeftBorderColorColor(); if (color == null) return 0; return color.getIndexed(); } + @Override public XSSFColor getRightBorderColorColor() { if(!_border.isSetRight()) return null; CTBorderPr pr = _border.getRight(); return new XSSFColor(pr.getColor()); } + @Override public short getRightBorderColor() { XSSFColor color = getRightBorderColorColor(); if (color == null) return 0; return color.getIndexed(); } + @Override public XSSFColor getTopBorderColorColor() { if(!_border.isSetTop()) return null; CTBorderPr pr = _border.getTop(); return new XSSFColor(pr.getColor()); } + @Override public short getTopBorderColor() { XSSFColor color = getRightBorderColorColor(); if (color == null) return 0; return color.getIndexed(); } + /** + * @deprecated 3.15 beta 1. Use {@link #setBorderBottom(BorderStyle)} + */ + @Override public void setBorderBottom(short border) { + setBorderBottom(BorderStyle.valueOf(border)); + } + @Override + public void setBorderBottom(BorderStyle border) { CTBorderPr pr = _border.isSetBottom() ? _border.getBottom() : _border.addNewBottom(); - if(border == BORDER_NONE) _border.unsetBottom(); - else pr.setStyle(STBorderStyle.Enum.forInt(border + 1)); + if(border == BorderStyle.NONE) _border.unsetBottom(); + else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1)); } + /** + * @deprecated 3.15 beta 1. Use {@link #setBorderDiagonal(BorderStyle)} + */ + @Override public void setBorderDiagonal(short border) { + setBorderDiagonal(BorderStyle.valueOf(border)); + } + @Override + public void setBorderDiagonal(BorderStyle border) { CTBorderPr pr = _border.isSetDiagonal() ? _border.getDiagonal() : _border.addNewDiagonal(); - if(border == BORDER_NONE) _border.unsetDiagonal(); - else pr.setStyle(STBorderStyle.Enum.forInt(border + 1)); + if(border == BorderStyle.NONE) _border.unsetDiagonal(); + else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1)); } + /** + * @deprecated 3.15 beta 1. Use {@link #setBorderLeft(BorderStyle)} + */ + @Override public void setBorderLeft(short border) { + setBorderLeft(BorderStyle.valueOf(border)); + } + @Override + public void setBorderLeft(BorderStyle border) { CTBorderPr pr = _border.isSetLeft() ? _border.getLeft() : _border.addNewLeft(); - if(border == BORDER_NONE) _border.unsetLeft(); - else pr.setStyle(STBorderStyle.Enum.forInt(border + 1)); + if(border == BorderStyle.NONE) _border.unsetLeft(); + else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1)); } + /** + * @deprecated 3.15 beta 1. Use {@link #setBorderRight(BorderStyle)} + */ + @Override public void setBorderRight(short border) { + setBorderRight(BorderStyle.valueOf(border)); + } + @Override + public void setBorderRight(BorderStyle border) { CTBorderPr pr = _border.isSetRight() ? _border.getRight() : _border.addNewRight(); - if(border == BORDER_NONE) _border.unsetRight(); - else pr.setStyle(STBorderStyle.Enum.forInt(border + 1)); + if(border == BorderStyle.NONE) _border.unsetRight(); + else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1)); } + /** + * @deprecated 3.15 beta 1. Use {@link #setBorderTop(BorderStyle)} + */ + @Override public void setBorderTop(short border) { + setBorderTop(BorderStyle.valueOf(border)); + } + @Override + public void setBorderTop(BorderStyle border) { CTBorderPr pr = _border.isSetTop() ? _border.getTop() : _border.addNewTop(); - if(border == BORDER_NONE) _border.unsetTop(); - else pr.setStyle(STBorderStyle.Enum.forInt(border + 1)); + if(border == BorderStyle.NONE) _border.unsetTop(); + else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1)); } + @Override public void setBottomBorderColor(Color color) { XSSFColor xcolor = XSSFColor.toXSSFColor(color); if (xcolor == null) setBottomBorderColor((CTColor)null); else setBottomBorderColor(xcolor.getCTColor()); } + @Override public void setBottomBorderColor(short color) { CTColor ctColor = CTColor.Factory.newInstance(); ctColor.setIndexed(color); @@ -168,11 +226,13 @@ } } + @Override public void setDiagonalBorderColor(Color color) { XSSFColor xcolor = XSSFColor.toXSSFColor(color); if (xcolor == null) setDiagonalBorderColor((CTColor)null); else setDiagonalBorderColor(xcolor.getCTColor()); } + @Override public void setDiagonalBorderColor(short color) { CTColor ctColor = CTColor.Factory.newInstance(); ctColor.setIndexed(color); @@ -187,11 +247,13 @@ } } + @Override public void setLeftBorderColor(Color color) { XSSFColor xcolor = XSSFColor.toXSSFColor(color); if (xcolor == null) setLeftBorderColor((CTColor)null); else setLeftBorderColor(xcolor.getCTColor()); } + @Override public void setLeftBorderColor(short color) { CTColor ctColor = CTColor.Factory.newInstance(); ctColor.setIndexed(color); @@ -206,11 +268,13 @@ } } + @Override public void setRightBorderColor(Color color) { XSSFColor xcolor = XSSFColor.toXSSFColor(color); if (xcolor == null) setRightBorderColor((CTColor)null); else setRightBorderColor(xcolor.getCTColor()); } + @Override public void setRightBorderColor(short color) { CTColor ctColor = CTColor.Factory.newInstance(); ctColor.setIndexed(color); @@ -225,11 +289,13 @@ } } + @Override public void setTopBorderColor(Color color) { XSSFColor xcolor = XSSFColor.toXSSFColor(color); if (xcolor == null) setTopBorderColor((CTColor)null); else setTopBorderColor(xcolor.getCTColor()); } + @Override public void setTopBorderColor(short color) { CTColor ctColor = CTColor.Factory.newInstance(); ctColor.setIndexed(color); Index: src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFCellStyle.java =================================================================== --- src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFCellStyle.java (revision 1737757) +++ src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFCellStyle.java (working copy) @@ -251,158 +251,113 @@ /** * Get the type of border to use for the bottom border of the cell * - * @return short - border type - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_NONE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_THIN - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOTTED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_THICK - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOUBLE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_HAIR - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#NONE} */ @Override - public short getBorderBottom() { - if(!_cellXf.getApplyBorder()) return BORDER_NONE; + public BorderStyle getBorderBottom() { + if(!_cellXf.getApplyBorder()) return BorderStyle.NONE; int idx = (int)_cellXf.getBorderId(); CTBorder ct = _stylesSource.getBorderAt(idx).getCTBorder(); STBorderStyle.Enum ptrn = ct.isSetBottom() ? ct.getBottom().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + if (ptrn == null) { + return BorderStyle.NONE; + } + return BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } /** * Get the type of border to use for the bottom border of the cell * * @return border type as Java enum - * @see BorderStyle + * @deprecated 3.15 beta 1. Use {@link #getBorderBottom} */ public BorderStyle getBorderBottomEnum() { - int style = getBorderBottom(); - return BorderStyle.values()[style]; + return getBorderBottom(); } /** * Get the type of border to use for the left border of the cell * - * @return short - border type, default value is {@link org.apache.poi.ss.usermodel.CellStyle#BORDER_NONE} - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_NONE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_THIN - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOTTED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_THICK - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOUBLE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_HAIR - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#NONE} */ @Override - public short getBorderLeft() { - if(!_cellXf.getApplyBorder()) return BORDER_NONE; + public BorderStyle getBorderLeft() { + if(!_cellXf.getApplyBorder()) return BorderStyle.NONE; int idx = (int)_cellXf.getBorderId(); CTBorder ct = _stylesSource.getBorderAt(idx).getCTBorder(); STBorderStyle.Enum ptrn = ct.isSetLeft() ? ct.getLeft().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + if (ptrn == null) { + return BorderStyle.NONE; + } + return BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } /** * Get the type of border to use for the left border of the cell * * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#NONE} + * @deprecated 3.15 beta 1. Use {@link #getBorderLeft} */ public BorderStyle getBorderLeftEnum() { - int style = getBorderLeft(); - return BorderStyle.values()[style]; + return getBorderLeft(); } /** * Get the type of border to use for the right border of the cell * - * @return short - border type, default value is {@link org.apache.poi.ss.usermodel.CellStyle#BORDER_NONE} - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_NONE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_THIN - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOTTED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_THICK - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOUBLE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_HAIR - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#NONE} */ @Override - public short getBorderRight() { - if(!_cellXf.getApplyBorder()) return BORDER_NONE; + public BorderStyle getBorderRight() { + if(!_cellXf.getApplyBorder()) return BorderStyle.NONE; int idx = (int)_cellXf.getBorderId(); CTBorder ct = _stylesSource.getBorderAt(idx).getCTBorder(); STBorderStyle.Enum ptrn = ct.isSetRight() ? ct.getRight().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + if (ptrn == null) { + return BorderStyle.NONE; + } + return BorderStyle.valueOf((short)(ptrn.intValue() - 1)); } /** * Get the type of border to use for the right border of the cell * * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#NONE} + * @deprecated 3.15 beta 1. Use {@link #getBorderRight} */ public BorderStyle getBorderRightEnum() { - int style = getBorderRight(); - return BorderStyle.values()[style]; + return getBorderRight(); } /** * Get the type of border to use for the top border of the cell * - * @return short - border type, default value is {@link org.apache.poi.ss.usermodel.CellStyle#BORDER_NONE} - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_NONE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_THIN - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOTTED - * @see org.apache.poi.ss.usermodel.CellStyle #BORDER_THICK - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DOUBLE - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_HAIR - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASHED - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT - * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#NONE} */ @Override - public short getBorderTop() { - if(!_cellXf.getApplyBorder()) return BORDER_NONE; + public BorderStyle getBorderTop() { + if(!_cellXf.getApplyBorder()) return BorderStyle.NONE; int idx = (int)_cellXf.getBorderId(); CTBorder ct = _stylesSource.getBorderAt(idx).getCTBorder(); STBorderStyle.Enum ptrn = ct.isSetTop() ? ct.getTop().getStyle() : null; - return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1); + if (ptrn == null) { + return BorderStyle.NONE; + } + return BorderStyle.valueOf((short) (ptrn.intValue() - 1)); } /** * Get the type of border to use for the top border of the cell * * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#NONE} + * @deprecated 3.15 beta 1. Use {@link #getBorderTop} */ public BorderStyle getBorderTopEnum() { - int style = getBorderTop(); - return BorderStyle.values()[style]; + return getBorderTop(); } /** @@ -849,6 +804,7 @@ * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ @Override public void setBorderBottom(short border) { @@ -869,8 +825,9 @@ * @param border - type of border to use * @see org.apache.poi.ss.usermodel.BorderStyle */ + @Override public void setBorderBottom(BorderStyle border) { - setBorderBottom((short)border.ordinal()); + setBorderBottom(border.getCode()); } /** @@ -890,6 +847,7 @@ * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ @Override public void setBorderLeft(short border) { @@ -909,8 +867,9 @@ * * @param border the type of border to use */ + @Override public void setBorderLeft(BorderStyle border) { - setBorderLeft((short)border.ordinal()); + setBorderLeft(border.getCode()); } /** @@ -931,6 +890,7 @@ * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ @Override public void setBorderRight(short border) { @@ -950,8 +910,9 @@ * * @param border the type of border to use */ + @Override public void setBorderRight(BorderStyle border) { - setBorderRight((short)border.ordinal()); + setBorderRight(border.getCode()); } /** @@ -972,9 +933,10 @@ * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_MEDIUM_DASH_DOT_DOT * @see org.apache.poi.ss.usermodel.CellStyle#BORDER_SLANTED_DASH_DOT + * @deprecated 3.15 beta 1 */ - @Override -public void setBorderTop(short border) { + @Override + public void setBorderTop(short border) { CTBorder ct = getCTBorder(); CTBorderPr pr = ct.isSetTop() ? ct.getTop() : ct.addNewTop(); if(border == BORDER_NONE) ct.unsetTop(); @@ -991,8 +953,9 @@ * * @param border the type of border to use */ + @Override public void setBorderTop(BorderStyle border) { - setBorderTop((short)border.ordinal()); + setBorderTop(border.getCode()); } /** Index: src/scratchpad/src/org/apache/poi/hssf/converter/ExcelToFoConverter.java =================================================================== --- src/scratchpad/src/org/apache/poi/hssf/converter/ExcelToFoConverter.java (revision 1737757) +++ src/scratchpad/src/org/apache/poi/hssf/converter/ExcelToFoConverter.java (working copy) @@ -38,6 +38,7 @@ import org.apache.poi.hwpf.converter.FoDocumentFacade; import org.apache.poi.hwpf.converter.FontReplacer.Triplet; import org.apache.poi.ss.formula.eval.ErrorEval; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.util.CellRangeAddress; import org.apache.poi.util.Beta; @@ -192,10 +193,10 @@ protected boolean isEmptyStyle( CellStyle cellStyle ) { return cellStyle == null || ( cellStyle.getFillPattern() == 0 - && cellStyle.getBorderTop() == HSSFCellStyle.BORDER_NONE - && cellStyle.getBorderRight() == HSSFCellStyle.BORDER_NONE - && cellStyle.getBorderBottom() == HSSFCellStyle.BORDER_NONE - && cellStyle.getBorderLeft() == HSSFCellStyle.BORDER_NONE + && cellStyle.getBorderTop() == BorderStyle.NONE + && cellStyle.getBorderRight() == BorderStyle.NONE + && cellStyle.getBorderBottom() == BorderStyle.NONE + && cellStyle.getBorderLeft() == BorderStyle.NONE ); } @@ -374,9 +375,9 @@ } protected void processCellStyleBorder( HSSFWorkbook workbook, - Element cellTarget, String type, short xlsBorder, short borderColor ) + Element cellTarget, String type, BorderStyle xlsBorder, short borderColor ) { - if ( xlsBorder == HSSFCellStyle.BORDER_NONE ) + if ( xlsBorder == BorderStyle.NONE ) return; StringBuilder borderStyle = new StringBuilder(); Index: src/scratchpad/src/org/apache/poi/hssf/converter/ExcelToHtmlConverter.java =================================================================== --- src/scratchpad/src/org/apache/poi/hssf/converter/ExcelToHtmlConverter.java (revision 1737757) +++ src/scratchpad/src/org/apache/poi/hssf/converter/ExcelToHtmlConverter.java (working copy) @@ -42,6 +42,7 @@ import org.apache.poi.hssf.util.HSSFColor; import org.apache.poi.hwpf.converter.HtmlDocumentFacade; import org.apache.poi.ss.formula.eval.ErrorEval; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.util.CellRangeAddress; import org.apache.poi.util.Beta; import org.apache.poi.util.POILogFactory; @@ -190,9 +191,9 @@ } private void buildStyle_border( HSSFWorkbook workbook, StringBuilder style, - String type, short xlsBorder, short borderColor ) + String type, BorderStyle xlsBorder, short borderColor ) { - if ( xlsBorder == HSSFCellStyle.BORDER_NONE ) { + if ( xlsBorder == BorderStyle.NONE ) { return; } Index: src/scratchpad/src/org/apache/poi/hssf/converter/AbstractExcelUtils.java =================================================================== --- src/scratchpad/src/org/apache/poi/hssf/converter/AbstractExcelUtils.java (revision 1737757) +++ src/scratchpad/src/org/apache/poi/hssf/converter/AbstractExcelUtils.java (working copy) @@ -25,6 +25,7 @@ import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.util.HSSFColor; import org.apache.poi.hwpf.converter.AbstractWordUtils; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.util.CellRangeAddress; import org.apache.poi.util.Beta; import org.apache.poi.util.IOUtils; @@ -66,28 +67,28 @@ } } - public static String getBorderStyle( short xlsBorder ) + public static String getBorderStyle( BorderStyle xlsBorder ) { final String borderStyle; switch ( xlsBorder ) { - case HSSFCellStyle.BORDER_NONE: + case NONE: borderStyle = "none"; break; - case HSSFCellStyle.BORDER_DASH_DOT: - case HSSFCellStyle.BORDER_DASH_DOT_DOT: - case HSSFCellStyle.BORDER_DOTTED: - case HSSFCellStyle.BORDER_HAIR: - case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT: - case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT: - case HSSFCellStyle.BORDER_SLANTED_DASH_DOT: + case DASH_DOT: + case DASH_DOT_DOT: + case DOTTED: + case HAIR: + case MEDIUM_DASH_DOT: + case MEDIUM_DASH_DOT_DOT: + case SLANTED_DASH_DOT: borderStyle = "dotted"; break; - case HSSFCellStyle.BORDER_DASHED: - case HSSFCellStyle.BORDER_MEDIUM_DASHED: + case DASHED: + case MEDIUM_DASHED: borderStyle = "dashed"; break; - case HSSFCellStyle.BORDER_DOUBLE: + case DOUBLE: borderStyle = "double"; break; default: @@ -97,17 +98,17 @@ return borderStyle; } - public static String getBorderWidth( short xlsBorder ) + public static String getBorderWidth( BorderStyle xlsBorder ) { final String borderWidth; switch ( xlsBorder ) { - case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT: - case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT: - case HSSFCellStyle.BORDER_MEDIUM_DASHED: + case MEDIUM_DASH_DOT: + case MEDIUM_DASH_DOT_DOT: + case MEDIUM_DASHED: borderWidth = "2pt"; break; - case HSSFCellStyle.BORDER_THICK: + case THICK: borderWidth = "thick"; break; default: Index: src/examples/src/org/apache/poi/hssf/view/SVBorder.java =================================================================== --- src/examples/src/org/apache/poi/hssf/view/SVBorder.java (revision 1737757) +++ src/examples/src/org/apache/poi/hssf/view/SVBorder.java (working copy) @@ -22,7 +22,7 @@ import javax.swing.border.AbstractBorder; -import org.apache.poi.hssf.usermodel.HSSFCellStyle; +import org.apache.poi.ss.usermodel.BorderStyle; /** * This is an attempt to implement Excel style borders for the SheetViewer. @@ -37,10 +37,10 @@ private Color eastColor = null; private Color southColor = null; private Color westColor = null; - private int northBorderType = HSSFCellStyle.BORDER_NONE; - private int eastBorderType =HSSFCellStyle.BORDER_NONE; - private int southBorderType = HSSFCellStyle.BORDER_NONE; - private int westBorderType = HSSFCellStyle.BORDER_NONE; + private BorderStyle northBorderType = BorderStyle.NONE; + private BorderStyle eastBorderType = BorderStyle.NONE; + private BorderStyle southBorderType = BorderStyle.NONE; + private BorderStyle westBorderType = BorderStyle.NONE; private boolean northBorder=false; private boolean eastBorder=false; private boolean southBorder=false; @@ -49,8 +49,8 @@ public void setBorder(Color northColor, Color eastColor, Color southColor, Color westColor, - int northBorderType, int eastBorderType, - int southBorderType, int westBorderType, + BorderStyle northBorderType, BorderStyle eastBorderType, + BorderStyle southBorderType, BorderStyle westBorderType, boolean selected) { this.eastColor = eastColor; this.southColor = southColor; @@ -59,10 +59,10 @@ this.eastBorderType = eastBorderType; this.southBorderType = southBorderType; this.westBorderType = westBorderType; - this.northBorder=northBorderType != HSSFCellStyle.BORDER_NONE; - this.eastBorder=eastBorderType != HSSFCellStyle.BORDER_NONE; - this.southBorder=southBorderType != HSSFCellStyle.BORDER_NONE; - this.westBorder=westBorderType != HSSFCellStyle.BORDER_NONE; + this.northBorder=northBorderType != BorderStyle.NONE; + this.eastBorder=eastBorderType != BorderStyle.NONE; + this.southBorder=southBorderType != BorderStyle.NONE; + this.westBorder=westBorderType != BorderStyle.NONE; this.selected = selected; } @@ -109,9 +109,9 @@ int height) { if (northBorder && - ((northBorderType == HSSFCellStyle.BORDER_THIN) || - (northBorderType == HSSFCellStyle.BORDER_MEDIUM) || - (northBorderType == HSSFCellStyle.BORDER_THICK) + ((northBorderType == BorderStyle.THIN) || + (northBorderType == BorderStyle.MEDIUM) || + (northBorderType == BorderStyle.THICK) ) ) { @@ -125,9 +125,9 @@ } if (eastBorder && - ((eastBorderType == HSSFCellStyle.BORDER_THIN) || - (eastBorderType == HSSFCellStyle.BORDER_MEDIUM) || - (eastBorderType == HSSFCellStyle.BORDER_THICK) + ((eastBorderType == BorderStyle.THIN) || + (eastBorderType == BorderStyle.MEDIUM) || + (eastBorderType == BorderStyle.THICK) ) ) { @@ -141,9 +141,9 @@ } if (southBorder && - ((southBorderType == HSSFCellStyle.BORDER_THIN) || - (southBorderType == HSSFCellStyle.BORDER_MEDIUM) || - (southBorderType == HSSFCellStyle.BORDER_THICK) + ((southBorderType == BorderStyle.THIN) || + (southBorderType == BorderStyle.MEDIUM) || + (southBorderType == BorderStyle.THICK) ) ) { @@ -156,9 +156,9 @@ } if (westBorder && - ((westBorderType == HSSFCellStyle.BORDER_THIN) || - (westBorderType == HSSFCellStyle.BORDER_MEDIUM) || - (westBorderType == HSSFCellStyle.BORDER_THICK) + ((westBorderType == BorderStyle.THIN) || + (westBorderType == BorderStyle.MEDIUM) || + (westBorderType == BorderStyle.THICK) ) ) { @@ -179,7 +179,7 @@ private void paintDottedBorders(Graphics g, int x, int y, int width, int height) { if (northBorder && - northBorderType == HSSFCellStyle.BORDER_DOTTED) { + northBorderType == BorderStyle.DOTTED) { int thickness = getThickness(northBorderType); g.setColor(northColor); @@ -192,7 +192,7 @@ } if (eastBorder && - eastBorderType == HSSFCellStyle.BORDER_DOTTED + eastBorderType == BorderStyle.DOTTED ) { int thickness = getThickness(eastBorderType); @@ -208,7 +208,7 @@ } if (southBorder && - southBorderType == HSSFCellStyle.BORDER_DOTTED + southBorderType == BorderStyle.DOTTED ) { int thickness = getThickness(southBorderType); @@ -222,7 +222,7 @@ } if (westBorder && - westBorderType == HSSFCellStyle.BORDER_DOTTED + westBorderType == BorderStyle.DOTTED ) { int thickness = getThickness(westBorderType); @@ -245,14 +245,14 @@ private void paintDashedBorders(Graphics g, int x, int y, int width, int height) { if (northBorder && - ((northBorderType == HSSFCellStyle.BORDER_DASHED) || - (northBorderType == HSSFCellStyle.BORDER_HAIR)) + ((northBorderType == BorderStyle.DASHED) || + (northBorderType == BorderStyle.HAIR)) ) { int thickness = getThickness(northBorderType); int dashlength = 1; - if (northBorderType == HSSFCellStyle.BORDER_DASHED) + if (northBorderType == BorderStyle.DASHED) dashlength = 2; g.setColor(northColor); @@ -265,8 +265,8 @@ } if (eastBorder && - ((eastBorderType == HSSFCellStyle.BORDER_DASHED) || - (eastBorderType == HSSFCellStyle.BORDER_HAIR)) + ((eastBorderType == BorderStyle.DASHED) || + (eastBorderType == BorderStyle.HAIR)) ) { int thickness = getThickness(eastBorderType); @@ -275,7 +275,7 @@ int dashlength = 1; - if (eastBorderType == HSSFCellStyle.BORDER_DASHED) + if (eastBorderType == BorderStyle.DASHED) dashlength = 2; g.setColor(eastColor); @@ -288,8 +288,8 @@ } if (southBorder && - ((southBorderType == HSSFCellStyle.BORDER_DASHED) || - (southBorderType == HSSFCellStyle.BORDER_HAIR)) + ((southBorderType == BorderStyle.DASHED) || + (southBorderType == BorderStyle.HAIR)) ) { int thickness = getThickness(southBorderType); @@ -297,7 +297,7 @@ int dashlength = 1; - if (southBorderType == HSSFCellStyle.BORDER_DASHED) + if (southBorderType == BorderStyle.DASHED) dashlength = 2; g.setColor(southColor); @@ -309,8 +309,8 @@ } if (westBorder && - ((westBorderType == HSSFCellStyle.BORDER_DASHED) || - (westBorderType == HSSFCellStyle.BORDER_HAIR)) + ((westBorderType == BorderStyle.DASHED) || + (westBorderType == BorderStyle.HAIR)) ) { int thickness = getThickness(westBorderType); @@ -318,7 +318,7 @@ int dashlength = 1; - if (westBorderType == HSSFCellStyle.BORDER_DASHED) + if (westBorderType == BorderStyle.DASHED) dashlength = 2; g.setColor(westColor); @@ -338,7 +338,7 @@ private void paintDoubleBorders(Graphics g, int x, int y, int width, int height) { if (northBorder && - northBorderType == HSSFCellStyle.BORDER_DOUBLE) { + northBorderType == BorderStyle.DOUBLE) { g.setColor(northColor); @@ -358,7 +358,7 @@ } if (eastBorder && - eastBorderType == HSSFCellStyle.BORDER_DOUBLE + eastBorderType == BorderStyle.DOUBLE ) { int thickness = getThickness(eastBorderType); @@ -380,7 +380,7 @@ } if (southBorder && - southBorderType == HSSFCellStyle.BORDER_DOUBLE + southBorderType == BorderStyle.DOUBLE ) { g.setColor(southColor); @@ -400,7 +400,7 @@ } if (westBorder && - westBorderType == HSSFCellStyle.BORDER_DOUBLE + westBorderType == BorderStyle.DOUBLE ) { int thickness = getThickness(westBorderType); @@ -429,8 +429,8 @@ private void paintDashDotDotBorders(Graphics g, int x, int y, int width, int height) { if (northBorder && - ((northBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) || - (northBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT)) + ((northBorderType == BorderStyle.DASH_DOT_DOT) || + (northBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT)) ) { int thickness = getThickness(northBorderType); @@ -442,8 +442,8 @@ } if (eastBorder && - ((eastBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) || - (eastBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT)) + ((eastBorderType == BorderStyle.DASH_DOT_DOT) || + (eastBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT)) ) { int thickness = getThickness(eastBorderType); @@ -457,8 +457,8 @@ } if (southBorder && - ((southBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) || - (southBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT)) + ((southBorderType == BorderStyle.DASH_DOT_DOT) || + (southBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT)) ) { int thickness = getThickness(southBorderType); @@ -472,8 +472,8 @@ } if (westBorder && - ((westBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) || - (westBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT)) + ((westBorderType == BorderStyle.DASH_DOT_DOT) || + (westBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT)) ) { int thickness = getThickness(westBorderType); @@ -530,34 +530,22 @@ /** * @returns the line thickness for a border based on border type */ - private int getThickness(int thickness) { - int retval=1; + private int getThickness(BorderStyle thickness) { switch (thickness) { - case HSSFCellStyle.BORDER_THIN: - retval=2; - break; - case HSSFCellStyle.BORDER_MEDIUM: - retval=3; - break; - case HSSFCellStyle.BORDER_THICK: - retval=4; - break; - case HSSFCellStyle.BORDER_DASHED: - retval=1; - break; - case HSSFCellStyle.BORDER_DASH_DOT_DOT: - retval=1; - break; - case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT: - retval=3; - break; - case HSSFCellStyle.BORDER_HAIR: - retval=1; - break; + case DASH_DOT_DOT: + case DASHED: + case HAIR: + return 1; + case THIN: + return 2; + case MEDIUM: + case MEDIUM_DASH_DOT_DOT: + return 3; + case THICK: + return 4; default: - retval=1; + return 1; } - return retval; } Index: src/examples/src/org/apache/poi/hssf/view/SVTableCellRenderer.java =================================================================== --- src/examples/src/org/apache/poi/hssf/view/SVTableCellRenderer.java (revision 1737757) +++ src/examples/src/org/apache/poi/hssf/view/SVTableCellRenderer.java (working copy) @@ -26,11 +26,11 @@ import java.awt.Component; import java.awt.Color; import java.awt.Rectangle; - import java.io.Serializable; import java.text.*; import org.apache.poi.hssf.usermodel.*; +import org.apache.poi.ss.usermodel.BorderStyle; /** @@ -224,10 +224,10 @@ SVTableUtils.black, SVTableUtils.black, SVTableUtils.black, - HSSFCellStyle.BORDER_NONE, - HSSFCellStyle.BORDER_NONE, - HSSFCellStyle.BORDER_NONE, - HSSFCellStyle.BORDER_NONE, + BorderStyle.NONE, + BorderStyle.NONE, + BorderStyle.NONE, + BorderStyle.NONE, isSelected); setBorder(cellBorder); } Index: src/examples/src/org/apache/poi/ss/examples/html/ToHtml.java =================================================================== --- src/examples/src/org/apache/poi/ss/examples/html/ToHtml.java (revision 1737757) +++ src/examples/src/org/apache/poi/ss/examples/html/ToHtml.java (working copy) @@ -62,22 +62,34 @@ private static final String COL_HEAD_CLASS = "colHeader"; private static final String ROW_HEAD_CLASS = "rowHeader"; - private static final Map ALIGN = mapFor(ALIGN_LEFT, "left", - ALIGN_CENTER, "center", ALIGN_RIGHT, "right", ALIGN_FILL, "left", - ALIGN_JUSTIFY, "left", ALIGN_CENTER_SELECTION, "center"); + private static final Map ALIGN = mapFor( + ALIGN_LEFT, "left", + ALIGN_CENTER, "center", + ALIGN_RIGHT, "right", + ALIGN_FILL, "left", + ALIGN_JUSTIFY, "left", + ALIGN_CENTER_SELECTION, "center"); private static final Map VERTICAL_ALIGN = mapFor( - VERTICAL_BOTTOM, "bottom", VERTICAL_CENTER, "middle", VERTICAL_TOP, - "top"); + VERTICAL_BOTTOM, "bottom", + VERTICAL_CENTER, "middle", + VERTICAL_TOP, "top"); - private static final Map BORDER = mapFor(BORDER_DASH_DOT, - "dashed 1pt", BORDER_DASH_DOT_DOT, "dashed 1pt", BORDER_DASHED, - "dashed 1pt", BORDER_DOTTED, "dotted 1pt", BORDER_DOUBLE, - "double 3pt", BORDER_HAIR, "solid 1px", BORDER_MEDIUM, "solid 2pt", - BORDER_MEDIUM_DASH_DOT, "dashed 2pt", BORDER_MEDIUM_DASH_DOT_DOT, - "dashed 2pt", BORDER_MEDIUM_DASHED, "dashed 2pt", BORDER_NONE, - "none", BORDER_SLANTED_DASH_DOT, "dashed 2pt", BORDER_THICK, - "solid 3pt", BORDER_THIN, "dashed 1pt"); + private static final Map BORDER = mapFor( + BorderStyle.DASH_DOT, "dashed 1pt", + BorderStyle.DASH_DOT_DOT, "dashed 1pt", + BorderStyle.DASHED, "dashed 1pt", + BorderStyle.DOTTED, "dotted 1pt", + BorderStyle.DOUBLE, "double 3pt", + BorderStyle.HAIR, "solid 1px", + BorderStyle.MEDIUM, "solid 2pt", + BorderStyle.MEDIUM_DASH_DOT, "dashed 2pt", + BorderStyle.MEDIUM_DASH_DOT_DOT, "dashed 2pt", + BorderStyle.MEDIUM_DASHED, "dashed 2pt", + BorderStyle.NONE, "none", + BorderStyle.SLANTED_DASH_DOT, "dashed 2pt", + BorderStyle.THICK, "solid 3pt", + BorderStyle.THIN, "dashed 1pt"); @SuppressWarnings({"unchecked"}) private static Map mapFor(Object... mapping) { Index: src/examples/src/org/apache/poi/ss/examples/ExcelComparator.java =================================================================== --- src/examples/src/org/apache/poi/ss/examples/ExcelComparator.java (revision 1737757) +++ src/examples/src/org/apache/poi/ss/examples/ExcelComparator.java (working copy) @@ -23,6 +23,7 @@ import java.util.List; import java.util.Locale; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Color; import org.apache.poi.ss.usermodel.DateUtil; @@ -362,23 +363,23 @@ String borderName; switch (borderSide) { case 't': default: - b1 = style1.getBorderTop() == 1; - b2 = style2.getBorderTop() == 1; + b1 = style1.getBorderTop() == BorderStyle.THIN; + b2 = style2.getBorderTop() == BorderStyle.THIN; borderName = "TOP"; break; case 'b': - b1 = style1.getBorderBottom() == 1; - b2 = style2.getBorderBottom() == 1; + b1 = style1.getBorderBottom() == BorderStyle.THIN; + b2 = style2.getBorderBottom() == BorderStyle.THIN; borderName = "BOTTOM"; break; case 'l': - b1 = style1.getBorderLeft() == 1; - b2 = style2.getBorderLeft() == 1; + b1 = style1.getBorderLeft() == BorderStyle.THIN; + b2 = style2.getBorderLeft() == BorderStyle.THIN; borderName = "LEFT"; break; case 'r': - b1 = style1.getBorderRight() == 1; - b2 = style2.getBorderRight() == 1; + b1 = style1.getBorderRight() == BorderStyle.THIN; + b2 = style2.getBorderRight() == BorderStyle.THIN; borderName = "RIGHT"; break; } Index: src/testcases/org/apache/poi/hssf/usermodel/TestHSSFOptimiser.java =================================================================== --- src/testcases/org/apache/poi/hssf/usermodel/TestHSSFOptimiser.java (revision 1737757) +++ src/testcases/org/apache/poi/hssf/usermodel/TestHSSFOptimiser.java (working copy) @@ -16,6 +16,8 @@ ==================================================================== */ package org.apache.poi.hssf.usermodel; +import org.apache.poi.ss.usermodel.BorderStyle; + import junit.framework.TestCase; public final class TestHSSFOptimiser extends TestCase { @@ -278,13 +280,13 @@ assertEquals(21, wb.getNumCellStyles()); HSSFCellStyle cs1 = wb.createCellStyle(); - cs1.setBorderBottom(HSSFCellStyle.BORDER_THICK); + cs1.setBorderBottom(BorderStyle.THICK); HSSFCellStyle cs2 = wb.createCellStyle(); - cs2.setBorderBottom(HSSFCellStyle.BORDER_DASH_DOT); + cs2.setBorderBottom(BorderStyle.DASH_DOT); HSSFCellStyle cs3 = wb.createCellStyle(); // = cs1 - cs3.setBorderBottom(HSSFCellStyle.BORDER_THICK); + cs3.setBorderBottom(BorderStyle.THICK); assertEquals(24, wb.getNumCellStyles()); @@ -306,8 +308,8 @@ // Check assertEquals(23, wb.getNumCellStyles()); - assertEquals(HSSFCellStyle.BORDER_THICK, r.getCell(0).getCellStyle().getBorderBottom()); - assertEquals(HSSFCellStyle.BORDER_DASH_DOT, r.getCell(1).getCellStyle().getBorderBottom()); - assertEquals(HSSFCellStyle.BORDER_THICK, r.getCell(2).getCellStyle().getBorderBottom()); + assertEquals(BorderStyle.THICK, r.getCell(0).getCellStyle().getBorderBottom()); + assertEquals(BorderStyle.DASH_DOT, r.getCell(1).getCellStyle().getBorderBottom()); + assertEquals(BorderStyle.THICK, r.getCell(2).getCellStyle().getBorderBottom()); } } Index: src/testcases/org/apache/poi/hssf/usermodel/TestRowStyle.java =================================================================== --- src/testcases/org/apache/poi/hssf/usermodel/TestRowStyle.java (revision 1737757) +++ src/testcases/org/apache/poi/hssf/usermodel/TestRowStyle.java (working copy) @@ -20,6 +20,7 @@ import junit.framework.TestCase; import org.apache.poi.hssf.HSSFTestDataSamples; +import org.apache.poi.ss.usermodel.BorderStyle; /** * Class to test row styling functionality @@ -110,10 +111,10 @@ HSSFCellStyle cs = wb.createCellStyle(); HSSFCellStyle cs2 = wb.createCellStyle(); - cs.setBorderBottom(HSSFCellStyle.BORDER_THIN); - cs.setBorderLeft(HSSFCellStyle.BORDER_THIN); - cs.setBorderRight(HSSFCellStyle.BORDER_THIN); - cs.setBorderTop(HSSFCellStyle.BORDER_THIN); + cs.setBorderBottom(BorderStyle.THIN); + cs.setBorderLeft(BorderStyle.THIN); + cs.setBorderRight(BorderStyle.THIN); + cs.setBorderTop(BorderStyle.THIN); cs.setFillForegroundColor(( short ) 0xA); cs.setFillPattern(( short ) 1); fnt.setColor(( short ) 0xf); @@ -150,12 +151,12 @@ assertNotNull("Row is not null", r); cs = r.getRowStyle(); - assertEquals("FillForegroundColor for row: ", cs.getBorderBottom(), HSSFCellStyle.BORDER_THIN); - assertEquals("FillPattern for row: ", cs.getBorderLeft(), HSSFCellStyle.BORDER_THIN); - assertEquals("FillForegroundColor for row: ", cs.getBorderRight(), HSSFCellStyle.BORDER_THIN); - assertEquals("FillPattern for row: ", cs.getBorderTop(), HSSFCellStyle.BORDER_THIN); - assertEquals("FillForegroundColor for row: ", cs.getFillForegroundColor(), 0xA); - assertEquals("FillPattern for row: ", cs.getFillPattern(), (short) 0x1); + assertEquals("Bottom Border Style for row:", BorderStyle.THIN, cs.getBorderBottom()); + assertEquals("Left Border Style for row:", BorderStyle.THIN, cs.getBorderLeft()); + assertEquals("Right Border Style for row:", BorderStyle.THIN, cs.getBorderRight()); + assertEquals("Top Border Style for row:", BorderStyle.THIN, cs.getBorderTop()); + assertEquals("FillForegroundColor for row:", 0xA, cs.getFillForegroundColor()); + assertEquals("FillPattern for row:", 0x1, cs.getFillPattern()); rownum++; if (rownum >= 100) break; // I feel too lazy to check if this isreqd :-/ Index: src/testcases/org/apache/poi/hssf/usermodel/TestCellStyle.java =================================================================== --- src/testcases/org/apache/poi/hssf/usermodel/TestCellStyle.java (revision 1737757) +++ src/testcases/org/apache/poi/hssf/usermodel/TestCellStyle.java (working copy) @@ -24,6 +24,7 @@ import java.util.Date; import org.apache.poi.hssf.HSSFTestDataSamples; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.Font; @@ -180,10 +181,10 @@ HSSFCellStyle cs = wb.createCellStyle(); HSSFCellStyle cs2 = wb.createCellStyle(); - cs.setBorderBottom(HSSFCellStyle.BORDER_THIN); - cs.setBorderLeft(HSSFCellStyle.BORDER_THIN); - cs.setBorderRight(HSSFCellStyle.BORDER_THIN); - cs.setBorderTop(HSSFCellStyle.BORDER_THIN); + cs.setBorderBottom(BorderStyle.THIN); + cs.setBorderLeft(BorderStyle.THIN); + cs.setBorderRight(BorderStyle.THIN); + cs.setBorderTop(BorderStyle.THIN); cs.setFillForegroundColor(( short ) 0xA); cs.setFillPattern(( short ) 1); fnt.setColor(( short ) 0xf); @@ -346,40 +347,40 @@ HSSFCellStyle cs; cs = s.getRow(0).getCell(0).getCellStyle(); - assertEquals(CellStyle.BORDER_HAIR, cs.getBorderRight()); + assertEquals(BorderStyle.HAIR, cs.getBorderRight()); cs = s.getRow(1).getCell(1).getCellStyle(); - assertEquals(CellStyle.BORDER_DOTTED, cs.getBorderRight()); + assertEquals(BorderStyle.DOTTED, cs.getBorderRight()); cs = s.getRow(2).getCell(2).getCellStyle(); - assertEquals(CellStyle.BORDER_DASH_DOT_DOT, cs.getBorderRight()); + assertEquals(BorderStyle.DASH_DOT_DOT, cs.getBorderRight()); cs = s.getRow(3).getCell(3).getCellStyle(); - assertEquals(CellStyle.BORDER_DASHED, cs.getBorderRight()); + assertEquals(BorderStyle.DASHED, cs.getBorderRight()); cs = s.getRow(4).getCell(4).getCellStyle(); - assertEquals(CellStyle.BORDER_THIN, cs.getBorderRight()); + assertEquals(BorderStyle.THIN, cs.getBorderRight()); cs = s.getRow(5).getCell(5).getCellStyle(); - assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT, cs.getBorderRight()); + assertEquals(BorderStyle.MEDIUM_DASH_DOT_DOT, cs.getBorderRight()); cs = s.getRow(6).getCell(6).getCellStyle(); - assertEquals(CellStyle.BORDER_SLANTED_DASH_DOT, cs.getBorderRight()); + assertEquals(BorderStyle.SLANTED_DASH_DOT, cs.getBorderRight()); cs = s.getRow(7).getCell(7).getCellStyle(); - assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT, cs.getBorderRight()); + assertEquals(BorderStyle.MEDIUM_DASH_DOT, cs.getBorderRight()); cs = s.getRow(8).getCell(8).getCellStyle(); - assertEquals(CellStyle.BORDER_MEDIUM_DASHED, cs.getBorderRight()); + assertEquals(BorderStyle.MEDIUM_DASHED, cs.getBorderRight()); cs = s.getRow(9).getCell(9).getCellStyle(); - assertEquals(CellStyle.BORDER_MEDIUM, cs.getBorderRight()); + assertEquals(BorderStyle.MEDIUM, cs.getBorderRight()); cs = s.getRow(10).getCell(10).getCellStyle(); - assertEquals(CellStyle.BORDER_THICK, cs.getBorderRight()); + assertEquals(BorderStyle.THICK, cs.getBorderRight()); cs = s.getRow(11).getCell(11).getCellStyle(); - assertEquals(CellStyle.BORDER_DOUBLE, cs.getBorderRight()); + assertEquals(BorderStyle.DOUBLE, cs.getBorderRight()); } public void testShrinkToFit() { @@ -485,7 +486,7 @@ font.setColor(Font.COLOR_RED); CellStyle style = wb.createCellStyle(); - style.setBorderBottom(CellStyle.BORDER_DOTTED); + style.setBorderBottom(BorderStyle.DOTTED); style.setFont(font); Cell cell = row.createCell(0); @@ -498,7 +499,7 @@ newCell.setCellValue("2testtext2"); CellStyle newStyle = newCell.getCellStyle(); - assertEquals(CellStyle.BORDER_DOTTED, newStyle.getBorderBottom()); + assertEquals(BorderStyle.DOTTED, newStyle.getBorderBottom()); assertEquals(Font.COLOR_RED, ((HSSFCellStyle)newStyle).getFont(wb).getColor()); // OutputStream out = new FileOutputStream("/tmp/56959.xls"); Index: src/testcases/org/apache/poi/hssf/usermodel/TestBugs.java =================================================================== --- src/testcases/org/apache/poi/hssf/usermodel/TestBugs.java (revision 1737757) +++ src/testcases/org/apache/poi/hssf/usermodel/TestBugs.java (working copy) @@ -68,6 +68,7 @@ import org.apache.poi.ss.formula.ptg.DeletedArea3DPtg; import org.apache.poi.ss.formula.ptg.Ptg; import org.apache.poi.ss.usermodel.BaseTestBugzillaIssues; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.ClientAnchor.AnchorType; @@ -2564,7 +2565,7 @@ HSSFSheet sheet = wb.getSheetAt(0); HSSFRow row = sheet.getRow(0); HSSFCellStyle rstyle = row.getRowStyle(); - assertEquals(rstyle.getBorderBottom(), CellStyle.BORDER_DOUBLE); + assertEquals(BorderStyle.DOUBLE, rstyle.getBorderBottom()); wb.close(); } Index: src/testcases/org/apache/poi/ss/usermodel/BaseTestCell.java =================================================================== --- src/testcases/org/apache/poi/ss/usermodel/BaseTestCell.java (revision 1737757) +++ src/testcases/org/apache/poi/ss/usermodel/BaseTestCell.java (working copy) @@ -254,10 +254,10 @@ f.setFontName("Arial Unicode MS"); cs.setFillBackgroundColor((short)3); cs.setFont(f); - cs.setBorderTop((short)1); - cs.setBorderRight((short)1); - cs.setBorderLeft((short)1); - cs.setBorderBottom((short)1); + cs.setBorderTop(BorderStyle.THIN); + cs.setBorderRight(BorderStyle.THIN); + cs.setBorderLeft(BorderStyle.THIN); + cs.setBorderBottom(BorderStyle.THIN); r = s.createRow(0); c=r.createCell(0); @@ -270,15 +270,15 @@ r = s.getRow(0); c = r.getCell(0); - assertTrue("Formula Cell at 0,0", (c.getCellType()==Cell.CELL_TYPE_FORMULA)); + assertEquals("Formula Cell at 0,0", Cell.CELL_TYPE_FORMULA, c.getCellType()); cs = c.getCellStyle(); assertNotNull("Formula Cell Style", cs); - assertTrue("Font Index Matches", (cs.getFontIndex() == f.getIndex())); - assertTrue("Top Border", (cs.getBorderTop() == (short)1)); - assertTrue("Left Border", (cs.getBorderLeft() == (short)1)); - assertTrue("Right Border", (cs.getBorderRight() == (short)1)); - assertTrue("Bottom Border", (cs.getBorderBottom() == (short)1)); + assertEquals("Font Index Matches", f.getIndex(), cs.getFontIndex()); + assertEquals("Top Border", BorderStyle.THIN, cs.getBorderTop()); + assertEquals("Left Border", BorderStyle.THIN, cs.getBorderLeft()); + assertEquals("Right Border", BorderStyle.THIN, cs.getBorderRight()); + assertEquals("Bottom Border", BorderStyle.THIN, cs.getBorderBottom()); wb2.close(); } Index: src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java =================================================================== --- src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java (revision 1737757) +++ src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java (working copy) @@ -323,10 +323,10 @@ fontFmt.setFontStyle(true, false); BorderFormatting bordFmt = rule1.createBorderFormatting(); - bordFmt.setBorderBottom(BorderFormatting.BORDER_THIN); - bordFmt.setBorderTop(BorderFormatting.BORDER_THICK); - bordFmt.setBorderLeft(BorderFormatting.BORDER_DASHED); - bordFmt.setBorderRight(BorderFormatting.BORDER_DOTTED); + bordFmt.setBorderBottom(BorderStyle.THIN); + bordFmt.setBorderTop(BorderStyle.THICK); + bordFmt.setBorderLeft(BorderStyle.DASHED); + bordFmt.setBorderRight(BorderStyle.DOTTED); PatternFormatting patternFmt = rule1.createPatternFormatting(); patternFmt.setFillBackgroundColor(IndexedColors.YELLOW.index); @@ -376,10 +376,10 @@ BorderFormatting r1bf = rule1.getBorderFormatting(); assertNotNull(r1bf); - assertEquals(BorderFormatting.BORDER_THIN, r1bf.getBorderBottom()); - assertEquals(BorderFormatting.BORDER_THICK,r1bf.getBorderTop()); - assertEquals(BorderFormatting.BORDER_DASHED,r1bf.getBorderLeft()); - assertEquals(BorderFormatting.BORDER_DOTTED,r1bf.getBorderRight()); + assertEquals(BorderStyle.THIN, r1bf.getBorderBottom()); + assertEquals(BorderStyle.THICK,r1bf.getBorderTop()); + assertEquals(BorderStyle.DASHED,r1bf.getBorderLeft()); + assertEquals(BorderStyle.DOTTED,r1bf.getBorderRight()); PatternFormatting r1pf = rule1.getPatternFormatting(); assertNotNull(r1pf); @@ -453,7 +453,7 @@ ConditionalFormattingRule rule2 = sheetCF.createConditionalFormattingRule( ComparisonOperator.BETWEEN, "SUM(A10:A15)", "1+SUM(B16:B30)"); BorderFormatting borderFmt = rule2.createBorderFormatting(); - borderFmt.setBorderDiagonal((short) 2); + borderFmt.setBorderDiagonal(BorderStyle.MEDIUM); CellRangeAddress [] regions = { new CellRangeAddress(2, 4, 0, 0), // A3:A5 @@ -1019,7 +1019,39 @@ workbook.close(); } + + @Test + public void testAllCreateBorderFormatting() throws IOException { + // Make sure it is possible to create a conditional formatting rule + // with every type of Border Style + Workbook workbook = _testDataProvider.createWorkbook(); + Sheet sheet = workbook.createSheet(); + SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting(); + + ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.EQUAL, "7"); + BorderFormatting borderFmt = rule1.createBorderFormatting(); + + for (BorderStyle border : BorderStyle.values()) { + borderFmt.setBorderTop(border); + assertEquals(border, borderFmt.getBorderTop()); + + borderFmt.setBorderBottom(border); + assertEquals(border, borderFmt.getBorderBottom()); + + borderFmt.setBorderLeft(border); + assertEquals(border, borderFmt.getBorderLeft()); + + borderFmt.setBorderRight(border); + assertEquals(border, borderFmt.getBorderRight()); + + borderFmt.setBorderDiagonal(border); + assertEquals(border, borderFmt.getBorderDiagonal()); + } + + workbook.close(); + } + @Test public void testCreateBorderFormatting() throws IOException { Workbook workbook = _testDataProvider.createWorkbook(); @@ -1030,37 +1062,37 @@ ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.EQUAL, "7"); BorderFormatting borderFmt = rule1.createBorderFormatting(); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderBottom()); - borderFmt.setBorderBottom(BorderFormatting.BORDER_DOTTED); - assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderBottom()); - borderFmt.setBorderBottom(BorderFormatting.BORDER_NONE); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderBottom()); - borderFmt.setBorderBottom(BorderFormatting.BORDER_THICK); - assertEquals(BorderFormatting.BORDER_THICK, borderFmt.getBorderBottom()); + assertEquals(BorderStyle.NONE, borderFmt.getBorderBottom()); + borderFmt.setBorderBottom(BorderStyle.DOTTED); + assertEquals(BorderStyle.DOTTED, borderFmt.getBorderBottom()); + borderFmt.setBorderBottom(BorderStyle.NONE); + assertEquals(BorderStyle.NONE, borderFmt.getBorderBottom()); + borderFmt.setBorderBottom(BorderStyle.THICK); + assertEquals(BorderStyle.THICK, borderFmt.getBorderBottom()); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderTop()); - borderFmt.setBorderTop(BorderFormatting.BORDER_DOTTED); - assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderTop()); - borderFmt.setBorderTop(BorderFormatting.BORDER_NONE); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderTop()); - borderFmt.setBorderTop(BorderFormatting.BORDER_THICK); - assertEquals(BorderFormatting.BORDER_THICK, borderFmt.getBorderTop()); + assertEquals(BorderStyle.NONE, borderFmt.getBorderTop()); + borderFmt.setBorderTop(BorderStyle.DOTTED); + assertEquals(BorderStyle.DOTTED, borderFmt.getBorderTop()); + borderFmt.setBorderTop(BorderStyle.NONE); + assertEquals(BorderStyle.NONE, borderFmt.getBorderTop()); + borderFmt.setBorderTop(BorderStyle.THICK); + assertEquals(BorderStyle.THICK, borderFmt.getBorderTop()); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderLeft()); - borderFmt.setBorderLeft(BorderFormatting.BORDER_DOTTED); - assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderLeft()); - borderFmt.setBorderLeft(BorderFormatting.BORDER_NONE); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderLeft()); - borderFmt.setBorderLeft(BorderFormatting.BORDER_THIN); - assertEquals(BorderFormatting.BORDER_THIN, borderFmt.getBorderLeft()); + assertEquals(BorderStyle.NONE, borderFmt.getBorderLeft()); + borderFmt.setBorderLeft(BorderStyle.DOTTED); + assertEquals(BorderStyle.DOTTED, borderFmt.getBorderLeft()); + borderFmt.setBorderLeft(BorderStyle.NONE); + assertEquals(BorderStyle.NONE, borderFmt.getBorderLeft()); + borderFmt.setBorderLeft(BorderStyle.THIN); + assertEquals(BorderStyle.THIN, borderFmt.getBorderLeft()); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderRight()); - borderFmt.setBorderRight(BorderFormatting.BORDER_DOTTED); - assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderRight()); - borderFmt.setBorderRight(BorderFormatting.BORDER_NONE); - assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderRight()); - borderFmt.setBorderRight(BorderFormatting.BORDER_HAIR); - assertEquals(BorderFormatting.BORDER_HAIR, borderFmt.getBorderRight()); + assertEquals(BorderStyle.NONE, borderFmt.getBorderRight()); + borderFmt.setBorderRight(BorderStyle.DOTTED); + assertEquals(BorderStyle.DOTTED, borderFmt.getBorderRight()); + borderFmt.setBorderRight(BorderStyle.NONE); + assertEquals(BorderStyle.NONE, borderFmt.getBorderRight()); + borderFmt.setBorderRight(BorderStyle.HAIR); + assertEquals(BorderStyle.HAIR, borderFmt.getBorderRight()); ConditionalFormattingRule [] cfRules = { rule1 }; @@ -1076,10 +1108,10 @@ BorderFormatting r1fp = cf.getRule(0).getBorderFormatting(); assertNotNull(r1fp); - assertEquals(BorderFormatting.BORDER_THICK, r1fp.getBorderBottom()); - assertEquals(BorderFormatting.BORDER_THICK, r1fp.getBorderTop()); - assertEquals(BorderFormatting.BORDER_THIN, r1fp.getBorderLeft()); - assertEquals(BorderFormatting.BORDER_HAIR, r1fp.getBorderRight()); + assertEquals(BorderStyle.THICK, r1fp.getBorderBottom()); + assertEquals(BorderStyle.THICK, r1fp.getBorderTop()); + assertEquals(BorderStyle.THIN, r1fp.getBorderLeft()); + assertEquals(BorderStyle.HAIR, r1fp.getBorderRight()); workbook.close(); } Index: src/testcases/org/apache/poi/ss/util/TestCellUtil.java =================================================================== --- src/testcases/org/apache/poi/ss/util/TestCellUtil.java (revision 1737757) +++ src/testcases/org/apache/poi/ss/util/TestCellUtil.java (working copy) @@ -29,13 +29,13 @@ import java.util.Map; import org.apache.poi.hssf.usermodel.HSSFWorkbook; +import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.Font; import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Workbook; - import org.junit.Test; /** @@ -53,13 +53,13 @@ // Add a border should create a new style int styCnt1 = wb.getNumCellStyles(); - CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, CellStyle.BORDER_THIN); + CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, BorderStyle.THIN); int styCnt2 = wb.getNumCellStyles(); assertEquals(styCnt2, styCnt1+1); // Add same border to another cell, should not create another style c = r.createCell(1); - CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, CellStyle.BORDER_THIN); + CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, BorderStyle.THIN); int styCnt3 = wb.getNumCellStyles(); assertEquals(styCnt3, styCnt2); @@ -76,19 +76,19 @@ // Add multiple border properties to cell should create a single new style int styCnt1 = wb.getNumCellStyles(); Map props = new HashMap(); - props.put(CellUtil.BORDER_TOP, CellStyle.BORDER_THIN); - props.put(CellUtil.BORDER_BOTTOM, CellStyle.BORDER_THIN); - props.put(CellUtil.BORDER_LEFT, CellStyle.BORDER_THIN); - props.put(CellUtil.BORDER_RIGHT, CellStyle.BORDER_THIN); + props.put(CellUtil.BORDER_TOP, BorderStyle.THIN); + props.put(CellUtil.BORDER_BOTTOM, BorderStyle.THIN); + props.put(CellUtil.BORDER_LEFT, BorderStyle.THIN); + props.put(CellUtil.BORDER_RIGHT, BorderStyle.THIN); CellUtil.setCellStyleProperties(c, props); int styCnt2 = wb.getNumCellStyles(); - assertEquals(styCnt2, styCnt1+1); + assertEquals(styCnt1+1, styCnt2); // Add same border another to same cell, should not create another style c = r.createCell(1); CellUtil.setCellStyleProperties(c, props); int styCnt3 = wb.getNumCellStyles(); - assertEquals(styCnt3, styCnt2); + assertEquals(styCnt2, styCnt3); wb.close(); } Index: src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCellStyle.java =================================================================== --- src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCellStyle.java (revision 1737757) +++ src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCellStyle.java (working copy) @@ -104,11 +104,11 @@ @Test public void testGetSetBorderBottom() { //default values - assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderBottom()); + assertEquals(BorderStyle.NONE, cellStyle.getBorderBottom()); int num = stylesTable.getBorders().size(); - cellStyle.setBorderBottom(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderBottom()); + cellStyle.setBorderBottom(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderBottom()); //a new border has been added assertEquals(num + 1, stylesTable.getBorders().size()); //id of the created border @@ -121,15 +121,15 @@ num = stylesTable.getBorders().size(); //setting the same border multiple times should not change borderId for (int i = 0; i < 3; i++) { - cellStyle.setBorderBottom(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderBottom()); + cellStyle.setBorderBottom(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderBottom()); } assertEquals(borderId, cellStyle.getCoreXf().getBorderId()); assertEquals(num, stylesTable.getBorders().size()); assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder()); //setting border to none removes the element - cellStyle.setBorderBottom(CellStyle.BORDER_NONE); + cellStyle.setBorderBottom(BorderStyle.NONE); assertEquals(num, stylesTable.getBorders().size()); borderId = (int)cellStyle.getCoreXf().getBorderId(); ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); @@ -139,11 +139,11 @@ @Test public void testGetSetBorderRight() { //default values - assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderRight()); + assertEquals(BorderStyle.NONE, cellStyle.getBorderRight()); int num = stylesTable.getBorders().size(); - cellStyle.setBorderRight(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderRight()); + cellStyle.setBorderRight(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderRight()); //a new border has been added assertEquals(num + 1, stylesTable.getBorders().size()); //id of the created border @@ -156,15 +156,15 @@ num = stylesTable.getBorders().size(); //setting the same border multiple times should not change borderId for (int i = 0; i < 3; i++) { - cellStyle.setBorderRight(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderRight()); + cellStyle.setBorderRight(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderRight()); } assertEquals(borderId, cellStyle.getCoreXf().getBorderId()); assertEquals(num, stylesTable.getBorders().size()); assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder()); //setting border to none removes the element - cellStyle.setBorderRight(CellStyle.BORDER_NONE); + cellStyle.setBorderRight(BorderStyle.NONE); assertEquals(num, stylesTable.getBorders().size()); borderId = (int)cellStyle.getCoreXf().getBorderId(); ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); @@ -174,11 +174,11 @@ @Test public void testGetSetBorderLeft() { //default values - assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderLeft()); + assertEquals(BorderStyle.NONE, cellStyle.getBorderLeft()); int num = stylesTable.getBorders().size(); - cellStyle.setBorderLeft(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderLeft()); + cellStyle.setBorderLeft(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderLeft()); //a new border has been added assertEquals(num + 1, stylesTable.getBorders().size()); //id of the created border @@ -191,15 +191,15 @@ num = stylesTable.getBorders().size(); //setting the same border multiple times should not change borderId for (int i = 0; i < 3; i++) { - cellStyle.setBorderLeft(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderLeft()); + cellStyle.setBorderLeft(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderLeft()); } assertEquals(borderId, cellStyle.getCoreXf().getBorderId()); assertEquals(num, stylesTable.getBorders().size()); assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder()); //setting border to none removes the element - cellStyle.setBorderLeft(CellStyle.BORDER_NONE); + cellStyle.setBorderLeft(BorderStyle.NONE); assertEquals(num, stylesTable.getBorders().size()); borderId = (int)cellStyle.getCoreXf().getBorderId(); ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); @@ -209,11 +209,11 @@ @Test public void testGetSetBorderTop() { //default values - assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderTop()); + assertEquals(BorderStyle.NONE, cellStyle.getBorderTop()); int num = stylesTable.getBorders().size(); - cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop()); + cellStyle.setBorderTop(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderTop()); //a new border has been added assertEquals(num + 1, stylesTable.getBorders().size()); //id of the created border @@ -226,165 +226,112 @@ num = stylesTable.getBorders().size(); //setting the same border multiple times should not change borderId for (int i = 0; i < 3; i++) { - cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop()); + cellStyle.setBorderTop(BorderStyle.MEDIUM); + assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderTop()); } assertEquals(borderId, cellStyle.getCoreXf().getBorderId()); assertEquals(num, stylesTable.getBorders().size()); assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder()); //setting border to none removes the element - cellStyle.setBorderTop(CellStyle.BORDER_NONE); + cellStyle.setBorderTop(BorderStyle.NONE); assertEquals(num, stylesTable.getBorders().size()); borderId = (int)cellStyle.getCoreXf().getBorderId(); ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); assertFalse(ctBorder.isSetTop()); - } - - @Test - public void testGetSetBorderThin() { - cellStyle.setBorderTop(CellStyle.BORDER_THIN); - assertEquals(CellStyle.BORDER_THIN, cellStyle.getBorderTop()); + } + + private void testGetSetBorderXMLBean(BorderStyle border, STBorderStyle.Enum expected) { + cellStyle.setBorderTop(border); + assertEquals(border, cellStyle.getBorderTop()); int borderId = (int)cellStyle.getCoreXf().getBorderId(); assertTrue(borderId > 0); //check changes in the underlying xml bean CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.THIN, ctBorder.getTop().getStyle()); - } - - @Test - public void testGetSetBorderMedium() { - cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM); - assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop()); + assertEquals(expected, ctBorder.getTop().getStyle()); + } + + + // Border Styles, in BorderStyle/STBorderStyle enum order + @Test + public void testGetSetBorderNone() { + cellStyle.setBorderTop(BorderStyle.NONE); + assertEquals(BorderStyle.NONE, cellStyle.getBorderTop()); int borderId = (int)cellStyle.getCoreXf().getBorderId(); assertTrue(borderId > 0); //check changes in the underlying xml bean CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.MEDIUM, ctBorder.getTop().getStyle()); - } - - @Test + assertNull(ctBorder.getTop()); + // no border style and STBorderStyle.NONE are equivalent + // POI prefers to unset the border style than explicitly set it STBorderStyle.NONE + } + + @Test + public void testGetSetBorderThin() { + testGetSetBorderXMLBean(BorderStyle.THIN, STBorderStyle.THIN); + } + + @Test + public void testGetSetBorderMedium() { + testGetSetBorderXMLBean(BorderStyle.MEDIUM, STBorderStyle.MEDIUM); + } + + @Test + public void testGetSetBorderDashed() { + testGetSetBorderXMLBean(BorderStyle.DASHED, STBorderStyle.DASHED); + } + + @Test + public void testGetSetBorderDotted() { + testGetSetBorderXMLBean(BorderStyle.DOTTED, STBorderStyle.DOTTED); + } + + @Test public void testGetSetBorderThick() { - cellStyle.setBorderTop(CellStyle.BORDER_THICK); - assertEquals(CellStyle.BORDER_THICK, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.THICK, ctBorder.getTop().getStyle()); - } - - @Test + testGetSetBorderXMLBean(BorderStyle.THICK, STBorderStyle.THICK); + } + + @Test + public void testGetSetBorderDouble() { + testGetSetBorderXMLBean(BorderStyle.DOUBLE, STBorderStyle.DOUBLE); + } + + @Test public void testGetSetBorderHair() { - cellStyle.setBorderTop(CellStyle.BORDER_HAIR); - assertEquals(CellStyle.BORDER_HAIR, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.HAIR, ctBorder.getTop().getStyle()); - } - - @Test - public void testGetSetBorderDotted() { - cellStyle.setBorderTop(CellStyle.BORDER_DOTTED); - assertEquals(CellStyle.BORDER_DOTTED, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.DOTTED, ctBorder.getTop().getStyle()); - } - - @Test - public void testGetSetBorderDashed() { - cellStyle.setBorderTop(CellStyle.BORDER_DASHED); - assertEquals(CellStyle.BORDER_DASHED, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.DASHED, ctBorder.getTop().getStyle()); - } - - @Test + testGetSetBorderXMLBean(BorderStyle.HAIR, STBorderStyle.HAIR); + } + + @Test + public void testGetSetBorderMediumDashed() { + testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASHED, STBorderStyle.MEDIUM_DASHED); + } + + @Test public void testGetSetBorderDashDot() { - cellStyle.setBorderTop(CellStyle.BORDER_DASH_DOT); - assertEquals(CellStyle.BORDER_DASH_DOT, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.DASH_DOT, ctBorder.getTop().getStyle()); - } - - @Test - public void testGetSetBorderDashDotDot() { - cellStyle.setBorderTop(CellStyle.BORDER_DASH_DOT_DOT); - assertEquals(CellStyle.BORDER_DASH_DOT_DOT, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.DASH_DOT_DOT, ctBorder.getTop().getStyle()); - } - - @Test + testGetSetBorderXMLBean(BorderStyle.DASH_DOT, STBorderStyle.DASH_DOT); + } + + @Test public void testGetSetBorderMediumDashDot() { - cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASH_DOT); - assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.MEDIUM_DASH_DOT, ctBorder.getTop().getStyle()); - } - - @Test + testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASH_DOT, STBorderStyle.MEDIUM_DASH_DOT); + } + + @Test + public void testGetSetBorderDashDotDot() { + testGetSetBorderXMLBean(BorderStyle.DASH_DOT_DOT, STBorderStyle.DASH_DOT_DOT); + } + + @Test public void testGetSetBorderMediumDashDotDot() { - cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT); - assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.MEDIUM_DASH_DOT_DOT, ctBorder.getTop().getStyle()); - } - - @Test - public void testGetSetBorderMediumDashed() { - cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASHED); - assertEquals(CellStyle.BORDER_MEDIUM_DASHED, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.MEDIUM_DASHED, ctBorder.getTop().getStyle()); - } - - @Test + testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASH_DOT_DOT, STBorderStyle.MEDIUM_DASH_DOT_DOT); + } + + @Test public void testGetSetBorderSlantDashDot() { - cellStyle.setBorderTop(CellStyle.BORDER_SLANTED_DASH_DOT); - assertEquals(CellStyle.BORDER_SLANTED_DASH_DOT, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.SLANT_DASH_DOT, ctBorder.getTop().getStyle()); - } - - @Test - public void testGetSetBorderDouble() { - cellStyle.setBorderTop(CellStyle.BORDER_DOUBLE); - assertEquals(CellStyle.BORDER_DOUBLE, cellStyle.getBorderTop()); - int borderId = (int)cellStyle.getCoreXf().getBorderId(); - assertTrue(borderId > 0); - //check changes in the underlying xml bean - CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder(); - assertEquals(STBorderStyle.DOUBLE, ctBorder.getTop().getStyle()); - } - - @Test + testGetSetBorderXMLBean(BorderStyle.SLANTED_DASH_DOT, STBorderStyle.SLANT_DASH_DOT); + } + + @Test public void testGetSetBottomBorderColor() { //defaults assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getBottomBorderColor()); @@ -1104,5 +1051,7 @@ cellStyle.setRightBorderColor(null); assertNull(cellStyle.getRightBorderXSSFColor()); + + workbook.close(); } }