org.jdesktop.swingx.painter

Class CompoundPainter<T>

java.lang.Object

org.jdesktop.beans.AbstractBean

org.jdesktop.swingx.painter.AbstractPainter<T>

org.jdesktop.swingx.painter.CompoundPainter<T>

Type Parameters:

T - an optional configuration parameter

All Implemented Interfaces:

Painter<T>

public class CompoundPainter<T>
extends AbstractPainter<T>

A Painter implementation composed of an array of Painters. CompoundPainter provides a means for combining several individual Painters, or groups of them, into one logical unit. Each of the Painters are executed in order. BufferedImageOp filter effects can be applied to them together as a whole. The entire set of painting operations may be cached together.

For example, if I want to create a CompoundPainter that started with a blue background, had pinstripes on it running at a 45 degree angle, and those pinstripes appeared to "fade in" from left to right, I would write the following:

  Color blue = new Color(0x417DDD);
  Color translucent = new Color(blue.getRed(), blue.getGreen(), blue.getBlue(), 0);
  panel.setBackground(blue);
  panel.setForeground(Color.LIGHT_GRAY);
  GradientPaint blueToTranslucent = new GradientPaint(
    new Point2D.Double(.4, 0),
    blue,
    new Point2D.Double(1, 0),
    translucent);
  MattePainter veil = new MattePainter(blueToTranslucent);
  veil.setPaintStretched(true);
  Painter pinstripes = new PinstripePainter(45);
  Painter backgroundPainter = new RectanglePainter(this.getBackground(), null);
  Painter p = new CompoundPainter(backgroundPainter, pinstripes, veil);
  panel.setBackgroundPainter(p);
 

Author:

rbair

Nested Class Summary

Nested classes/interfaces inherited from class org.jdesktop.swingx.painter.AbstractPainter

AbstractPainter.Interpolation

Constructor Summary

Constructors

Constructor and Description
CompoundPainter() Creates a new instance of CompoundPainter
CompoundPainter(List<? extends Painter<T>> painters) Convenience constructor for creating a CompoundPainter for a list of painters.
CompoundPainter(Painter<T>... painters) Convenience constructor for creating a CompoundPainter for an array of painters.

Method Summary

Methods

Modifier and Type	Method and Description
void	addPainter(Painter<T> painter) Adds a painter to the queue of painters
void	clearCache() Clears the cache of this Painter, and all child Painters.
void	clearLocalCache() Clears the cache of this painter only, and not of any of the children.
protected void	configureGraphics(Graphics2D g) This method is called by the paint method prior to any drawing operations to configure the drawing surface.
protected void	doPaint(Graphics2D g, T component, int width, int height) Subclasses must implement this method and perform custom painting operations here.
Collection<Painter<T>>	getPainters() Gets the array of painters used by this CompoundPainter
AffineTransform	getTransform() Gets the current transform applied to all painters in this CompoundPainter.
boolean	isCheckingDirtyChildPainters() Used by isDirty() to check if the child Painters should be checked for their dirty flag as part of processing.
boolean	isClipPreserved() Indicates if the clip produced by any painter is left set once it finishes painting.
protected boolean	isDirty() This CompoundPainter is dirty if it, or (optionally) any of its children, are dirty.
void	removePainter(Painter<T> painter) Removes a painter from the queue of painters
void	setCheckingDirtyChildPainters(boolean b) Set the flag used by isDirty() to check if the child Painters should be checked for their dirty flag as part of processing.
void	setClipPreserved(boolean shouldRestoreState) Sets if the clip should be preserved.
protected void	setDirty(boolean d) Sets the dirty bit.
void	setPainters(List<? extends Painter<T>> painters) Sets the array of Painters to use.
void	setPainters(Painter<T>... painters) Sets the array of Painters to use.
void	setTransform(AffineTransform transform) Set a transform to be applied to all painters contained in this CompoundPainter
protected boolean	shouldUseCache() Returns true if the painter should use caching.
protected void	validate(T object) Iterates over all child Painters and gives them a chance to validate themselves.

Methods inherited from class org.jdesktop.swingx.painter.AbstractPainter

getFilters, getInterpolation, isAntialiasing, isCacheable, isVisible, paint, setAntialiasing, setCacheable, setFilters, setInterpolation, setVisible

Methods inherited from class org.jdesktop.beans.AbstractBean

addPropertyChangeListener, addPropertyChangeListener, addVetoableChangeListener, addVetoableChangeListener, clone, fireIndexedPropertyChange, firePropertyChange, firePropertyChange, fireVetoableChange, fireVetoableChange, getPropertyChangeListeners, getPropertyChangeListeners, getVetoableChangeListeners, getVetoableChangeListeners, hasPropertyChangeListeners, hasVetoableChangeListeners, removePropertyChangeListener, removePropertyChangeListener, removeVetoableChangeListener, removeVetoableChangeListener

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CompoundPainter

public CompoundPainter()

Creates a new instance of CompoundPainter

CompoundPainter

public CompoundPainter(Painter<T>... painters)

Convenience constructor for creating a CompoundPainter for an array of painters. A defensive copy of the given array is made, so that future modification to the array does not result in changes to the CompoundPainter.

Parameters:

painters - array of painters, which will be painted in order

CompoundPainter

public CompoundPainter(List<? extends Painter<T>> painters)

Convenience constructor for creating a CompoundPainter for a list of painters. A defensive copy of the given array is made, so that future modification to the list does not result in changes to the CompoundPainter.

Parameters:

painters - array of painters, which will be painted in order

Method Detail

setPainters

