Attachment #33725 for bug #59264

View | Details | Raw Unified | Return to bug 59264
Collapse All | Expand All

Lines 24-67 Link Here

(-)src/java/org/apache/poi/ss/usermodel/BorderFormatting.java (-21 / +108 lines)
24	* of Conditional Formatting settings	24	* of Conditional Formatting settings
25	*/	25	*/
26	public interface BorderFormatting {	26	public interface BorderFormatting {
27	/** No border */	27	/** No border
		28	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		29	*/
28	short BORDER_NONE = 0x0;	30	short BORDER_NONE = 0x0;
29	/** Thin border */	31
		32	/** Thin border
		33	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		34	*/
30	short BORDER_THIN = 0x1;	35	short BORDER_THIN = 0x1;
31	/** Medium border */	36
		37	/** Medium border
		38	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		39	*/
32	short BORDER_MEDIUM = 0x2;	40	short BORDER_MEDIUM = 0x2;
33	/** dash border */	41
		42	/** dash border
		43	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		44	*/
34	short BORDER_DASHED = 0x3;	45	short BORDER_DASHED = 0x3;
35	/** dot border */	46
36	short BORDER_HAIR = 0x4;	47	/** dot border
37	/** Thick border */	48	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		49	*/
		50	short BORDER_DOTTED = 0x4;
		51
		52	/** Thick border
		53	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		54	*/
38	short BORDER_THICK = 0x5;	55	short BORDER_THICK = 0x5;
39	/** double-line border */	56
		57	/** double-line border
		58	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		59	*/
40	short BORDER_DOUBLE = 0x6;	60	short BORDER_DOUBLE = 0x6;
41	/** hair-line border */	61
42	short BORDER_DOTTED = 0x7;	62	/** hair-line border
43	/** Medium dashed border */	63	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		64	*/
		65	short BORDER_HAIR = 0x7;
		66
		67	/** Medium dashed border
		68	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		69	*/
44	short BORDER_MEDIUM_DASHED = 0x8;	70	short BORDER_MEDIUM_DASHED = 0x8;
45	/** dash-dot border */	71
		72
		73	/** dash-dot border
		74	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		75	*/
46	short BORDER_DASH_DOT = 0x9;	76	short BORDER_DASH_DOT = 0x9;
47	/** medium dash-dot border */	77
		78	/** medium dash-dot border
		79	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		80	*/
48	short BORDER_MEDIUM_DASH_DOT = 0xA;	81	short BORDER_MEDIUM_DASH_DOT = 0xA;
49	/** dash-dot-dot border */	82
		83	/** dash-dot-dot border
		84	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		85	*/
50	short BORDER_DASH_DOT_DOT = 0xB;	86	short BORDER_DASH_DOT_DOT = 0xB;
51	/** medium dash-dot-dot border */	87
		88	/** medium dash-dot-dot border
		89	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		90	*/
52	short BORDER_MEDIUM_DASH_DOT_DOT = 0xC;	91	short BORDER_MEDIUM_DASH_DOT_DOT = 0xC;
53	/** slanted dash-dot border */	92
		93	/** slanted dash-dot border
		94	* @deprecated 3.15 beta 1. Use {@link BorderStyle}
		95	*/
54	short BORDER_SLANTED_DASH_DOT = 0xD;	96	short BORDER_SLANTED_DASH_DOT = 0xD;
55		97
56	short getBorderBottom();	98	BorderStyle getBorderBottom();
57		99
58	short getBorderDiagonal();	100	BorderStyle getBorderDiagonal();
59		101
60	short getBorderLeft();	102	BorderStyle getBorderLeft();
61		103
62	short getBorderRight();	104	BorderStyle getBorderRight();
63		105
64	short getBorderTop();	106	BorderStyle getBorderTop();
65		107
66	short getBottomBorderColor();	108	short getBottomBorderColor();
67	Color getBottomBorderColorColor();	109	Color getBottomBorderColorColor();
Lines 78-112 Link Here
78	short getTopBorderColor();	120	short getTopBorderColor();
79	Color getTopBorderColorColor();	121	Color getTopBorderColorColor();
80		122
		123	/**
		124	* Set bottom border.
		125	*
		126	* @param border MUST be a BORDER_* constant
		127	* @deprecated 3.15 beta 1
		128	*/
81	void setBorderBottom(short border);	129	void setBorderBottom(short border);
82		130
83	/**	131	/**
		132	* Set bottom border.
		133	*
		134	* @param border
		135	*/
		136	void setBorderBottom(BorderStyle border);
		137
		138	/**
84	* Set diagonal border.	139	* Set diagonal border.
85	*	140	*
86	* @param border MUST be a BORDER_* constant	141	* @param border MUST be a BORDER_* constant
		142	* @deprecated 3.15 beta 1
87	*/	143	*/
88	void setBorderDiagonal(short border);	144	void setBorderDiagonal(short border);
		145
		146	/**
		147	* Set diagonal border.
		148	*
		149	* @param border
		150	*/
		151	void setBorderDiagonal(BorderStyle border);
89		152
90	/**	153	/**
91	* Set left border.	154	* Set left border.
92	*	155	*
93	* @param border MUST be a BORDER_* constant	156	* @param border MUST be a BORDER_* constant
		157	* @deprecated 3.15 beta 1
94	*/	158	*/
95	void setBorderLeft(short border);	159	void setBorderLeft(short border);
		160
		161	/**
		162	* Set left border.
		163	*
		164	* @param border
		165	*/
		166	void setBorderLeft(BorderStyle border);
96		167
97	/**	168	/**
98	* Set right border.	169	* Set right border.
99	*	170	*
100	* @param border MUST be a BORDER_* constant	171	* @param border MUST be a BORDER_* constant
		172	* @deprecated 3.15 beta 1
101	*/	173	*/
102	void setBorderRight(short border);	174	void setBorderRight(short border);
		175
		176	/**
		177	* Set right border.
		178	*
		179	* @param border
		180	*/
		181	void setBorderRight(BorderStyle border);
103		182
104	/**	183	/**
105	* Set top border.	184	* Set top border.
106	*	185	*
107	* @param border MUST be a BORDER_* constant	186	* @param border MUST be a BORDER_* constant
		187	* @deprecated 3.15 beta 1
108	*/	188	*/
109	void setBorderTop(short border);	189	void setBorderTop(short border);
		190
		191	/**
		192	* Set top border.
		193	*
		194	* @param border
		195	*/
		196	void setBorderTop(BorderStyle border);
110		197
111	void setBottomBorderColor(short color);	198	void setBottomBorderColor(short color);
112	void setBottomBorderColor(Color color);	199	void setBottomBorderColor(Color color);





    /**
     * 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;

     * @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

     * @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

     * @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

     * @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
     */
    BorderStyle getBorderBottom();

    /**
     * set the color to use for the left border





/**
 * The enumeration value indicating the line style of a border in a cell,
 * 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 (default)
     */
    NONE(0x0),


     * 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-dot border
     */
    MEDIUM_DASH_DOT_DOT(0xC),

    /**
     * slanted dash-dot border
     */
    SLANTED_DASH_DOT(0xD);
    

    private final short 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];
    }
}




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;

	private static Map<String, Object> getFormatProperties(CellStyle style) {
		Map<String, Object> properties = new HashMap<String, Object>();
		putShort(properties, ALIGNMENT, style.getAlignment());
		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());

	 */
	private static void setFormatProperties(CellStyle style, Workbook workbook, Map<String, Object> properties) {
		style.setAlignment(getShort(properties, ALIGNMENT));
		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));

		}
		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<String, Object> 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.

	private static void putShort(Map<String, Object> 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<String, Object> properties, String name, BorderStyle border) {
		properties.put(name, border);
	}

	/**
	 * Utility method that puts the named boolean value to the given map.




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;


     * @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)

        _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 BorderStyle getBorderLeft()
    {
        return BorderStyle.valueOf(_format.getBorderLeft());
    }

    /**

     * @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)

        _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 BorderStyle getBorderRight()
    {
        return BorderStyle.valueOf(_format.getBorderRight());
    }

    /**

     * @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)

        _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 BorderStyle getBorderTop()
    {
        return BorderStyle.valueOf(_format.getBorderTop());
    }

    /**

     * @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)

        _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 BorderStyle getBorderBottom()
    {
        return BorderStyle.valueOf(_format.getBorderBottom());
    }

    /**




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;

/**

        return borderFormatting;
    }

    @Override
    public BorderStyle getBorderBottom() {
        return BorderStyle.valueOf((short)borderFormatting.getBorderBottom());
    }

    @Override
    public BorderStyle getBorderDiagonal() {
        return BorderStyle.valueOf((short)borderFormatting.getBorderDiagonal());
    }

    @Override
    public BorderStyle getBorderLeft() {
        return BorderStyle.valueOf((short)borderFormatting.getBorderLeft());
    }

    @Override
    public BorderStyle getBorderRight() {
        return BorderStyle.valueOf((short)borderFormatting.getBorderRight());
    }

    @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()

        }
    }

    @Override
    public void setBorderBottom(short border) {
        borderFormatting.setBorderBottom(border);
        if (border != 0) {

            cfRuleRecord.setBottomBorderModified(false);
        }
    }
    @Override
    public void setBorderBottom(BorderStyle border) {
        setBorderBottom(border.getCode());
    }

    @Override
    public void setBorderDiagonal(short border) {
        borderFormatting.setBorderDiagonal(border);
        if (border != 0) {

            cfRuleRecord.setTopLeftBottomRightBorderModified(false);
        }
    }
    @Override
    public void setBorderDiagonal(BorderStyle border) {
        setBorderDiagonal(border.getCode());
    }

    @Override
    public void setBorderLeft(short border) {
        borderFormatting.setBorderLeft(border);
        if (border != 0) {

            cfRuleRecord.setLeftBorderModified(false);
        }
    }
    @Override
    public void setBorderLeft(BorderStyle border) {
        setBorderLeft(border.getCode());
    }

    @Override
    public void setBorderRight(short border) {
        borderFormatting.setBorderRight(border);
        if (border != 0) {

            cfRuleRecord.setRightBorderModified(false);
        }
    }
    @Override
    public void setBorderRight(BorderStyle border) {
        setBorderRight(border.getCode());
    }

    @Override
    public void setBorderTop(short border) {
        borderFormatting.setBorderTop(border);
        if (border != 0) {

            cfRuleRecord.setTopBorderModified(false);
        }
    }
    @Override
    public void setBorderTop(BorderStyle border) {
        setBorderTop(border.getCode());
    }

    @Override
    public void setBottomBorderColor(short color) {
        borderFormatting.setBottomBorderColor(color);
        if (color != 0) {

        }
    }

    @Override
    public void setDiagonalBorderColor(short color) {
        borderFormatting.setDiagonalBorderColor(color);
        if (color != 0) {

            cfRuleRecord.setTopLeftBottomRightBorderModified(false);
        }
    }
    @Override
    public void setDiagonalBorderColor(Color color) {
        HSSFColor hcolor = HSSFColor.toHSSFColor(color);
        if (hcolor == null) {

        }
    }

    @Override
    public void setLeftBorderColor(short color) {
        borderFormatting.setLeftBorderColor(color);
        if (color != 0) {

            cfRuleRecord.setLeftBorderModified(false);
        }
    }
    @Override
    public void setLeftBorderColor(Color color) {
        HSSFColor hcolor = HSSFColor.toHSSFColor(color);
        if (hcolor == null) {

        }
    }

    @Override
    public void setRightBorderColor(short color) {
        borderFormatting.setRightBorderColor(color);
        if (color != 0) {

            cfRuleRecord.setRightBorderModified(false);
        }
    }
    @Override
    public void setRightBorderColor(Color color) {
        HSSFColor hcolor = HSSFColor.toHSSFColor(color);
        if (hcolor == null) {

        }
    }

    @Override
    public void setTopBorderColor(short color) {
        borderFormatting.setTopBorderColor(color);
        if (color != 0) {

            cfRuleRecord.setTopBorderModified(false);
        }
    }
    @Override
    public void setTopBorderColor(Color color) {
        HSSFColor hcolor = HSSFColor.toHSSFColor(color);
        if (hcolor == null) {




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;

        _border = border;
    }

    @Override
    public BorderStyle getBorderBottom() {
        STBorderStyle.Enum ptrn = _border.isSetBottom() ? _border.getBottom().getStyle() : null;
        return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
    }

    @Override
    public BorderStyle getBorderDiagonal() {
        STBorderStyle.Enum ptrn = _border.isSetDiagonal() ? _border.getDiagonal().getStyle() : null;
        return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
    }

    @Override
    public BorderStyle getBorderLeft() {
        STBorderStyle.Enum ptrn = _border.isSetLeft() ? _border.getLeft().getStyle() : null;
        return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
    }

    @Override
    public BorderStyle getBorderRight() {
        STBorderStyle.Enum ptrn = _border.isSetRight() ? _border.getRight().getStyle() : null;
        return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
    }

    @Override
    public BorderStyle getBorderTop() {
        STBorderStyle.Enum ptrn = _border.isSetTop() ? _border.getTop().getStyle() : null;
        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 == 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 == 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 == 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 == 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 == 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);

        }
    }

    @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);

        }
    }

    @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);

        }
    }

    @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);

        }
    }

    @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);




    /**
     * Get the type of border to use for the bottom border of the cell
     *
     * @return border type, default value is {@link org.apache.poi.ss.usermodel.BorderStyle#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
     */
    @Override
    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;
        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
     * @deprecated 3.15 beta 1. Use {@link #getBorderBottom}
     */
    public BorderStyle getBorderBottomEnum() {
        return getBorderBottom();
        return BorderStyle.values()[style];
    }

    /**
     * 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}
     * @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
     */
    @Override
    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;
        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() {
        return getBorderLeft();
        return BorderStyle.values()[style];
    }

    /**
     * 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}
     * @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
     */
    @Override
    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;
        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() {
        return getBorderRight();
        return BorderStyle.values()[style];
    }

    /**
     * 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}
     * @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
     */
    @Override
    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;
        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() {
         return getBorderTop();
         return BorderStyle.values()[style];
    }

    /**

     * @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) {

     * @param border - type of border to use
     * @see org.apache.poi.ss.usermodel.BorderStyle
     */
    @Override
    public void setBorderBottom(BorderStyle border) {
        setBorderBottom(border.getCode());
    }

    /**

     * @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) {

      *
     * @param border the type of border to use
     */
    @Override
    public void setBorderLeft(BorderStyle border) {
        setBorderLeft(border.getCode());
    }

    /**

     * @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) {

      *
     * @param border the type of border to use
     */
    @Override
    public void setBorderRight(BorderStyle border) {
        setBorderRight(border.getCode());
    }

    /**

     * @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) {
        CTBorder ct = getCTBorder();
        CTBorderPr pr = ct.isSetTop() ? ct.getTop() : ct.addNewTop();
        if(border == BORDER_NONE) ct.unsetTop();

     *
     * @param border the type of border to use
     */
    @Override
    public void setBorderTop(BorderStyle border) {
        setBorderTop(border.getCode());
    }

    /**




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;

    protected boolean isEmptyStyle( CellStyle cellStyle ) {
        return cellStyle == null || (
               cellStyle.getFillPattern() == 0
            && cellStyle.getBorderTop() == BorderStyle.NONE
            && cellStyle.getBorderRight() == BorderStyle.NONE
            && cellStyle.getBorderBottom() == BorderStyle.NONE
            && cellStyle.getBorderLeft() == BorderStyle.NONE
        );
    }


    }

    protected void processCellStyleBorder( HSSFWorkbook workbook,
            Element cellTarget, String type, BorderStyle xlsBorder, short borderColor )
    {
        if ( xlsBorder == BorderStyle.NONE )
            return;

        StringBuilder borderStyle = new StringBuilder();




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;

    }

    private void buildStyle_border( HSSFWorkbook workbook, StringBuilder style,
            String type, BorderStyle xlsBorder, short borderColor )
    {
        if ( xlsBorder == BorderStyle.NONE ) {
            return;
        }





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;

        }
    }

    public static String getBorderStyle( BorderStyle xlsBorder )
    {
        final String borderStyle;
        switch ( xlsBorder )
        {
        case NONE:
            borderStyle = "none";
            break;
        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 DASHED:
        case MEDIUM_DASHED:
            borderStyle = "dashed";
            break;
        case DOUBLE:
            borderStyle = "double";
            break;
        default:

        return borderStyle;
    }

    public static String getBorderWidth( BorderStyle xlsBorder )
    {
        final String borderWidth;
        switch ( xlsBorder )
        {
        case MEDIUM_DASH_DOT:
        case MEDIUM_DASH_DOT_DOT:
        case MEDIUM_DASHED:
            borderWidth = "2pt";
            break;
        case THICK:
            borderWidth = "thick";
            break;
        default:





import javax.swing.border.AbstractBorder;

import org.apache.poi.ss.usermodel.BorderStyle;

/**
 * This is an attempt to implement Excel style borders for the SheetViewer.

  private Color eastColor = null;
  private Color southColor = null;
  private Color westColor = null;
  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;


   public void setBorder(Color northColor, Color eastColor,
                         Color southColor, Color westColor,
                         BorderStyle northBorderType, BorderStyle eastBorderType,
                         BorderStyle southBorderType, BorderStyle westBorderType,
                         boolean selected) {
     this.eastColor = eastColor;
     this.southColor = southColor;

     this.eastBorderType = eastBorderType;
     this.southBorderType = southBorderType;
     this.westBorderType = westBorderType;
     this.northBorder=northBorderType != BorderStyle.NONE;
     this.eastBorder=eastBorderType != BorderStyle.NONE;
     this.southBorder=southBorderType != BorderStyle.NONE;
     this.westBorder=westBorderType != BorderStyle.NONE;
     this.selected = selected;
   }


                                  int height) {

      if (northBorder &&
             ((northBorderType == BorderStyle.THIN) ||
              (northBorderType == BorderStyle.MEDIUM) ||
              (northBorderType == BorderStyle.THICK)
             )
         ) {


      }

      if (eastBorder &&
             ((eastBorderType == BorderStyle.THIN) ||
              (eastBorderType == BorderStyle.MEDIUM) ||
              (eastBorderType == BorderStyle.THICK)
             )
         ) {


      }

      if (southBorder &&
              ((southBorderType == BorderStyle.THIN) ||
               (southBorderType == BorderStyle.MEDIUM) ||
               (southBorderType == BorderStyle.THICK)
              )
         ) {


      }

      if (westBorder &&
             ((westBorderType == BorderStyle.THIN) ||
              (westBorderType == BorderStyle.MEDIUM) ||
              (westBorderType == BorderStyle.THICK)
             )
         ) {


   private void paintDottedBorders(Graphics g, int x, int y, int width,
                                  int height) {
      if (northBorder &&
             northBorderType == BorderStyle.DOTTED) {
        int thickness = getThickness(northBorderType);

      	g.setColor(northColor);

      }

      if (eastBorder &&
              eastBorderType == BorderStyle.DOTTED
         ) {

        int thickness = getThickness(eastBorderType);

      }

      if (southBorder &&
              southBorderType == BorderStyle.DOTTED
         ) {

        int thickness = getThickness(southBorderType);

      }

      if (westBorder &&
            westBorderType == BorderStyle.DOTTED
         ) {

        int thickness = getThickness(westBorderType);

   private void paintDashedBorders(Graphics g, int x, int y, int width,
                                  int height) {
      if (northBorder &&
             ((northBorderType == BorderStyle.DASHED) ||
              (northBorderType == BorderStyle.HAIR))
         ) {
        int thickness = getThickness(northBorderType);

        int dashlength = 1;

        if (northBorderType == BorderStyle.DASHED)
           dashlength = 2;

      	g.setColor(northColor);

      }

      if (eastBorder &&
              ((eastBorderType == BorderStyle.DASHED) ||
               (eastBorderType == BorderStyle.HAIR))
         ) {

        int thickness = getThickness(eastBorderType);


        int dashlength = 1;

        if (eastBorderType == BorderStyle.DASHED)
           dashlength = 2;

      	g.setColor(eastColor);

      }

      if (southBorder &&
              ((southBorderType == BorderStyle.DASHED) ||
               (southBorderType == BorderStyle.HAIR))
         ) {

        int thickness = getThickness(southBorderType);


        int dashlength = 1;

        if (southBorderType == BorderStyle.DASHED)
           dashlength = 2;

      	g.setColor(southColor);

      }

      if (westBorder &&
            ((westBorderType == BorderStyle.DASHED) ||
             (westBorderType == BorderStyle.HAIR))
         ) {

        int thickness = getThickness(westBorderType);


        int dashlength = 1;

        if (westBorderType == BorderStyle.DASHED)
           dashlength = 2;

      	g.setColor(westColor);

   private void paintDoubleBorders(Graphics g, int x, int y, int width,
                                  int height) {
      if (northBorder &&
             northBorderType == BorderStyle.DOUBLE) {

      	g.setColor(northColor);


      }

      if (eastBorder &&
              eastBorderType == BorderStyle.DOUBLE
         ) {

        int thickness = getThickness(eastBorderType);

      }

      if (southBorder &&
              southBorderType == BorderStyle.DOUBLE
         ) {

      	g.setColor(southColor);

      }

      if (westBorder &&
            westBorderType == BorderStyle.DOUBLE
         ) {

        int thickness = getThickness(westBorderType);

   private void paintDashDotDotBorders(Graphics g, int x, int y, int width,
                                  int height) {
      if (northBorder &&
             ((northBorderType == BorderStyle.DASH_DOT_DOT) ||
              (northBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
         ) {
        int thickness = getThickness(northBorderType);


      }

      if (eastBorder &&
              ((eastBorderType == BorderStyle.DASH_DOT_DOT) ||
               (eastBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
         ) {

        int thickness = getThickness(eastBorderType);

      }

      if (southBorder &&
              ((southBorderType == BorderStyle.DASH_DOT_DOT) ||
               (southBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
         ) {

        int thickness = getThickness(southBorderType);

      }

      if (westBorder &&
            ((westBorderType == BorderStyle.DASH_DOT_DOT) ||
             (westBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
         ) {

        int thickness = getThickness(westBorderType);

   /**
    * @returns the line thickness for a border based on border type
    */
   private int getThickness(BorderStyle thickness) {
       int retval=1;
       switch (thickness) {
           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;
             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;
           default:
             return 1;
       }
       return retval;
   }






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;


/**

                                   SVTableUtils.black,
                                   SVTableUtils.black,
                                   SVTableUtils.black,
                                   BorderStyle.NONE,
                                   BorderStyle.NONE,
                                   BorderStyle.NONE,
                                   BorderStyle.NONE,
                                   isSelected);
              setBorder(cellBorder);
            }




    private static final String COL_HEAD_CLASS = "colHeader";
    private static final String ROW_HEAD_CLASS = "rowHeader";

    private static final Map<Short, String> 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<Short, String> VERTICAL_ALIGN = mapFor(
            VERTICAL_BOTTOM, "bottom",
            VERTICAL_CENTER, "middle",
            VERTICAL_TOP, "top");

    private static final Map<BorderStyle, String> 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 <K, V> Map<K, V> mapFor(Object... mapping) {




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;

        String borderName;
        switch (borderSide) {
            case 't': default:
                b1 = style1.getBorderTop() == BorderStyle.THIN;
                b2 = style2.getBorderTop() == BorderStyle.THIN;
                borderName = "TOP";
                break;
            case 'b':
                b1 = style1.getBorderBottom() == BorderStyle.THIN;
                b2 = style2.getBorderBottom() == BorderStyle.THIN;
                borderName = "BOTTOM";
                break;
            case 'l':
                b1 = style1.getBorderLeft() == BorderStyle.THIN;
                b2 = style2.getBorderLeft() == BorderStyle.THIN;
                borderName = "LEFT";
                break;
            case 'r':
                b1 = style1.getBorderRight() == BorderStyle.THIN;
                b2 = style2.getBorderRight() == BorderStyle.THIN;
                borderName = "RIGHT";
                break;
        }




import junit.framework.TestCase;

import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.usermodel.BorderStyle;

/**
 * Class to test row styling functionality

        HSSFCellStyle    cs   = wb.createCellStyle();
        HSSFCellStyle    cs2  = wb.createCellStyle();

        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);

            assertNotNull("Row is not null", r);
            
            cs = r.getRowStyle();
            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 :-/ 




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;

        HSSFCellStyle    cs   = wb.createCellStyle();
        HSSFCellStyle    cs2  = wb.createCellStyle();

        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);

    	HSSFCellStyle cs;

    	cs = s.getRow(0).getCell(0).getCellStyle();
    	assertEquals(BorderStyle.HAIR, cs.getBorderRight());

    	cs = s.getRow(1).getCell(1).getCellStyle();
    	assertEquals(BorderStyle.DOTTED, cs.getBorderRight());

    	cs = s.getRow(2).getCell(2).getCellStyle();
    	assertEquals(BorderStyle.DASH_DOT_DOT, cs.getBorderRight());

    	cs = s.getRow(3).getCell(3).getCellStyle();
    	assertEquals(BorderStyle.DASHED, cs.getBorderRight());

    	cs = s.getRow(4).getCell(4).getCellStyle();
    	assertEquals(BorderStyle.THIN, cs.getBorderRight());

    	cs = s.getRow(5).getCell(5).getCellStyle();
    	assertEquals(BorderStyle.MEDIUM_DASH_DOT_DOT, cs.getBorderRight());

    	cs = s.getRow(6).getCell(6).getCellStyle();
    	assertEquals(BorderStyle.SLANTED_DASH_DOT, cs.getBorderRight());

    	cs = s.getRow(7).getCell(7).getCellStyle();
    	assertEquals(BorderStyle.MEDIUM_DASH_DOT, cs.getBorderRight());

    	cs = s.getRow(8).getCell(8).getCellStyle();
    	assertEquals(BorderStyle.MEDIUM_DASHED, cs.getBorderRight());

    	cs = s.getRow(9).getCell(9).getCellStyle();
    	assertEquals(BorderStyle.MEDIUM, cs.getBorderRight());

    	cs = s.getRow(10).getCell(10).getCellStyle();
    	assertEquals(BorderStyle.THICK, cs.getBorderRight());

    	cs = s.getRow(11).getCell(11).getCellStyle();
    	assertEquals(BorderStyle.DOUBLE, cs.getBorderRight());
    }

    public void testShrinkToFit() {

        font.setColor(Font.COLOR_RED);
        
        CellStyle style = wb.createCellStyle();
        style.setBorderBottom(BorderStyle.DOTTED);
        style.setFont(font);
        
        Cell cell = row.createCell(0);

        newCell.setCellValue("2testtext2");

        CellStyle newStyle = newCell.getCellStyle();
        assertEquals(BorderStyle.DOTTED, newStyle.getBorderBottom());
        assertEquals(Font.COLOR_RED, ((HSSFCellStyle)newStyle).getFont(wb).getColor());
        
//        OutputStream out = new FileOutputStream("/tmp/56959.xls");

Lines 68-73 Link Here

(-)src/testcases/org/apache/poi/hssf/usermodel/TestBugs.java (-1 / +2 lines)
68	import org.apache.poi.ss.formula.ptg.DeletedArea3DPtg;	68	import org.apache.poi.ss.formula.ptg.DeletedArea3DPtg;
69	import org.apache.poi.ss.formula.ptg.Ptg;	69	import org.apache.poi.ss.formula.ptg.Ptg;
70	import org.apache.poi.ss.usermodel.BaseTestBugzillaIssues;	70	import org.apache.poi.ss.usermodel.BaseTestBugzillaIssues;
		71	import org.apache.poi.ss.usermodel.BorderStyle;
71	import org.apache.poi.ss.usermodel.Cell;	72	import org.apache.poi.ss.usermodel.Cell;
72	import org.apache.poi.ss.usermodel.CellStyle;	73	import org.apache.poi.ss.usermodel.CellStyle;
73	import org.apache.poi.ss.usermodel.ClientAnchor.AnchorType;	74	import org.apache.poi.ss.usermodel.ClientAnchor.AnchorType;
Lines 2564-2570 Link Here
2564	HSSFSheet sheet = wb.getSheetAt(0);	2565	HSSFSheet sheet = wb.getSheetAt(0);
2565	HSSFRow row = sheet.getRow(0);	2566	HSSFRow row = sheet.getRow(0);
2566	HSSFCellStyle rstyle = row.getRowStyle();	2567	HSSFCellStyle rstyle = row.getRowStyle();
2567	assertEquals(rstyle.getBorderBottom(), CellStyle.BORDER_DOUBLE);	2568	assertEquals(BorderStyle.DOUBLE, rstyle.getBorderBottom());
2568	wb.close();	2569	wb.close();
2569	}	2570	}
2570		2571




        f.setFontName("Arial Unicode MS");
        cs.setFillBackgroundColor((short)3);
        cs.setFont(f);
        cs.setBorderTop(BorderStyle.THIN);
        cs.setBorderRight(BorderStyle.THIN);
        cs.setBorderLeft(BorderStyle.THIN);
        cs.setBorderBottom(BorderStyle.THIN);

        r = s.createRow(0);
        c=r.createCell(0);

        r = s.getRow(0);
        c = r.getCell(0);

        assertEquals("Formula Cell at 0,0", Cell.CELL_TYPE_FORMULA, c.getCellType());
        cs = c.getCellStyle();

        assertNotNull("Formula Cell Style", cs);
        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();
    }





        fontFmt.setFontStyle(true, false);

        BorderFormatting bordFmt = rule1.createBorderFormatting();
        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);


        BorderFormatting  r1bf = rule1.getBorderFormatting();
        assertNotNull(r1bf);
        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);

        ConditionalFormattingRule rule2 = sheetCF.createConditionalFormattingRule(
                ComparisonOperator.BETWEEN, "SUM(A10:A15)", "1+SUM(B16:B30)");
        BorderFormatting borderFmt = rule2.createBorderFormatting();
        borderFmt.setBorderDiagonal(BorderStyle.MEDIUM);

        CellRangeAddress [] regions = {
            new CellRangeAddress(2, 4, 0, 0), // A3:A5

        
        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();

        ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.EQUAL, "7");
        BorderFormatting borderFmt = rule1.createBorderFormatting();

        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(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(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(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 };



        BorderFormatting  r1fp = cf.getRule(0).getBorderFormatting();
        assertNotNull(r1fp);
        assertEquals(BorderStyle.THICK, r1fp.getBorderBottom());
        assertEquals(BorderStyle.THICK, r1fp.getBorderTop());
        assertEquals(BorderStyle.THIN, r1fp.getBorderLeft());
        assertEquals(BorderStyle.HAIR, r1fp.getBorderRight());
        
        workbook.close();
    }




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;

/**


        // Add a border should create a new style
        int styCnt1 = wb.getNumCellStyles();
        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, BorderStyle.THIN);
        int styCnt3 = wb.getNumCellStyles();
        assertEquals(styCnt3, styCnt2);


        // Add multiple border properties to cell should create a single new style
        int styCnt1 = wb.getNumCellStyles();
        Map<String, Object> props = new HashMap<String, Object>();
        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(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(styCnt2, styCnt3);

        wb.close();
    }




	@Test
	public void testGetSetBorderBottom() {
        //default values
        assertEquals(BorderStyle.NONE, cellStyle.getBorderBottom());

        int num = stylesTable.getBorders().size();
        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

        num = stylesTable.getBorders().size();
        //setting the same border multiple times should not change borderId
        for (int i = 0; i < 3; i++) {
            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 <bottom> element
        cellStyle.setBorderBottom(BorderStyle.NONE);
        assertEquals(num, stylesTable.getBorders().size());
        borderId = (int)cellStyle.getCoreXf().getBorderId();
        ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();

	@Test
    public void testGetSetBorderRight() {
        //default values
        assertEquals(BorderStyle.NONE, cellStyle.getBorderRight());

        int num = stylesTable.getBorders().size();
        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

        num = stylesTable.getBorders().size();
        //setting the same border multiple times should not change borderId
        for (int i = 0; i < 3; i++) {
            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 <right> element
        cellStyle.setBorderRight(BorderStyle.NONE);
        assertEquals(num, stylesTable.getBorders().size());
        borderId = (int)cellStyle.getCoreXf().getBorderId();
        ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();

	@Test
    public void testGetSetBorderLeft() {
        //default values
        assertEquals(BorderStyle.NONE, cellStyle.getBorderLeft());

        int num = stylesTable.getBorders().size();
        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

        num = stylesTable.getBorders().size();
        //setting the same border multiple times should not change borderId
        for (int i = 0; i < 3; i++) {
            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 <left> element
        cellStyle.setBorderLeft(BorderStyle.NONE);
        assertEquals(num, stylesTable.getBorders().size());
        borderId = (int)cellStyle.getCoreXf().getBorderId();
        ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();

	@Test
    public void testGetSetBorderTop() {
        //default values
        assertEquals(BorderStyle.NONE, cellStyle.getBorderTop());

        int num = stylesTable.getBorders().size();
        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

        num = stylesTable.getBorders().size();
        //setting the same border multiple times should not change borderId
        for (int i = 0; i < 3; i++) {
            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 <top> element
        cellStyle.setBorderTop(BorderStyle.NONE);
        assertEquals(num, stylesTable.getBorders().size());
        borderId = (int)cellStyle.getCoreXf().getBorderId();
        ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
        assertFalse(ctBorder.isSetTop());
    }
    
    private void testGetSetBorderXMLBean(BorderStyle border, STBorderStyle.Enum expected) {
        cellStyle.setBorderTop(border);
        assertEquals(border, cellStyle.getBorderTop());
        assertEquals(CellStyle.BORDER_THIN, 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(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();
        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() {
        testGetSetBorderXMLBean(BorderStyle.THICK, STBorderStyle.THICK);
    }
    
    @Test
    public void testGetSetBorderDouble() {
        testGetSetBorderXMLBean(BorderStyle.DOUBLE, STBorderStyle.DOUBLE);
    }
    
    @Test
	@Test
    public void testGetSetBorderHair() {
        testGetSetBorderXMLBean(BorderStyle.HAIR, STBorderStyle.HAIR);
    }
    
    @Test
    public void testGetSetBorderMediumDashed() {
        testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASHED, STBorderStyle.MEDIUM_DASHED);
    }
    
    @Test
	@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
    public void testGetSetBorderDashDot() {
        testGetSetBorderXMLBean(BorderStyle.DASH_DOT, STBorderStyle.DASH_DOT);
    }
    
    @Test
        //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
    public void testGetSetBorderMediumDashDot() {
        testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASH_DOT, STBorderStyle.MEDIUM_DASH_DOT);
    }
    
    @Test
    public void testGetSetBorderDashDotDot() {
        testGetSetBorderXMLBean(BorderStyle.DASH_DOT_DOT, STBorderStyle.DASH_DOT_DOT);
    }
    
    @Test
	@Test
    public void testGetSetBorderMediumDashDotDot() {
        testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASH_DOT_DOT, STBorderStyle.MEDIUM_DASH_DOT_DOT);
    }
    
    @Test
        //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
    public void testGetSetBorderSlantDashDot() {
        testGetSetBorderXMLBean(BorderStyle.SLANTED_DASH_DOT, STBorderStyle.SLANT_DASH_DOT);
    }
    
    @Test
        //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
    public void testGetSetBottomBorderColor() {
        //defaults
        assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getBottomBorderColor());


        cellStyle.setRightBorderColor(null);
        assertNull(cellStyle.getRightBorderXSSFColor());
        
        workbook.close();
    }
}

Return to bug 59264

Lines 24-29 Link Here

(-)src/testcases/org/apache/poi/hssf/usermodel/TestCellStyle.java (-18 / +19 lines)
24	import java.util.Date;	24	import java.util.Date;
25		25
26	import org.apache.poi.hssf.HSSFTestDataSamples;	26	import org.apache.poi.hssf.HSSFTestDataSamples;
		27	import org.apache.poi.ss.usermodel.BorderStyle;
27	import org.apache.poi.ss.usermodel.Cell;	28	import org.apache.poi.ss.usermodel.Cell;
28	import org.apache.poi.ss.usermodel.CellStyle;	29	import org.apache.poi.ss.usermodel.CellStyle;
29	import org.apache.poi.ss.usermodel.Font;	30	import org.apache.poi.ss.usermodel.Font;
Lines 180-189 Link Here
180	HSSFCellStyle cs = wb.createCellStyle();	181	HSSFCellStyle cs = wb.createCellStyle();
181	HSSFCellStyle cs2 = wb.createCellStyle();	182	HSSFCellStyle cs2 = wb.createCellStyle();
182		183
183	cs.setBorderBottom(HSSFCellStyle.BORDER_THIN);	184	cs.setBorderBottom(BorderStyle.THIN);
184	cs.setBorderLeft(HSSFCellStyle.BORDER_THIN);	185	cs.setBorderLeft(BorderStyle.THIN);
185	cs.setBorderRight(HSSFCellStyle.BORDER_THIN);	186	cs.setBorderRight(BorderStyle.THIN);
186	cs.setBorderTop(HSSFCellStyle.BORDER_THIN);	187	cs.setBorderTop(BorderStyle.THIN);
187	cs.setFillForegroundColor(( short ) 0xA);	188	cs.setFillForegroundColor(( short ) 0xA);
188	cs.setFillPattern(( short ) 1);	189	cs.setFillPattern(( short ) 1);
189	fnt.setColor(( short ) 0xf);	190	fnt.setColor(( short ) 0xf);
Lines 346-385 Link Here
346	HSSFCellStyle cs;	347	HSSFCellStyle cs;
347		348
348	cs = s.getRow(0).getCell(0).getCellStyle();	349	cs = s.getRow(0).getCell(0).getCellStyle();
349	assertEquals(CellStyle.BORDER_HAIR, cs.getBorderRight());	350	assertEquals(BorderStyle.HAIR, cs.getBorderRight());
350		351
351	cs = s.getRow(1).getCell(1).getCellStyle();	352	cs = s.getRow(1).getCell(1).getCellStyle();
352	assertEquals(CellStyle.BORDER_DOTTED, cs.getBorderRight());	353	assertEquals(BorderStyle.DOTTED, cs.getBorderRight());
353		354
354	cs = s.getRow(2).getCell(2).getCellStyle();	355	cs = s.getRow(2).getCell(2).getCellStyle();
355	assertEquals(CellStyle.BORDER_DASH_DOT_DOT, cs.getBorderRight());	356	assertEquals(BorderStyle.DASH_DOT_DOT, cs.getBorderRight());
356		357
357	cs = s.getRow(3).getCell(3).getCellStyle();	358	cs = s.getRow(3).getCell(3).getCellStyle();
358	assertEquals(CellStyle.BORDER_DASHED, cs.getBorderRight());	359	assertEquals(BorderStyle.DASHED, cs.getBorderRight());
359		360
360	cs = s.getRow(4).getCell(4).getCellStyle();	361	cs = s.getRow(4).getCell(4).getCellStyle();
361	assertEquals(CellStyle.BORDER_THIN, cs.getBorderRight());	362	assertEquals(BorderStyle.THIN, cs.getBorderRight());
362		363
363	cs = s.getRow(5).getCell(5).getCellStyle();	364	cs = s.getRow(5).getCell(5).getCellStyle();
364	assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT, cs.getBorderRight());	365	assertEquals(BorderStyle.MEDIUM_DASH_DOT_DOT, cs.getBorderRight());
365		366
366	cs = s.getRow(6).getCell(6).getCellStyle();	367	cs = s.getRow(6).getCell(6).getCellStyle();
367	assertEquals(CellStyle.BORDER_SLANTED_DASH_DOT, cs.getBorderRight());	368	assertEquals(BorderStyle.SLANTED_DASH_DOT, cs.getBorderRight());
368		369
369	cs = s.getRow(7).getCell(7).getCellStyle();	370	cs = s.getRow(7).getCell(7).getCellStyle();
370	assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT, cs.getBorderRight());	371	assertEquals(BorderStyle.MEDIUM_DASH_DOT, cs.getBorderRight());
371		372
372	cs = s.getRow(8).getCell(8).getCellStyle();	373	cs = s.getRow(8).getCell(8).getCellStyle();
373	assertEquals(CellStyle.BORDER_MEDIUM_DASHED, cs.getBorderRight());	374	assertEquals(BorderStyle.MEDIUM_DASHED, cs.getBorderRight());
374		375
375	cs = s.getRow(9).getCell(9).getCellStyle();	376	cs = s.getRow(9).getCell(9).getCellStyle();
376	assertEquals(CellStyle.BORDER_MEDIUM, cs.getBorderRight());	377	assertEquals(BorderStyle.MEDIUM, cs.getBorderRight());
377		378
378	cs = s.getRow(10).getCell(10).getCellStyle();	379	cs = s.getRow(10).getCell(10).getCellStyle();
379	assertEquals(CellStyle.BORDER_THICK, cs.getBorderRight());	380	assertEquals(BorderStyle.THICK, cs.getBorderRight());
380		381
381	cs = s.getRow(11).getCell(11).getCellStyle();	382	cs = s.getRow(11).getCell(11).getCellStyle();
382	assertEquals(CellStyle.BORDER_DOUBLE, cs.getBorderRight());	383	assertEquals(BorderStyle.DOUBLE, cs.getBorderRight());
383	}	384	}
384		385
385	public void testShrinkToFit() {	386	public void testShrinkToFit() {
Lines 485-491 Link Here
485	font.setColor(Font.COLOR_RED);	486	font.setColor(Font.COLOR_RED);
486		487
487	CellStyle style = wb.createCellStyle();	488	CellStyle style = wb.createCellStyle();
488	style.setBorderBottom(CellStyle.BORDER_DOTTED);	489	style.setBorderBottom(BorderStyle.DOTTED);
489	style.setFont(font);	490	style.setFont(font);
490		491
491	Cell cell = row.createCell(0);	492	Cell cell = row.createCell(0);
Lines 498-504 Link Here
498	newCell.setCellValue("2testtext2");	499	newCell.setCellValue("2testtext2");
499		500
500	CellStyle newStyle = newCell.getCellStyle();	501	CellStyle newStyle = newCell.getCellStyle();
501	assertEquals(CellStyle.BORDER_DOTTED, newStyle.getBorderBottom());	502	assertEquals(BorderStyle.DOTTED, newStyle.getBorderBottom());
502	assertEquals(Font.COLOR_RED, ((HSSFCellStyle)newStyle).getFont(wb).getColor());	503	assertEquals(Font.COLOR_RED, ((HSSFCellStyle)newStyle).getFont(wb).getColor());
503		504
504	// OutputStream out = new FileOutputStream("/tmp/56959.xls");	505	// OutputStream out = new FileOutputStream("/tmp/56959.xls");

Lines 323-332 Link Here

(-)src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java (-41 / +73 lines)
323	fontFmt.setFontStyle(true, false);	323	fontFmt.setFontStyle(true, false);
324		324
325	BorderFormatting bordFmt = rule1.createBorderFormatting();	325	BorderFormatting bordFmt = rule1.createBorderFormatting();
326	bordFmt.setBorderBottom(BorderFormatting.BORDER_THIN);	326	bordFmt.setBorderBottom(BorderStyle.THIN);
327	bordFmt.setBorderTop(BorderFormatting.BORDER_THICK);	327	bordFmt.setBorderTop(BorderStyle.THICK);
328	bordFmt.setBorderLeft(BorderFormatting.BORDER_DASHED);	328	bordFmt.setBorderLeft(BorderStyle.DASHED);
329	bordFmt.setBorderRight(BorderFormatting.BORDER_DOTTED);	329	bordFmt.setBorderRight(BorderStyle.DOTTED);
330		330
331	PatternFormatting patternFmt = rule1.createPatternFormatting();	331	PatternFormatting patternFmt = rule1.createPatternFormatting();
332	patternFmt.setFillBackgroundColor(IndexedColors.YELLOW.index);	332	patternFmt.setFillBackgroundColor(IndexedColors.YELLOW.index);
Lines 376-385 Link Here
376		376
377	BorderFormatting r1bf = rule1.getBorderFormatting();	377	BorderFormatting r1bf = rule1.getBorderFormatting();
378	assertNotNull(r1bf);	378	assertNotNull(r1bf);
379	assertEquals(BorderFormatting.BORDER_THIN, r1bf.getBorderBottom());	379	assertEquals(BorderStyle.THIN, r1bf.getBorderBottom());
380	assertEquals(BorderFormatting.BORDER_THICK,r1bf.getBorderTop());	380	assertEquals(BorderStyle.THICK,r1bf.getBorderTop());
381	assertEquals(BorderFormatting.BORDER_DASHED,r1bf.getBorderLeft());	381	assertEquals(BorderStyle.DASHED,r1bf.getBorderLeft());
382	assertEquals(BorderFormatting.BORDER_DOTTED,r1bf.getBorderRight());	382	assertEquals(BorderStyle.DOTTED,r1bf.getBorderRight());
383		383
384	PatternFormatting r1pf = rule1.getPatternFormatting();	384	PatternFormatting r1pf = rule1.getPatternFormatting();
385	assertNotNull(r1pf);	385	assertNotNull(r1pf);
Lines 453-459 Link Here
453	ConditionalFormattingRule rule2 = sheetCF.createConditionalFormattingRule(	453	ConditionalFormattingRule rule2 = sheetCF.createConditionalFormattingRule(
454	ComparisonOperator.BETWEEN, "SUM(A10:A15)", "1+SUM(B16:B30)");	454	ComparisonOperator.BETWEEN, "SUM(A10:A15)", "1+SUM(B16:B30)");
455	BorderFormatting borderFmt = rule2.createBorderFormatting();	455	BorderFormatting borderFmt = rule2.createBorderFormatting();
456	borderFmt.setBorderDiagonal((short) 2);	456	borderFmt.setBorderDiagonal(BorderStyle.MEDIUM);
457		457
458	CellRangeAddress [] regions = {	458	CellRangeAddress [] regions = {
459	new CellRangeAddress(2, 4, 0, 0), // A3:A5	459	new CellRangeAddress(2, 4, 0, 0), // A3:A5
Lines 1019-1025 Link Here
1019		1019
1020	workbook.close();	1020	workbook.close();
1021	}	1021	}
		1022
		1023	@Test
		1024	public void testAllCreateBorderFormatting() throws IOException {
		1025	// Make sure it is possible to create a conditional formatting rule
		1026	// with every type of Border Style
		1027	Workbook workbook = _testDataProvider.createWorkbook();
		1028	Sheet sheet = workbook.createSheet();
1022		1029
		1030	SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
		1031
		1032	ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.EQUAL, "7");
		1033	BorderFormatting borderFmt = rule1.createBorderFormatting();
		1034
		1035	for (BorderStyle border : BorderStyle.values()) {
		1036	borderFmt.setBorderTop(border);
		1037	assertEquals(border, borderFmt.getBorderTop());
		1038
		1039	borderFmt.setBorderBottom(border);
		1040	assertEquals(border, borderFmt.getBorderBottom());
		1041
		1042	borderFmt.setBorderLeft(border);
		1043	assertEquals(border, borderFmt.getBorderLeft());
		1044
		1045	borderFmt.setBorderRight(border);
		1046	assertEquals(border, borderFmt.getBorderRight());
		1047
		1048	borderFmt.setBorderDiagonal(border);
		1049	assertEquals(border, borderFmt.getBorderDiagonal());
		1050	}
		1051
		1052	workbook.close();
		1053	}
		1054
1023	@Test	1055	@Test
1024	public void testCreateBorderFormatting() throws IOException {	1056	public void testCreateBorderFormatting() throws IOException {
1025	Workbook workbook = _testDataProvider.createWorkbook();	1057	Workbook workbook = _testDataProvider.createWorkbook();
Lines 1030-1066 Link Here
1030	ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.EQUAL, "7");	1062	ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.EQUAL, "7");
1031	BorderFormatting borderFmt = rule1.createBorderFormatting();	1063	BorderFormatting borderFmt = rule1.createBorderFormatting();
1032		1064
1033	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderBottom());	1065	assertEquals(BorderStyle.NONE, borderFmt.getBorderBottom());
1034	borderFmt.setBorderBottom(BorderFormatting.BORDER_DOTTED);	1066	borderFmt.setBorderBottom(BorderStyle.DOTTED);
1035	assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderBottom());	1067	assertEquals(BorderStyle.DOTTED, borderFmt.getBorderBottom());
1036	borderFmt.setBorderBottom(BorderFormatting.BORDER_NONE);	1068	borderFmt.setBorderBottom(BorderStyle.NONE);
1037	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderBottom());	1069	assertEquals(BorderStyle.NONE, borderFmt.getBorderBottom());
1038	borderFmt.setBorderBottom(BorderFormatting.BORDER_THICK);	1070	borderFmt.setBorderBottom(BorderStyle.THICK);
1039	assertEquals(BorderFormatting.BORDER_THICK, borderFmt.getBorderBottom());	1071	assertEquals(BorderStyle.THICK, borderFmt.getBorderBottom());
1040		1072
1041	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderTop());	1073	assertEquals(BorderStyle.NONE, borderFmt.getBorderTop());
1042	borderFmt.setBorderTop(BorderFormatting.BORDER_DOTTED);	1074	borderFmt.setBorderTop(BorderStyle.DOTTED);
1043	assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderTop());	1075	assertEquals(BorderStyle.DOTTED, borderFmt.getBorderTop());
1044	borderFmt.setBorderTop(BorderFormatting.BORDER_NONE);	1076	borderFmt.setBorderTop(BorderStyle.NONE);
1045	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderTop());	1077	assertEquals(BorderStyle.NONE, borderFmt.getBorderTop());
1046	borderFmt.setBorderTop(BorderFormatting.BORDER_THICK);	1078	borderFmt.setBorderTop(BorderStyle.THICK);
1047	assertEquals(BorderFormatting.BORDER_THICK, borderFmt.getBorderTop());	1079	assertEquals(BorderStyle.THICK, borderFmt.getBorderTop());
1048		1080
1049	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderLeft());	1081	assertEquals(BorderStyle.NONE, borderFmt.getBorderLeft());
1050	borderFmt.setBorderLeft(BorderFormatting.BORDER_DOTTED);	1082	borderFmt.setBorderLeft(BorderStyle.DOTTED);
1051	assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderLeft());	1083	assertEquals(BorderStyle.DOTTED, borderFmt.getBorderLeft());
1052	borderFmt.setBorderLeft(BorderFormatting.BORDER_NONE);	1084	borderFmt.setBorderLeft(BorderStyle.NONE);
1053	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderLeft());	1085	assertEquals(BorderStyle.NONE, borderFmt.getBorderLeft());
1054	borderFmt.setBorderLeft(BorderFormatting.BORDER_THIN);	1086	borderFmt.setBorderLeft(BorderStyle.THIN);
1055	assertEquals(BorderFormatting.BORDER_THIN, borderFmt.getBorderLeft());	1087	assertEquals(BorderStyle.THIN, borderFmt.getBorderLeft());
1056		1088
1057	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderRight());	1089	assertEquals(BorderStyle.NONE, borderFmt.getBorderRight());
1058	borderFmt.setBorderRight(BorderFormatting.BORDER_DOTTED);	1090	borderFmt.setBorderRight(BorderStyle.DOTTED);
1059	assertEquals(BorderFormatting.BORDER_DOTTED, borderFmt.getBorderRight());	1091	assertEquals(BorderStyle.DOTTED, borderFmt.getBorderRight());
1060	borderFmt.setBorderRight(BorderFormatting.BORDER_NONE);	1092	borderFmt.setBorderRight(BorderStyle.NONE);
1061	assertEquals(BorderFormatting.BORDER_NONE, borderFmt.getBorderRight());	1093	assertEquals(BorderStyle.NONE, borderFmt.getBorderRight());
1062	borderFmt.setBorderRight(BorderFormatting.BORDER_HAIR);	1094	borderFmt.setBorderRight(BorderStyle.HAIR);
1063	assertEquals(BorderFormatting.BORDER_HAIR, borderFmt.getBorderRight());	1095	assertEquals(BorderStyle.HAIR, borderFmt.getBorderRight());
1064		1096
1065	ConditionalFormattingRule [] cfRules = { rule1 };	1097	ConditionalFormattingRule [] cfRules = { rule1 };
1066		1098
Lines 1076-1085 Link Here
1076		1108
1077	BorderFormatting r1fp = cf.getRule(0).getBorderFormatting();	1109	BorderFormatting r1fp = cf.getRule(0).getBorderFormatting();
1078	assertNotNull(r1fp);	1110	assertNotNull(r1fp);
1079	assertEquals(BorderFormatting.BORDER_THICK, r1fp.getBorderBottom());	1111	assertEquals(BorderStyle.THICK, r1fp.getBorderBottom());
1080	assertEquals(BorderFormatting.BORDER_THICK, r1fp.getBorderTop());	1112	assertEquals(BorderStyle.THICK, r1fp.getBorderTop());
1081	assertEquals(BorderFormatting.BORDER_THIN, r1fp.getBorderLeft());	1113	assertEquals(BorderStyle.THIN, r1fp.getBorderLeft());
1082	assertEquals(BorderFormatting.BORDER_HAIR, r1fp.getBorderRight());	1114	assertEquals(BorderStyle.HAIR, r1fp.getBorderRight());
1083		1115
1084	workbook.close();	1116	workbook.close();
1085	}	1117	}

Lines 87-170 Link Here

(-)src/java/org/apache/poi/ss/usermodel/CellStyle.java (-67 / +46 lines)
87		87
88	/**	88	/**
89	* No border	89	* No border
		90	* @deprecated Use {@link BorderStyle}
90	*/	91	*/
91		92
92	short BORDER_NONE = 0x0;	93	short BORDER_NONE = 0x0;
93		94
94	/**	95	/**
95	* Thin border	96	* Thin border
		97	* @deprecated Use {@link BorderStyle}
96	*/	98	*/
97		99
98	short BORDER_THIN = 0x1;	100	short BORDER_THIN = 0x1;
99		101
100	/**	102	/**
101	* Medium border	103	* Medium border
		104	* @deprecated Use {@link BorderStyle}
102	*/	105	*/
103		106
104	short BORDER_MEDIUM = 0x2;	107	short BORDER_MEDIUM = 0x2;
105		108
106	/**	109	/**
107	* dash border	110	* dash border
		111	* @deprecated Use {@link BorderStyle}
108	*/	112	*/
109		113
110	short BORDER_DASHED = 0x3;	114	short BORDER_DASHED = 0x3;
111		115
112	/**	116	/**
113	* dot border	117	* dot border
		118	* @deprecated Use {@link BorderStyle}
114	*/	119	*/
115		120
116	short BORDER_DOTTED = 0x4;	121	short BORDER_DOTTED = 0x4;
117		122
118	/**	123	/**
119	* Thick border	124	* Thick border
		125	* @deprecated Use {@link BorderStyle}
120	*/	126	*/
121		127
122	short BORDER_THICK = 0x5;	128	short BORDER_THICK = 0x5;
123		129
124	/**	130	/**
125	* double-line border	131	* double-line border
		132	* @deprecated Use {@link BorderStyle}
126	*/	133	*/
127		134
128	short BORDER_DOUBLE = 0x6;	135	short BORDER_DOUBLE = 0x6;
129		136
130	/**	137	/**
131	* hair-line border	138	* hair-line border
		139	* @deprecated Use {@link BorderStyle}
132	*/	140	*/
133		141
134	short BORDER_HAIR = 0x7;	142	short BORDER_HAIR = 0x7;
135		143
136	/**	144	/**
137	* Medium dashed border	145	* Medium dashed border
		146	* @deprecated Use {@link BorderStyle}
138	*/	147	*/
139		148
140	short BORDER_MEDIUM_DASHED = 0x8;	149	short BORDER_MEDIUM_DASHED = 0x8;
141		150
142	/**	151	/**
143	* dash-dot border	152	* dash-dot border
		153	* @deprecated Use {@link BorderStyle}
144	*/	154	*/
145		155
146	short BORDER_DASH_DOT = 0x9;	156	short BORDER_DASH_DOT = 0x9;
147		157
148	/**	158	/**
149	* medium dash-dot border	159	* medium dash-dot border
		160	* @deprecated Use {@link BorderStyle}
150	*/	161	*/
151		162
152	short BORDER_MEDIUM_DASH_DOT = 0xA;	163	short BORDER_MEDIUM_DASH_DOT = 0xA;
153		164
154	/**	165	/**
155	* dash-dot-dot border	166	* dash-dot-dot border
		167	* @deprecated Use {@link BorderStyle}
156	*/	168	*/
157		169
158	short BORDER_DASH_DOT_DOT = 0xB;	170	short BORDER_DASH_DOT_DOT = 0xB;
159		171
160	/**	172	/**
161	* medium dash-dot-dot border	173	* medium dash-dot-dot border
		174	* @deprecated Use {@link BorderStyle}
162	*/	175	*/
163		176
164	short BORDER_MEDIUM_DASH_DOT_DOT = 0xC;	177	short BORDER_MEDIUM_DASH_DOT_DOT = 0xC;
165		178
166	/**	179	/**
167	* slanted dash-dot border	180	* slanted dash-dot border
		181	* @deprecated Use {@link BorderStyle}
168	*/	182	*/
169		183
170	short BORDER_SLANTED_DASH_DOT = 0xD;	184	short BORDER_SLANTED_DASH_DOT = 0xD;
Lines 416-446 Link Here
416	* @see #BORDER_DASH_DOT_DOT	430	* @see #BORDER_DASH_DOT_DOT
417	* @see #BORDER_MEDIUM_DASH_DOT_DOT	431	* @see #BORDER_MEDIUM_DASH_DOT_DOT
418	* @see #BORDER_SLANTED_DASH_DOT	432	* @see #BORDER_SLANTED_DASH_DOT
		433	* @deprecated 3.15 beta 1
419	*/	434	*/
420
421	void setBorderLeft(short border);	435	void setBorderLeft(short border);
		436
		437	/**
		438	* set the type of border to use for the left border of the cell
		439	* @param border type
		440	*/
		441	void setBorderLeft(BorderStyle border);
422		442
423	/**	443	/**
424	* get the type of border to use for the left border of the cell	444	* get the type of border to use for the left border of the cell
425	* @return border type	445	* @return border type
426	* @see #BORDER_NONE
427	* @see #BORDER_THIN
428	* @see #BORDER_MEDIUM
429	* @see #BORDER_DASHED
430	* @see #BORDER_DOTTED
431	* @see #BORDER_THICK
432	* @see #BORDER_DOUBLE
433	* @see #BORDER_HAIR
434	* @see #BORDER_MEDIUM_DASHED
435	* @see #BORDER_DASH_DOT
436	* @see #BORDER_MEDIUM_DASH_DOT
437	* @see #BORDER_DASH_DOT_DOT
438	* @see #BORDER_MEDIUM_DASH_DOT_DOT
439	* @see #BORDER_SLANTED_DASH_DOT
440	*/	446	*/
		447	BorderStyle getBorderLeft();
441		448
442	short getBorderLeft();
443
444	/**	449	/**
445	* set the type of border to use for the right border of the cell	450	* set the type of border to use for the right border of the cell
446	* @param border type	451	* @param border type
Lines 458-488 Link Here
458	* @see #BORDER_DASH_DOT_DOT	463	* @see #BORDER_DASH_DOT_DOT
459	* @see #BORDER_MEDIUM_DASH_DOT_DOT	464	* @see #BORDER_MEDIUM_DASH_DOT_DOT
460	* @see #BORDER_SLANTED_DASH_DOT	465	* @see #BORDER_SLANTED_DASH_DOT
		466	* @deprecated 3.15 beta 1
461	*/	467	*/
462
463	void setBorderRight(short border);	468	void setBorderRight(short border);
		469
		470	/**
		471	* set the type of border to use for the right border of the cell
		472	* @param border type
		473	*/
		474	void setBorderRight(BorderStyle border);
464		475
465	/**	476	/**
466	* get the type of border to use for the right border of the cell	477	* get the type of border to use for the right border of the cell
467	* @return border type	478	* @return border type
468	* @see #BORDER_NONE
469	* @see #BORDER_THIN
470	* @see #BORDER_MEDIUM
471	* @see #BORDER_DASHED
472	* @see #BORDER_DOTTED
473	* @see #BORDER_THICK
474	* @see #BORDER_DOUBLE
475	* @see #BORDER_HAIR
476	* @see #BORDER_MEDIUM_DASHED
477	* @see #BORDER_DASH_DOT
478	* @see #BORDER_MEDIUM_DASH_DOT
479	* @see #BORDER_DASH_DOT_DOT
480	* @see #BORDER_MEDIUM_DASH_DOT_DOT
481	* @see #BORDER_SLANTED_DASH_DOT
482	*/	479	*/
		480	BorderStyle getBorderRight();
483		481
484	short getBorderRight();
485
486	/**	482	/**
487	* set the type of border to use for the top border of the cell	483	* set the type of border to use for the top border of the cell
488	* @param border type	484	* @param border type
Lines 500-530 Link Here
500	* @see #BORDER_DASH_DOT_DOT	496	* @see #BORDER_DASH_DOT_DOT
501	* @see #BORDER_MEDIUM_DASH_DOT_DOT	497	* @see #BORDER_MEDIUM_DASH_DOT_DOT
502	* @see #BORDER_SLANTED_DASH_DOT	498	* @see #BORDER_SLANTED_DASH_DOT
		499	* @deprecated 3.15 beta 1
503	*/	500	*/
504
505	void setBorderTop(short border);	501	void setBorderTop(short border);
		502
		503	/**
		504	* set the type of border to use for the top border of the cell
		505	* @param border type
		506	*/
		507	void setBorderTop(BorderStyle border);
506		508
507	/**	509	/**
508	* get the type of border to use for the top border of the cell	510	* get the type of border to use for the top border of the cell
509	* @return border type	511	* @return border type
510	* @see #BORDER_NONE
511	* @see #BORDER_THIN
512	* @see #BORDER_MEDIUM
513	* @see #BORDER_DASHED
514	* @see #BORDER_DOTTED
515	* @see #BORDER_THICK
516	* @see #BORDER_DOUBLE
517	* @see #BORDER_HAIR
518	* @see #BORDER_MEDIUM_DASHED
519	* @see #BORDER_DASH_DOT
520	* @see #BORDER_MEDIUM_DASH_DOT
521	* @see #BORDER_DASH_DOT_DOT
522	* @see #BORDER_MEDIUM_DASH_DOT_DOT
523	* @see #BORDER_SLANTED_DASH_DOT
524	*/	512	*/
		513	BorderStyle getBorderTop();
525		514
526	short getBorderTop();
527
528	/**	515	/**
529	* set the type of border to use for the bottom border of the cell	516	* set the type of border to use for the bottom border of the cell
530	* @param border type	517	* @param border type
Lines 542-570 Link Here
542	* @see #BORDER_DASH_DOT_DOT	529	* @see #BORDER_DASH_DOT_DOT
543	* @see #BORDER_MEDIUM_DASH_DOT_DOT	530	* @see #BORDER_MEDIUM_DASH_DOT_DOT
544	* @see #BORDER_SLANTED_DASH_DOT	531	* @see #BORDER_SLANTED_DASH_DOT
		532	* @deprecated 3.15 beta 1
545	*/	533	*/
546
547	void setBorderBottom(short border);	534	void setBorderBottom(short border);
		535
		536	/**
		537	* set the type of border to use for the bottom border of the cell
		538	* @param border type
		539	*/
		540	void setBorderBottom(BorderStyle border);
548		541
549	/**	542	/**
550	* get the type of border to use for the bottom border of the cell	543	* get the type of border to use for the bottom border of the cell
551	* @return border type	544	* @return border type
552	* @see #BORDER_NONE
553	* @see #BORDER_THIN
554	* @see #BORDER_MEDIUM
555	* @see #BORDER_DASHED
556	* @see #BORDER_DOTTED
557	* @see #BORDER_THICK
558	* @see #BORDER_DOUBLE
559	* @see #BORDER_HAIR
560	* @see #BORDER_MEDIUM_DASHED
561	* @see #BORDER_DASH_DOT
562	* @see #BORDER_MEDIUM_DASH_DOT
563	* @see #BORDER_DASH_DOT_DOT
564	* @see #BORDER_MEDIUM_DASH_DOT_DOT
565	* @see #BORDER_SLANTED_DASH_DOT
566	*/	545	*/
567	short getBorderBottom();	546	BorderStyle getBorderBottom();
568		547
569	/**	548	/**
570	* set the color to use for the left border	549	* set the color to use for the left border

Lines 19-31 Link Here

(-)src/java/org/apache/poi/ss/usermodel/BorderStyle.java (-6 / +20 lines)
19		19
20	/**	20	/**
21	* The enumeration value indicating the line style of a border in a cell,	21	* The enumeration value indicating the line style of a border in a cell,
22	* i.e., whether it is borded dash dot, dash dot dot, dashed, dotted, double, hair, medium,	22	* i.e., whether it is bordered dash dot, dash dot dot, dashed, dotted, double, hair, medium,
23	* medium dash dot, medium dash dot dot, medium dashed, none, slant dash dot, thick or thin.	23	* medium dash dot, medium dash dot dot, medium dashed, none, slant dash dot, thick or thin.
24	*/	24	*/
25	public enum BorderStyle {	25	public enum BorderStyle {
26		26
27	/**	27	/**
28	* No border	28	* No border (default)
29	*/	29	*/
30	NONE(0x0),	30	NONE(0x0),
31		31
Lines 88-109 Link Here
88	* medium dash-dot-dot border	88	* medium dash-dot-dot border
89	* @deprecated POI 3.15 beta 1. Use {@link MEDIUM_DASH_DOT_DOT} instead.	89	* @deprecated POI 3.15 beta 1. Use {@link MEDIUM_DASH_DOT_DOT} instead.
90	*/	90	*/
91	MEDIUM_DASH_DOT_DOTC(0xC),	91	//MEDIUM_DASH_DOT_DOTC(0xC),
		92
		93	/**
		94	* medium dash-dot-dot border
		95	*/
92	MEDIUM_DASH_DOT_DOT(0xC),	96	MEDIUM_DASH_DOT_DOT(0xC),
93		97
94	/**	98	/**
95	* slanted dash-dot border	99	* slanted dash-dot border
96	*/	100	*/
97	SLANTED_DASH_DOT(0xD);	101	SLANTED_DASH_DOT(0xD);
98		102
99
100	private final short code;	103	private final short code;
101		104
102	BorderStyle(int code) {	105	private BorderStyle(int code) {
103	this.code = (short)code;	106	this.code = (short)code;
104	}	107	}
105		108
106	public short getCode() {	109	public short getCode() {
107	return code;	110	return code;
108	}	111	}
		112
		113	private static final BorderStyle[] _table = new BorderStyle[0xD + 1];
		114	static {
		115	for (BorderStyle c : values()) {
		116	_table[c.getCode()] = c;
		117	}
		118	}
		119
		120	public static BorderStyle valueOf(short code) {
		121	return _table[code];
		122	}
109	}	123	}

Lines 22-27 Link Here

(-)src/java/org/apache/poi/ss/util/CellUtil.java (-8 / +32 lines)
22	import java.util.Locale;	22	import java.util.Locale;
23	import java.util.Map;	23	import java.util.Map;
24		24
		25	import org.apache.poi.ss.usermodel.BorderStyle;
25	import org.apache.poi.ss.usermodel.Cell;	26	import org.apache.poi.ss.usermodel.Cell;
26	import org.apache.poi.ss.usermodel.CellStyle;	27	import org.apache.poi.ss.usermodel.CellStyle;
27	import org.apache.poi.ss.usermodel.Font;	28	import org.apache.poi.ss.usermodel.Font;
Lines 277-286 Link Here
277	private static Map<String, Object> getFormatProperties(CellStyle style) {	278	private static Map<String, Object> getFormatProperties(CellStyle style) {
278	Map<String, Object> properties = new HashMap<String, Object>();	279	Map<String, Object> properties = new HashMap<String, Object>();
279	putShort(properties, ALIGNMENT, style.getAlignment());	280	putShort(properties, ALIGNMENT, style.getAlignment());
280	putShort(properties, BORDER_BOTTOM, style.getBorderBottom());	281	putBorderStyle(properties, BORDER_BOTTOM, style.getBorderBottom());
281	putShort(properties, BORDER_LEFT, style.getBorderLeft());	282	putBorderStyle(properties, BORDER_LEFT, style.getBorderLeft());
282	putShort(properties, BORDER_RIGHT, style.getBorderRight());	283	putBorderStyle(properties, BORDER_RIGHT, style.getBorderRight());
283	putShort(properties, BORDER_TOP, style.getBorderTop());	284	putBorderStyle(properties, BORDER_TOP, style.getBorderTop());
284	putShort(properties, BOTTOM_BORDER_COLOR, style.getBottomBorderColor());	285	putShort(properties, BOTTOM_BORDER_COLOR, style.getBottomBorderColor());
285	putShort(properties, DATA_FORMAT, style.getDataFormat());	286	putShort(properties, DATA_FORMAT, style.getDataFormat());
286	putShort(properties, FILL_BACKGROUND_COLOR, style.getFillBackgroundColor());	287	putShort(properties, FILL_BACKGROUND_COLOR, style.getFillBackgroundColor());
Lines 309-318 Link Here
309	*/	310	*/
310	private static void setFormatProperties(CellStyle style, Workbook workbook, Map<String, Object> properties) {	311	private static void setFormatProperties(CellStyle style, Workbook workbook, Map<String, Object> properties) {
311	style.setAlignment(getShort(properties, ALIGNMENT));	312	style.setAlignment(getShort(properties, ALIGNMENT));
312	style.setBorderBottom(getShort(properties, BORDER_BOTTOM));	313	style.setBorderBottom(getBorderStyle(properties, BORDER_BOTTOM));
313	style.setBorderLeft(getShort(properties, BORDER_LEFT));	314	style.setBorderLeft(getBorderStyle(properties, BORDER_LEFT));
314	style.setBorderRight(getShort(properties, BORDER_RIGHT));	315	style.setBorderRight(getBorderStyle(properties, BORDER_RIGHT));
315	style.setBorderTop(getShort(properties, BORDER_TOP));	316	style.setBorderTop(getBorderStyle(properties, BORDER_TOP));
316	style.setBottomBorderColor(getShort(properties, BOTTOM_BORDER_COLOR));	317	style.setBottomBorderColor(getShort(properties, BOTTOM_BORDER_COLOR));
317	style.setDataFormat(getShort(properties, DATA_FORMAT));	318	style.setDataFormat(getShort(properties, DATA_FORMAT));
318	style.setFillBackgroundColor(getShort(properties, FILL_BACKGROUND_COLOR));	319	style.setFillBackgroundColor(getShort(properties, FILL_BACKGROUND_COLOR));
Lines 345-350 Link Here
345	}	346	}
346	return 0;	347	return 0;
347	}	348	}
		349
		350	/**
		351	* Utility method that returns the named BorderStyle value form the given map.
		352	*
		353	* @param properties map of named properties (String -> Object)
		354	* @param name property name
		355	* @return Border style if set, otherwise {@link BorderStyle#NONE}
		356	*/
		357	private static BorderStyle getBorderStyle(Map<String, Object> properties, String name) {
		358	BorderStyle value = (BorderStyle) properties.get(name);
		359	return (value != null) ? value : BorderStyle.NONE;
		360	}
348		361
349	/**	362	/**
350	* Utility method that returns the named boolean value form the given map.	363	* Utility method that returns the named boolean value form the given map.
Lines 373-378 Link Here
373	private static void putShort(Map<String, Object> properties, String name, short value) {	386	private static void putShort(Map<String, Object> properties, String name, short value) {
374	properties.put(name, Short.valueOf(value));	387	properties.put(name, Short.valueOf(value));
375	}	388	}
		389
		390	/**
		391	* Utility method that puts the named short value to the given map.
		392	*
		393	* @param properties map of properties (String -> Object)
		394	* @param name property name
		395	* @param value property value
		396	*/
		397	private static void putBorderStyle(Map<String, Object> properties, String name, BorderStyle border) {
		398	properties.put(name, border);
		399	}
376		400
377	/**	401	/**
378	* Utility method that puts the named boolean value to the given map.	402	* Utility method that puts the named boolean value to the given map.

Lines 26-31 Link Here

(-)src/java/org/apache/poi/hssf/usermodel/HSSFCellStyle.java (-64 / +53 lines)
26	import org.apache.poi.hssf.record.FormatRecord;	26	import org.apache.poi.hssf.record.FormatRecord;
27	import org.apache.poi.hssf.record.StyleRecord;	27	import org.apache.poi.hssf.record.StyleRecord;
28	import org.apache.poi.hssf.util.HSSFColor;	28	import org.apache.poi.hssf.util.HSSFColor;
		29	import org.apache.poi.ss.usermodel.BorderStyle;
29	import org.apache.poi.ss.usermodel.CellStyle;	30	import org.apache.poi.ss.usermodel.CellStyle;
30	import org.apache.poi.ss.usermodel.Font;	31	import org.apache.poi.ss.usermodel.Font;
31		32
Lines 410-415 Link Here
410	* @see #BORDER_DASH_DOT_DOT	411	* @see #BORDER_DASH_DOT_DOT
411	* @see #BORDER_MEDIUM_DASH_DOT_DOT	412	* @see #BORDER_MEDIUM_DASH_DOT_DOT
412	* @see #BORDER_SLANTED_DASH_DOT	413	* @see #BORDER_SLANTED_DASH_DOT
		414	* @deprecated 3.15 beta 1
413	*/	415	*/
414	@Override	416	@Override
415	public void setBorderLeft(short border)	417	public void setBorderLeft(short border)
Lines 417-445 Link Here
417	_format.setIndentNotParentBorder(true);	419	_format.setIndentNotParentBorder(true);
418	_format.setBorderLeft(border);	420	_format.setBorderLeft(border);
419	}	421	}
		422
		423	/**
		424	* set the type of border to use for the left border of the cell
		425	* @param border type
		426	*/
		427	@Override
		428	public void setBorderLeft(BorderStyle border)
		429	{
		430	setBorderLeft(border.getCode());
		431	}
