Blakes 21 Days Chapter 13 Document

• Supporting Links
  • Version (23) | Blakes 21 Days: Chapter 1 & Appendix A | Book's Website | 21 Days | Download JDK 8 (Oracle) | Download NetBeans 8.0.2 (netbeans) | reserve
  • Chapter 1 & Appendix A | (1) | (2) | (3) | (4) | (5) | (6) | (7) | (8) | (9) | (10) | (11) | (12) | (13) | (14) | (15) | (16) | (17) | (18) | (19) | (20) | (21) | reserve | Project Files | Grid | Blank

• Internal Links
  • Chapter 13 pages 367 to 390 | 123 - 95 = 23 pages | 13 is the mid way point for this chapter | Current Page 387 - 367 = 20 | Comments: 3 more pages till the end | reserve
  • page 367 | The Graphics2D Class | The Graphics Coordinate System | Drawing Text | Improving Fonts and Graphics with Antialiasing | Finding Information About a Font | reserve
  • First Program | The Explanation | Color | Using Color Objects | Testing and Setting the Current Colors | Drawing Lines and Polygons | reserve | reserve
  • User and Device Coordinate Spaces | Specifying the Rendering Attributes | Fill Patterns | Setting a Drawing Stroke | reserve
  • Creating Objects to Draw | Lines | Rectangles | Ellipses | Arcs | Polygons | Drawing Objects | reserve
  • Drawing a Map - (The Second Program) | The Explanation | reserve | Summary | reserve

Day 13, Creating Java2D Graphics

• Top
• 367 Today, you'll work with Java classes that put the graphics in graphical user interfaces.
  • Java2D is a set of classes that support high-quality, scalable, two-dimensional images, color, and text.
• 367 Java2D, which includes classes in the java.awt and javax.swing packages, can be used for each of these visually appealing tasks:
  • Drawing text
  • Drawing shapes such as circles and polygons
  • Using different fonts, colors, and line widths
  • Filling shapes with colors and patterns

The Graphics2D Class

• Top
• 368 Everything in Java2D begins with the Graphics2D class in the java.awt package,
  • which represents a graphics context,
    • an environment in which something can be drawn.
  • A Graphics2D object can represent a component on a graphical user interface, printer, or another display device.

• 368 Graphics2D is a subclass of the Graphics class that extends and improves its visual capabilities.

• 368 Before you can start using the Graphics2D class, you need a surface on which to draw.

• 368 Several user interface components can act as a canvas for graphical operations, including panels and windows.

• 368 As soon as you have a component to use as a canvas, you can draw text, lines, ovals, circles, arcs, rectangles, and other polygons on that object.

• 368 One component that's suitable for this purpose is JPanel in the java.swing package.
  • This class represents panels in a graphical user interface that can be empty or contain other components.

• Top
• 368 The following code creates a frame and a panel and then adds the panel to the frame:
  • JFrame main = new JFrame("Welcome Screen");
    JPanel pane = new JPanel();
    main.add(pane);

• 368 Like many user interface components in Java,
  • panels have a paintComponent(Graphics) method that is called automatically when the component needs to be redisplayed.

• 368 Several things could cause paintComponent() to be called:
  • The graphical user interface containing the component is displayed for the first time.
  • A window that was displayed on top of the component, is closed.
  • The graphical user interface containing the component is resized.

• 368 By creating a subclass of JPanel,
  • you can override the panel's paintComponent() method and put all your drawing operations in this method.

• Top
• 368 As you might have noticed, a Graphics object is sent to an interface component's paintComponent() method - not the Graphics2D you need.
  • To create a Graphics2D object that represents the component's drawing surface, you must use casting to convert it, as in the following example:
    • 
      public void paintComponent(Graphics comp) {
          Graphics2D comp2D = (Graphics2D) comp;
          // body of method
      }

• 369 After a comp2D object has been cast from the Graphics object sent to the method as an argument,
  • all drawing methods use this new object.
• The Graphics object will not be used again.

The Graphics Coordinate System

• Top
• 369 Java2D classes use the same (x,y) coordinate system
  • you have used when setting the size of frames and other components in your Swing applications.

• 369 Java's coordinate system uses pixels as its unit of measure.
  • The origin coordinate (0,0) is in the upper-left corner of a component.

• 369 The value of x-coordinates increases to the right of (0,0), and the y-coordinates increases downward.

• 369 When you set a frame's size by calling its setSize(int, int) method,
  • the frame's upper-left corner is at (0,0), and its lower-right corner is at the two arguments sent to setSize().

• 369 The following statement creates a frame 425 pixels wide by 130 pixels tall with its lower-right corner at (425, 130):
  • setSize(425, 130);

