![[An illustration of two LineBorders]](doc-files/LineBorder-1.png)
*
* serialver tool
* of Apple/Sun JDK 1.3.1 on MacOS X 10.1.5.
*/
static final long serialVersionUID = -787563427772288970L;
/**
* A shared instance of a black, one pixel thick, plain LineBorder.
* The singleton object is lazily created by {@link
* #createBlackLineBorder()} upon its first invocation.
*/
private static LineBorder blackLineBorder;
/**
* A shared instance of a gray, one pixel thick, plain LineBorder.
* The singleton object is lazily created by {@link
* #createGrayLineBorder()} upon its first invocation.
*/
private static LineBorder grayLineBorder;
/**
* The width of the line in pixels.
*/
protected int thickness;
/**
* The color of the line.
*/
protected Color lineColor;
/**
* Indicates whether the line is drawn with rounded corners
* (true) or not ((false).
*/
protected boolean roundedCorners;
/**
* Constructs a LineBorder given its color. The border will be one
* pixel thick and have plain corners.
*
* @param color the color for drawing the border.
*
* @see #LineBorder(java.awt.Color, int, boolean)
*/
public LineBorder(Color color)
{
this(color, /* thickness */ 1, /* roundedCorners */ false);
}
/**
* Constructs a LineBorder given its color and thickness. The
* border will have plain corners.
*
* @param color the color for drawing the border.
* @param thickness the width of the line in pixels.
*
* @see #LineBorder(java.awt.Color, int, boolean)
*/
public LineBorder(Color color, int thickness)
{
this (color, thickness, /* roundedCorners */ false);
}
/**
* Constructs a LineBorder given its color, thickness, and whether
* it has rounded corners.
*
*
*
*
Note that the enlarged view in the right-hand picture shows
* that the implementation draws one more pixel than specified,
* provided that roundedCorders is true
* and anti-aliasing is turned on while painting. While this might
* be considered a bug, the Sun reference implementation (at least
* JDK 1.3.1 on Apple MacOS X 10.1.5) can be observed to fill
* exactly the same pixels as shown above. The GNU Classpath
* LineBorder replicates the observed behavior of the Sun
* implementation.
*
* @param color the color for drawing the border.
* @param thickness the width of the line in pixels.
* @param roundedCorners true for rounded corners,
* false for plain corners.
*
* @since 1.3
*/
// For the bug mentioned in the JavaDoc, please see also the comment
// in the paintBorder method below.
//
public LineBorder(Color color, int thickness, boolean roundedCorners)
{
if ((color == null) || (thickness < 0))
throw new IllegalArgumentException();
this.lineColor = color;
this.thickness = thickness;
this.roundedCorners = roundedCorners;
}
/**
* Returns a black, one pixel thick, plain {@link LineBorder}. The method
* may always return the same (singleton) {@link LineBorder} instance.
*
* @return The border.
*/
public static Border createBlackLineBorder()
{
/* Swing is not designed to be thread-safe, so there is no
* need to synchronize the access to the global variable.
*/
if (blackLineBorder == null)
blackLineBorder = new LineBorder(Color.black);
return blackLineBorder;
}
/**
* Returns a gray, one pixel thick, plain {@link LineBorder}. The method
* may always return the same (singleton) {@link LineBorder} instance.
*
* @return The border.
*/
public static Border createGrayLineBorder()
{
/* Swing is not designed to be thread-safe, so there is no
* need to synchronize the access to the global variable.
*/
if (grayLineBorder == null)
grayLineBorder = new LineBorder(Color.gray);
return grayLineBorder;
}
/**
* Paints the line border around a given Component.
*
* @param c the component whose border is to be painted.
* @param g the graphics for painting.
* @param x the horizontal position for painting the border.
* @param y the vertical position for painting the border.
* @param width the width of the available area for painting the border.
* @param height the height of the available area for painting the border.
*/
public void paintBorder(Component c, Graphics g,
int x, int y, int width, int height)
{
Color oldColor = g.getColor();
try
{
g.setColor(lineColor);
// If width and height were not adjusted, the border would
// appear one pixel too large in both directions.
width -= 1;
height -= 1;
// Blurred, too large appearance
// -----------------------------
// While Java 2D has introduced line strokes of arbitrary width,
// it seems desirable to keep this code independent of Java 2D.
// Therefore, multiple nested rectangles (or rounded rectangles)
// are drawn in order to simulate a line whose thickness is
// greater than one pixel.
//
// This hack causes a blurred appearance when anti-aliasing is
// on. Interestingly enough, though, the Sun JDK 1.3.1 (at least
// on MacOS X 10.1.5) shows exactly the same appearance under
// this condition. It thus seems likely that Sun does the same
// hack for simulating thick lines. For this reason, the
// blurred appearance seems acceptable -- especially since GNU
// Classpath tries to be compatible with the Sun reference
// implementation.
for (int i = 0; i < thickness; i++)
{
if (roundedCorners)
g.drawRoundRect(x, y, width, height, thickness, thickness);
else
g.drawRect(x, y, width, height);
x += 1;
y += 1;
width -= 2;
height -= 2;
}
}
finally
{
g.setColor(oldColor);
}
}
/**
* Measures the width of this border.
*
* @param c the component whose border is to be measured.
*
* @return an Insets object whose left, right,
* top and bottom fields indicate the
* width of the border at the respective edge, which is the
* thickness of the line.
*
* @see #getBorderInsets(java.awt.Component, java.awt.Insets)
*/
public Insets getBorderInsets(Component c)
{
return new Insets(thickness, thickness, thickness, thickness);
}
/**
* Measures the width of this border, storing the results into a
* pre-existing Insets object.
*
* @param insets an Insets object for holding the result values.
* After invoking this method, the left,
* right, top and
* bottom fields indicate the width of the
* border at the respective edge, which is the thickness
* of the line.
*
* @return the same object that was passed for insets.
*
* @see #getBorderInsets(Component)
*/
public Insets getBorderInsets(Component c, Insets insets)
{
insets.left = insets.right = insets.top = insets.bottom = thickness;
return insets;
}
/**
* Returns the color of the line.
*
* @return The line color (never null).
*/
public Color getLineColor()
{
return lineColor;
}
/**
* Returns the thickness of the line in pixels.
*
* @return The line thickness (in pixels).
*/
public int getThickness()
{
return thickness;
}
/**
* Returns whether this LineBorder os drawm with rounded
* or with plain corners.
*
* @return true if the corners are rounded,
* false if the corners are plain.
*/
public boolean getRoundedCorners()
{
return roundedCorners;
}
/**
* Determines whether this border fills every pixel in its area
* when painting.
*
* @return true if the corners are plain and the line
* color is fully opaque; false if the corners
* are rounded or the line color is partially transparent.
*/
public boolean isBorderOpaque()
{
return (!roundedCorners) && (lineColor.getAlpha() == 255);
}
}