420		432
421	/**	433	/**
422	* get the type of border to use for the left border of the cell	434	* get the type of border to use for the left border of the cell
423	* @return border type	435	* @return border type
424	* @see #BORDER_NONE
425	* @see #BORDER_THIN
426	* @see #BORDER_MEDIUM
427	* @see #BORDER_DASHED
428	* @see #BORDER_DOTTED
429	* @see #BORDER_THICK
430	* @see #BORDER_DOUBLE
431	* @see #BORDER_HAIR
432	* @see #BORDER_MEDIUM_DASHED
433	* @see #BORDER_DASH_DOT
434	* @see #BORDER_MEDIUM_DASH_DOT
435	* @see #BORDER_DASH_DOT_DOT
436	* @see #BORDER_MEDIUM_DASH_DOT_DOT
437	* @see #BORDER_SLANTED_DASH_DOT
438	*/	436	*/
439	@Override	437	@Override
440	public short getBorderLeft()	438	public BorderStyle getBorderLeft()
441	{	439	{
442	return _format.getBorderLeft();	440	return BorderStyle.valueOf(_format.getBorderLeft());
443	}	441	}
444		442
445	/**	443	/**
Lines 459-464 Link Here
459	* @see #BORDER_DASH_DOT_DOT	457	* @see #BORDER_DASH_DOT_DOT
460	* @see #BORDER_MEDIUM_DASH_DOT_DOT	458	* @see #BORDER_MEDIUM_DASH_DOT_DOT
461	* @see #BORDER_SLANTED_DASH_DOT	459	* @see #BORDER_SLANTED_DASH_DOT
		460	* @deprecated 3.15 beta 1
462	*/	461	*/
463	@Override	462	@Override
464	public void setBorderRight(short border)	463	public void setBorderRight(short border)
Lines 466-494 Link Here
466	_format.setIndentNotParentBorder(true);	465	_format.setIndentNotParentBorder(true);
467	_format.setBorderRight(border);	466	_format.setBorderRight(border);
468	}	467	}
		468
		469	/**
		470	* set the type of border to use for the right border of the cell
		471	* @param border type
		472	*/
		473	@Override
		474	public void setBorderRight(BorderStyle border)
		475	{
		476	setBorderRight(border.getCode());
		477	}