• Top
• 369 CAUTION: Java2D differs from other drawing systems in which the (0,0) origin is at the lower left and the y values increase in an upward direction.

• 369 All pixel values are integers, you can't use decimal numbers to display something at a position between two integer values.

• 369 Figure 13.1 shows Java's graphical coordinate system visually, with the origin at (0,0).
  • Two of the points of a rectangle are at (20, 20) and (60, 60).

Figure 13.1 - The Java graphics coordinate system. - goes here

Drawing Text

• Top
• 370 Text is the easiest thing to draw in Java2D.
  • To draw text, call a Graphics2D object's drawString(String, int, int) method with three arguments:
    • The string to display
    • The x-coordinate where it should be displayed
    • The y-coordinate where it should be displayed

• 370 The (x,y) coordinates used in the drawString() method represents the pixel at the lower-left corner of the string.

• 370 The following paintComponent() method draws the string "Free the bound periodicals" at the coordinates (22, 100):
  • 
    public void paintComponent(Graphics comp) {
        Graphics2D comp2D = (Graphics2D) comp;
        comp2D.drawString("Free the bound periodicals", 22, 100);
    }

• Top
• 370 This example uses a default font.
  • To use a different font, you must create an object of the Font class in the java.awt package.

• 370 Font objects represent a font's name, style, and point size.
  • A Font object is created by sending three arguments to its constructor:
    • The font's name
    • The font's style
    • The font's point size

• Top
• 371 A font's name can be its physical name, such as Arial, Courier New, Garamond, or Turman Grotesk.
  • If the font is present on the computer running the application, it is used.
  • If the font is not present, the default is used.

• 371 The name also can be one of the five logical fonts, Dialog, DialogInput, Monospaced, SanSerif, or Serif.
  • These fonts can be used to specify the kind of font to use without requiring a specific font.
  • This often is a better choice, because some font families might not be present on all implementations of Java.

• 371 Three Font styles can be selected by using class variables: PLAIN, BOLD, and ITALIC.
  • These constants are integers, and you cann add them to combine effects.

• Top
• 371 The following statement creates a 24-point Dialog font that is bold and italicized:
  • Font f = new Font("Dialog", Font.BOLD + Font.ITALIC, 24);

• 371 After you have created a font,
  • you can use it by calling the setFont(Font) method of the Graphics2D class with the font as the argument.

• 371 The setFont() method sets the current font,
  • which will be used for all subsequent calls to the drawString() method on the same Graphics2D object until another font is set.

• Top
• 371 The following paintComponent() method
  • creates a new Font object,
  • sets the current font to that object,
  • and draws the string "I'm deeply font of you" in 72-point type
  • at the coordinates (13, 100):
    • 
      public void paintComponent(Graphics comp) {
          Graphics2D comp2D = (Graphics2D) comp;
          Font f = new Font("Arial Narrow", Font.PLAIN, 72);
          comp2D.setFont(f);
          comp2D.drawString("I'm deeply font of you", 13, 100);
      }

• Top
• 371 Java applications can ensure that a font is available by including it with the program and loading it from a file.
  • This technique requires the Font class method createFont(int, InputStream), which returns a Font object representing that font.

• 371 Input Streams, which are covered on Day 15, "Working with Input and Output,"
  • are objects that can lold data from a source such as a disk file or web address.
  • The following statements load a font from a file named Verdana.ttf in the same folder as the class file that uses it:
    • 
      try {
          File ttf = new File("Verdana.ttf");
          FileInputStream fis = new FileInputStream(ttf);
          Font font = Font.createFont(Font.TRUETYPE_FONT, fis);
      } catch (IOException|FontFormatException exe) {
          System.out.println("Error: " + exc.getMessage());
      }

• 372 The try-catch block handles input/output errors, which must be considered when data is loaded from a file.
  • The File,FileInputStream, and IOException classes are part of the java.io package and are discussed in depth on Day 15.

• 372 When a font is loaded with createFont(), the Font object is 1 point and plain style.
  • To change the size and style, call the font object's deriveFont(int, int) method with two arguments: the desired style and size.

Improving Fonts and Graphics with Antialiasing

• Top
• 372 If you display text using the skills introduced up to this point,
  • the font's appearance would look crude compared to what you've come to expect from other software.
• Characters would be rendered with jagged edges, especially on curves and diagonal lines.

• 372 Java2D can draw fonts and graphics much more attractively using its support for antialiasing,
  • a rendering technique that smooths out rough edges by altering the color of surrounding pixels.

