Newsgroup: it.comp.java
Titolo: Insulto !!

Ma nessuno sa usare la grafica in java???
Sono veramente disperato ... provate a dare un occhio alla mia mail con
titolo Double Buffering
Sicuramente se avete fatto applicazioni che rigardassero anche minimamente
la grafica vi ci siete scontrati
--
My home page: 
http://www.pasteur.3000.it
Mirror: 
http://www.fortunecity.it/olimpico/pallavolo/6/index.html
Standard mail: 
mac_p...@hotmail.com
Fast mail (for little mail only) : 
bul...@wappi.com
Icq number :: 14165006

la grafica vi ci siete scontrati
Ciao, io conosco tre metodi diversi per fare il double-buffering
(1) quello che hai usato tu, cioe il drawimage
(2) un canvas ridefinito come immagine di pixel (?)
(3) usare il system.array.copy
non ho mai incontrato il problema che dici tu del flickering
(sfarfallio o lampeggio dell'immagine):
e sinceramente non ho capito ancora qual'e' il metodo piu' veloce,
sentiamoci in e-mail, se vuoi ti mando i sorgenti di tutti e tre,
ti interessa?
Ciao
Morfeus

 ha scritto nel messaggio
news:nW6i6.107$Uj1....@twister2.tin.it...




visto che si sta parlando di buffering e flickering potreste prendere in considerazione questo 
mio pezzo di codice e dirmi se c'e' modo di riuscire a farlo funzionare senza flickering
/*
 * demo.java - version 0.1
 * Copyright (C) 2000 Andrea Medeghini
 * 
http://digilander.iol.it/schiele
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
import java.util.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
public class demo implements ImageProducer, Runnable
{
	private int w;
	private int h;
	private int[] ARGB;
	private Vector consumers;
	private DirectColorModel model;
 
	public demo()
	{
		init();
	}
	public void run()
	{
		try
		{
			Thread.sleep(1000);
 
			while (true)
			{	
				for (int i = 0; i < ARGB.length; i++)
				{
					ARGB[i] = 0xFFFF0000;
				}
 
				aggiorna();
 
				Thread.sleep(500);
 
				for (int i = 0; i < ARGB.length; i++)
				{
					ARGB[i] = 0xFF0000FF;
				}
 
				aggiorna();
 
				Thread.sleep(500);
			}
		}
		catch (InterruptedException e)
		{
			System.out.println(e);
		}
	}
 
	public void startProduction(ImageConsumer ic)
	{
		if (!consumers.contains(ic)) consumers.addElement(ic);
		produci();
	}
	public void addConsumer(ImageConsumer ic)
	{
		if (!consumers.contains(ic)) consumers.addElement(ic);
	}
	public void removeConsumer(ImageConsumer ic)
	{
		consumers.removeElement(ic);
	}
	public boolean isConsumer(ImageConsumer ic)
	{
		return (consumers.contains(ic));
	}
	public void requestTopDownLeftRightResend(ImageConsumer ic)
	{
		ic.setHints(ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.SINGLEPASS);
 
		ic.setDimensions(w,h);
		ic.setColorModel(model);
 
		ic.setPixels(0,0,w,h,model,ARGB,0,w);
		ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
	}
	private void produci()
	{
		for (int i = 0; i < consumers.size(); i++)
		{		
			ImageConsumer ic = (ImageConsumer)consumers.elementAt(i);
			ic.setHints(ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.SINGLEPASS);
 
			ic.setDimensions(w,h);
			ic.setColorModel(model);
 
			ic.setPixels(0,0,w,h,model,ARGB,0,w);
			ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
		}
	}
	private void aggiorna()
	{
		for (int i = 0; i < consumers.size(); i++)
		{		
			ImageConsumer ic = (ImageConsumer)consumers.elementAt(i);
			ic.setPixels(0,0,w,h,model,ARGB,0,w);
			ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
		}
	}
	private void init()
	{
		model = new DirectColorModel(32,0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);
		consumers = new Vector(4,2);
		w = 200;
		h = 200;
		ARGB = new int[w * h];
 
		new Thread(this).start();
	}
	public int[] getARGB()
	{
		return (ARGB);
	}
	public int getWidth()
	{
		return (w);
	}
	public int getHeight()
	{
		return (h);
	}
	public static void main(String[] args)
	{
		new window();
	}
}
class window extends Frame implements WindowListener
{
	public window()
	{
		add(new immagine());
 
		addWindowListener(this);
 
		pack();
 
		show();
	}
 
	public void windowClosing(WindowEvent e)
	{
		hide();
 
		System.exit(0);
	}
	public void windowOpened(WindowEvent e)
	{
	}
	public void windowClosed(WindowEvent e)
	{
	}
	public void windowActivated(WindowEvent e)
	{
	}
	public void windowDeactivated(WindowEvent e)
	{
	}
	public void windowIconified(WindowEvent e)
	{
	}
	public void windowDeiconified(WindowEvent e)
	{
	}
}
class immagine extends Canvas
{
	private Image i;
 
	public immagine()
	{
		i = createImage(new demo());
 
		setSize(i.getWidth(this),i.getHeight(this));
	}
	public void update(Graphics g)
	{
		paint(g);
	}
 
	public void paint(Graphics g)
	{
		if (i != null) g.drawImage(i,0,0,this);
	}
}
http://digilander.iol.it/schiele

 wrote in message
8p7i6.103$LM4....@twister1.tin.it...

Uso un Jpannel .. quindi Swing, il problema sembra derivare dal fatto che la
paint viene richiamata prima che sia stata finita la produzione da parte
delle istruzioni appartenenti a graph che si occupando di ridisegnala...
Se guardate il codice trovate un rettangolo nero e un rettangolo riempito in
bianco che non ricalca il bordo nero.
Se guardate bene il rettangono nero non viene mai cancelleto e coperto,
infatti il flickering rigiuarda solo l'area coperta dal bianco.
Il sospetto a sto punto è sempre più fondato, non è che la grap lancia un
processo concorrente che si occupa di disegnare, per mantenere le
prestazioni del processo principale.
Se anche così fosse come posso fare per attenedere la fine del processo e
disegnare l'immagine giusta??


Il tuo caso e' piu' complicato del previsto (almeno per me)
mi arrendo!
Ciao
Morfeus

ho scritto questo semplice image producer
la mia intenzione e' di utilizzarlo per generare un'animazione 
non capisco pero' come si comporta questo pezzo di codice
cioe' quando produco un'immagine e segnalo imageComplete()
viene invocato paint e disegnata l'immagine 
secondo me questo e' equivalente ad un double buffering
(l'array interno al producer e l'array interno ad image)
succede pero' che riducendo le pause aumenta il flickering
vorrei risolvere questo problema, qualcuno potrebbe aiutarmi?
devo ricorrere alla classe BufferedImage? 
(il codice e' gia' pronto per essere compilato ed avviato)
il codice funziona maluccio con la jvm della sun 
e in modo pessimo con la jvm di iexplorer

import java.util.*;


	private int[] ARGB;
	private Vector consumers;


				Thread.sleep(200);
 
				for (int i = 0; i < ARGB.length; i++)
				{
					ARGB[i] = 0xFF0000FF;
				}
 
				aggiorna();
 
				Thread.sleep(200);