469		478
470	/**	479	/**
471	* get the type of border to use for the right border of the cell	480	* get the type of border to use for the right border of the cell
472	* @return border type	481	* @return border type
473	* @see #BORDER_NONE
474	* @see #BORDER_THIN
475	* @see #BORDER_MEDIUM
476	* @see #BORDER_DASHED
477	* @see #BORDER_DOTTED
478	* @see #BORDER_THICK
479	* @see #BORDER_DOUBLE
480	* @see #BORDER_HAIR
481	* @see #BORDER_MEDIUM_DASHED
482	* @see #BORDER_DASH_DOT
483	* @see #BORDER_MEDIUM_DASH_DOT
484	* @see #BORDER_DASH_DOT_DOT
485	* @see #BORDER_MEDIUM_DASH_DOT_DOT
486	* @see #BORDER_SLANTED_DASH_DOT
487	*/	482	*/
488	@Override	483	@Override
489	public short getBorderRight()	484	public BorderStyle getBorderRight()
490	{	485	{
491	return _format.getBorderRight();	486	return BorderStyle.valueOf(_format.getBorderRight());
492	}	487	}
493		488
494	/**	489	/**
Lines 508-513 Link Here
508	* @see #BORDER_DASH_DOT_DOT	503	* @see #BORDER_DASH_DOT_DOT
509	* @see #BORDER_MEDIUM_DASH_DOT_DOT	504	* @see #BORDER_MEDIUM_DASH_DOT_DOT
510	* @see #BORDER_SLANTED_DASH_DOT	505	* @see #BORDER_SLANTED_DASH_DOT
		506	* @deprecated 3.15 beta 1
511	*/	507	*/
512	@Override	508	@Override
513	public void setBorderTop(short border)	509	public void setBorderTop(short border)
Lines 515-543 Link Here
515	_format.setIndentNotParentBorder(true);	511	_format.setIndentNotParentBorder(true);
516	_format.setBorderTop(border);	512	_format.setBorderTop(border);
517	}	513	}
		514
		515	/**
		516	* set the type of border to use for the top border of the cell
		517	* @param border type
		518	*/
		519	@Override
		520	public void setBorderTop(BorderStyle border)
		521	{
		522	setBorderTop(border.getCode());
		523	}