• 372 This funtionality is off by default.
  • To turn it on, call a Graphics2D object's setRenderingHint() method with two arguments:
    • A RenderingHint.Key object that identifies the rendering hint being set
    • A RenderingHint.Key object that sets the value of that hint

• Top
• 372 The following code enables antialiasing on a Graphics2D object named comp2D:
  • 
    comp2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
        RenderingHints.VALUE_ANTIALIAS_ON);
    

• 372 By calling this method in the paintComponent() method of a component,
  • you can cause all subsequent drawing operations to employ antialiasing.

Finding Information About a Font

• Top
• 372 To make text look good in a graphical user interface,
  • you often must figure out how much space the text is taking up on an interface component.

• 373 The FontMetrics class in the java.awt package
  • provides methods to determine the size of the characters being displayed with a specific font,
  • which can be used for things such as formatting and centering text.

• 373 The FontMetrics class can be used to find out detailed information about the current font,
  • such as the width or height of characters it can display.

• 373 To use this class's methods, you must create a FontMetrics object using the getFontMetrics() method.
  • The method takes a single argument: a Font object.

• 373 Table 13.1 shows some of the information you can find using font metrics.
  • All these methods should be called on a FontMetrics object.

First Program - Listing 13.1

• Top
• page 373 - 374
  
  package com.java21days;
  
  import java.awt.*
  import java.awt.event.*;
  import javax.swing.*;
  
  
  public class TextFrame extends JFrame {
      public TextFrame(String text, String fontName) {
          super("Show Font");
          setSize(425, 150);
          setDefaultCloseOperation(JFRame.EXIT_ON_CLOSE);
          TextFramePanel sf = new TextFramePanel(text, fontName);
          add(sf);
          setVisible(true);
      }
  
      public static void main(String[] arguments) {
          if (arguments.length < 1) {
              System.out.println("Usage: java TextFrame msg font");
              System.exit(-1);
          }
          TextFrame tf = new TextFrame(arguments[0], arguments[1]);
      }
  
  }
  
  class TextFramePanel extends JPanel {
      String text;
      String fontName;
  
      public TextFramePanel(String text, String fontName) {
          super();
          this.text = text;
          this.fontName = fontName;
      }
  
      public void paintComponent(Graphics comp) {
          super.paintComponent(comp);
          Graphics2D comp2D = (Graphics2D) comp;
          comp2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
              RenderingHints.VALUE_ANTIALIAS_ON);
          Font font = new Font(fontName, Font.BOLD, 18);
          FontMetrics metrics = getFontMetrics(font);
          comp2D.setFont(font);
          int x = (getSize().width - metrics.stringWidth(text)) / 2;
          int y = (getSize().height / 2;
          comp2D.drawString(text, x, y);
      }
  }

Command Line & Run Project Instructions

• Top
• 374 The TextFrame application takes two command-line arguments,
  • which you can set in NetBeans by choosing Project, Set Project Configuration, Customize.
• To run the application with this configuration, choose Run, Run Project.

The Explanation

• Top
• 374 Figure 13.2 shows how the application looks with a text message displayed in the font Arial Black.
  • When you run the application, resize the frame window to see how the text moves so that it remains centered.

• 374 The TextFrame application consists of two classes: a frame and a panel subclass called TextFramePanel.
  • The text is drawn on the panel by overriding the paintComponent(Graphics) method
    • and calling drawing methods of the Graphics2D class inside the method.

Figure 13.2 - Displaying centered text in a graphical user interface - goes here

• Top
• 375 The getSize() method calls in lines 45 and 46 use the panel's width and height to determine where the text should be displayed.
  • When the application is resized, the panel also is resized, and paintComponent() is called automatically.

Color

• Top
• 375 The Color class (in the java.awt packakge) and ColorSpace class (in java.awt.color) can be used to make a graphical user interface more, well colorful.
  • With these classes, you can set the color for use in drawing operations, as well as the background color of an interface component and other windows.
  • You also can translate a color from one color system into another.

• 375 Bt default, Java uses colors according to the sRGB color system, which describes each shade by the amounts of red, green, and blue it cintains (R, G, and B).
  • Each of the three components can be represented as an integer between 0 and 255.
  • Black is 0,0,0 - the absence of any red, green, or blue.
  • White is 255,255,255 - the maximum amount of all three colors.
  • You also can represent sRGB values using three floating-point numbers ranging from 0 to 1.0.
  • Java can represent millions of colors between the two extremes using sRGB.

• 375 A color system is called a color space, and sRGB is only one such space.
  • There also is XYZ, which was created by an international conference in 1931.
  • Java supports the use of any color space desired as long as a ColorSpace object is used that defines the description system.
  • You also can convert from any color space to sRGB, and vice versa.