public void setPainters(List<? extends Painter<T>> painters)

Sets the array of Painters to use. These painters will be executed in order. A null value will be treated as an empty array. To prevent unexpected behavior all values in provided array are copied to internally held array. Any changes to the original array will not be reflected.

Parameters:

painters - array of painters, which will be painted in order

setPainters

public void setPainters(Painter<T>... painters)

Sets the array of Painters to use. These painters will be executed in order. A null value will be treated as an empty array. To prevent unexpected behavior all values in provided array are copied to internally held array. Any changes to the original array will not be reflected.

Parameters:

painters - array of painters, which will be painted in order

addPainter

public void addPainter(Painter<T> painter)

Adds a painter to the queue of painters

Parameters:

painter - the painter that is added

removePainter

public void removePainter(Painter<T> painter)

Removes a painter from the queue of painters

Parameters:

painter - the painter that is added

getPainters

public final Collection<Painter<T>> getPainters()

Gets the array of painters used by this CompoundPainter

Returns:

a defensive copy of the painters used by this CompoundPainter. This will never be null.

isClipPreserved

public boolean isClipPreserved()

Indicates if the clip produced by any painter is left set once it finishes painting. Normally the clip will be reset between each painter. Setting clipPreserved to true can be used to let one painter mask other painters that come after it.

Returns:

if the clip should be preserved

See Also:

setClipPreserved(boolean)

setClipPreserved

public void setClipPreserved(boolean shouldRestoreState)

Sets if the clip should be preserved. Normally the clip will be reset between each painter. Setting clipPreserved to true can be used to let one painter mask other painters that come after it.

Parameters:

shouldRestoreState - new value of the clipPreserved property

See Also:

isClipPreserved()

getTransform

public AffineTransform getTransform()

Gets the current transform applied to all painters in this CompoundPainter. May be null.

Returns:

the current AffineTransform

setTransform

public void setTransform(AffineTransform transform)

Set a transform to be applied to all painters contained in this CompoundPainter

Parameters:

transform - a new AffineTransform

validate

protected void validate(T object)

Iterates over all child Painters and gives them a chance to validate themselves. If any of the child painters are dirty, then this CompoundPainter marks itself as dirty.

Overrides:

validate in class AbstractPainter<T>

Parameters:

object - the object to validate

isCheckingDirtyChildPainters

public boolean isCheckingDirtyChildPainters()

Used by isDirty() to check if the child Painters should be checked for their dirty flag as part of processing.
Default value is: true
This should be set to false if the cacheable state of the child Painters are different from each other. This will allow the cacheable == true Painters to keep their cached image during regular repaints. In this case, client code should call clearCache() manually when the cacheable Painters should be updated.

Returns:

the dirty check flag

See Also:

isDirty()

setCheckingDirtyChildPainters

public void setCheckingDirtyChildPainters(boolean b)

Set the flag used by isDirty() to check if the child Painters should be checked for their dirty flag as part of processing.

Parameters:

b - the dirty check flag

See Also:

isCheckingDirtyChildPainters(), isDirty()

isDirty

protected boolean isDirty()

This CompoundPainter is dirty if it, or (optionally) any of its children, are dirty. If the super implementation returns true, we return true. Otherwise, if isCheckingDirtyChildPainters() is true, we iterate over all child Painters and query them to see if they are dirty. If so, then true is returned. Otherwise, we return false.

Overrides:

isDirty in class AbstractPainter<T>

Returns:

true if the painter state has changed and the painter needs to be repainted.

See Also:

isCheckingDirtyChildPainters()

setDirty

protected void setDirty(boolean d)

Description copied from class: AbstractPainter

Sets the dirty bit. If true, then the painter is considered dirty, and the cache will be cleared. This property is bound.

Overrides:

setDirty in class AbstractPainter<T>

Parameters:

d - whether this Painter is dirty.

clearCache

public void clearCache()

Clears the cache of this Painter, and all child Painters. This is done to ensure that resources are collected, even if clearCache is called by some framework or other code that doesn't realize this is a CompoundPainter.

Call #clearLocalCache if you only want to clear the cache of this CompoundPainter

Overrides:

clearCache in class AbstractPainter<T>

clearLocalCache

public void clearLocalCache()

Clears the cache of this painter only, and not of any of the children.

doPaint

protected void doPaint(Graphics2D g,
           T component,
           int width,
           int height)

Description copied from class: AbstractPainter

Subclasses must implement this method and perform custom painting operations here.

Specified by:

doPaint in class AbstractPainter<T>

Parameters:

g - The Graphics2D object in which to paint

component - an optional configuration parameter

width - the width

height - the height

configureGraphics

protected void configureGraphics(Graphics2D g)

Description copied from class: AbstractPainter

This method is called by the paint method prior to any drawing operations to configure the drawing surface. The default implementation sets the rendering hints that have been specified for this AbstractPainter.

This method can be overridden by subclasses to modify the drawing surface before any painting happens.

Overrides:

configureGraphics in class AbstractPainter<T>

Parameters:

g - the graphics surface to configure. This will never be null.

See Also:

AbstractPainter.paint(Graphics2D, Object, int, int)

shouldUseCache

protected boolean shouldUseCache()

Description copied from class: AbstractPainter

Returns true if the painter should use caching. This method allows subclasses to specify the heuristics regarding whether to cache or not. If a Painter has intelligent rules regarding painting times, and can more accurately indicate whether it should be cached, it could implement that logic in this method.

Overrides:

shouldUseCache in class AbstractPainter<T>

Returns:

whether or not a cache should be used