ShapePanel.java

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Path2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.border.BevelBorder;

/**
 * A custom Swing component that displays an assortment of geometric shapes
 * rendered in various ways: solid fills, gradient paints, affine transforms,
 * constructive solid geometry, and text rendering.
 * <p>
 * This example has no interaction (no listeners) — it focuses purely on the
 * rendering pipeline of Java 2D. Two instances are shown side by side so
 * you can compare anti-aliased vs. aliased rendering.
 * <p>
 * Updated for modern Java with better naming and Swing threading best practices.
 *
 * @author Ilkka Kokkarinen
 */
public class ShapePanel extends JPanel {

 private final boolean antiAlias;

 // -----------------------------------------------------------------------
 // Construction
 // -----------------------------------------------------------------------

 /**
 * Create a ShapePanel with the given anti-aliasing setting.
 *
 * @param antiAlias whether rendering should use anti-aliasing
 */
 public ShapePanel(boolean antiAlias) {
 this.antiAlias = antiAlias;
 // The one setting you *must* provide for a custom Swing component.
 setPreferredSize(new Dimension(500, 300));
 // Optional cosmetic settings.
 setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
 setToolTipText("Anti-aliasing is " + (antiAlias ? "on" : "off"));
 }

 // -----------------------------------------------------------------------
 // Rendering — the heart of this example.
 // -----------------------------------------------------------------------

 /**
 * Render the component's contents. Swing calls this method whenever the
 * component needs to be redrawn (e.g. after a resize or when first shown).
 *
 * @param g the {@code Graphics} context provided by Swing
 */
 @Override
 protected void paintComponent(Graphics g) {
 super.paintComponent(g); // Erase previous contents.
 // Downcast to Graphics2D for access to the modern Java 2D API.
 var g2 = (Graphics2D) g;
 if (antiAlias) {
 g2.setRenderingHint(
 RenderingHints.KEY_ANTIALIASING,
 RenderingHints.VALUE_ANTIALIAS_ON
 );
 }

 drawConcentricSquares(g2);
 drawRoundedRectangle(g2);
 drawTransformedEllipse(g2);
 drawStar(g2);
 drawText(g2);
 }

 // -----------------------------------------------------------------------
 // Individual shape-drawing methods, factored out for clarity.
 // -----------------------------------------------------------------------

 /**
 * Concentric squares: a simple loop demonstrating the polymorphic
 * {@code draw} method that can render the outline of <em>any</em> Shape.
 */
 private void drawConcentricSquares(Graphics2D g2) {
 g2.setStroke(new BasicStroke(3.0f));
 g2.setPaint(Color.RED);
 for (int size = 0; size < 150; size += 10) {
 double offset = size / 2.0;
 g2.draw(new Rectangle2D.Double(100 - offset, 100 - offset, size, size));
 }
 }

 /**
 * A rounded rectangle filled with a gradient and outlined in orange.
 * Demonstrates: GradientPaint, fill vs. draw, RoundRectangle2D.
 */
 private void drawRoundedRectangle(Graphics2D g2) {
 var roundRect = new RoundRectangle2D.Double(200, 50, 100, 100, 30, 45);
 g2.setStroke(new BasicStroke(8.0f));
 g2.setPaint(new GradientPaint(210, 60, Color.YELLOW, 290, 140, Color.BLUE));
 g2.fill(roundRect);
 g2.setPaint(Color.ORANGE);
 g2.draw(roundRect);
 }

 /**
 * An ellipse that is rotated and then has a circular hole subtracted.
 * Demonstrates: Area (constructive solid geometry), AffineTransform,
 * and the fact that polymorphic draw/fill work on any Shape — including
 * these computed composite areas.
 */
 private void drawTransformedEllipse(Graphics2D g2) {
 // An ellipse defined by its invisible bounding rectangle.
 var ellipse = new Area(new Ellipse2D.Double(350, 50, 70, 140));

 // Rotate 13° around the center of the ellipse.
 // Note: AffineTransform uses radians, not degrees.
 var rotation = AffineTransform.getRotateInstance(
 Math.toRadians(13), 385, 120
 );
 ellipse = ellipse.createTransformedArea(rotation);

 // Constructive solid geometry: subtract a circular hole.
 // Other available operations: add, intersect, exclusiveOr.
 ellipse.subtract(new Area(new Ellipse2D.Double(400, 100, 50, 50)));

 // Fill with a gradient, then draw the outline.
 g2.setPaint(new GradientPaint(370, 60, Color.BLACK, 360, 150, Color.WHITE));
 g2.fill(ellipse);
 g2.setStroke(new BasicStroke(
 5.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND
 ));
 g2.setPaint(Color.BLUE);
 g2.draw(ellipse);
 }

 /**
 * A ten-pointed star built as a polygon path, partially clipped by the
 * component bounds. Demonstrates: Path2D for custom polygon shapes, and
 * automatic clipping by the rendering engine.
 */
 private void drawStar(Graphics2D g2) {
 final int centerX = 150;
 final int centerY = 250;
 final int points = 10;
 final double outerRadius = 100;
 final double innerRadius = 50;
 int vertices = 2 * points; // A 10-point star has 20 polygon vertices.

 var path = new Path2D.Double();
 for (int i = 0; i < vertices; i++) {
 double angle = i * 2 * Math.PI / vertices;
 double radius = (i % 2 == 0) ? outerRadius : innerRadius;
 double x = centerX + radius * Math.cos(angle);
 double y = centerY + radius * Math.sin(angle);
 if (i == 0) {
 path.moveTo(x, y); // First vertex starts the path.
 } else {
 path.lineTo(x, y); // Subsequent vertices add line segments.
 }
 }
 path.closePath();

 // Convert the closed path into an Area and render it.
 var starArea = new Area(path);
 g2.setStroke(new BasicStroke(
 5.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND
 ));
 g2.setPaint(Color.WHITE);
 g2.fill(starArea);
 g2.setPaint(Color.BLACK);
 g2.draw(starArea);
 }

 /**
 * Render some text. Font glyphs are ultimately just curves and line
 * segments — their rendering is fundamentally no different from the
 * shapes above.
 */
 private void drawText(Graphics2D g2) {
 g2.setColor(Color.BLACK);
 // The Font constructor hooks into the fonts installed on your system.
 g2.setFont(new Font("Serif", Font.ITALIC, 28));
 // Note how the letter 'y' reaches below the baseline.
 g2.drawString("Hello, wyrld!", 300, 250);
 }

 // -----------------------------------------------------------------------
 // Main — create a JFrame with two ShapePanels for comparison.
 // -----------------------------------------------------------------------

 /**
 * Launch the demo. A JPanel cannot exist alone on screen — it must be
 * placed inside a top-level container, which here is a JFrame.
 */
 public static void main(String[] args) {
 // Swing components must be created and manipulated on the Event
 // Dispatch Thread (EDT). SwingUtilities.invokeLater ensures this.
 SwingUtilities.invokeLater(() -> {
 var frame = new JFrame("ShapePanel Demo");
 frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
 // FlowLayout places the two panels side by side, unlike the
 // default BorderLayout which would stack or stretch them.
 frame.setLayout(new FlowLayout());
 frame.add(new ShapePanel(true)); // with anti-aliasing
 frame.add(new ShapePanel(false)); // without anti-aliasing
 frame.pack();
 frame.setVisible(true);
 });
 }
}