518		524
519	/**	525	/**
520	* get the type of border to use for the top border of the cell	526	* get the type of border to use for the top border of the cell
521	* @return border type	527	* @return border type
522	* @see #BORDER_NONE
523	* @see #BORDER_THIN
524	* @see #BORDER_MEDIUM
525	* @see #BORDER_DASHED
526	* @see #BORDER_DOTTED
527	* @see #BORDER_THICK
528	* @see #BORDER_DOUBLE
529	* @see #BORDER_HAIR
530	* @see #BORDER_MEDIUM_DASHED
531	* @see #BORDER_DASH_DOT
532	* @see #BORDER_MEDIUM_DASH_DOT
533	* @see #BORDER_DASH_DOT_DOT
534	* @see #BORDER_MEDIUM_DASH_DOT_DOT
535	* @see #BORDER_SLANTED_DASH_DOT
536	*/	528	*/
537	@Override	529	@Override
538	public short getBorderTop()	530	public BorderStyle getBorderTop()
539	{	531	{
540	return _format.getBorderTop();	532	return BorderStyle.valueOf(_format.getBorderTop());
541	}	533	}
542		534
543	/**	535	/**
Lines 557-562 Link Here
557	* @see #BORDER_DASH_DOT_DOT	549	* @see #BORDER_DASH_DOT_DOT
558	* @see #BORDER_MEDIUM_DASH_DOT_DOT	550	* @see #BORDER_MEDIUM_DASH_DOT_DOT
559	* @see #BORDER_SLANTED_DASH_DOT	551	* @see #BORDER_SLANTED_DASH_DOT
		552	* @deprecated 3.15 beta 1
560	*/	553	*/
561	@Override	554	@Override
562	public void setBorderBottom(short border)	555	public void setBorderBottom(short border)
Lines 564-592 Link Here
564	_format.setIndentNotParentBorder(true);	557	_format.setIndentNotParentBorder(true);
565	_format.setBorderBottom(border);	558	_format.setBorderBottom(border);
566	}	559	}
		560
		561	/**
		562	* set the type of border to use for the bottom border of the cell
		563	* @param border type
		564	*/
		565	@Override
		566	public void setBorderBottom(BorderStyle border)
		567	{
		568	setBorderBottom(border.getCode());
		569	}
