AWT Wann ist paint() fertig?

[hdw]

Hallo zusammen,

ich bin Neuling und versuche eine "Animation" zu basteln, aber ich habe noch folgendes Problem:
In der Animation (realisiert mit AWT, in einem eigenen Thread mit DoubleBuffering bei ca. 5Hz) werden pro Bildaufbau () einige tausend Linien gezeichnet.
Da die Wiederholrate nicht wirklich kritisch ist, möchte ich das Programm dazu bringen, zu erkennen wann paint() fertig ist, d.h. wann die letzte Linie gezeichnet wurde. Aber ich fand bisher nichts Elegantes das Ende von paint zu erkennen.

paint läuft vermutl. innerhalb der AWT-EventQueue-0, ist aber kein eigener Thread, den ich z.B. mit join() abwarten könnte.

Meine einzige Anfänger-Idee:
Ich zähle einfach die zu zeichnenden Linien innerhalb von paint und verwende ein Flag, das das Ende paint an den Haupt Thread signalisiert. Aber wirklich schön finde ich das nicht.

Gibt es bessere Ideen? Bietet Swing hier etwas?

Danke und Gruss, Holger

 

[Schandro]

du könntest am Ende der paint-Methode einen neuen Thread starten, in dem du dann das ausführen kannst was nach beenden der paint-Methode ausgeführt werden soll.

Warum der umweg über nen neuen Thread? Weil du ansonsten den EDT blockierst.

 

[hdw]

das ging ja schnell

Am Ende des paint() Aufrufes beginnt die Schleife des Haupt-Threads von neuem: Berechnung aller Linien und Projektion auf die Frame-Koordinaten, dann repaint(). Viel mehr ist in dieser Schleife nicht drin.
Den Haupt-Thread wollte ich nicht nach jedem Bildaufbau beenden und neu starten. Aber vielleicht muss ich noch mal darüber meine Programm-Architektur nachdenken...

Wenn ich nach paint() einen neuen Thread starte ohne meinen Haupt-Thread zu beenden, dann kann ich diesen neuen Thread eigentl. auch nur nutzen, um dem main-Thread zu signalisieren, dass paint fertig ist? Oder hab ich jetzt alles misverstanden?

 

[Schandro]

Poste doch bitte mal den kompletten Code.

Ansonsten:

Den Haupt-Thread wollte ich nicht nach jedem Bildaufbau beenden und neu starten. Aber vielleicht muss ich noch mal darüber meine Programm-Architektur nachdenken...

Wie wärs mit ner Schleife innerhalb des Threads? Natürlich muss Thread.sleep auch innerhalb dieser Schleife stehen.

 

[hdw]

dann versuch ich mal mein Glück mit dem Code, hoffe es hilft:

  // code skipped...

  /**
   * main loop - display thread
   */
  public void run()
  {    
    long tStart   = 0;               // start time in ms
    long tElapsed = 0;               // end of processing/frame update etc.

    while (true) {
      tStart = getTimeInMillis();    // get loop time stamp

      center = communicator.getLatLon(); // get latest center position in lat/lon coords from network
      projection2frame(center);      // calculate projection to frame pixel
      repaint();                     // update frame display

      tElapsed = getTimeInMillis() - tStart;
      if (tElapsed < CYCLETIME) {
        mySleep(CYCLETIME - tElapsed); // sleep if spare time avail.
      }
    }
  } // end run()

  /**
   * update off-screen/double buffer
   */
  public void update (Graphics g) {
    // initialize double buffer
    int width  = this.getSize().width;
    int height = this.getSize().height;

    if (dbImage == null) {
      dbImage    = createImage(width, height);
      dbGraphics = dbImage.getGraphics();
    } // end if (dbImage == null)

    // delete background
    dbGraphics.setColor(getBackground());
    dbGraphics.fillRect(0, 0, width, height);

    // draw foreground
    dbGraphics.setColor(getForeground());
    paint(dbGraphics);

    // display offscreen
    g.drawImage(dbImage, 0, 0, this);    
  } // end update

  /**
   * paint method for window
   */
  public void paint(Graphics g)
  {
    Color col;
    int drawCount = 0;
    ColoredLineCartesian2D line;
    Iterator lineIterator = screenLineArray.iterator();
    while (lineIterator.hasNext()) {
      line = (ColoredLineCartesian2D)lineIterator.next();
      // draw updated line if within clipping area
      drawCount++;  // track lines to draw FIXME
      g.setColor(line.getColor());
      g.drawLine((int)line.getLine()[0][0],
                 (int)line.getLine()[0][1],
                 (int)line.getLine()[1][0],
                 (int)line.getLine()[1][1]);
    } // end while iterate screenLineArray
  } // end public void paint
  
  // more code skipped

