Re: Graphics help please
On 28.01.2008 06:35, Daniele Futtorovic allegedly wrote:
On 28.01.2008 05:57, Knute Johnson allegedly wrote:
Daniele Futtorovic wrote:
If you use an Image, and register the default ImageObserver in the
Graphics#drawImage call, to wit the Component itself, then
theoretically you won't have to bother about repaint() at all, since
a call to ImageObserver#imageUpdate should trigger a repaint,
possibly with some optimisations handled behind the scenes (? for
the last point).
The user does not call imageUpdate(), it is called by the
ImageObserver and overridden by the user to detect changes in the image.
No, the user doesn't call imageUpdate(). But neither is the
ImageObserver likely to call it, given that it is a method of the
ImageObserver interface itself.
According to the docs:
"This method is called when information about an image which was
previously requested using an asynchronous interface becomes available"
The standard way of using Graphics#drawImage while performing custom
painting in a Component (which includes JComponents) is to pass that
method the Component itself as the ImageObserver. My comment was aiming
at the fact that the Component class, when its imageUpdate() method is
called, triggers a repaint. Consequently, if your code makes sure
ImageObserver#imageUpdate gets called, you won't have to bother yourself
with repaints at all. One way of getting that method called, following
my earlier reference to the ImageProducer/ImageConsumer pattern, would
be to write a proper, mayhap delaying, etc. ImageProducer, and let AWT
handle the rest.
It would be interesting to know whether this also works if you use a
simple container for your Image, like a JLabel (ergo no need to
bother about paint(Graphics) or paintComponent(Graphics) at all).
Although, since I seem to recall seeing animated GIFs displayed with
a JLabel, I expect it to be the case.
DF.
You still have to have a call to Graphics.drawImage().
Not if you embed your Image in an ImageIcon and then in a JLabel, you
don't.
Furthermore, to answer the question I asked myself, the docs for
ImageIcon#paintIcon(Component, Graphics, int, int) state:
"If this icon has no image observer, this method uses the c component as
the observer."
DF.
The following code gives an example of what I mean:
package scratch;
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.awt.image.*;
/**
*
* @author da.futt
*/
public class ImageProducerTest {
private ImageProducerTest() {
}
public static void main(String[] ss){
JFrame f = new JFrame("ImageProducerTest");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
final ClockProducer cp = ClockProducer.newInstance(400, 0xfdfdfd);
JLabel lab = new JLabel(new ImageIcon( f.createImage(cp) ));
f.getContentPane().add(lab, BorderLayout.CENTER);
f.pack();
f.setLocationRelativeTo(null);
f.setVisible(true);
TimerTask tt = new TimerTask(){
public void run(){
cp.tick();
}
};
java.util.Timer t1 = new java.util.Timer(true);
t1.scheduleAtFixedRate(tt, 1000, 1000);
}
private static class ClockProducer
extends MemoryImageSource
{
static final int MARGIN = 25;
static int[] createBackground(int w, int h, int color){
int[] ret = new int[w * h];
Arrays.fill(ret, color);
return ret;
}
public static ClockProducer newInstance(int size, int background){
int[] pixels = createBackground(size, size, background);
return new ClockProducer(size, pixels);
}
int secondsrun = 0;
int size;
int[] points, pixels;
protected ClockProducer(int size, int[] pixels){
super(size, size, pixels, 0, size);
this.size = size;
this.pixels = pixels;
init0();
}
private void init0(){
setAnimated(true);
setFullBufferUpdates(false);
initPoints();
}
private void initPoints(){
int cxy = size >> 1;
int rad = (size - (MARGIN << 1)) >> 1;
points = new int[120];
double dg = Math.PI / 30;
double g = - Math.PI / 2;
for(int ii = 0; ii < points.length >> 1; ii++, g += dg){
points[2 * ii] = cxy + (int) Math.round(Math.cos(g) * rad);
points[2 * ii + 1] = cxy + (int) Math.round(Math.sin(g)
* rad);
}
}
public void tick(){
int x, y, off, col;
for(int ii = Math.max(0, secondsrun - 7); ii <= secondsrun;
ii++){
off = ii % (points.length >> 1);
if(off < 0) off += points.length >> 1;
x = points[2 * off];
y = points[2 * off + 1];
col = ((0xff >> (secondsrun - ii)) << 24);
for(int xx = x - 2; xx <= x + 2; xx++)
for(int yy = y - 2; yy <= y + 2; yy++)
pixels[xx + yy * size] = col;
this.newPixels(x-2, y-2, 5, 5, ii == secondsrun);
}
secondsrun++;
}
}
}