567		570
568	/**	571	/**
569	* get the type of border to use for the bottom border of the cell	572	* get the type of border to use for the bottom border of the cell
570	* @return border type	573	* @return border type
571	* @see #BORDER_NONE
572	* @see #BORDER_THIN
573	* @see #BORDER_MEDIUM
574	* @see #BORDER_DASHED
575	* @see #BORDER_DOTTED
576	* @see #BORDER_THICK
577	* @see #BORDER_DOUBLE
578	* @see #BORDER_HAIR
579	* @see #BORDER_MEDIUM_DASHED
580	* @see #BORDER_DASH_DOT
581	* @see #BORDER_MEDIUM_DASH_DOT
582	* @see #BORDER_DASH_DOT_DOT
583	* @see #BORDER_MEDIUM_DASH_DOT_DOT
584	* @see #BORDER_SLANTED_DASH_DOT
585	*/	574	*/
586	@Override	575	@Override
587	public short getBorderBottom()	576	public BorderStyle getBorderBottom()
588	{	577	{
589	return _format.getBorderBottom();	578	return BorderStyle.valueOf(_format.getBorderBottom());
590	}	579	}
591		580
592	/**	581	/**

Lines 20-25 Link Here

(-)src/java/org/apache/poi/hssf/usermodel/HSSFBorderFormatting.java (-10 / +60 lines)
20	import org.apache.poi.hssf.record.CFRuleBase;	20	import org.apache.poi.hssf.record.CFRuleBase;
21	import org.apache.poi.hssf.record.cf.BorderFormatting;	21	import org.apache.poi.hssf.record.cf.BorderFormatting;
22	import org.apache.poi.hssf.util.HSSFColor;	22	import org.apache.poi.hssf.util.HSSFColor;
		23	import org.apache.poi.ss.usermodel.BorderStyle;
23	import org.apache.poi.ss.usermodel.Color;	24	import org.apache.poi.ss.usermodel.Color;
24		25
25	/**	26	/**
Lines 41-105 Link Here
41	return borderFormatting;	42	return borderFormatting;
42	}	43	}
43		44
44	public short getBorderBottom() {	45	@Override
45	return (short)borderFormatting.getBorderBottom();	46	public BorderStyle getBorderBottom() {
		47	return BorderStyle.valueOf((short)borderFormatting.getBorderBottom());
46	}	48	}
47		49
48	public short getBorderDiagonal() {	50	@Override
49	return (short)borderFormatting.getBorderDiagonal();	51	public BorderStyle getBorderDiagonal() {
		52	return BorderStyle.valueOf((short)borderFormatting.getBorderDiagonal());
50	}	53	}
51		54
52	public short getBorderLeft() {	55	@Override
53	return (short)borderFormatting.getBorderLeft();	56	public BorderStyle getBorderLeft() {
		57	return BorderStyle.valueOf((short)borderFormatting.getBorderLeft());
54	}	58	}
55		59
56	public short getBorderRight() {	60	@Override
57	return (short)borderFormatting.getBorderRight();	61	public BorderStyle getBorderRight() {
		62	return BorderStyle.valueOf((short)borderFormatting.getBorderRight());
58	}	63	}
59		64
60	public short getBorderTop() {	65	@Override
61	return (short)borderFormatting.getBorderTop();	66	public BorderStyle getBorderTop() {
		67	return BorderStyle.valueOf((short)borderFormatting.getBorderTop());
62	}	68	}
63		69
		70	@Override
64	public short getBottomBorderColor() {	71	public short getBottomBorderColor() {
65	return (short)borderFormatting.getBottomBorderColor();	72	return (short)borderFormatting.getBottomBorderColor();
66	}	73	}
		74	@Override
67	public HSSFColor getBottomBorderColorColor() {	75	public HSSFColor getBottomBorderColorColor() {
68	return workbook.getCustomPalette().getColor(	76	return workbook.getCustomPalette().getColor(
69	borderFormatting.getBottomBorderColor()	77	borderFormatting.getBottomBorderColor()
70	);	78	);
71	}	79	}
72		80
		81	@Override
73	public short getDiagonalBorderColor() {	82	public short getDiagonalBorderColor() {
74	return (short)borderFormatting.getDiagonalBorderColor();	83	return (short)borderFormatting.getDiagonalBorderColor();
75	}	84	}
		85	@Override
76	public HSSFColor getDiagonalBorderColorColor() {	86	public HSSFColor getDiagonalBorderColorColor() {
77	return workbook.getCustomPalette().getColor(	87	return workbook.getCustomPalette().getColor(
78	borderFormatting.getDiagonalBorderColor()	88	borderFormatting.getDiagonalBorderColor()
79	);	89	);
80	}	90	}
81		91
		92	@Override
82	public short getLeftBorderColor() {	93	public short getLeftBorderColor() {
83	return (short)borderFormatting.getLeftBorderColor();	94	return (short)borderFormatting.getLeftBorderColor();
84	}	95	}
		96	@Override
85	public HSSFColor getLeftBorderColorColor() {	97	public HSSFColor getLeftBorderColorColor() {
86	return workbook.getCustomPalette().getColor(	98	return workbook.getCustomPalette().getColor(
87	borderFormatting.getLeftBorderColor()	99	borderFormatting.getLeftBorderColor()
88	);	100	);
89	}	101	}
90		102
		103	@Override
91	public short getRightBorderColor() {	104	public short getRightBorderColor() {
92	return (short)borderFormatting.getRightBorderColor();	105	return (short)borderFormatting.getRightBorderColor();
93	}	106	}
		107	@Override
94	public HSSFColor getRightBorderColorColor() {	108	public HSSFColor getRightBorderColorColor() {
95	return workbook.getCustomPalette().getColor(	109	return workbook.getCustomPalette().getColor(
96	borderFormatting.getRightBorderColor()	110	borderFormatting.getRightBorderColor()
97	);	111	);
98	}	112	}
99		113
		114	@Override
100	public short getTopBorderColor() {	115	public short getTopBorderColor() {
101	return (short)borderFormatting.getTopBorderColor();	116	return (short)borderFormatting.getTopBorderColor();
102	}	117	}
		118	@Override
103	public HSSFColor getTopBorderColorColor() {	119	public HSSFColor getTopBorderColorColor() {
104	return workbook.getCustomPalette().getColor(	120	return workbook.getCustomPalette().getColor(
105	borderFormatting.getTopBorderColor()	121	borderFormatting.getTopBorderColor()
Lines 126-131 Link Here
126	}	142	}
127	}	143	}
128		144
		145	@Override
129	public void setBorderBottom(short border) {	146	public void setBorderBottom(short border) {
130	borderFormatting.setBorderBottom(border);	147	borderFormatting.setBorderBottom(border);
131	if (border != 0) {	148	if (border != 0) {
Lines 134-140 Link Here
134	cfRuleRecord.setBottomBorderModified(false);	151	cfRuleRecord.setBottomBorderModified(false);
135	}	152	}
136	}	153	}
		154	@Override
		155	public void setBorderBottom(BorderStyle border) {
		156	setBorderBottom(border.getCode());
		157	}
137		158
		159	@Override
138	public void setBorderDiagonal(short border) {	160	public void setBorderDiagonal(short border) {
139	borderFormatting.setBorderDiagonal(border);	161	borderFormatting.setBorderDiagonal(border);
140	if (border != 0) {	162	if (border != 0) {
Lines 145-151 Link Here
145	cfRuleRecord.setTopLeftBottomRightBorderModified(false);	167	cfRuleRecord.setTopLeftBottomRightBorderModified(false);
146	}	168	}
147	}	169	}
		170	@Override
		171	public void setBorderDiagonal(BorderStyle border) {
		172	setBorderDiagonal(border.getCode());
		173	}
148		174
		175	@Override
149	public void setBorderLeft(short border) {	176	public void setBorderLeft(short border) {
150	borderFormatting.setBorderLeft(border);	177	borderFormatting.setBorderLeft(border);
151	if (border != 0) {	178	if (border != 0) {
Lines 154-160 Link Here
154	cfRuleRecord.setLeftBorderModified(false);	181	cfRuleRecord.setLeftBorderModified(false);
155	}	182	}
156	}	183	}
		184	@Override
		185	public void setBorderLeft(BorderStyle border) {
		186	setBorderLeft(border.getCode());
		187	}
157		188
		189	@Override
158	public void setBorderRight(short border) {	190	public void setBorderRight(short border) {
159	borderFormatting.setBorderRight(border);	191	borderFormatting.setBorderRight(border);
160	if (border != 0) {	192	if (border != 0) {
Lines 163-169 Link Here
163	cfRuleRecord.setRightBorderModified(false);	195	cfRuleRecord.setRightBorderModified(false);
164	}	196	}
165	}	197	}
		198	@Override
		199	public void setBorderRight(BorderStyle border) {
		200	setBorderRight(border.getCode());
		201	}
166		202
		203	@Override
167	public void setBorderTop(short border) {	204	public void setBorderTop(short border) {
168	borderFormatting.setBorderTop(border);	205	borderFormatting.setBorderTop(border);
169	if (border != 0) {	206	if (border != 0) {
Lines 172-178 Link Here
172	cfRuleRecord.setTopBorderModified(false);	209	cfRuleRecord.setTopBorderModified(false);
173	}	210	}
174	}	211	}
		212	@Override
		213	public void setBorderTop(BorderStyle border) {
		214	setBorderTop(border.getCode());
		215	}
175		216
		217	@Override
176	public void setBottomBorderColor(short color) {	218	public void setBottomBorderColor(short color) {
177	borderFormatting.setBottomBorderColor(color);	219	borderFormatting.setBottomBorderColor(color);
178	if (color != 0) {	220	if (color != 0) {
Lines 190-195 Link Here
190	}	232	}
191	}	233	}
192		234
		235	@Override
193	public void setDiagonalBorderColor(short color) {	236	public void setDiagonalBorderColor(short color) {
194	borderFormatting.setDiagonalBorderColor(color);	237	borderFormatting.setDiagonalBorderColor(color);
195	if (color != 0) {	238	if (color != 0) {
Lines 200-205 Link Here
200	cfRuleRecord.setTopLeftBottomRightBorderModified(false);	243	cfRuleRecord.setTopLeftBottomRightBorderModified(false);
201	}	244	}
202	}	245	}
		246	@Override
203	public void setDiagonalBorderColor(Color color) {	247	public void setDiagonalBorderColor(Color color) {
204	HSSFColor hcolor = HSSFColor.toHSSFColor(color);	248	HSSFColor hcolor = HSSFColor.toHSSFColor(color);
205	if (hcolor == null) {	249	if (hcolor == null) {
Lines 209-214 Link Here
209	}	253	}
210	}	254	}
211		255
		256	@Override
212	public void setLeftBorderColor(short color) {	257	public void setLeftBorderColor(short color) {
213	borderFormatting.setLeftBorderColor(color);	258	borderFormatting.setLeftBorderColor(color);
214	if (color != 0) {	259	if (color != 0) {
Lines 217-222 Link Here
217	cfRuleRecord.setLeftBorderModified(false);	262	cfRuleRecord.setLeftBorderModified(false);
218	}	263	}
219	}	264	}
		265	@Override
220	public void setLeftBorderColor(Color color) {	266	public void setLeftBorderColor(Color color) {
221	HSSFColor hcolor = HSSFColor.toHSSFColor(color);	267	HSSFColor hcolor = HSSFColor.toHSSFColor(color);
222	if (hcolor == null) {	268	if (hcolor == null) {
Lines 226-231 Link Here
226	}	272	}
227	}	273	}
228		274
		275	@Override
229	public void setRightBorderColor(short color) {	276	public void setRightBorderColor(short color) {
230	borderFormatting.setRightBorderColor(color);	277	borderFormatting.setRightBorderColor(color);
231	if (color != 0) {	278	if (color != 0) {
Lines 234-239 Link Here
234	cfRuleRecord.setRightBorderModified(false);	281	cfRuleRecord.setRightBorderModified(false);
235	}	282	}
236	}	283	}
		284	@Override
237	public void setRightBorderColor(Color color) {	285	public void setRightBorderColor(Color color) {
238	HSSFColor hcolor = HSSFColor.toHSSFColor(color);	286	HSSFColor hcolor = HSSFColor.toHSSFColor(color);
239	if (hcolor == null) {	287	if (hcolor == null) {
Lines 243-248 Link Here
243	}	291	}
244	}	292	}
245		293
		294	@Override
246	public void setTopBorderColor(short color) {	295	public void setTopBorderColor(short color) {
247	borderFormatting.setTopBorderColor(color);	296	borderFormatting.setTopBorderColor(color);
248	if (color != 0) {	297	if (color != 0) {
Lines 251-256 Link Here
251	cfRuleRecord.setTopBorderModified(false);	300	cfRuleRecord.setTopBorderModified(false);
252	}	301	}
253	}	302	}
		303	@Override
254	public void setTopBorderColor(Color color) {	304	public void setTopBorderColor(Color color) {
255	HSSFColor hcolor = HSSFColor.toHSSFColor(color);	305	HSSFColor hcolor = HSSFColor.toHSSFColor(color);
256	if (hcolor == null) {	306	if (hcolor == null) {

Lines 17-22 Link Here

(-)src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFBorderFormatting.java (-20 / +86 lines)
17	package org.apache.poi.xssf.usermodel;	17	package org.apache.poi.xssf.usermodel;
18		18
19	import org.apache.poi.ss.usermodel.BorderFormatting;	19	import org.apache.poi.ss.usermodel.BorderFormatting;
		20	import org.apache.poi.ss.usermodel.BorderStyle;
20	import org.apache.poi.ss.usermodel.Color;	21	import org.apache.poi.ss.usermodel.Color;
21	import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorder;	22	import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorder;
22	import org.openxmlformats.schemas.spreadsheetml.x2006.main.STBorderStyle;	23	import org.openxmlformats.schemas.spreadsheetml.x2006.main.STBorderStyle;
Lines 34-159 Link Here
34	_border = border;	35	_border = border;
35	}	36	}
36		37
37	public short getBorderBottom() {	38	@Override
		39	public BorderStyle getBorderBottom() {
38	STBorderStyle.Enum ptrn = _border.isSetBottom() ? _border.getBottom().getStyle() : null;	40	STBorderStyle.Enum ptrn = _border.isSetBottom() ? _border.getBottom().getStyle() : null;
39	return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1);	41	return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
40	}	42	}
41		43
42	public short getBorderDiagonal() {	44	@Override
		45	public BorderStyle getBorderDiagonal() {
43	STBorderStyle.Enum ptrn = _border.isSetDiagonal() ? _border.getDiagonal().getStyle() : null;	46	STBorderStyle.Enum ptrn = _border.isSetDiagonal() ? _border.getDiagonal().getStyle() : null;
44	return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1);	47	return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
45	}	48	}
46		49
47	public short getBorderLeft() {	50	@Override
		51	public BorderStyle getBorderLeft() {
48	STBorderStyle.Enum ptrn = _border.isSetLeft() ? _border.getLeft().getStyle() : null;	52	STBorderStyle.Enum ptrn = _border.isSetLeft() ? _border.getLeft().getStyle() : null;
49	return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1);	53	return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
50	}	54	}
51		55
52	public short getBorderRight() {	56	@Override
		57	public BorderStyle getBorderRight() {
53	STBorderStyle.Enum ptrn = _border.isSetRight() ? _border.getRight().getStyle() : null;	58	STBorderStyle.Enum ptrn = _border.isSetRight() ? _border.getRight().getStyle() : null;
54	return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1);	59	return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
55	}	60	}
56		61
57	public short getBorderTop() {	62	@Override
		63	public BorderStyle getBorderTop() {
58	STBorderStyle.Enum ptrn = _border.isSetTop() ? _border.getTop().getStyle() : null;	64	STBorderStyle.Enum ptrn = _border.isSetTop() ? _border.getTop().getStyle() : null;
59	return ptrn == null ? BORDER_NONE : (short)(ptrn.intValue() - 1);	65	return ptrn == null ? BorderStyle.NONE : BorderStyle.valueOf((short)(ptrn.intValue() - 1));
60	}	66	}
61		67
		68	@Override
62	public XSSFColor getBottomBorderColorColor() {	69	public XSSFColor getBottomBorderColorColor() {
63	if(!_border.isSetBottom()) return null;	70	if(!_border.isSetBottom()) return null;
64		71
65	CTBorderPr pr = _border.getBottom();	72	CTBorderPr pr = _border.getBottom();
66	return new XSSFColor(pr.getColor());	73	return new XSSFColor(pr.getColor());
67	}	74	}
		75	@Override
68	public short getBottomBorderColor() {	76	public short getBottomBorderColor() {
69	XSSFColor color = getBottomBorderColorColor();	77	XSSFColor color = getBottomBorderColorColor();
70	if (color == null) return 0;	78	if (color == null) return 0;
71	return color.getIndexed();	79	return color.getIndexed();
72	}	80	}
73		81
		82	@Override
74	public XSSFColor getDiagonalBorderColorColor() {	83	public XSSFColor getDiagonalBorderColorColor() {
75	if(!_border.isSetDiagonal()) return null;	84	if(!_border.isSetDiagonal()) return null;
76		85
77	CTBorderPr pr = _border.getDiagonal();	86	CTBorderPr pr = _border.getDiagonal();
78	return new XSSFColor(pr.getColor());	87	return new XSSFColor(pr.getColor());
79	}	88	}
		89	@Override
80	public short getDiagonalBorderColor() {	90	public short getDiagonalBorderColor() {
81	XSSFColor color = getDiagonalBorderColorColor();	91	XSSFColor color = getDiagonalBorderColorColor();
82	if (color == null) return 0;	92	if (color == null) return 0;
83	return color.getIndexed();	93	return color.getIndexed();
84	}	94	}
85		95
		96	@Override
86	public XSSFColor getLeftBorderColorColor() {	97	public XSSFColor getLeftBorderColorColor() {
87	if(!_border.isSetLeft()) return null;	98	if(!_border.isSetLeft()) return null;
88		99
89	CTBorderPr pr = _border.getLeft();	100	CTBorderPr pr = _border.getLeft();
90	return new XSSFColor(pr.getColor());	101	return new XSSFColor(pr.getColor());
91	}	102	}
		103	@Override
92	public short getLeftBorderColor() {	104	public short getLeftBorderColor() {
93	XSSFColor color = getLeftBorderColorColor();	105	XSSFColor color = getLeftBorderColorColor();
94	if (color == null) return 0;	106	if (color == null) return 0;
95	return color.getIndexed();	107	return color.getIndexed();
96	}	108	}
97		109
		110	@Override
98	public XSSFColor getRightBorderColorColor() {	111	public XSSFColor getRightBorderColorColor() {
99	if(!_border.isSetRight()) return null;	112	if(!_border.isSetRight()) return null;
100		113
101	CTBorderPr pr = _border.getRight();	114	CTBorderPr pr = _border.getRight();
102	return new XSSFColor(pr.getColor());	115	return new XSSFColor(pr.getColor());
103	}	116	}
		117	@Override
104	public short getRightBorderColor() {	118	public short getRightBorderColor() {
105	XSSFColor color = getRightBorderColorColor();	119	XSSFColor color = getRightBorderColorColor();
106	if (color == null) return 0;	120	if (color == null) return 0;
107	return color.getIndexed();	121	return color.getIndexed();
108	}	122	}
109		123
		124	@Override
110	public XSSFColor getTopBorderColorColor() {	125	public XSSFColor getTopBorderColorColor() {
111	if(!_border.isSetTop()) return null;	126	if(!_border.isSetTop()) return null;
112		127
113	CTBorderPr pr = _border.getTop();	128	CTBorderPr pr = _border.getTop();
114	return new XSSFColor(pr.getColor());	129	return new XSSFColor(pr.getColor());
115	}	130	}
		131	@Override
116	public short getTopBorderColor() {	132	public short getTopBorderColor() {
117	XSSFColor color = getRightBorderColorColor();	133	XSSFColor color = getRightBorderColorColor();
118	if (color == null) return 0;	134	if (color == null) return 0;
119	return color.getIndexed();	135	return color.getIndexed();
120	}	136	}
121		137
		138	/**
		139	* @deprecated 3.15 beta 1. Use {@link #setBorderBottom(BorderStyle)}
		140	*/
		141	@Override
122	public void setBorderBottom(short border) {	142	public void setBorderBottom(short border) {
		143	setBorderBottom(BorderStyle.valueOf(border));
		144	}
		145	@Override
		146	public void setBorderBottom(BorderStyle border) {
123	CTBorderPr pr = _border.isSetBottom() ? _border.getBottom() : _border.addNewBottom();	147	CTBorderPr pr = _border.isSetBottom() ? _border.getBottom() : _border.addNewBottom();
124	if(border == BORDER_NONE) _border.unsetBottom();	148	if(border == BorderStyle.NONE) _border.unsetBottom();
125	else pr.setStyle(STBorderStyle.Enum.forInt(border + 1));	149	else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1));
126	}	150	}
127		151
		152	/**
		153	* @deprecated 3.15 beta 1. Use {@link #setBorderDiagonal(BorderStyle)}
		154	*/
		155	@Override
128	public void setBorderDiagonal(short border) {	156	public void setBorderDiagonal(short border) {
		157	setBorderDiagonal(BorderStyle.valueOf(border));
		158	}
		159	@Override
		160	public void setBorderDiagonal(BorderStyle border) {
129	CTBorderPr pr = _border.isSetDiagonal() ? _border.getDiagonal() : _border.addNewDiagonal();	161	CTBorderPr pr = _border.isSetDiagonal() ? _border.getDiagonal() : _border.addNewDiagonal();
130	if(border == BORDER_NONE) _border.unsetDiagonal();	162	if(border == BorderStyle.NONE) _border.unsetDiagonal();
131	else pr.setStyle(STBorderStyle.Enum.forInt(border + 1));	163	else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1));
132	}	164	}
133		165
		166	/**
		167	* @deprecated 3.15 beta 1. Use {@link #setBorderLeft(BorderStyle)}
		168	*/
		169	@Override
134	public void setBorderLeft(short border) {	170	public void setBorderLeft(short border) {
		171	setBorderLeft(BorderStyle.valueOf(border));
		172	}
		173	@Override
		174	public void setBorderLeft(BorderStyle border) {
135	CTBorderPr pr = _border.isSetLeft() ? _border.getLeft() : _border.addNewLeft();	175	CTBorderPr pr = _border.isSetLeft() ? _border.getLeft() : _border.addNewLeft();
136	if(border == BORDER_NONE) _border.unsetLeft();	176	if(border == BorderStyle.NONE) _border.unsetLeft();
137	else pr.setStyle(STBorderStyle.Enum.forInt(border + 1));	177	else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1));
138	}	178	}
139		179
		180	/**
		181	* @deprecated 3.15 beta 1. Use {@link #setBorderRight(BorderStyle)}
		182	*/
		183	@Override
140	public void setBorderRight(short border) {	184	public void setBorderRight(short border) {
		185	setBorderRight(BorderStyle.valueOf(border));
		186	}
		187	@Override
		188	public void setBorderRight(BorderStyle border) {
141	CTBorderPr pr = _border.isSetRight() ? _border.getRight() : _border.addNewRight();	189	CTBorderPr pr = _border.isSetRight() ? _border.getRight() : _border.addNewRight();
142	if(border == BORDER_NONE) _border.unsetRight();	190	if(border == BorderStyle.NONE) _border.unsetRight();
143	else pr.setStyle(STBorderStyle.Enum.forInt(border + 1));	191	else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1));
144	}	192	}
145		193
		194	/**
		195	* @deprecated 3.15 beta 1. Use {@link #setBorderTop(BorderStyle)}
		196	*/
		197	@Override