• 375 Java's internal representation of colors using sRGB is just one color space used in a program.
  • An output device such as a monitor or printer also has its own color space.

• 375 When you display or print something of a designated color, the output device might not support the designated color.
  • In this circumstance, a different color is substituted or a dithering pattern is used to approximate the unavailable color.

• 375 The practical reality of color management is that the color you designate with sRGB will not be available on all output devices.
  • If you need more precise control of the color, you can use the ColorSpace and other classes in the java.awt.color package.

• 375 For most needs, the built-in use of sRGB to define colors should be sufficient.

Using Color Objects

• Top
• 376 Colors are represented by Color objects,
  • which can be created with a constructor or by using one of the small number of standard colors available in the Color class.

• 376 You can call the Color() constructor to create a color with three integers that represent the sRGB value of the desired color
  • or three floating-point numbers that serve the same purpose:
    • 
      Color c1 = new Color(0.807F, 1F, 0F);
      Color c2 = new Color(255, 204, 102);
      
      
    • The c1 object describes a neon green color, and c2 is butterscotch.

• Top
• 376 NOTE: It's easy to confuse floating-point literals such as 0F and 1F with hexadecimal numbers, which were discussed on Day 2, "The ABCs of Programming."
  • Colors often are expressed in hexadecimal, such as when background color is set on a web page using Cascading Style Sheets.
  • The Java classes and methods you work with don't take hexadecimal arguments, so when you see a literal such as 1F or 0F, you're dealing with floating-point numbers.

Testing and Setting the Current Colors

• Top
• 376 The current color for drawing is designated by using the setColor() method of the Graphics2D class.
  • This method must be called on the Graphics2D object that represents the area on which something is being drawn.

• 376 Several of the most common colors are available as class variables in the Color class.
  • These colors use the following Color variables (sRGB values appear in parentheses):

• Top
• 376 The following statement sets the color for a Graphics2D object named comp2D by using one of the standard class variables:
  • comp2D.setColor(Color.pink);

• 377 If you have created a Color object, it can be set in a similar fashion:
  • Color brush = new Color(255, 204, 102);
    comp2D.setColor(brush);

• 377 After you set the current color, subsequent methods to draw strings and other graphics will use that color.
• 377 You can set the background color for a component, such as a panel or frame, by calling the component's setBackground(Color) method.
• 377 The setBackground() method sets the component's background color, as in this example:
  • setBackground(Color.white);
    
    
• 377 If you want to find out what the current color is, you can use the getColor() method on a Graphics2D object, or the getBackground() method on a component.

• 377 The following statement sets the current color of comp2D - a Graphics2D object - to the same color as a component's background:
  • comp2D.setColor(getBackground());

Drawing Lines and Polygons

• Top
• 377 All the basic drawing commands covered today are Graphics2D methods called within a component's paintComponent() method.
• 377 This is an ideal place for all drawing operations because paintComponent() is automatically called any time the component needs to be redisplayed.
• 377 If another program's window overlaps the component and it needs to be redrawn, putting all the drawing operations in paintComponent() ensures that no part of the drawing is left out.
• 377 Java2D features include the following:
  • The capability to draw empty polygons and polygons filled with a solid color
  • Special fill patterms, such as gradients and patterns
  • Strokes that define the width and style of a drawing stroke
  • Antialiasing to smooth edges of drawn objects

User and Device Coordinate Spaces

• Top
• 378 One concept introduced with Java2D is the difference between an output device's coordinate space and the coordinate space you refer to when drawing an object.
  • Coordinate space is any 2D area that can be described using (x,y) coordinates.

• 378 For all drawing operations prior to Java, the only coordinate space used was the device coordinate space.
  • You specified the (x,y) coordinates of an output surface, such as a panel, and those coordinates were used to draw text and other elements.

• 378 Java2D requires a second coordinate space that you refer to when creating an object and actually drawing it.
  • This is called the user coordinate space.

• 378 Before any 2D drawing has occurred in a program, the device space and user space have the (0,0) coordinates in the same place,
  • the upper-left corner of the drawing area.

• 378 The user space's (0,0) coordinates can move as a result of the 2D drawing operations being conducted.
  • The x- and y-axes even can shift because of a 2D rotation.
  • You'll learn more about the two coordinate systems as you work with Java2D.

Specifying the Rendering Attributes

• Top
• 378 The next step in 2D drawing is to specify how a drawn object is rendered.
  • Java2D offers a wide range of attributes for designating color, including line width, fill patterns, transparency, and many other features.

Fill Patterns

• Top
• 378 Fill patterns control how a drawn object will be filled in.
  • With Java2D, you can use a solid color, gradient fill, texture, or pattern of your own devising.

