Newsgroup: it.comp.java
Titolo: appletviewer IE4

Riposto il messaggio sperando in una risposta (ho letto la FAQ!).
Ho un paio di domande da farvi riguardo ad un semplice applet che ho appena
fatto. In fondo c'è il codice.
L'applet Rettangoli2 semplicemente visualizza dei rettangoli di
dimensioni e colori casuali. Per evitare la cancellazione dei medesimi
ad ogni chiamata al metodo paint() dell'applet (che avrebbe comportato
la visualizzazione di un rettangolo per volta), ho ridefinito update:
public void update(Graphics g) {
paint(g);
}
Internet Explorer 4.01 visualizza correttamente l'applet, mentre
appletviewer visualizza un solo rettangolo per volta, penso alla
massima velocità, occupando la maggior parte delle risorse del sistema
tanto che il puntatore del mouse si muove lentamente e a tratti.
Quindi è come se non avessi inserito il tutto in un thread.
Come mai? E' sbagliato il programma (cosa che mi auguro) o
appletviewer non è il visualizzatore affidabile al 100% che credevo?
Seconda domanda:
se io non volessi che l'applet ripartisse da capo ogni volta che gli
viene sovrapposta un'altra finestra, oppure ogni volta che ridimensiono
la finestra, come potrei fare?
Non proponetemi soluzioni troppo sofisticate, perché programmo in Java
da pochissimo tempo.
Terza:
mi pare di capire che per default lo sfondo di un applet è grigio scuro,
giusto?
setBackground() non funziona quasi mai con il mio IE4.01, è normale? Devo
usare
una fillRect alla quale passo le dimensioni dell'applet
Quarta (ed ultima):
riprodurre file audio non AU è una prerogativa di Java 1.2 *non* supportata
da IE4.01,
giusto?
Ringrazio anticipatamente per le risposte.
Massimo
****************************************************************************
***********
*                                CODICE
*
****************************************************************************
***********
<body>
<div align="center">
<applet code="Rettangoli2.class" width=700 height=400>
</applet>
</div>
</body>
****************************************************************************
***********
/*
 Rettangoli2.java
   Questa applet disegna rettangoli di colore e dimensioni casuali.
*/
import java.awt.Graphics;
import java.awt.Color;
import java.util.Random;
public class Rettangoli2 extends java.applet.Applet implements Runnable
{
   Thread runner;
   int x, y;   // coordinate del rettangolo
   int lx, ly;  // lunghezza del lato lungo i due assi
   public void start()
   {
    if (runner == null) {
       runner = new Thread(this);
         runner.start();
      }
   }
   public void stop()
   {
    runner = null;
   }
   public void run()
   {
    Random rand = new Random();
      int red, green, blue;
      Color colore = new Color(0,0,0);
      Thread thisThread = Thread.currentThread();
      while (runner == thisThread) {
       do {       // genero casualmente origine e dimensione lungo asse x
        x = (int) (rand.nextDouble() * 600);   // origine x del rettangolo
          lx = (int) (rand.nextDouble() * 150); // dimensione x del
rettangolo
         } while ( (x + lx) > 700);
         do {        // genero casualmente origine e dimensione lungo asse y
          y = (int) (rand.nextDouble() * 300); // origine y del rettangolo
          ly = (int) (rand.nextDouble() * 100); // dimensione y del
rettangolo
         } while ( (y + ly) > 400);
         red = (int) (rand.nextDouble() * 256);    // trovo un colore
generando
         green = (int) (rand.nextDouble() * 256);  // tre interi casuali
compresi
         blue = (int) (rand.nextDouble() * 256);   // tra 0 e 255
         colore = new Color(red, green, blue);
         setForeground(colore);                    // imposto il colore
         repaint();
         try {                                     // pausa di 20 millisec
          Thread.sleep(20);
         }
         catch (InterruptedException e) {}
      }
   }//run
 public void paint(Graphics g)
   {
    g.fillRoundRect(x,y,lx,ly,0,0);  // disegno il rettangolo
      g.setColor(Color.black);
      g.drawRoundRect(x,y,lx,ly,0,0);  // disegno in nero il contorno del
rett.
   }
   public void update(Graphics g)         // ridefinisco update per evitare
   {                                      // sfarfallio e cancellazione del
    paint(g);                           // rettangolo appena disegnato
   }
}//class Rettangoli

Ciao,
l'appletviewer non č proprio un browser anche lui ha i suoi limiti ma in questo
caso il piccolo grande tool di Sun non ha colpe. La JVM di appletviewer e di IE4
sono ovviamente diverse e ovviamente ti puoi aspettare prestazioni diverse, ma
attenzione a non inserire codice che mette in crisi i poveri green  thread di
Java. I thread devono essere gentili l'uno con l'altro e magari evitare cicli
attivi lunghi. Ho capito il tuo codice ma non condivido molto i while nella run
del thread runner.
Se ridefinisci update devi per forza cancellare e colorare manualmente lo sfondo
dell'applet e se non vuoi perdere i rettangoli quando questi vengono cancellati
da altre finestre devi salvarli. Ti riporto la mia implementazione della tua
applet fanne quello che vuoi.
<body bgColor=#8080C0>
<applet code="Rettangoli.class" width=400 height=400>
<param name="bgColor" value="#8080C0">
<param name="delay" value="5">
</applet>
</body>
import java.applet.*;
import java.awt.*;
public class Rettangoli extends Applet implements Runnable {
  public static final int DEFAULT_DELAY = 100;
  Thread runner;
  Image buffer;
  boolean invalid = true;
  int delay = DEFAULT_DELAY;
  public void init() {
    String param;
    if((param = getParameter("bgColor")) != null)
      setBackground(Color.decode(param));
    if((param = getParameter("delay")) != null)
      delay = Integer.parseInt(param);
  }
  public void start() {
    if(runner == null) {
      runner = new Thread(this);
      runner.start();
    }
  }
  public void stop() {
    if(runner != null) {
      Thread moribund = runner;
      runner = null;
      moribund.interrupt();
    }
  }
  public void run() {
    Thread current = Thread.currentThread();
    while(current == runner) {
      repaint();
      try {
        current.sleep(delay);
      } catch(Exception e) { }
    }
  }
  public void invalidate() {
    // chiede il ridimensionamento del componente
    invalid = true;
    super.invalidate();
  }
  public void update(Graphics gc) {
    // non voglio che venga cancellato lo schermo ad ogni repaint
    paint(gc);
  }
  public void paint(Graphics gc) {
    Dimension d = getSize();
    if(invalid) {
      Image newBuffer = createImage(d.width, d.height);
      Graphics bg = newBuffer.getGraphics();
      // cancella il nuovo buffer
      bg.setColor(getBackground());
      bg.fillRect(0, 0, d.width, d.height);
      if(buffer != null)
        // copia il contenuto del vecchio buffer nel nuovo buffer
        bg.drawImage(buffer, 0, 0, null);
      // elimina il vecchio buffer
      buffer = newBuffer;
      invalid = false;
    }
    Graphics bg = buffer.getGraphics();
    int r = (int)(255.0 * Math.random());
    int g = (int)(255.0 * Math.random());
    int b = (int)(255.0 * Math.random());
    bg.setColor(new Color(r, g, b));
    int x = (int)(d.width * Math.random());
    int y = (int)(d.height * Math.random());
    int w = (int)(d.width * Math.random());
    int h = (int)(d.height * Math.random());
    bg.fillRect(x, y, w, h);
    gc.drawImage(buffer, 0, 0, null);
    bg.dispose();
  }
}