146	public void setBorderTop(short border) {	198	public void setBorderTop(short border) {
		199	setBorderTop(BorderStyle.valueOf(border));
		200	}
		201	@Override
		202	public void setBorderTop(BorderStyle border) {
147	CTBorderPr pr = _border.isSetTop() ? _border.getTop() : _border.addNewTop();	203	CTBorderPr pr = _border.isSetTop() ? _border.getTop() : _border.addNewTop();
148	if(border == BORDER_NONE) _border.unsetTop();	204	if(border == BorderStyle.NONE) _border.unsetTop();
149	else pr.setStyle(STBorderStyle.Enum.forInt(border + 1));	205	else pr.setStyle(STBorderStyle.Enum.forInt(border.getCode() + 1));
150	}	206	}
151		207
		208	@Override
152	public void setBottomBorderColor(Color color) {	209	public void setBottomBorderColor(Color color) {
153	XSSFColor xcolor = XSSFColor.toXSSFColor(color);	210	XSSFColor xcolor = XSSFColor.toXSSFColor(color);
154	if (xcolor == null) setBottomBorderColor((CTColor)null);	211	if (xcolor == null) setBottomBorderColor((CTColor)null);
155	else setBottomBorderColor(xcolor.getCTColor());	212	else setBottomBorderColor(xcolor.getCTColor());
156	}	213	}
		214	@Override
157	public void setBottomBorderColor(short color) {	215	public void setBottomBorderColor(short color) {
158	CTColor ctColor = CTColor.Factory.newInstance();	216	CTColor ctColor = CTColor.Factory.newInstance();
159	ctColor.setIndexed(color);	217	ctColor.setIndexed(color);
Lines 168-178 Link Here
168	}	226	}
169	}	227	}
170		228
		229	@Override
171	public void setDiagonalBorderColor(Color color) {	230	public void setDiagonalBorderColor(Color color) {
172	XSSFColor xcolor = XSSFColor.toXSSFColor(color);	231	XSSFColor xcolor = XSSFColor.toXSSFColor(color);
173	if (xcolor == null) setDiagonalBorderColor((CTColor)null);	232	if (xcolor == null) setDiagonalBorderColor((CTColor)null);
174	else setDiagonalBorderColor(xcolor.getCTColor());	233	else setDiagonalBorderColor(xcolor.getCTColor());
175	}	234	}
		235	@Override
176	public void setDiagonalBorderColor(short color) {	236	public void setDiagonalBorderColor(short color) {
177	CTColor ctColor = CTColor.Factory.newInstance();	237	CTColor ctColor = CTColor.Factory.newInstance();
178	ctColor.setIndexed(color);	238	ctColor.setIndexed(color);
Lines 187-197 Link Here
187	}	247	}
188	}	248	}
189		249
		250	@Override
190	public void setLeftBorderColor(Color color) {	251	public void setLeftBorderColor(Color color) {
191	XSSFColor xcolor = XSSFColor.toXSSFColor(color);	252	XSSFColor xcolor = XSSFColor.toXSSFColor(color);
192	if (xcolor == null) setLeftBorderColor((CTColor)null);	253	if (xcolor == null) setLeftBorderColor((CTColor)null);
193	else setLeftBorderColor(xcolor.getCTColor());	254	else setLeftBorderColor(xcolor.getCTColor());
194	}	255	}
		256	@Override
195	public void setLeftBorderColor(short color) {	257	public void setLeftBorderColor(short color) {
196	CTColor ctColor = CTColor.Factory.newInstance();	258	CTColor ctColor = CTColor.Factory.newInstance();
197	ctColor.setIndexed(color);	259	ctColor.setIndexed(color);
Lines 206-216 Link Here
206	}	268	}
207	}	269	}
208		270
		271	@Override
209	public void setRightBorderColor(Color color) {	272	public void setRightBorderColor(Color color) {
210	XSSFColor xcolor = XSSFColor.toXSSFColor(color);	273	XSSFColor xcolor = XSSFColor.toXSSFColor(color);
211	if (xcolor == null) setRightBorderColor((CTColor)null);	274	if (xcolor == null) setRightBorderColor((CTColor)null);
212	else setRightBorderColor(xcolor.getCTColor());	275	else setRightBorderColor(xcolor.getCTColor());
213	}	276	}
		277	@Override
214	public void setRightBorderColor(short color) {	278	public void setRightBorderColor(short color) {
215	CTColor ctColor = CTColor.Factory.newInstance();	279	CTColor ctColor = CTColor.Factory.newInstance();
216	ctColor.setIndexed(color);	280	ctColor.setIndexed(color);
Lines 225-235 Link Here
225	}	289	}
226	}	290	}
227		291
		292	@Override
228	public void setTopBorderColor(Color color) {	293	public void setTopBorderColor(Color color) {
229	XSSFColor xcolor = XSSFColor.toXSSFColor(color);	294	XSSFColor xcolor = XSSFColor.toXSSFColor(color);
230	if (xcolor == null) setTopBorderColor((CTColor)null);	295	if (xcolor == null) setTopBorderColor((CTColor)null);
231	else setTopBorderColor(xcolor.getCTColor());	296	else setTopBorderColor(xcolor.getCTColor());
232	}	297	}
		298	@Override