• 378 A fill pattern is defined by using the setPaint(Paint) method of Graphics2D with a Paint object as its only argument.
  • Any class that can be a fill pattern, including GradientPaint, TexturePaint, and Color, can implement the Paint interface.
  • Using a Color object with setPaint() is the same thing as using a solid color as the pattern.

• 378 A gradient fill is a gradual shift from one color at one coordinate point to another color at a different coordinate point.
  • The shift can occur once between the points, which is called an acyclic gradient,
    • or it can happen repeatedly, which is a cylic gradient.

• 378 Figure 13.3 shows examples of acyclic and cyclic gradients between white and a darker color.
  • The arrow indicate the points that the colors shift between.

Figure 13.3 - acyclic and cyclic gradients shifts. - goes here

• Top
• 379 The coordinate points in a gradient do not refer directly to points on the Graphics2D object being drawn onto.
  • Instead, they refer to user space and even can be outside the object being filled with a gradient.

• 379 Figure 13.4 illustrates this. Both rectangles are filled using the same GradientPaint object as a guide.
  • One way to think of a gradient pattern is as a peice of fabric that has been spread over a flat surface.
  • The shapes being filled with a gradient are the patterns cut from the fabric, and more than one pattern can be cut from the same piece of cloth.

Figure 13.4 - Two rectangles using the same GradientPaint. - goes here

• Top
• 379 A call to the GradientPaint constructor method takes the following format:
  • GradientPaint gp = new GradientPaint(
        x1, y1, color1, x2, y2, color2);

• 379 The point (x1,y1) is where the color represented by color1 begins, and (x2, y2) is where the shift ends at color2.

• 379 If you want to use a cyclic gradient shift, an extra argument is added at the end:
  • GradientPaint gp = new GradientPaint(
        x1, y1, color1, x2, y2, color2, true);

• Top
• 380 The last argument is a Boolean value that is true for a cyclic shift.
  • A false argument can be used for acyclic shifts, or you can omit this argument: acyclic shifts are the default behavior.

• 380 After you have created a GradientPaint object, set it as the current paint attribute by using the setPaint() method.
  • The following statements create and select a gradient:
  • 
    GradientPaint pat = new GradientPaint(0f, 0f, Color.white,
        100f, 45f, Color.blue);
    comp2D.setPaint(pat);

• 380 All subsequent drawing operations to the comp2D object use this fill pattern until another one is chosen.

Setting a Drawing Stroke

• Top
• 380 Java2D allows you to vary the width of drawn lines by using the setStroke() method with a BasicStroke.

• 380 A simple BasicStroke constructor takes three arguments:
  • A float value representing the line width, with 1.0 as the norm
  • An int value determining the style of cap decoration drawn at the end of a line
  • An int value determining the style of juncture between two line segments

• 380 The endcap- and juncture-style arguments use BasicStroke class variables.
  • Endcap styles apply to the ends of lines that do not connect to other lines.
  • Juncture styles apply to the ends of lines that join other lines.

• 380 Possible endcap styles are CAP_BUTT for no endpoints, CAP_ROUND for circles around each endpoint, and CAP_SQUARE for squares.
  • Figure 13.5 shows each endcap style.
  • As you can see, the only visible difference between the CAP_BUTT and CAP_SQUARE styles is that CAP_SQUARE is longer because of the added square endcap.

Figure 13.5 - Endpoint cap styles. - goes here

• Top
• 380 Possible juncture styles include
  • JOIN_MITER, which joins segments by extending their outer edges,
  • JOIN_ROUND, which rounds off a corner between two segments, and
  • JOIN_BEVEL, which joins segments with a straight line.
  • Figure 13.6 shows examples of each juncture style.

Figure 13.6 - Endpoint juncture styles. - goes here

