Download the JDK
Search the Tutorials
Hide the TOC
Trail: Creating a GUI with JFC/Swing
Lesson: Performing Custom Painting
Performing Custom Painting
How Swing Components Are Displayed
Introduction to Painting Concepts
Implementing a Custom Component
Summary
Solving Common Painting Problems
Home Page > Creating a GUI with JFC/Swing > Performing Custom Painting
« Previous • Trail • Next »
Solving Common Painting Problems

> Problem: I don't know where to put my painting code.
> - Painting code belongs in the `paintComponent` method of any component descended from `JComponent`. See How Swing Components Are Displayed for details.
> Problem: The stuff I paint doesn't show up.
> - Check whether your component is showing up at all. Solving Common Component Problems should help you with this.
> - Check whether `repaint` is invoked on your component whenever its appearance needs to be updated.
> Problem: The background of my applet shows up, but the foreground stuff doesn't show up.
> - Did you make the mistake of performing painting directly in a `JApplet` subclass? If so, then your contents will be covered by the content pane that is automatically created for every `JApplet` instance. Instead, create another class that performs the painting and then add that class to the `JApplet`'s content pane. See How Swing Components Are Displayed for more information on how painting in Swing works.
> Problem: My component's foreground shows up, but its background is invisible. The result is that one or more components directly behind my component are unexpectedly visible.
> - Make sure your component is opaque. `JPanel`s, for example, are opaque by default in many but not all look and feels. To make components such as `JLabel`s and GTK+ `JPanel`s opaque, you must invoke `setOpaque(true)` on them.
> - If your custom component extends `JPanel` or a more specialized `JComponent` descendant, then you can paint the background by invoking `super.paintComponent` before painting the contents of your component.
> - You can paint the background yourself using this code at the top of a custom component's `paintComponent` method:

>   >     g.setColor(getBackground());
>   >     g.fillRect(0, 0, getWidth(), getHeight());
>   >     g.setColor(getForeground());

> Problem: I used `setBackground` to set my component's background color, but it seemed to have no effect.

> - Most likely, your component isn't painting its background, either because it's not opaque or your custom painting code doesn't paint the background. If you set the background color for a `JLabel`, for example, you must also invoke `setOpaque(true)` on the label to make the label's background be painted. For more help, see the preceding problem.

> Problem: I'm using the exact same code as a tutorial example, but it doesn't work. Why?

> - Is the code executed in the exact same method as the tutorial example? For example, if the tutorial example has the code in the example's `paintComponent` method, then this method might be the only place where the code is guaranteed to work.
> Problem: How do I paint thick lines? patterns?
> - The JavaTM 2D API provides extensive support for implementing line widths and styles, as well as patterns for use in filling and stroking shapes. See the 2D Graphics trail for more information on using the Java 2D API.
> Problem: The edges of a particular component look odd.
> - Because components often update their borders to reflect component state, you generally should avoid invoking `setBorder` except on `JPanel`s and custom subclasses of `JComponent`.
> - Is the component painted by a look and feel such as GTK+ or Windows XP that uses UI-painted borders instead of `Border` objects? If so, don't invoke `setBorder` on the component.
> - Does the component have custom painting code? If so, does the painting code take the component's insets into account?
> Problem: Visual artifacts appear in my GUI.
> - If you set the background color of a component, be sure the color has no transparency if the component is supposed to be opaque.
> - Use the `setOpaque` method to set component opacity if necessary. For example, the content pane must be opaque, but components with transparent backgrounds must not be opaque.
> - Make sure your custom component fills its painting area completely if it's opaque.
> Problem: The performance of my custom painting code is poor.
> - If you can paint part of your component, use the `getClip` or `getClipBounds` method of `Graphics` to determine which area you need to paint. The less you paint, the faster it will be.
> - If only part of your component needs to be updated, make paint requests using a version of `repaint` that specifies the painting region. An example of doing this is in the `updateSize` method in `SelectionDemo.java`.
> - For help on choosing efficient painting techniques, look for the string "performance" in the Java 2D API home page.
> Problem: The same transforms applied to seemingly identical `Graphics` objects sometimes have slightly different effects.
> - Because the Swing painting code sets the transform (using the `Graphics` method `translate`) before invoking `paintComponent`, any transforms that you apply have a cumulative effect. This doesn't matter when doing a simple translation, but a more complex `AffineTransform`, for example, might have unexpected results.

> If you don't see your problem in this list, see Solving Common Component Problems and Solving Common Layout Problems.

« Previous • Trail • Next »
Previous page: Summary
Next page: Questions and Exercises: Performing Custom Painting