233	public void setTopBorderColor(short color) {	299	public void setTopBorderColor(short color) {
234	CTColor ctColor = CTColor.Factory.newInstance();	300	CTColor ctColor = CTColor.Factory.newInstance();
235	ctColor.setIndexed(color);	301	ctColor.setIndexed(color);

Lines 38-43 Link Here

(-)src/scratchpad/src/org/apache/poi/hssf/converter/ExcelToFoConverter.java (-6 / +7 lines)
38	import org.apache.poi.hwpf.converter.FoDocumentFacade;	38	import org.apache.poi.hwpf.converter.FoDocumentFacade;
39	import org.apache.poi.hwpf.converter.FontReplacer.Triplet;	39	import org.apache.poi.hwpf.converter.FontReplacer.Triplet;
40	import org.apache.poi.ss.formula.eval.ErrorEval;	40	import org.apache.poi.ss.formula.eval.ErrorEval;
		41	import org.apache.poi.ss.usermodel.BorderStyle;
41	import org.apache.poi.ss.usermodel.CellStyle;	42	import org.apache.poi.ss.usermodel.CellStyle;
42	import org.apache.poi.ss.util.CellRangeAddress;	43	import org.apache.poi.ss.util.CellRangeAddress;
43	import org.apache.poi.util.Beta;	44	import org.apache.poi.util.Beta;
Lines 192-201 Link Here
192	protected boolean isEmptyStyle( CellStyle cellStyle ) {	193	protected boolean isEmptyStyle( CellStyle cellStyle ) {
193	return cellStyle == null \|\| (	194	return cellStyle == null \|\| (
194	cellStyle.getFillPattern() == 0	195	cellStyle.getFillPattern() == 0
195	&& cellStyle.getBorderTop() == HSSFCellStyle.BORDER_NONE	196	&& cellStyle.getBorderTop() == BorderStyle.NONE
196	&& cellStyle.getBorderRight() == HSSFCellStyle.BORDER_NONE	197	&& cellStyle.getBorderRight() == BorderStyle.NONE
197	&& cellStyle.getBorderBottom() == HSSFCellStyle.BORDER_NONE	198	&& cellStyle.getBorderBottom() == BorderStyle.NONE
198	&& cellStyle.getBorderLeft() == HSSFCellStyle.BORDER_NONE	199	&& cellStyle.getBorderLeft() == BorderStyle.NONE
199	);	200	);
200	}	201	}
201		202
Lines 374-382 Link Here
374	}	375	}
375		376
376	protected void processCellStyleBorder( HSSFWorkbook workbook,	377	protected void processCellStyleBorder( HSSFWorkbook workbook,
377	Element cellTarget, String type, short xlsBorder, short borderColor )	378	Element cellTarget, String type, BorderStyle xlsBorder, short borderColor )
378	{	379	{
379	if ( xlsBorder == HSSFCellStyle.BORDER_NONE )	380	if ( xlsBorder == BorderStyle.NONE )
380	return;	381	return;
381		382
382	StringBuilder borderStyle = new StringBuilder();	383	StringBuilder borderStyle = new StringBuilder();

Lines 25-30 Link Here

(-)src/scratchpad/src/org/apache/poi/hssf/converter/AbstractExcelUtils.java (-17 / +18 lines)
25	import org.apache.poi.hssf.usermodel.HSSFWorkbook;	25	import org.apache.poi.hssf.usermodel.HSSFWorkbook;
26	import org.apache.poi.hssf.util.HSSFColor;	26	import org.apache.poi.hssf.util.HSSFColor;
27	import org.apache.poi.hwpf.converter.AbstractWordUtils;	27	import org.apache.poi.hwpf.converter.AbstractWordUtils;
		28	import org.apache.poi.ss.usermodel.BorderStyle;
28	import org.apache.poi.ss.util.CellRangeAddress;	29	import org.apache.poi.ss.util.CellRangeAddress;
29	import org.apache.poi.util.Beta;	30	import org.apache.poi.util.Beta;
30	import org.apache.poi.util.IOUtils;	31	import org.apache.poi.util.IOUtils;
Lines 66-93 Link Here
66	}	67	}
67	}	68	}
68		69
69	public static String getBorderStyle( short xlsBorder )	70	public static String getBorderStyle( BorderStyle xlsBorder )
70	{	71	{
71	final String borderStyle;	72	final String borderStyle;
72	switch ( xlsBorder )	73	switch ( xlsBorder )
73	{	74	{
74	case HSSFCellStyle.BORDER_NONE:	75	case NONE:
75	borderStyle = "none";	76	borderStyle = "none";
76	break;	77	break;
77	case HSSFCellStyle.BORDER_DASH_DOT:	78	case DASH_DOT:
78	case HSSFCellStyle.BORDER_DASH_DOT_DOT:	79	case DASH_DOT_DOT:
79	case HSSFCellStyle.BORDER_DOTTED:	80	case DOTTED:
80	case HSSFCellStyle.BORDER_HAIR:	81	case HAIR:
81	case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT:	82	case MEDIUM_DASH_DOT:
82	case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT:	83	case MEDIUM_DASH_DOT_DOT:
83	case HSSFCellStyle.BORDER_SLANTED_DASH_DOT:	84	case SLANTED_DASH_DOT:
84	borderStyle = "dotted";	85	borderStyle = "dotted";
85	break;	86	break;
86	case HSSFCellStyle.BORDER_DASHED:	87	case DASHED:
87	case HSSFCellStyle.BORDER_MEDIUM_DASHED:	88	case MEDIUM_DASHED:
88	borderStyle = "dashed";	89	borderStyle = "dashed";
89	break;	90	break;
90	case HSSFCellStyle.BORDER_DOUBLE:	91	case DOUBLE:
91	borderStyle = "double";	92	borderStyle = "double";
92	break;	93	break;
93	default:	94	default:
Lines 97-113 Link Here
97	return borderStyle;	98	return borderStyle;
98	}	99	}
99		100
100	public static String getBorderWidth( short xlsBorder )	101	public static String getBorderWidth( BorderStyle xlsBorder )
101	{	102	{
102	final String borderWidth;	103	final String borderWidth;
103	switch ( xlsBorder )	104	switch ( xlsBorder )
104	{	105	{
105	case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT:	106	case MEDIUM_DASH_DOT:
106	case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT:	107	case MEDIUM_DASH_DOT_DOT:
107	case HSSFCellStyle.BORDER_MEDIUM_DASHED:	108	case MEDIUM_DASHED:
108	borderWidth = "2pt";	109	borderWidth = "2pt";
109	break;	110	break;
110	case HSSFCellStyle.BORDER_THICK:	111	case THICK:
111	borderWidth = "thick";	112	borderWidth = "thick";
112	break;	113	break;
113	default:	114	default:

Lines 22-28 Link Here

(-)src/examples/src/org/apache/poi/hssf/view/SVBorder.java (-76 / +64 lines)
22		22
23	import javax.swing.border.AbstractBorder;	23	import javax.swing.border.AbstractBorder;
24		24
25	import org.apache.poi.hssf.usermodel.HSSFCellStyle;	25	import org.apache.poi.ss.usermodel.BorderStyle;
26		26
27	/**	27	/**
28	* This is an attempt to implement Excel style borders for the SheetViewer.	28	* This is an attempt to implement Excel style borders for the SheetViewer.
Lines 37-46 Link Here
37	private Color eastColor = null;	37	private Color eastColor = null;
38	private Color southColor = null;	38	private Color southColor = null;
39	private Color westColor = null;	39	private Color westColor = null;
40	private int northBorderType = HSSFCellStyle.BORDER_NONE;	40	private BorderStyle northBorderType = BorderStyle.NONE;
41	private int eastBorderType =HSSFCellStyle.BORDER_NONE;	41	private BorderStyle eastBorderType = BorderStyle.NONE;
42	private int southBorderType = HSSFCellStyle.BORDER_NONE;	42	private BorderStyle southBorderType = BorderStyle.NONE;
43	private int westBorderType = HSSFCellStyle.BORDER_NONE;	43	private BorderStyle westBorderType = BorderStyle.NONE;
44	private boolean northBorder=false;	44	private boolean northBorder=false;
45	private boolean eastBorder=false;	45	private boolean eastBorder=false;
46	private boolean southBorder=false;	46	private boolean southBorder=false;
Lines 49-56 Link Here
49		49
50	public void setBorder(Color northColor, Color eastColor,	50	public void setBorder(Color northColor, Color eastColor,
51	Color southColor, Color westColor,	51	Color southColor, Color westColor,
52	int northBorderType, int eastBorderType,	52	BorderStyle northBorderType, BorderStyle eastBorderType,
53	int southBorderType, int westBorderType,	53	BorderStyle southBorderType, BorderStyle westBorderType,
54	boolean selected) {	54	boolean selected) {
55	this.eastColor = eastColor;	55	this.eastColor = eastColor;
56	this.southColor = southColor;	56	this.southColor = southColor;
Lines 59-68 Link Here
59	this.eastBorderType = eastBorderType;	59	this.eastBorderType = eastBorderType;
60	this.southBorderType = southBorderType;	60	this.southBorderType = southBorderType;
61	this.westBorderType = westBorderType;	61	this.westBorderType = westBorderType;
62	this.northBorder=northBorderType != HSSFCellStyle.BORDER_NONE;	62	this.northBorder=northBorderType != BorderStyle.NONE;
63	this.eastBorder=eastBorderType != HSSFCellStyle.BORDER_NONE;	63	this.eastBorder=eastBorderType != BorderStyle.NONE;
64	this.southBorder=southBorderType != HSSFCellStyle.BORDER_NONE;	64	this.southBorder=southBorderType != BorderStyle.NONE;
65	this.westBorder=westBorderType != HSSFCellStyle.BORDER_NONE;	65	this.westBorder=westBorderType != BorderStyle.NONE;
66	this.selected = selected;	66	this.selected = selected;
67	}	67	}
68		68
Lines 109-117 Link Here
109	int height) {	109	int height) {
110		110
111	if (northBorder &&	111	if (northBorder &&
112	((northBorderType == HSSFCellStyle.BORDER_THIN) \|\|	112	((northBorderType == BorderStyle.THIN) \|\|
113	(northBorderType == HSSFCellStyle.BORDER_MEDIUM) \|\|	113	(northBorderType == BorderStyle.MEDIUM) \|\|
114	(northBorderType == HSSFCellStyle.BORDER_THICK)	114	(northBorderType == BorderStyle.THICK)
115	)	115	)
116	) {	116	) {
117		117
Lines 125-133 Link Here
125	}	125	}
126		126
127	if (eastBorder &&	127	if (eastBorder &&
128	((eastBorderType == HSSFCellStyle.BORDER_THIN) \|\|	128	((eastBorderType == BorderStyle.THIN) \|\|
129	(eastBorderType == HSSFCellStyle.BORDER_MEDIUM) \|\|	129	(eastBorderType == BorderStyle.MEDIUM) \|\|
130	(eastBorderType == HSSFCellStyle.BORDER_THICK)	130	(eastBorderType == BorderStyle.THICK)
131	)	131	)
132	) {	132	) {
133		133
Lines 141-149 Link Here
141	}	141	}
142		142
143	if (southBorder &&	143	if (southBorder &&
144	((southBorderType == HSSFCellStyle.BORDER_THIN) \|\|	144	((southBorderType == BorderStyle.THIN) \|\|
145	(southBorderType == HSSFCellStyle.BORDER_MEDIUM) \|\|	145	(southBorderType == BorderStyle.MEDIUM) \|\|
146	(southBorderType == HSSFCellStyle.BORDER_THICK)	146	(southBorderType == BorderStyle.THICK)
147	)	147	)
148	) {	148	) {
149		149
Lines 156-164 Link Here
156	}	156	}
157		157
158	if (westBorder &&	158	if (westBorder &&
159	((westBorderType == HSSFCellStyle.BORDER_THIN) \|\|	159	((westBorderType == BorderStyle.THIN) \|\|
160	(westBorderType == HSSFCellStyle.BORDER_MEDIUM) \|\|	160	(westBorderType == BorderStyle.MEDIUM) \|\|
161	(westBorderType == HSSFCellStyle.BORDER_THICK)	161	(westBorderType == BorderStyle.THICK)
162	)	162	)
163	) {	163	) {
164		164
Lines 179-185 Link Here
179	private void paintDottedBorders(Graphics g, int x, int y, int width,	179	private void paintDottedBorders(Graphics g, int x, int y, int width,
180	int height) {	180	int height) {
181	if (northBorder &&	181	if (northBorder &&
182	northBorderType == HSSFCellStyle.BORDER_DOTTED) {	182	northBorderType == BorderStyle.DOTTED) {
183	int thickness = getThickness(northBorderType);	183	int thickness = getThickness(northBorderType);
184		184
185	g.setColor(northColor);	185	g.setColor(northColor);
Lines 192-198 Link Here
192	}	192	}
193		193
194	if (eastBorder &&	194	if (eastBorder &&
195	eastBorderType == HSSFCellStyle.BORDER_DOTTED	195	eastBorderType == BorderStyle.DOTTED
196	) {	196	) {
197		197
198	int thickness = getThickness(eastBorderType);	198	int thickness = getThickness(eastBorderType);
Lines 208-214 Link Here
208	}	208	}
209		209
210	if (southBorder &&	210	if (southBorder &&
211	southBorderType == HSSFCellStyle.BORDER_DOTTED	211	southBorderType == BorderStyle.DOTTED
212	) {	212	) {
213		213
214	int thickness = getThickness(southBorderType);	214	int thickness = getThickness(southBorderType);
Lines 222-228 Link Here
222	}	222	}
223		223
224	if (westBorder &&	224	if (westBorder &&
225	westBorderType == HSSFCellStyle.BORDER_DOTTED	225	westBorderType == BorderStyle.DOTTED
226	) {	226	) {
227		227
228	int thickness = getThickness(westBorderType);	228	int thickness = getThickness(westBorderType);
Lines 245-258 Link Here
245	private void paintDashedBorders(Graphics g, int x, int y, int width,	245	private void paintDashedBorders(Graphics g, int x, int y, int width,
246	int height) {	246	int height) {
247	if (northBorder &&	247	if (northBorder &&
248	((northBorderType == HSSFCellStyle.BORDER_DASHED) \|\|	248	((northBorderType == BorderStyle.DASHED) \|\|
249	(northBorderType == HSSFCellStyle.BORDER_HAIR))	249	(northBorderType == BorderStyle.HAIR))
250	) {	250	) {
251	int thickness = getThickness(northBorderType);	251	int thickness = getThickness(northBorderType);
252		252
253	int dashlength = 1;	253	int dashlength = 1;
254		254
255	if (northBorderType == HSSFCellStyle.BORDER_DASHED)	255	if (northBorderType == BorderStyle.DASHED)
256	dashlength = 2;	256	dashlength = 2;
257		257
258	g.setColor(northColor);	258	g.setColor(northColor);
Lines 265-272 Link Here
265	}	265	}
266		266
267	if (eastBorder &&	267	if (eastBorder &&
268	((eastBorderType == HSSFCellStyle.BORDER_DASHED) \|\|	268	((eastBorderType == BorderStyle.DASHED) \|\|
269	(eastBorderType == HSSFCellStyle.BORDER_HAIR))	269	(eastBorderType == BorderStyle.HAIR))
270	) {	270	) {
271		271
272	int thickness = getThickness(eastBorderType);	272	int thickness = getThickness(eastBorderType);
Lines 275-281 Link Here
275		275
276	int dashlength = 1;	276	int dashlength = 1;
277		277
278	if (eastBorderType == HSSFCellStyle.BORDER_DASHED)	278	if (eastBorderType == BorderStyle.DASHED)
279	dashlength = 2;	279	dashlength = 2;
280		280
281	g.setColor(eastColor);	281	g.setColor(eastColor);
Lines 288-295 Link Here
288	}	288	}
289		289
290	if (southBorder &&	290	if (southBorder &&
291	((southBorderType == HSSFCellStyle.BORDER_DASHED) \|\|	291	((southBorderType == BorderStyle.DASHED) \|\|
292	(southBorderType == HSSFCellStyle.BORDER_HAIR))	292	(southBorderType == BorderStyle.HAIR))
293	) {	293	) {
294		294
295	int thickness = getThickness(southBorderType);	295	int thickness = getThickness(southBorderType);
Lines 297-303 Link Here
297		297
298	int dashlength = 1;	298	int dashlength = 1;
299		299
300	if (southBorderType == HSSFCellStyle.BORDER_DASHED)	300	if (southBorderType == BorderStyle.DASHED)
301	dashlength = 2;	301	dashlength = 2;
302		302
303	g.setColor(southColor);	303	g.setColor(southColor);
Lines 309-316 Link Here
309	}	309	}
310		310
311	if (westBorder &&	311	if (westBorder &&
312	((westBorderType == HSSFCellStyle.BORDER_DASHED) \|\|	312	((westBorderType == BorderStyle.DASHED) \|\|
313	(westBorderType == HSSFCellStyle.BORDER_HAIR))	313	(westBorderType == BorderStyle.HAIR))
314	) {	314	) {
315		315
316	int thickness = getThickness(westBorderType);	316	int thickness = getThickness(westBorderType);
Lines 318-324 Link Here
318		318
319	int dashlength = 1;	319	int dashlength = 1;
320		320
321	if (westBorderType == HSSFCellStyle.BORDER_DASHED)	321	if (westBorderType == BorderStyle.DASHED)
322	dashlength = 2;	322	dashlength = 2;
323		323
324	g.setColor(westColor);	324	g.setColor(westColor);
Lines 338-344 Link Here
338	private void paintDoubleBorders(Graphics g, int x, int y, int width,	338	private void paintDoubleBorders(Graphics g, int x, int y, int width,
339	int height) {	339	int height) {
340	if (northBorder &&	340	if (northBorder &&
341	northBorderType == HSSFCellStyle.BORDER_DOUBLE) {	341	northBorderType == BorderStyle.DOUBLE) {
342		342
343	g.setColor(northColor);	343	g.setColor(northColor);
344		344
Lines 358-364 Link Here
358	}	358	}
359		359
360	if (eastBorder &&	360	if (eastBorder &&
361	eastBorderType == HSSFCellStyle.BORDER_DOUBLE	361	eastBorderType == BorderStyle.DOUBLE
362	) {	362	) {
363		363
364	int thickness = getThickness(eastBorderType);	364	int thickness = getThickness(eastBorderType);
Lines 380-386 Link Here
380	}	380	}
381		381
382	if (southBorder &&	382	if (southBorder &&
383	southBorderType == HSSFCellStyle.BORDER_DOUBLE	383	southBorderType == BorderStyle.DOUBLE
384	) {	384	) {
385		385
386	g.setColor(southColor);	386	g.setColor(southColor);
Lines 400-406 Link Here
400	}	400	}
401		401
402	if (westBorder &&	402	if (westBorder &&
403	westBorderType == HSSFCellStyle.BORDER_DOUBLE	403	westBorderType == BorderStyle.DOUBLE
404	) {	404	) {
405		405
406	int thickness = getThickness(westBorderType);	406	int thickness = getThickness(westBorderType);
Lines 429-436 Link Here
429	private void paintDashDotDotBorders(Graphics g, int x, int y, int width,	429	private void paintDashDotDotBorders(Graphics g, int x, int y, int width,
430	int height) {	430	int height) {
431	if (northBorder &&	431	if (northBorder &&
432	((northBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) \|\|	432	((northBorderType == BorderStyle.DASH_DOT_DOT) \|\|
433	(northBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT))	433	(northBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
434	) {	434	) {
435	int thickness = getThickness(northBorderType);	435	int thickness = getThickness(northBorderType);
436		436
Lines 442-449 Link Here
442	}	442	}
443		443
444	if (eastBorder &&	444	if (eastBorder &&
445	((eastBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) \|\|	445	((eastBorderType == BorderStyle.DASH_DOT_DOT) \|\|
446	(eastBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT))	446	(eastBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
447	) {	447	) {
448		448
449	int thickness = getThickness(eastBorderType);	449	int thickness = getThickness(eastBorderType);
Lines 457-464 Link Here
457	}	457	}
458		458
459	if (southBorder &&	459	if (southBorder &&
460	((southBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) \|\|	460	((southBorderType == BorderStyle.DASH_DOT_DOT) \|\|
461	(southBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT))	461	(southBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
462	) {	462	) {
463		463
464	int thickness = getThickness(southBorderType);	464	int thickness = getThickness(southBorderType);
Lines 472-479 Link Here
472	}	472	}
473		473
474	if (westBorder &&	474	if (westBorder &&
475	((westBorderType == HSSFCellStyle.BORDER_DASH_DOT_DOT) \|\|	475	((westBorderType == BorderStyle.DASH_DOT_DOT) \|\|
476	(westBorderType == HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT))	476	(westBorderType == BorderStyle.MEDIUM_DASH_DOT_DOT))
477	) {	477	) {
478		478
479	int thickness = getThickness(westBorderType);	479	int thickness = getThickness(westBorderType);
Lines 530-563 Link Here
530	/**	530	/**
531	* @returns the line thickness for a border based on border type	531	* @returns the line thickness for a border based on border type
532	*/	532	*/
533	private int getThickness(int thickness) {	533	private int getThickness(BorderStyle thickness) {
534	int retval=1;
535	switch (thickness) {	534	switch (thickness) {
536	case HSSFCellStyle.BORDER_THIN:	535	case DASH_DOT_DOT:
537	retval=2;	536	case DASHED:
538	break;	537	case HAIR:
539	case HSSFCellStyle.BORDER_MEDIUM:	538	return 1;
540	retval=3;	539	case THIN:
541	break;	540	return 2;
542	case HSSFCellStyle.BORDER_THICK:	541	case MEDIUM:
543	retval=4;	542	case MEDIUM_DASH_DOT_DOT:
544	break;	543	return 3;
545	case HSSFCellStyle.BORDER_DASHED:	544	case THICK:
546	retval=1;	545	return 4;
547	break;
548	case HSSFCellStyle.BORDER_DASH_DOT_DOT:
549	retval=1;
550	break;
551	case HSSFCellStyle.BORDER_MEDIUM_DASH_DOT_DOT:
552	retval=3;
553	break;
554	case HSSFCellStyle.BORDER_HAIR:
555	retval=1;
556	break;
557	default:	546	default:
558	retval=1;	547	return 1;
559	}	548	}
560	return retval;
561	}	549	}
562		550
563		551

Lines 26-36 Link Here

(-)src/examples/src/org/apache/poi/hssf/view/SVTableCellRenderer.java (-5 / +5 lines)
26	import java.awt.Component;	26	import java.awt.Component;
27	import java.awt.Color;	27	import java.awt.Color;
28	import java.awt.Rectangle;	28	import java.awt.Rectangle;
29
30	import java.io.Serializable;	29	import java.io.Serializable;
31	import java.text.*;	30	import java.text.*;
32		31
33	import org.apache.poi.hssf.usermodel.*;	32	import org.apache.poi.hssf.usermodel.*;
		33	import org.apache.poi.ss.usermodel.BorderStyle;
34		34
35		35
36	/**	36	/**
Lines 224-233 Link Here
224	SVTableUtils.black,	224	SVTableUtils.black,
225	SVTableUtils.black,	225	SVTableUtils.black,
226	SVTableUtils.black,	226	SVTableUtils.black,
227	HSSFCellStyle.BORDER_NONE,	227	BorderStyle.NONE,
228	HSSFCellStyle.BORDER_NONE,	228	BorderStyle.NONE,
229	HSSFCellStyle.BORDER_NONE,	229	BorderStyle.NONE,
230	HSSFCellStyle.BORDER_NONE,	230	BorderStyle.NONE,
231	isSelected);	231	isSelected);
232	setBorder(cellBorder);	232	setBorder(cellBorder);
233	}	233	}

Lines 62-83 Link Here

(-)src/examples/src/org/apache/poi/ss/examples/html/ToHtml.java (-13 / +25 lines)
62	private static final String COL_HEAD_CLASS = "colHeader";	62	private static final String COL_HEAD_CLASS = "colHeader";
63	private static final String ROW_HEAD_CLASS = "rowHeader";	63	private static final String ROW_HEAD_CLASS = "rowHeader";
64		64
65	private static final Map<Short, String> ALIGN = mapFor(ALIGN_LEFT, "left",	65	private static final Map<Short, String> ALIGN = mapFor(
66	ALIGN_CENTER, "center", ALIGN_RIGHT, "right", ALIGN_FILL, "left",	66	ALIGN_LEFT, "left",
67	ALIGN_JUSTIFY, "left", ALIGN_CENTER_SELECTION, "center");	67	ALIGN_CENTER, "center",
		68	ALIGN_RIGHT, "right",
		69	ALIGN_FILL, "left",
		70	ALIGN_JUSTIFY, "left",
		71	ALIGN_CENTER_SELECTION, "center");
68		72
69	private static final Map<Short, String> VERTICAL_ALIGN = mapFor(	73	private static final Map<Short, String> VERTICAL_ALIGN = mapFor(
70	VERTICAL_BOTTOM, "bottom", VERTICAL_CENTER, "middle", VERTICAL_TOP,	74	VERTICAL_BOTTOM, "bottom",
71	"top");	75	VERTICAL_CENTER, "middle",
		76	VERTICAL_TOP, "top");
72		77
73	private static final Map<Short, String> BORDER = mapFor(BORDER_DASH_DOT,	78	private static final Map<BorderStyle, String> BORDER = mapFor(
74	"dashed 1pt", BORDER_DASH_DOT_DOT, "dashed 1pt", BORDER_DASHED,	79	BorderStyle.DASH_DOT, "dashed 1pt",
75	"dashed 1pt", BORDER_DOTTED, "dotted 1pt", BORDER_DOUBLE,	80	BorderStyle.DASH_DOT_DOT, "dashed 1pt",
76	"double 3pt", BORDER_HAIR, "solid 1px", BORDER_MEDIUM, "solid 2pt",	81	BorderStyle.DASHED, "dashed 1pt",
77	BORDER_MEDIUM_DASH_DOT, "dashed 2pt", BORDER_MEDIUM_DASH_DOT_DOT,	82	BorderStyle.DOTTED, "dotted 1pt",
78	"dashed 2pt", BORDER_MEDIUM_DASHED, "dashed 2pt", BORDER_NONE,	83	BorderStyle.DOUBLE, "double 3pt",
79	"none", BORDER_SLANTED_DASH_DOT, "dashed 2pt", BORDER_THICK,	84	BorderStyle.HAIR, "solid 1px",
80	"solid 3pt", BORDER_THIN, "dashed 1pt");	85	BorderStyle.MEDIUM, "solid 2pt",
		86	BorderStyle.MEDIUM_DASH_DOT, "dashed 2pt",
		87	BorderStyle.MEDIUM_DASH_DOT_DOT, "dashed 2pt",
		88	BorderStyle.MEDIUM_DASHED, "dashed 2pt",
		89	BorderStyle.NONE, "none",
		90	BorderStyle.SLANTED_DASH_DOT, "dashed 2pt",
		91	BorderStyle.THICK, "solid 3pt",
		92	BorderStyle.THIN, "dashed 1pt");
81		93
82	@SuppressWarnings({"unchecked"})	94	@SuppressWarnings({"unchecked"})
83	private static <K, V> Map<K, V> mapFor(Object... mapping) {	95	private static <K, V> Map<K, V> mapFor(Object... mapping) {

Lines 23-28 Link Here

(-)src/examples/src/org/apache/poi/ss/examples/ExcelComparator.java (-8 / +9 lines)
23	import java.util.List;	23	import java.util.List;
24	import java.util.Locale;	24	import java.util.Locale;
25		25
		26	import org.apache.poi.ss.usermodel.BorderStyle;
26	import org.apache.poi.ss.usermodel.Cell;	27	import org.apache.poi.ss.usermodel.Cell;
27	import org.apache.poi.ss.usermodel.Color;	28	import org.apache.poi.ss.usermodel.Color;
28	import org.apache.poi.ss.usermodel.DateUtil;	29	import org.apache.poi.ss.usermodel.DateUtil;
Lines 362-384 Link Here
362	String borderName;	363	String borderName;
363	switch (borderSide) {	364	switch (borderSide) {
364	case 't': default:	365	case 't': default:
365	b1 = style1.getBorderTop() == 1;	366	b1 = style1.getBorderTop() == BorderStyle.THIN;
366	b2 = style2.getBorderTop() == 1;	367	b2 = style2.getBorderTop() == BorderStyle.THIN;
367	borderName = "TOP";	368	borderName = "TOP";
368	break;	369	break;
369	case 'b':	370	case 'b':
370	b1 = style1.getBorderBottom() == 1;	371	b1 = style1.getBorderBottom() == BorderStyle.THIN;
371	b2 = style2.getBorderBottom() == 1;	372	b2 = style2.getBorderBottom() == BorderStyle.THIN;
372	borderName = "BOTTOM";	373	borderName = "BOTTOM";
373	break;	374	break;
374	case 'l':	375	case 'l':
375	b1 = style1.getBorderLeft() == 1;	376	b1 = style1.getBorderLeft() == BorderStyle.THIN;
376	b2 = style2.getBorderLeft() == 1;	377	b2 = style2.getBorderLeft() == BorderStyle.THIN;
377	borderName = "LEFT";	378	borderName = "LEFT";
378	break;	379	break;
379	case 'r':	380	case 'r':
380	b1 = style1.getBorderRight() == 1;	381	b1 = style1.getBorderRight() == BorderStyle.THIN;
381	b2 = style2.getBorderRight() == 1;	382	b2 = style2.getBorderRight() == BorderStyle.THIN;
382	borderName = "RIGHT";	383	borderName = "RIGHT";
383	break;	384	break;
384	}	385	}

Lines 16-21 Link Here

(-)src/testcases/org/apache/poi/hssf/usermodel/TestHSSFOptimiser.java (-6 / +8 lines)
16	==================================================================== */	16	==================================================================== */
17	package org.apache.poi.hssf.usermodel;	17	package org.apache.poi.hssf.usermodel;
18		18
		19	import org.apache.poi.ss.usermodel.BorderStyle;
		20
19	import junit.framework.TestCase;	21	import junit.framework.TestCase;
20		22
21	public final class TestHSSFOptimiser extends TestCase {	23	public final class TestHSSFOptimiser extends TestCase {
Lines 278-290 Link Here
278	assertEquals(21, wb.getNumCellStyles());	280	assertEquals(21, wb.getNumCellStyles());
279		281
280	HSSFCellStyle cs1 = wb.createCellStyle();	282	HSSFCellStyle cs1 = wb.createCellStyle();
281	cs1.setBorderBottom(HSSFCellStyle.BORDER_THICK);	283	cs1.setBorderBottom(BorderStyle.THICK);
282		284
283	HSSFCellStyle cs2 = wb.createCellStyle();	285	HSSFCellStyle cs2 = wb.createCellStyle();
284	cs2.setBorderBottom(HSSFCellStyle.BORDER_DASH_DOT);	286	cs2.setBorderBottom(BorderStyle.DASH_DOT);
285		287
286	HSSFCellStyle cs3 = wb.createCellStyle(); // = cs1	288	HSSFCellStyle cs3 = wb.createCellStyle(); // = cs1
287	cs3.setBorderBottom(HSSFCellStyle.BORDER_THICK);	289	cs3.setBorderBottom(BorderStyle.THICK);
288		290
289	assertEquals(24, wb.getNumCellStyles());	291	assertEquals(24, wb.getNumCellStyles());
290		292
Lines 306-313 Link Here
306	// Check	308	// Check
307	assertEquals(23, wb.getNumCellStyles());	309	assertEquals(23, wb.getNumCellStyles());
308		310
309	assertEquals(HSSFCellStyle.BORDER_THICK, r.getCell(0).getCellStyle().getBorderBottom());	311	assertEquals(BorderStyle.THICK, r.getCell(0).getCellStyle().getBorderBottom());
310	assertEquals(HSSFCellStyle.BORDER_DASH_DOT, r.getCell(1).getCellStyle().getBorderBottom());	312	assertEquals(BorderStyle.DASH_DOT, r.getCell(1).getCellStyle().getBorderBottom());
311	assertEquals(HSSFCellStyle.BORDER_THICK, r.getCell(2).getCellStyle().getBorderBottom());	313	assertEquals(BorderStyle.THICK, r.getCell(2).getCellStyle().getBorderBottom());
312	}	314	}
313	}	315	}

Lines 254-263 Link Here

(-)src/testcases/org/apache/poi/ss/usermodel/BaseTestCell.java (-10 / +10 lines)
254	f.setFontName("Arial Unicode MS");	254	f.setFontName("Arial Unicode MS");
255	cs.setFillBackgroundColor((short)3);	255	cs.setFillBackgroundColor((short)3);
256	cs.setFont(f);	256	cs.setFont(f);
257	cs.setBorderTop((short)1);	257	cs.setBorderTop(BorderStyle.THIN);
258	cs.setBorderRight((short)1);	258	cs.setBorderRight(BorderStyle.THIN);
259	cs.setBorderLeft((short)1);	259	cs.setBorderLeft(BorderStyle.THIN);
260	cs.setBorderBottom((short)1);	260	cs.setBorderBottom(BorderStyle.THIN);
261		261
262	r = s.createRow(0);	262	r = s.createRow(0);
263	c=r.createCell(0);	263	c=r.createCell(0);
Lines 270-284 Link Here
270	r = s.getRow(0);	270	r = s.getRow(0);
271	c = r.getCell(0);	271	c = r.getCell(0);
272		272
273	assertTrue("Formula Cell at 0,0", (c.getCellType()==Cell.CELL_TYPE_FORMULA));	273	assertEquals("Formula Cell at 0,0", Cell.CELL_TYPE_FORMULA, c.getCellType());
274	cs = c.getCellStyle();	274	cs = c.getCellStyle();
275		275
276	assertNotNull("Formula Cell Style", cs);	276	assertNotNull("Formula Cell Style", cs);
277	assertTrue("Font Index Matches", (cs.getFontIndex() == f.getIndex()));	277	assertEquals("Font Index Matches", f.getIndex(), cs.getFontIndex());
278	assertTrue("Top Border", (cs.getBorderTop() == (short)1));	278	assertEquals("Top Border", BorderStyle.THIN, cs.getBorderTop());
279	assertTrue("Left Border", (cs.getBorderLeft() == (short)1));	279	assertEquals("Left Border", BorderStyle.THIN, cs.getBorderLeft());
280	assertTrue("Right Border", (cs.getBorderRight() == (short)1));	280	assertEquals("Right Border", BorderStyle.THIN, cs.getBorderRight());
281	assertTrue("Bottom Border", (cs.getBorderBottom() == (short)1));	281	assertEquals("Bottom Border", BorderStyle.THIN, cs.getBorderBottom());
282	wb2.close();	282	wb2.close();
283	}	283	}
284		284

Lines 29-41 Link Here

(-)src/testcases/org/apache/poi/ss/util/TestCellUtil.java (-9 / +9 lines)
29	import java.util.Map;	29	import java.util.Map;
30		30
31	import org.apache.poi.hssf.usermodel.HSSFWorkbook;	31	import org.apache.poi.hssf.usermodel.HSSFWorkbook;
		32	import org.apache.poi.ss.usermodel.BorderStyle;
32	import org.apache.poi.ss.usermodel.Cell;	33	import org.apache.poi.ss.usermodel.Cell;
33	import org.apache.poi.ss.usermodel.CellStyle;	34	import org.apache.poi.ss.usermodel.CellStyle;
34	import org.apache.poi.ss.usermodel.Font;	35	import org.apache.poi.ss.usermodel.Font;
35	import org.apache.poi.ss.usermodel.Row;	36	import org.apache.poi.ss.usermodel.Row;
36	import org.apache.poi.ss.usermodel.Sheet;	37	import org.apache.poi.ss.usermodel.Sheet;
37	import org.apache.poi.ss.usermodel.Workbook;	38	import org.apache.poi.ss.usermodel.Workbook;
38
39	import org.junit.Test;	39	import org.junit.Test;
40		40
41	/**	41	/**
Lines 53-65 Link Here
53		53
54	// Add a border should create a new style	54	// Add a border should create a new style
55	int styCnt1 = wb.getNumCellStyles();	55	int styCnt1 = wb.getNumCellStyles();
56	CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, CellStyle.BORDER_THIN);	56	CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, BorderStyle.THIN);
57	int styCnt2 = wb.getNumCellStyles();	57	int styCnt2 = wb.getNumCellStyles();
58	assertEquals(styCnt2, styCnt1+1);	58	assertEquals(styCnt2, styCnt1+1);
59		59
60	// Add same border to another cell, should not create another style	60	// Add same border to another cell, should not create another style
61	c = r.createCell(1);	61	c = r.createCell(1);
62	CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, CellStyle.BORDER_THIN);	62	CellUtil.setCellStyleProperty(c, wb, CellUtil.BORDER_BOTTOM, BorderStyle.THIN);
63	int styCnt3 = wb.getNumCellStyles();	63	int styCnt3 = wb.getNumCellStyles();
64	assertEquals(styCnt3, styCnt2);	64	assertEquals(styCnt3, styCnt2);
65		65
Lines 76-94 Link Here
76	// Add multiple border properties to cell should create a single new style	76	// Add multiple border properties to cell should create a single new style
77	int styCnt1 = wb.getNumCellStyles();	77	int styCnt1 = wb.getNumCellStyles();
78	Map<String, Object> props = new HashMap<String, Object>();	78	Map<String, Object> props = new HashMap<String, Object>();
79	props.put(CellUtil.BORDER_TOP, CellStyle.BORDER_THIN);	79	props.put(CellUtil.BORDER_TOP, BorderStyle.THIN);
80	props.put(CellUtil.BORDER_BOTTOM, CellStyle.BORDER_THIN);	80	props.put(CellUtil.BORDER_BOTTOM, BorderStyle.THIN);
81	props.put(CellUtil.BORDER_LEFT, CellStyle.BORDER_THIN);	81	props.put(CellUtil.BORDER_LEFT, BorderStyle.THIN);
82	props.put(CellUtil.BORDER_RIGHT, CellStyle.BORDER_THIN);	82	props.put(CellUtil.BORDER_RIGHT, BorderStyle.THIN);
83	CellUtil.setCellStyleProperties(c, props);	83	CellUtil.setCellStyleProperties(c, props);
84	int styCnt2 = wb.getNumCellStyles();	84	int styCnt2 = wb.getNumCellStyles();
85	assertEquals(styCnt2, styCnt1+1);	85	assertEquals(styCnt1+1, styCnt2);
86		86
87	// Add same border another to same cell, should not create another style	87	// Add same border another to same cell, should not create another style
88	c = r.createCell(1);	88	c = r.createCell(1);
89	CellUtil.setCellStyleProperties(c, props);	89	CellUtil.setCellStyleProperties(c, props);
90	int styCnt3 = wb.getNumCellStyles();	90	int styCnt3 = wb.getNumCellStyles();
91	assertEquals(styCnt3, styCnt2);	91	assertEquals(styCnt2, styCnt3);
92		92
93	wb.close();	93	wb.close();
94	}	94	}

Lines 104-114 Link Here

(-)src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCellStyle.java (-156 / +105 lines)
104	@Test	104	@Test
105	public void testGetSetBorderBottom() {	105	public void testGetSetBorderBottom() {
106	//default values	106	//default values
107	assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderBottom());	107	assertEquals(BorderStyle.NONE, cellStyle.getBorderBottom());
108		108
109	int num = stylesTable.getBorders().size();	109	int num = stylesTable.getBorders().size();
110	cellStyle.setBorderBottom(CellStyle.BORDER_MEDIUM);	110	cellStyle.setBorderBottom(BorderStyle.MEDIUM);
111	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderBottom());	111	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderBottom());
112	//a new border has been added	112	//a new border has been added
113	assertEquals(num + 1, stylesTable.getBorders().size());	113	assertEquals(num + 1, stylesTable.getBorders().size());
114	//id of the created border	114	//id of the created border
Lines 121-135 Link Here
121	num = stylesTable.getBorders().size();	121	num = stylesTable.getBorders().size();
122	//setting the same border multiple times should not change borderId	122	//setting the same border multiple times should not change borderId
123	for (int i = 0; i < 3; i++) {	123	for (int i = 0; i < 3; i++) {
124	cellStyle.setBorderBottom(CellStyle.BORDER_MEDIUM);	124	cellStyle.setBorderBottom(BorderStyle.MEDIUM);
125	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderBottom());	125	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderBottom());
126	}	126	}
127	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());	127	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
128	assertEquals(num, stylesTable.getBorders().size());	128	assertEquals(num, stylesTable.getBorders().size());
129	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());	129	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
130		130
131	//setting border to none removes the <bottom> element	131	//setting border to none removes the <bottom> element
132	cellStyle.setBorderBottom(CellStyle.BORDER_NONE);	132	cellStyle.setBorderBottom(BorderStyle.NONE);
133	assertEquals(num, stylesTable.getBorders().size());	133	assertEquals(num, stylesTable.getBorders().size());
134	borderId = (int)cellStyle.getCoreXf().getBorderId();	134	borderId = (int)cellStyle.getCoreXf().getBorderId();
135	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	135	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
Lines 139-149 Link Here
139	@Test	139	@Test
140	public void testGetSetBorderRight() {	140	public void testGetSetBorderRight() {
141	//default values	141	//default values
142	assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderRight());	142	assertEquals(BorderStyle.NONE, cellStyle.getBorderRight());
143		143
144	int num = stylesTable.getBorders().size();	144	int num = stylesTable.getBorders().size();
145	cellStyle.setBorderRight(CellStyle.BORDER_MEDIUM);	145	cellStyle.setBorderRight(BorderStyle.MEDIUM);
146	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderRight());	146	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderRight());
147	//a new border has been added	147	//a new border has been added
148	assertEquals(num + 1, stylesTable.getBorders().size());	148	assertEquals(num + 1, stylesTable.getBorders().size());
149	//id of the created border	149	//id of the created border
Lines 156-170 Link Here
156	num = stylesTable.getBorders().size();	156	num = stylesTable.getBorders().size();
157	//setting the same border multiple times should not change borderId	157	//setting the same border multiple times should not change borderId
158	for (int i = 0; i < 3; i++) {	158	for (int i = 0; i < 3; i++) {
159	cellStyle.setBorderRight(CellStyle.BORDER_MEDIUM);	159	cellStyle.setBorderRight(BorderStyle.MEDIUM);
160	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderRight());	160	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderRight());
161	}	161	}
162	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());	162	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
163	assertEquals(num, stylesTable.getBorders().size());	163	assertEquals(num, stylesTable.getBorders().size());
164	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());	164	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
165		165
166	//setting border to none removes the <right> element	166	//setting border to none removes the <right> element
167	cellStyle.setBorderRight(CellStyle.BORDER_NONE);	167	cellStyle.setBorderRight(BorderStyle.NONE);
168	assertEquals(num, stylesTable.getBorders().size());	168	assertEquals(num, stylesTable.getBorders().size());
169	borderId = (int)cellStyle.getCoreXf().getBorderId();	169	borderId = (int)cellStyle.getCoreXf().getBorderId();
170	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	170	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
Lines 174-184 Link Here
174	@Test	174	@Test
175	public void testGetSetBorderLeft() {	175	public void testGetSetBorderLeft() {
176	//default values	176	//default values
177	assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderLeft());	177	assertEquals(BorderStyle.NONE, cellStyle.getBorderLeft());
178		178
179	int num = stylesTable.getBorders().size();	179	int num = stylesTable.getBorders().size();
180	cellStyle.setBorderLeft(CellStyle.BORDER_MEDIUM);	180	cellStyle.setBorderLeft(BorderStyle.MEDIUM);
181	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderLeft());	181	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderLeft());
182	//a new border has been added	182	//a new border has been added
183	assertEquals(num + 1, stylesTable.getBorders().size());	183	assertEquals(num + 1, stylesTable.getBorders().size());
184	//id of the created border	184	//id of the created border
Lines 191-205 Link Here
191	num = stylesTable.getBorders().size();	191	num = stylesTable.getBorders().size();
192	//setting the same border multiple times should not change borderId	192	//setting the same border multiple times should not change borderId
193	for (int i = 0; i < 3; i++) {	193	for (int i = 0; i < 3; i++) {
194	cellStyle.setBorderLeft(CellStyle.BORDER_MEDIUM);	194	cellStyle.setBorderLeft(BorderStyle.MEDIUM);
195	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderLeft());	195	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderLeft());
196	}	196	}
197	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());	197	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
198	assertEquals(num, stylesTable.getBorders().size());	198	assertEquals(num, stylesTable.getBorders().size());
199	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());	199	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
200		200
201	//setting border to none removes the <left> element	201	//setting border to none removes the <left> element
202	cellStyle.setBorderLeft(CellStyle.BORDER_NONE);	202	cellStyle.setBorderLeft(BorderStyle.NONE);
203	assertEquals(num, stylesTable.getBorders().size());	203	assertEquals(num, stylesTable.getBorders().size());
204	borderId = (int)cellStyle.getCoreXf().getBorderId();	204	borderId = (int)cellStyle.getCoreXf().getBorderId();
205	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	205	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
Lines 209-219 Link Here
209	@Test	209	@Test
210	public void testGetSetBorderTop() {	210	public void testGetSetBorderTop() {
211	//default values	211	//default values
212	assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderTop());	212	assertEquals(BorderStyle.NONE, cellStyle.getBorderTop());
213		213
214	int num = stylesTable.getBorders().size();	214	int num = stylesTable.getBorders().size();
215	cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM);	215	cellStyle.setBorderTop(BorderStyle.MEDIUM);
216	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop());	216	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderTop());
217	//a new border has been added	217	//a new border has been added
218	assertEquals(num + 1, stylesTable.getBorders().size());	218	assertEquals(num + 1, stylesTable.getBorders().size());
219	//id of the created border	219	//id of the created border
Lines 226-390 Link Here
226	num = stylesTable.getBorders().size();	226	num = stylesTable.getBorders().size();
227	//setting the same border multiple times should not change borderId	227	//setting the same border multiple times should not change borderId
228	for (int i = 0; i < 3; i++) {	228	for (int i = 0; i < 3; i++) {
229	cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM);	229	cellStyle.setBorderTop(BorderStyle.MEDIUM);
230	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop());	230	assertEquals(BorderStyle.MEDIUM, cellStyle.getBorderTop());
231	}	231	}
232	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());	232	assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
233	assertEquals(num, stylesTable.getBorders().size());	233	assertEquals(num, stylesTable.getBorders().size());
234	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());	234	assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
235		235
236	//setting border to none removes the <top> element	236	//setting border to none removes the <top> element
237	cellStyle.setBorderTop(CellStyle.BORDER_NONE);	237	cellStyle.setBorderTop(BorderStyle.NONE);
238	assertEquals(num, stylesTable.getBorders().size());	238	assertEquals(num, stylesTable.getBorders().size());
239	borderId = (int)cellStyle.getCoreXf().getBorderId();	239	borderId = (int)cellStyle.getCoreXf().getBorderId();
240	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	240	ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
241	assertFalse(ctBorder.isSetTop());	241	assertFalse(ctBorder.isSetTop());
242	}	242	}
243		243
244	@Test	244	private void testGetSetBorderXMLBean(BorderStyle border, STBorderStyle.Enum expected) {
245	public void testGetSetBorderThin() {	245	cellStyle.setBorderTop(border);
246	cellStyle.setBorderTop(CellStyle.BORDER_THIN);	246	assertEquals(border, cellStyle.getBorderTop());
247	assertEquals(CellStyle.BORDER_THIN, cellStyle.getBorderTop());
248	int borderId = (int)cellStyle.getCoreXf().getBorderId();	247	int borderId = (int)cellStyle.getCoreXf().getBorderId();
249	assertTrue(borderId > 0);	248	assertTrue(borderId > 0);
250	//check changes in the underlying xml bean	249	//check changes in the underlying xml bean
251	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	250	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
252	assertEquals(STBorderStyle.THIN, ctBorder.getTop().getStyle());	251	assertEquals(expected, ctBorder.getTop().getStyle());
253	}	252	}
254		253
255	@Test	254
256	public void testGetSetBorderMedium() {	255	// Border Styles, in BorderStyle/STBorderStyle enum order
257	cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM);	256	@Test
258	assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop());	257	public void testGetSetBorderNone() {
		258	cellStyle.setBorderTop(BorderStyle.NONE);
		259	assertEquals(BorderStyle.NONE, cellStyle.getBorderTop());
259	int borderId = (int)cellStyle.getCoreXf().getBorderId();	260	int borderId = (int)cellStyle.getCoreXf().getBorderId();
260	assertTrue(borderId > 0);	261	assertTrue(borderId > 0);
261	//check changes in the underlying xml bean	262	//check changes in the underlying xml bean
262	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	263	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
263	assertEquals(STBorderStyle.MEDIUM, ctBorder.getTop().getStyle());	264	assertNull(ctBorder.getTop());
264	}	265	// no border style and STBorderStyle.NONE are equivalent
265		266	// POI prefers to unset the border style than explicitly set it STBorderStyle.NONE
266	@Test	267	}
		268
		269	@Test
		270	public void testGetSetBorderThin() {
		271	testGetSetBorderXMLBean(BorderStyle.THIN, STBorderStyle.THIN);
		272	}
		273
		274	@Test
		275	public void testGetSetBorderMedium() {
		276	testGetSetBorderXMLBean(BorderStyle.MEDIUM, STBorderStyle.MEDIUM);
		277	}
		278
		279	@Test
		280	public void testGetSetBorderDashed() {
		281	testGetSetBorderXMLBean(BorderStyle.DASHED, STBorderStyle.DASHED);
		282	}
		283
		284	@Test
		285	public void testGetSetBorderDotted() {
		286	testGetSetBorderXMLBean(BorderStyle.DOTTED, STBorderStyle.DOTTED);
		287	}
		288
		289	@Test
267	public void testGetSetBorderThick() {	290	public void testGetSetBorderThick() {
268	cellStyle.setBorderTop(CellStyle.BORDER_THICK);	291	testGetSetBorderXMLBean(BorderStyle.THICK, STBorderStyle.THICK);
269	assertEquals(CellStyle.BORDER_THICK, cellStyle.getBorderTop());	292	}
270	int borderId = (int)cellStyle.getCoreXf().getBorderId();	293
271	assertTrue(borderId > 0);	294	@Test
272	//check changes in the underlying xml bean	295	public void testGetSetBorderDouble() {
273	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	296	testGetSetBorderXMLBean(BorderStyle.DOUBLE, STBorderStyle.DOUBLE);
274	assertEquals(STBorderStyle.THICK, ctBorder.getTop().getStyle());	297	}
275	}	298
276		299	@Test
277	@Test
278	public void testGetSetBorderHair() {	300	public void testGetSetBorderHair() {
279	cellStyle.setBorderTop(CellStyle.BORDER_HAIR);	301	testGetSetBorderXMLBean(BorderStyle.HAIR, STBorderStyle.HAIR);
280	assertEquals(CellStyle.BORDER_HAIR, cellStyle.getBorderTop());	302	}
281	int borderId = (int)cellStyle.getCoreXf().getBorderId();	303
282	assertTrue(borderId > 0);	304	@Test
283	//check changes in the underlying xml bean	305	public void testGetSetBorderMediumDashed() {
284	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	306	testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASHED, STBorderStyle.MEDIUM_DASHED);
285	assertEquals(STBorderStyle.HAIR, ctBorder.getTop().getStyle());	307	}
286	}	308
287		309	@Test
288	@Test
289	public void testGetSetBorderDotted() {
290	cellStyle.setBorderTop(CellStyle.BORDER_DOTTED);
291	assertEquals(CellStyle.BORDER_DOTTED, cellStyle.getBorderTop());
292	int borderId = (int)cellStyle.getCoreXf().getBorderId();
293	assertTrue(borderId > 0);
294	//check changes in the underlying xml bean
295	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
296	assertEquals(STBorderStyle.DOTTED, ctBorder.getTop().getStyle());
297	}
298
299	@Test
300	public void testGetSetBorderDashed() {
301	cellStyle.setBorderTop(CellStyle.BORDER_DASHED);
302	assertEquals(CellStyle.BORDER_DASHED, cellStyle.getBorderTop());
303	int borderId = (int)cellStyle.getCoreXf().getBorderId();
304	assertTrue(borderId > 0);
305	//check changes in the underlying xml bean
306	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
307	assertEquals(STBorderStyle.DASHED, ctBorder.getTop().getStyle());
308	}
309
310	@Test
311	public void testGetSetBorderDashDot() {	310	public void testGetSetBorderDashDot() {
312	cellStyle.setBorderTop(CellStyle.BORDER_DASH_DOT);	311	testGetSetBorderXMLBean(BorderStyle.DASH_DOT, STBorderStyle.DASH_DOT);
313	assertEquals(CellStyle.BORDER_DASH_DOT, cellStyle.getBorderTop());	312	}
314	int borderId = (int)cellStyle.getCoreXf().getBorderId();	313
315	assertTrue(borderId > 0);	314	@Test
316	//check changes in the underlying xml bean
317	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
318	assertEquals(STBorderStyle.DASH_DOT, ctBorder.getTop().getStyle());
319	}
320
321	@Test
322	public void testGetSetBorderDashDotDot() {
323	cellStyle.setBorderTop(CellStyle.BORDER_DASH_DOT_DOT);
324	assertEquals(CellStyle.BORDER_DASH_DOT_DOT, cellStyle.getBorderTop());
325	int borderId = (int)cellStyle.getCoreXf().getBorderId();
326	assertTrue(borderId > 0);
327	//check changes in the underlying xml bean
328	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
329	assertEquals(STBorderStyle.DASH_DOT_DOT, ctBorder.getTop().getStyle());
330	}
331
332	@Test
333	public void testGetSetBorderMediumDashDot() {	315	public void testGetSetBorderMediumDashDot() {
334	cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASH_DOT);	316	testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASH_DOT, STBorderStyle.MEDIUM_DASH_DOT);
335	assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT, cellStyle.getBorderTop());	317	}
336	int borderId = (int)cellStyle.getCoreXf().getBorderId();	318
337	assertTrue(borderId > 0);	319	@Test
338	//check changes in the underlying xml bean	320	public void testGetSetBorderDashDotDot() {
339	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();	321	testGetSetBorderXMLBean(BorderStyle.DASH_DOT_DOT, STBorderStyle.DASH_DOT_DOT);
340	assertEquals(STBorderStyle.MEDIUM_DASH_DOT, ctBorder.getTop().getStyle());	322	}
341	}	323
342		324	@Test
343	@Test
344	public void testGetSetBorderMediumDashDotDot() {	325	public void testGetSetBorderMediumDashDotDot() {
345	cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT);	326	testGetSetBorderXMLBean(BorderStyle.MEDIUM_DASH_DOT_DOT, STBorderStyle.MEDIUM_DASH_DOT_DOT);
346	assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT, cellStyle.getBorderTop());	327	}
347	int borderId = (int)cellStyle.getCoreXf().getBorderId();	328
348	assertTrue(borderId > 0);	329	@Test
349	//check changes in the underlying xml bean
350	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
351	assertEquals(STBorderStyle.MEDIUM_DASH_DOT_DOT, ctBorder.getTop().getStyle());
352	}
353
354	@Test
355	public void testGetSetBorderMediumDashed() {
356	cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASHED);
357	assertEquals(CellStyle.BORDER_MEDIUM_DASHED, cellStyle.getBorderTop());
358	int borderId = (int)cellStyle.getCoreXf().getBorderId();
359	assertTrue(borderId > 0);
360	//check changes in the underlying xml bean
361	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
362	assertEquals(STBorderStyle.MEDIUM_DASHED, ctBorder.getTop().getStyle());
363	}
364
365	@Test
366	public void testGetSetBorderSlantDashDot() {	330	public void testGetSetBorderSlantDashDot() {
367	cellStyle.setBorderTop(CellStyle.BORDER_SLANTED_DASH_DOT);	331	testGetSetBorderXMLBean(BorderStyle.SLANTED_DASH_DOT, STBorderStyle.SLANT_DASH_DOT);
368	assertEquals(CellStyle.BORDER_SLANTED_DASH_DOT, cellStyle.getBorderTop());	332	}
369	int borderId = (int)cellStyle.getCoreXf().getBorderId();	333
370	assertTrue(borderId > 0);	334	@Test
371	//check changes in the underlying xml bean
372	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
373	assertEquals(STBorderStyle.SLANT_DASH_DOT, ctBorder.getTop().getStyle());
374	}
375
376	@Test
377	public void testGetSetBorderDouble() {
378	cellStyle.setBorderTop(CellStyle.BORDER_DOUBLE);
379	assertEquals(CellStyle.BORDER_DOUBLE, cellStyle.getBorderTop());
380	int borderId = (int)cellStyle.getCoreXf().getBorderId();
381	assertTrue(borderId > 0);
382	//check changes in the underlying xml bean
383	CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
384	assertEquals(STBorderStyle.DOUBLE, ctBorder.getTop().getStyle());
385	}
386
387	@Test
388	public void testGetSetBottomBorderColor() {	335	public void testGetSetBottomBorderColor() {
389	//defaults	336	//defaults
390	assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getBottomBorderColor());	337	assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getBottomBorderColor());
Lines 1104-1108 Link Here
1104		1051
1105	cellStyle.setRightBorderColor(null);	1052	cellStyle.setRightBorderColor(null);
1106	assertNull(cellStyle.getRightBorderXSSFColor());	1053	assertNull(cellStyle.getRightBorderXSSFColor());
		1054
		1055	workbook.close();
1107	}	1056	}
1108	}	1057	}