• Top
• 381 The following statements create a BasicStroke object and make it the current stroke:
  • 
    BasicStroke pen = new BasicStroke(2.0f,
        BasicStroke.CAP_BUTT,
        BasicStroke.JOIN_ROUND,
    comp2D.setStroke(pen);

• 381 The stroke has a width of 2 pixels, plain endpoints, and rounded segment corners.

Creating Objects to Draw

• Top
• 381 After you have created a Graphics2D object and specified the rendering attributes, the final two steps are to create the object and draw it.

• 381 You create a drawn object in Java2D by defining it as a geometric shape using a class in the java.awt.geom package.

• 381 The Graphics2D class does not have a different method for each shape you can draw.
  • Instead, you define the shape and use it as an argument to draw() or fill() methods.

Lines

• Top
• 381 Lines are created using the Line2D.Float class.
  • This class takes four arguments, the (x,y) coordinates of one endpoint followed by the (x,y) coordinates of the other.
  • Here's an example:
  • 
    Line2D.Float in = new Line2D.Float(60F, 5F, 13F, 28F);

• 381 This statement creates a line between (60,5) and (13,28).
  • Note that an F is used with the literals sent as arguments.
  • Otherwise, the Java compiler would assume that the values were integers.

Rectangles

• Top
• 381 Rectangles are created by using the Rectangle2D.Float class or Rectangle2D.Double class.
  • The difference between the two is that one takes float arguments, and the other takes double arguments.

• Top
• 382 Rectangle2D.Float takes four arguments: x-coordinate, y-coordinate, width, and height.
  • The following is an example:
  • 
    Rectangle2D.Float rc = new Rectangle2D.Float(10F, 11F, 40F, 20F);

• 382 This creates a rectangle at 10, 13 that is 40 pixels wide and 20 pixels tall.

Ellipses

• Top
• 382 Ellipses can be created with the Ellipses2D.Float class.
  • It takes four arguments: x-coordinate, y-coordinate, width, and height

• 382 The following statement creates an ellipses at (113,25) with a width of 22 pixels and a height of 40 pixels:
  • 
    Ellipses2D.Float ee = new Ellipses2D.Float(113, 25, 22, 40);

Arcs

• Top
• 382 Of all the shapes you can draw in Java2D, arcs are the complex to construct.
• 382 Arcs are created with the Arc2D.Float class, which takes seven arguments:
  • The (x,y) coordinates of an invisible ellipse that would include the arc if it were drawn (first two arguments)
  • The width and height of the ellipse (third and forth arguments)
  • The starting degree of the arc
  • The number of degrees it travels on the ellipse
  • An integer describing how the arc is closed

• 382 The number of degrees the arc travels is specified in a counterclockwise direction by using negative numbers.

• 382 Figure 13.7 shows where degree values are located when determining an arc's starting degree.
  • The arc's starting angle ranges from 0 to 359 degrees counterclockwise.
  • On a circular ellipse,
    • 0 degrees is at the 3 o'clock position.
    • 90 degrees is at 12 o'clock,
    • 180 degrees is at 9 o'clock, and
    • 270 degrees is at 6 o'clock.

• 382 The last argument to the Arc2D.Float constructor uses one of three class variables:
  • Arc2D.OPEN for an unclosed arc,
  • Arc2D.CHORD to connect the arc's endpoints with a straight line, and
  • Arc2D.PIE to connect the arc to the center of the ellipses like a pie slice.
  • Figure 13.8 shows each of these styles.

Figure 13.7 - Determining the starting degree of an arc. - goes here

Figure 13.8 - Arc closure styles. - goes here

• Top
• 383 NOTE: The Arc2D.OPEN closure style does not apply to filled arcs.
  • A filled arc that has Arc2D.OPEN as its style will be closed using the same style as Arc2D.CHORD.

• Top
• 383 The following statement creates an Arc2D.Float object:
  • 
    Arc2D.Float arc = new Arc2D.Float(
        27F, 22F, 42F, 30F, 33F 90F, Arc2D.PIE);

• 383 This creates an arc for an oval at (27,22) that is 42 pixels wide by 30 pixels tall.
  • The arc begins at 33 degrees, extends 90 degrees clockwise, and is closed like a pie slice.

Polygons

• Top
• 383 You create polygons in Java2D by defining each movement from one point on the polygon to another.
  • A polygon can be formed from stright lines, quadratic curves, or Bezier curves.

• 384 The movements to create a polygon are defined as a GeneralPath object, which also is part of the java.awt.geom package.

• 384 A GeneralPath object can be created without any arguments, as shown here:
  • 
    GeneralPath polly = new GeneralPath());

• Top
• 384 The moveTo() method of GeneralPath is used to create the first point on the polygon.
  • The following statement would be used if you wanted to start polly at the coordinate 5, 0:
  • 
    polly.moveTo(5F, 0F);

• 384 After creating the first point, the lineTo() method is used to create lines that end at a new point.
  • This method takes two arguments: the (x,y) coordinates of the new point.

• 384 The following statements add three lines to the polly object:
  • 
    polly.lineTo(205F, 0F);
    polly.lineTo(205F, 90F);
    polly.lineTo(5F, 90F);

• 384 The lineTo() and moveTo() methods require float arguments to specify coordinate points.

• Top
• 384 If you want to close a polygon, the closePath() method is used without any arguments. as shown here:
  • 
    polly.closePath();

• 384 This method closes a polygon by connecting the current point with the point specified by the most recent moveTo() method.
  • You can close a polygon without this method by using a lineTo() method that connects to the original point.

