ShapePainter class offers a set of static methods to render thick shapes (with or without
* anti-aliasing) and polygons.
*/
public class ShapePainter {
/**
* Defines the cap representation when drawing a line or a circle arc.
*/
public enum Cap {
/**
* No specific cap is drawn.
*/
NONE,
/**
* Cap is represented by a semi circle (default configuration).
*/
ROUNDED,
/**
* Cap is perpendicular to the line.
*/
PERPENDICULAR
}
/**
* Draws a faded point at (x,y) using the {@link GraphicsContext}'s current color.
*
* The shape's bounding box is
* (x - thickness / 2 - fade, y - thickness / 2 - fade) to (x + thickness / 2 + fade, y + thickness / 2 + fade).
*
* @param gc
* the graphics context where render the drawing.
* @param x
* the x coordinate of the point
* @param y
* the y coordinate of the point
* @param thickness
* the thickness to apply.
* @param fade
* the fade to apply.
* @throws IllegalArgumentException
* when given thickness is negative
*/
public static void drawThickFadedPoint(GraphicsContext gc, int x, int y, int thickness, int fade) {
throw new RuntimeException();
}
/**
* Draws a line from (x1,y1) to (x2,y2) using the {@link GraphicsContext}'s current color.
*
* The rendering is aliased but the rendering time is often faster than * {@link #drawThickFadedLine(GraphicsContext, int, int, int, int, int, int, Cap, Cap)}. *
* Equivalent to calling {@link #drawThickFadedLine(GraphicsContext, int, int, int, int, int, int, Cap, Cap)} with a * fade equals to 0 and {@link Cap#NONE} for caps. *
* The shape's bounding box is
* (min(startX, endX) - thickness / 2, min(startY, endY) - thickness / 2) to (max(startX, endX) + thickness / 2, max(startY, endY) + thickness / 2).
*
* @param gc
* the graphics context where render the drawing.
* @param startX
* the x coordinate of the start of the line.
* @param startY
* the y coordinate of the start of the line.
* @param endX
* the x coordinate of the end of the line.
* @param endY
* the y coordinate of the end of the line.
* @param thickness
* the thickness to apply.
* @throws IllegalArgumentException
* when given thickness is negative
*/
public static void drawThickLine(GraphicsContext gc, int startX, int startY, int endX, int endY, int thickness) {
throw new RuntimeException();
}
/**
* Draws a faded line from (x1,y1) to (x2,y2) using the {@link GraphicsContext}'s current
* color and caps.
*
* The shape's bounding box is
* (min(startX, endX) - thickness / 2 - fade, min(startY, endY) - thickness / 2 - fade) to (max(startX, endX) + thickness / 2 + fade, max(startY, endY) + thickness / 2 + fade).
*
* @param gc
* the graphics context where render the drawing.
* @param startX
* the x coordinate of the start of the line
* @param startY
* the y coordinate of the start of the line
* @param endX
* the x coordinate of the end of the line
* @param endY
* the y coordinate of the end of the line
* @param thickness
* the thickness to apply.
* @param fade
* the fade to apply.
* @param startCap
* the cap to draw on (x1,y1).
* @param endCap
* the cap to draw on (x2,y2).
* @throws IllegalArgumentException
* when given thickness or fade is negative
*/
public static void drawThickFadedLine(GraphicsContext gc, int startX, int startY, int endX, int endY, int thickness, int fade, Cap startCap, Cap endCap) {
throw new RuntimeException();
}
/**
* Draws the outline of a circular arc covering the specified square, using the {@link GraphicsContext} 's current
* color.
*
* The arc is drawn from startAngle up to arcAngle degrees. The center of the arc is
* defined as the center of the square whose origin is at (x,y) (upper-left corner) and whose dimension
* is given by diameter.
*
* Angles are interpreted such that 0 degrees is at the 3 o'clock position. A positive value indicates a
* counter-clockwise rotation while a negative value indicates a clockwise rotation.
*
* If diameter is negative, nothing is drawn.
*
* The rendering is aliased but the rendering time is often faster than * {@link #drawThickFadedCircleArc(GraphicsContext, int, int, int, float, float, int, int, Cap, Cap)}. *
* Equivalent to calling * {@link #drawThickFadedCircleArc(GraphicsContext, int, int, int, float, float, int, int, Cap, Cap)} with a fade * equals to 0 and {@link Cap#NONE} for caps. *
* The shape's bounding box is (when arcAngle is 360°):
* (x - thickness / 2, y - thickness / 2) to (x + diameter + thickness / 2, y + diameter + thickness / 2).
*
* @param gc
* the graphics context where render the drawing.
* @param x
* the x coordinate of the upper-left corner of the square where the arc is drawn.
* @param y
* the y coordinate of the upper-left corner of the square where the arc is drawn.
* @param diameter
* the diameter of the arc to draw.
* @param startAngle
* the beginning angle of the arc to draw.
* @param arcAngle
* the angular extent of the arc from startAngle.
* @param thickness
* the thickness to apply.
* @throws IllegalArgumentException
* when given thickness is negative
*/
public static void drawThickCircleArc(GraphicsContext gc, int x, int y, int diameter, float startAngle, float arcAngle, int thickness) {
throw new RuntimeException();
}
/**
* Draws the faded outline of a circular arc covering the specified square, using the current color and caps.
*
* The arc is drawn from startAngle up to arcAngle degrees. The center of the arc is
* defined as the center of the square whose origin is at (x,y) (upper-left corner) and whose dimension
* is given by diameter.
*
* Angles are interpreted such that 0 degrees is at the 3 o'clock position. A positive value indicates a
* counter-clockwise rotation while a negative value indicates a clockwise rotation.
*
* If diameter is negative or zero, nothing is drawn.
*
* The angles are given relative to the square. For instance an angle of 45 degrees is always defined by the line
* from the center of the square to the upper right corner of the square. Thus for a non squared square angles are
* skewed along either height or width.
*
* The shape's bounding box is (when arcAngle is 360°):
* (x - thickness / 2 - fade, y - thickness / 2 - fade) to (x + diameter + thickness / 2 + fade, y + diameter + thickness / 2 + fade).
*
* @param gc
* the graphics context where render the drawing.
* @param x
* the x coordinate of the upper-left corner of the square where the arc is drawn
* @param y
* the y coordinate of the upper-left corner of the square where the arc is drawn
* @param diameter
* the diameter of the arc to draw
* @param startAngle
* the beginning angle of the arc to draw
* @param arcAngle
* the angular extent of the arc from startAngle
* @param thickness
* the thickness to apply.
* @param fade
* the fade to apply.
* @param startCap
* the cap to draw at startAngle.
* @param endCap
* the cap to draw at startAngle + arcAngle.
* @throws IllegalArgumentException
* when given thickness or fade is negative
*/
public static void drawThickFadedCircleArc(GraphicsContext gc, int x, int y, int diameter, float startAngle, float arcAngle, int thickness, int fade, Cap startCap, Cap endCap) {
throw new RuntimeException();
}
/**
* Draws the outline of a circle covering the square specified by its diameter, using the {@link GraphicsContext} 's
* current color.
*
* The center of the circle is defined as the center of the square whose origin is at (x,y) (upper-left
* corner) and whose dimension is given by diameter.
*
* If diameter is negative, nothing is drawn.
*
* The rendering is aliased but the rendering time is often faster than * {@link #drawThickFadedCircle(GraphicsContext, int, int, int, int, int)}. *
* Equivalent to calling {@link #drawThickFadedCircle(GraphicsContext, int, int, int, int, int)} with a fade equals * to 0. *
* The shape's bounding box is
* (x - thickness / 2, y - thickness / 2) to (x + diameter + thickness / 2, y + diameter + thickness / 2).
*
* @param gc
* the graphics context where render the drawing.
* @param x
* the x coordinate of the upper-left corner of the square where the circle is drawn.
* @param y
* the y coordinate of the upper-left corner of the square where the circle is drawn.
* @param diameter
* the diameter of the circle to draw.
* @param thickness
* the thickness to apply.
* @throws IllegalArgumentException
* when given thickness is negative
*/
public static void drawThickCircle(GraphicsContext gc, int x, int y, int diameter, int thickness) {
throw new RuntimeException();
}
/**
* Draws the faded outline of a circle covering the square specified by its diameter, using the
* {@link GraphicsContext} 's current color.
*
* The center of the circle is defined as the center of the square whose origin is at (x,y) (upper-left
* corner) and whose dimension is given by diameter.
*
* If diameter is negative or zero, nothing is drawn.
*
* The shape's bounding box is
* (x - thickness / 2 - fade, y - thickness / 2 - fade) to (x + diameter + thickness / 2 + fade, y + diameter + thickness / 2 + fade).
*
* @param gc
* the graphics context where render the drawing.
* @param x
* the x coordinate of the upper-left corner of the square where the circle is drawn
* @param y
* the y coordinate of the upper-left corner of the square where the circle is drawn
* @param diameter
* the diameter of the circle to draw
* @param thickness
* the thickness to apply.
* @param fade
* the fade to apply.
* @throws IllegalArgumentException
* when given thickness or fade is negative
*/
public static void drawThickFadedCircle(GraphicsContext gc, int x, int y, int diameter, int thickness, int fade) {
throw new RuntimeException();
}
/**
* Draws the outline of a ellipse covering the specified rectangle, using the {@link GraphicsContext}'s current
* color.
*
* The center of the ellipse is defined as the center of the rectangle whose origin is at (x,y)
* (upper-left corner) and whose dimension is given by width and height.
*
* If either width or height is negative or zero, nothing is drawn.
*
* The rendering is aliased but the rendering time is often faster than * {@link #drawThickFadedEllipse(GraphicsContext, int, int, int, int, int, int)}. *
* Equivalent to calling {@link #drawThickFadedEllipse(GraphicsContext, int, int, int, int, int, int)} with a fade * equals to 0. *
* The shape's bounding box is
* (x - thickness / 2, y - thickness / 2) to (x + width + thickness / 2, y + height + thickness / 2).
*
* @param gc
* the graphics context where render the drawing.
* @param x
* the x coordinate of the upper-left corner of the rectangle where the ellipse is drawn
* @param y
* the y coordinate of the upper-left corner of the rectangle where the ellipse is drawn
* @param width
* the width of the ellipse to draw
* @param height
* the height of the ellipse to draw
* @param thickness
* the thickness to apply.
* @throws IllegalArgumentException
* when given thickness is negative
*/
public static void drawThickEllipse(GraphicsContext gc, int x, int y, int width, int height, int thickness) {
throw new RuntimeException();
}
/**
* Draws the outline of a ellipse covering the specified rectangle, using the {@link GraphicsContext}'s current
* color.
*
* The center of the ellipse is defined as the center of the rectangle whose origin is at (x,y)
* (upper-left corner) and whose dimension is given by width and height.
*
* If either width or height is negative or zero, nothing is drawn.
*
* The shape's bounding box is
* (x - thickness / 2 - fade, y - thickness / 2 - fade) to (x + width + thickness / 2 + fade, y + height + thickness / 2 + fade).
*
* @param gc
* the graphics context where render the drawing.
* @param x
* the x coordinate of the upper-left corner of the rectangle where the ellipse is drawn
* @param y
* the y coordinate of the upper-left corner of the rectangle where the ellipse is drawn
* @param width
* the width of the ellipse to draw
* @param height
* the height of the ellipse to draw
* @param thickness
* the thickness to apply.
* @param fade
* the fade to apply.
* @throws IllegalArgumentException
* when given thickness or fade is negative
*/
public static void drawThickFadedEllipse(GraphicsContext gc, int x, int y, int width, int height, int thickness, int fade) {
throw new RuntimeException();
}
/**
* Draws the closed polygon which is defined by the array of integer coordinates, using the current color. Lines are
* drawn between each consecutive pair, and between the first pair and last pair in the array. The effect is
* identical to
* draw(xys,0,xys.length);
*
* @param gc
* the graphics context where render the drawing.
* @param xys
* the array of coordinates : x1,y1,......xn,yn.
* @throws IllegalArgumentException
* if the given array length is odd.
*/
public static void drawPolygon(GraphicsContext gc, int[] xys) {
throw new RuntimeException();
}
/**
* Draws the closed polygon which is defined by the array of integer coordinates, using the current color. Lines are
* drawn between each consecutive pair, and between the first pair and last pair in the array.
*
* @param gc
* the graphics context where render the drawing.
* @param xys
* the array of coordinates : x1,y1,......xn,yn.
* @param offset
* the x1 index in xys.
* @param length
* the number of coordinates, must be even.
* @throws IllegalArgumentException
* if the given array length is odd.
* @throws ArrayIndexOutOfBoundsException
* the wanted data is outside the array bounds.
*/
public static void drawPolygon(GraphicsContext gc, int[] xys, int offset, int length) {
throw new RuntimeException();
}
/**
* Fills the closed polygon which is defined by the array of integer coordinates, using the current color. Lines are
* drawn between each consecutive pair, and between the first pair and last pair in the array. The lines connecting
* each pair of points are included in the filled polygon. The effect is identical to
* fill(xys,0,xys.length);
*
* @param gc
* the graphics context where render the drawing.
* @param xys
* the array of coordinates : x1,y1,......xn,yn.
* @throws IllegalArgumentException
* if the given array length is odd.
*/
public static void fillPolygon(GraphicsContext gc, int[] xys) {
throw new RuntimeException();
}
/**
* Fills the closed polygon which is defined by the array of integer coordinates, using the current color. Lines are
* drawn between each consecutive pair, and between the first pair and last pair in the array. The lines connecting
* each pair of points are included in the filled polygon.
*
* @param gc
* the graphics context where render the drawing.
* @param xys
* the array of coordinates : x1,y1,......xn,yn.
* @param offset
* the x1 index in xys.
* @param length
* the number of coordinates, must be even.
* @throws ArrayIndexOutOfBoundsException
* if offset and length do not specify a valid range within xys.
* @throws IllegalArgumentException
* if the xys length is odd.
*/
public static void fillPolygon(GraphicsContext gc, int[] xys, int offset, int length) {
throw new RuntimeException();
}
}