Object-Oriented Programming with Java Lecture Notes

3 April 2008 • Java Graphics

Outline

• Dragon curves.

• Java graphics programming.

Kinking

• Given a line segment s, the kink of s is the legs of the right triangle having s as its hypotenuse.

  

  .

Orientation

• A line segment has two kinks, one on each side.

  

• Looking from p₁ to p₂ the two kinks are the left and right kinks

Repeated Kinking

• A sequence of points defines a chain, a sequence of line segments.

  

Kinking Chains

• A chain can be kinked by kinking each segment.

  

  • Kink orientation alternates between adjacent segments.

  • The first kink has either orientation.

Recursion!

• Kinking a chain produces another chain.

  

Dragon Curves

• A dragon curve of order 0 is a chain that hasn't been kinked.

• A dragon curve of order n is a chain produced by kinking a dragon curve of order n - 1.

• I want a toy that

  accepts an order-0 dragon curve,

  produces an order-n dragon curve,

  and displays it.

Operation

• dragon-curve should take a single command-line argument n giving the dragon-curve order.

• It should read a sequence of point coordinates from std-in and construct an order-n dragon curve.

• It should display the order-n dragon curve.

Example

$ echo 100 400 100 100 400 400 100 400 | 
  java DCShow 15

Screen Real Estate

• Stand-alone graphics ouput needs some screen real estate to be seen.

  • Applets don't have this problem because they're part of the real estate.

• The Swing JFrame class is an abstraction of visible screen surface.

  • It's also the gateway between the graphics program and the window manager.

JFrame Example

public static void 
main(String args[])
  JFrame frame = new JFrame()
  frame.setSize(200, 200)
  frame.setDefaultCloseOperation(
    JFrame.EXIT_ON_CLOSE)
  frame.setVisible(true)

JFrame Classes

JFrame Structure

• A JFrame's content pane is the class instance for displaying graphics.

  • The content pane is part of a JFrame's fairly complex structure.

• The content pane can't display graphics itself.

  • It's the easel for a class instance that can display graphics.

• A sensible structure given applet-program differences.

Drawing Surfaces

Custom JPanels

• Like JFrames, JPanels should be customized to fit a particular graphics application.

• In addition to a constructor, the custom JPanel should override the JComponent paintComponent() method.

  class DragonCurvePanel
  extends JPanel
  
    DragonCurvePanel() { ... }
  
    @Override void 
    paintComponent(Graphics g) { ... }

JFrames And JPanels

• A JFrame instance has to install a custom JPanel:

  JFrame frame = new JFrame()
  Container cp = frame.getContentPane()
  DragonCurvePanel p = new DragonCurvePanel()
  cp.add(p)

  or, as Horstmann and Cornell point out

  JFrame frame = new JFrame()
  frame.add(new DragonCurvePanel())

• These details should be hidden in a custom Frame.

On-Demand Graphics

• Modern visual display devices are treterous.

  • They're every combination of dynamic, shared, and variable.

• Graphics may need to be drawn or redrawn at any time.

  • As determined by the visual-display manager.

• The paintComponent() method abstracts the notion of drawing on demand.

The paintComponent() Method

• The powers that be call a panel's paintComponent() method whenever the panel's graphics should be drawn or redrawn.

  @Override void
  paintComponent(Graphics g) {
    super.paintComponent(g)
    // the magic happens here.
    }
  
  

• Don't forget to let the parent redraw too.

Redraw Example

• JPanel.paintComponent() redraws the panel background at the specified color.

  • DragonCuvePanel.paintComponent() should make sure that gets done.

The Graphics Class

• The Graphics class abstracts the ability to scribble on a Component.

• A Graphics class determines

  • what can be drawn on the component, and

  • the characteristics of the drawing made.

• Graphics is an abstract class; concrete Graphics descendants implements specifics for various devices.

  • And extend basic Graphics capabilities.

Graphical Items

• The things that a Graphics class can draw include

  arcs, images, lines and polylines, ovals, rectangles and polygons, strings (text).

• There are methods to draw each.

  drawString(String str, int x, int y) 
  
  drawRect(int x, int y, int w, int h)
  
  fillPolygon(int[] x, int[] y, int n) 
  

Graphical Properties

• The properties that apply when drawing include

  color, clipping region, font, and origin translation

• There are methods to establish and query property.

  setColor(Color c)
  getColor()
  
  setFont(Font f)
  getFont()
  

Items and Properties

• Graphical properties and items are decoupled.

  • A Graphics instance defines a set of property-value pairs.

  • Items are drawn using the current property-value set.

• For example

  g.setColor(Color.BLACK)
  g.drawRect(0, 0, 10, 10)
  

Concrete Graphics Classes

• Concrete descendents of Graphics

  • Implement Graphics features for specific devices.

  • Add new features.

• The most common concrete descendant of Graphics is Graphics2D.

  • Implements raster-oriented graphics.

  • Extends Graphics with affine transformations.

Summary

Main Example

class DCShow

  public static void
  main(String args[])
    int order = doArgs(args)

    DragonCurve dc = new DragonCurve(readPoints())
    while (--order > -1)
      dc = new DragonCurve(dc)

    displayDragonCurve(dc)

  private static void
  displayDragonCurve(DragonCurve dc)
    DragonFrame frame = new DragonFrame(dc, 500, 500)
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
    frame.setVisible(true)

• See the code.

Custom Frame Example

class DragonFrame
extends JFrame

  DragonFrame(
    DragonCurve dc, int ht, int wd)

    setTitle("Order " + 
      dc.order() + " Dragon Curve")

    setSize(ht, wd)

    add(new DragonPanel(dc))

Custom Panel Example

class DragonPanel
extends JPanel

  public DragonPanel(DragonCurve dc)
    super()
    dragonCurve = dc

  public void paintComponent(Graphics g)
    super.paintComponent(g)
    final Graphics2D g2 = (Graphics2D) g

    final Point2D points [] = dragonCurve.points()
    for (int i = 0; i < points.length - 1; i++)
      g2.draw(new Line2D.Float(points[i], points[i + 1]))

  private final DragonCurve dragonCurve

• See the code.

References

• Avoid Common Pitfalls when Programming 2D Graphics in Java by Alexandre Denault and Jörg Kienzle, ACM Crossroads, Spring 2007.