• 384 After you have created an open or closed polygon, you can draw it like any other shape using the draw() and fill() methods.
  • The polly object is a rectangle with points at (5,0), (205, 0) (205, 90), and (5, 90).

Drawing Objects

• Top
• 384 After you have defined the rendering attributes, such as color and line width, and have created the object to be drawn, you're ready to draw something in all its 2D glory.

• 384 All drawn objects use the same Graphics2D class's methods: draw() for outlines and fill() for filled objects.
  • These take an object as the only argument.

Drawing a Map - (The Second Program)

• Top
• 385 The next project you will create is an application that draws a simple map using 2D drawing techniques.
  • Create the Map class in the com.java21days package in NetBeans and fill it with the code from Listing 13.2

Second Program - Listing 13.2

• Top
• page 385 - 386
  
  package com.java21days;
  
  import java.awt.*
  import java.awt.geom.*;
  import javax.swing.*;
  
  
  public class Map extends JFrame {
      public Map() {
          super("Map");
          setSize(360, 350);
          setDefaultCloseOperation(JFRame.EXIT_ON_CLOSE);
          MapPane map = new MapPane();
          add(map);
          setVisible(true);
      }
  
      public static void main(String[] arguments) {
          Map frame = new Map();
    
      }
  
  }
  
  class MapPane extends JPanel {
      public void paintComponent(Graphics comp) {
          Graphics2D comp2D = (Graphics2D) comp;
          comp2D.setColor(Color.blue);
          comp2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
              RenderingHints.VALUE_ANTIALIAS_ON);
          Rectangle2D.Float background = new Rectangle2D.Float(
              0F, 0F, getSize().width, getSize().height;
          comp2D.fill(background);
          // Draw waves
          comp2D.setColor(Color.white);
          BasicStroke pen = new BasicStroke(2F,
          BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND);
          comp2D.setStroke(pen);
          for (int ax = 0; ax < 340; ax += 10) {
              for (int ay = 0; ay < 340; ay += 10) {
                  Arc2D.Float wave = new Arc2D.Float(ax, ay,
                      10, 10, 0, -180, Arc2D.OPEN);
                  comp2D.draw(wave);
              }
          }
          // Draw Florida
          GradientPaint gp = new GradientPaint(0F, 0F, Color.green,
              350F, 350F, Color.orange, true);
          comp2D.setPaint(gp);
          GeneralPath f1 = new GeneralPath();
          f1.moveTo(10F, 12F);
          f1.lineTo(234F, 15F);
          f1.lineTo(253F, 25F);
          f1.lineTo(261F, 71F);
          f1.lineTo(344F, 209F);
          f1.lineTo(336F, 278F);
          f1.lineTo(295F, 310F);
          f1.lineTo(259F, 274F);
          f1.lineTo(205F, 188F);
          f1.lineTo(211F, 171F);
          f1.lineTo(195F, 174F);
          f1.lineTo(191F, 118F);
          f1.lineTo(120F, 56F);
          f1.lineTo(94F, 68F);
          f1.lineTo(81F, 49F);
          f1.lineTo(12F, 37F);
          f1.closePath();
          comp2D.fill(f1);
          // Draw ovals
          comp2D.setColor(Color.black);
          BasicStroke pen2 = new BasicStroke();
          comp2D.setStroke(pen2);
          Ellipse2D.Float e1 = new Ellipse2D.Float(235, 140, 15, 15);
          Ellipse2D.Float e2 = new Ellipse2D.Float(225, 130, 15, 15);
          Ellipse2D.Float e3 = new Ellipse2D.Float(245, 130, 15, 15);
          comp2D.fill(e1);
          comp2D.fill(e2);
          comp2D.fill(e3);
      }
  }

The Explanation

• Top
• 386 In the Map application, line 4 imports the classes in the java.awt.geom package.
  • This statement is required because
    • import java.awt.*; in line 1 handles only classes, not packages, available under java.awt.

• 386 Line 25 creates the comp2D object used for all 2D drawing operations.
  • It's a cast of the Graphics object that represents the panel's visible surface.

• 386 Lines 34 - 36 create a BasicStroke object
  • that represents a line width of 2 pixels and then makes this the current stroke with the setStroke() method of Graphics2D.

• 386 Lines 37 - 42 use two nested for loops to create waves from individual arcs.

• 387 Lines 45 - 46 create a gradient fill pattern from the color green at (0,0) to orange at (50,50).
  • The last argument to the constructor, true, causes the fill pattern to repeat itself as many times as needed to fill the object.

• 387 Line 47 sets the current gradient fill pattern using the setPaint() method and the gp object just created.