Noch ein paar Worte zur Erkärung:
Die Aufruf von repaint() kommt innerhalb von ca. 10-20 Millisekunden zurück. Aber paint() ist nicht annähernd so schnell fertig mit dem Zeichnen aller Linien. Genau dieses Weiterlaufen von paint() möchte ich erkennen können.

Eigentlich liest das Programm Koordinaten vom Netzwerk und eine Art Landkarte aus einem File.
Mit getLatLon() werden die aktuellen Beobachter-Koordinaten vom Netzwerk gelesen.
In projection2frame() werden Landkarten-Linien entspr. der Beobachterposition neu zentriert und dann auf die Frame Koordinaten projeziert/skaliert.
Dann wird der Bildaufbau mit repaint angestoßen.
Schliesslich wird noch etwas geschlafen (mySleep), falls noch Zeit übrig ist.

Zu update hab ich nicht viel zu sagen, hab ich im Internet gefunden, realisiert nur den DoubleBuffer um das Flackern zu vermeiden.

Paint iteriert nur über eine ArrayList aller Linien. Jede Linie hat jew. Anfangs- und Endkoordinaten (x/y) plus Farbe.

Edit:
Wenn man das Ende von paint() nicht rechtzeitig erkennt, dann wird durch den nächsten Durchlauf der Schleife der Buffer gelöscht, bevor er vollständig gezeichnet wurde. Das Ergebnis ist dann eine unvolständige Landkarte

 

[Schandro]

Ok, ich denk ich weiß jetzt was du willst^^

Beispielcode:
[JAVA=8]public class XXX{

public static void main(String[] args){
new XXX();}


private JFrame window = new JFrame();
private volatile Object o23 = new Object(); // existiert nur um darauf wait und notifyAll aufzurufen

public XXX(){
window.setBounds(100,100,400,400);
window.add(panel);

SwingUtilities.invokeLater(new Runnable() {
public void run() {
window.setVisible(true);
}
});

// der "mainThread"
new Thread(new Runnable(){
public void run(){
while(true){

panel.repaint();

try{
synchronized(o23){
o23.wait();
}
}catch(InterruptedException e){
e.printStackTrace();
}

// hier gehts erst weiter wenn paint fertig ist

}
}
}).start();
}


JPanel panel = new JPanel(){
public void paintComponent(Graphics g){
super.paintComponent(g);

// malt viel Zeug, wird hier durch Thread.sleep dargestellt
try{Thread.sleep(50);}catch(InterruptedException e){e.printStackTrace();}

// weckt am Schluss den mainThread wieder auf
synchronized(o23){
o23.notifyAll();
}
}
};

}[/code]

 

[hdw]

Hi,
o.k., ich glaube ich verstehe das Prinzip Deines Beispiels. Das sollte ja in analoger Weise auch für AWT realisierbar sein. Ich werde es jedenfalls ausprobieren.
Danke jedenfalls fuer Deine super-schnelle Hilfe. Das macht Mut bald mal wieder hier reinzuschauen.
Hab als Anfänger ja noch viele Fragen...
Danke + :applaus:

 

[hdw]

Hallo,
nachdem ich den mainThread nun mit wai() auf ein Dummy-Snchronized Object so lange warten lasse, bis paint() fertig ist, läuft der eigentl. paint() um ca. den Faktor 5-10 schneller .
Vielleicht hilft dieser Tipp jemandem, der paint() fuer eine Animation beschleunigen will und noch etwas CPU-Reserven hat.

In meinem ursprünglichen Ansatz hatte ich nur ein Thread.sleep(time) in meinem main-Thread nach jedem Schleifendurchlauf.
In meinem neuen Ansatz gibt es nun im main-Thread zusätzlich noch ein wait() solange paint() läuft. Das scheint zumind. in meinem Fall performanter zu sein.
Danke Schandro.