public class CompoundPainter<T> extends AbstractPainter<T>
A Painter
implementation composed of an array of Painter
s.
CompoundPainter
provides a means for combining several individual
Painter
s, or groups of them, into one logical unit. Each of the
Painter
s 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);
Modifier and Type | Class and Description |
---|---|
private static class |
CompoundPainter.Handler |
AbstractPainter.Interpolation
Modifier and Type | Field and Description |
---|---|
private boolean |
checkForDirtyChildPainters |
private boolean |
clearLocalCacheOnly |
private boolean |
clipPreserved |
private CompoundPainter.Handler |
handler |
private Painter[] |
painters |
private AffineTransform |
transform |
Constructor and Description |
---|
CompoundPainter()
Creates a new instance of CompoundPainter
|
CompoundPainter(Painter... painters)
Convenience constructor for creating a CompoundPainter for an array
of painters.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Painter[] |
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 Painter s
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()
Ye olde dirty bit.
|
void |
setCheckingDirtyChildPainters(boolean b)
Set the flag used by
isDirty() to check if the
child Painter s 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(Painter... 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
Painter s and gives them a chance
to validate themselves. |
getFilters, getInterpolation, isAntialiasing, isCacheable, isCacheCleared, isInPaintContext, isVisible, paint, setAntialiasing, setCacheable, setFilters, setInPaintContext, setInterpolation, setVisible
addPropertyChangeListener, addPropertyChangeListener, addVetoableChangeListener, addVetoableChangeListener, clone, fireIndexedPropertyChange, firePropertyChange, firePropertyChange, fireVetoableChange, fireVetoableChange, getPropertyChangeListeners, getPropertyChangeListeners, getVetoableChangeListeners, getVetoableChangeListeners, hasPropertyChangeListeners, hasVetoableChangeListeners, removePropertyChangeListener, removePropertyChangeListener, removeVetoableChangeListener, removeVetoableChangeListener
private CompoundPainter.Handler handler
private AffineTransform transform
private boolean clipPreserved
private boolean checkForDirtyChildPainters
private boolean clearLocalCacheOnly
public CompoundPainter()
public CompoundPainter(Painter... painters)
painters
- array of painters, which will be painted in orderpublic void setPainters(Painter... painters)
painters
- array of painters, which will be painted in orderpublic final Painter[] getPainters()
public boolean isClipPreserved()
setClipPreserved(boolean)
public void setClipPreserved(boolean shouldRestoreState)
shouldRestoreState
- new value of the clipPreserved propertyisClipPreserved()
public AffineTransform getTransform()
public void setTransform(AffineTransform transform)
transform
- a new AffineTransformprotected void validate(T object)
Iterates over all child Painter
s and gives them a chance
to validate themselves. If any of the child painters are dirty, then
this CompoundPainter
marks itself as dirty.
Called to allow Painter
subclasses a chance to see if any state
in the given object has changed from the last paint operation. If it has, then
the Painter
has a chance to mark itself as dirty, thus causing a
repaint, even if cached.
validate
in class AbstractPainter<T>
public boolean isCheckingDirtyChildPainters()
isDirty()
to check if the child Painter
s
should be checked for their dirty
flag as part of
processing.true
Painter
s are different from each other. This
will allow the cacheable == true
Painter
s to
keep their cached image during regular repaints. In this case,
client code should call clearCache()
manually when the cacheable
Painter
s should be updated.isDirty()
public void setCheckingDirtyChildPainters(boolean b)
isDirty()
to check if the
child Painter
s should be checked for their
dirty
flag as part of processing.isCheckingDirtyChildPainters()
,
isDirty()
protected boolean isDirty()
isDirty
in class AbstractPainter<T>
isCheckingDirtyChildPainters()
protected void setDirty(boolean d)
setDirty
in class AbstractPainter<T>
d
- whether this Painter
is dirty.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
Call this method to clear the cacheable. This may be called whether there is
a cacheable being used or not. If cleared, on the next call to paint
,
the painting routines will be called.
SubclassesIf overridden in subclasses, you must call super.clearCache, or physical resources (such as an Image) may leak.
clearCache
in class AbstractPainter<T>
public void clearLocalCache()
Clears the cache of this painter only, and not of any of the children.
protected void doPaint(Graphics2D g, T component, int width, int height)
doPaint
in class AbstractPainter<T>
g
- The Graphics2D object in which to paintprotected void configureGraphics(Graphics2D g)
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.
configureGraphics
in class AbstractPainter<T>
g
- the graphics surface to configure. This will never be null.AbstractPainter.paint(Graphics2D, Object, int, int)
protected boolean shouldUseCache()
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.
shouldUseCache
in class AbstractPainter<T>
WebARTS Library Licensed Under the GNU - General Public License. Other Libraries licensed under their respective Open Source Licenses