• 387 Lines 48 - 66 create the polygon shaped like the author's home state and draw it.
  • This polygon is filled with a green-to-orange gradient pattern.

• 387 Line 68 sets the current color to black.
  • This replaces the gradient fill pattern for the next drawing operation because the colors are also the fill patterns.

• 387 Line 69 creates a new BasicStroke() object with no arguments, which defaults to a 1-pixel line width.

• 387 Line 70 sets the current line width to the new BasicStroke object pen2.

• 387 Lines 71 - 73 create three ellipses at (235,140), (225,130), and (245,130).
  • Each is 15 pixels wide by 15 pixels tall, making the circles.

• Top
• 387 Figure 13.9 shows the application running.

Figure 13.9 - The Map application. - goes here

Summary

• Top
• 387 You now have some tools to improve the looks of a Java program.
  • You can draw with lines, rectangles, ellipses, polygons, fonts, colors, and patterns onto a frame, a panel, and other user interface components using Java2D
• 388 Java2D uses the same two methods for each drawing operation
  • draw()
  • and fill().
  • Different objects are created using classes of the java.awt.geom package,
    • and these are used as arguments for the drawing methods of Graphics2D.
• 388 Tomorrow, on Day 14, "Developing Swing Applications,"
  • you'll learn how to create applications that are launched from a web page using Java Web Start technology.

Q & A

• Top | Page 388
• Q What does the uppercase F refer to in source code today ?
  • It is added to coordinates, as in the method polly.moveTo(5F, 0F).
  • Why is F used for these coordinates and not others,
    • and why is a lowercase f used elewhere ?
• A The F or f indicates that a number is a floating-point number rather than an integer,
  • The length() method counts the characters in the string,
    • and uppercase and lower case can be used interchangeably.
  • If you don't use one of them, the Java compiler assumes that the number is an int value.
  • Many methods and constructors in Java require floating-point arguments
    • but can handle integers because an integer can be converted to floating-point without changing its value.
  • For this reason, constructors such as Arc2D.Float()
    • can use arguments such as 10 and 180 instead of 10F and 180F

• Q The section "Improving Fonts and Graphics wiith Antialiasing" mentioned a class called RenderingHint.Key.
  • Why does this class have two names separated by a period ?
  • What does this signify ?
• A The use of two names to identify a class indicates that it is an inner class.
  • The first class name in the enclosing class,
    • followed by a period
    • and the name of the inner class.
  • In this case, the Key class is an inner class within the RenderingHint class.

Quiz - Questions

• Top | Page 388

1. What object is required before you can draw something in Java using Swing ?
   1. Graphics2D
   2. WindowListener
   3. JFrame
2. Which of the following is not a valid Java statement to create a Color object ?
   1. Color c1 = new Color(0F, 0F, 0F);
   2. Color c2 = new Color(0, 0, 0);
   3. Both are valid
3. What does getSize().width refer to ?
   1. The width of the interface component's window
   2. The width of the frame's window
   3. The width of any graphical user interface component in Java

Answers

• Top | Note A is 1, B is 2, and C is 3

1. A. The Graphics2D object is cast from a Graphics object and represents a graphics context for a graphical user interface component.
2. C. Both are valid ways to create the object.
   • You also can use hexadecimal values to create a Color, as in this example:
   • Color c3 = new Color(0xFF, 0xCC, 0x66);
3. C. You can call getSize().width and getSize().height on any user interface component.

Certification Practice

• Top
• 389 The following question is the kind of thing you could expect to be asked on a Java programming certification test.
  • Answer it without looking at today's material or using the Java compiler to test the code.

• Given:
• 
  import java.awt.*;
  import javax.swing.*;
  
  public class Result extends JFrame {
      public Result() {
          super("Result");
          JLabel width = new JLabel("This frame is " +
              getSize().width + " pixels wide.");
          add("North", width);
          setSize(220, 120);
      }
  
      public static void main(String[] arguments) {
          Result r = new Result();
          r.setVisible(true);
      }
  }
  

• 390 What will be the reported width of the frame, in pixels, when the application runs ?
  1. 0 pixels
  2. 120 pixels
  3. 220 pixels
  4. The width of the user's monitor

• Top
• 390 The answer is available on the book's website at www.java21days.com
  • Visit the Day 13 page and click the Certification Practice link.

Exercise

• Top
• 390 To extend your knowledge of the subjects covered today, try the following exercises:
  1. Create an application that draws a circle, with its radius, (x,y) position, and color, all determined by arguments.
  2. Create an application that draws a pie graph.

• Top
• 390 Exercise solutions are offered on the book's website at www.java21days.com. | Chapter 13's Page