Wieviel Logik in paintComponent?

[Verjigorm]

Hallo, wenn ich mal das Tutorial von Wildcard zitieren darf:
"Das daraus resultierende Fazit lautet: In paintComponent wird nur gezeichnet "

Nun frag ich mich nen bissl, was "Logik" genau beinhaltet
Ich habe mehrere Drawimages, die in einer Schleife gezeichnet werden

		      int width = img.getWidth();
		      while(width < getWidth()-10)
		      {
			      g.drawImage(img , 10 + width - img.getWidth(), (getHeight()-img.getHeight())/2, null);
		    	  width += img.getWidth();
		      }

Geht sowas in Ordnung?

Sind ja immerhin einige Schleifendurchläufe mit "Rechenoperationen" und von diesen Schleifen gäbe es bis zu 36!
Im Endeffekt will ich ein Bild solange von Links zeichnen, bis es an den "rechten Panelrand stößt" (Bild nicht skalieren, sondern fortsetzen!)

geht das irgendwie besser,einfacher oder ist das so ok?
(ich kann leider momentan noch keine wirkliche Aussage zur Performance machen)


mfg Verjigorm

 

[Quaxli]

Das kommt darauf an, was Du vorhast. Bei "kleinen" Programmen ist es vertretbar, denke ich.

Grundsätzlich würde ich es aber in eine eigene Kasse packen, nennen Sie wir mal vereinfacht MyImage.
Der würde ich zwei Methoden verpassen:
- checkSize();
- paintImage(Grahpics g);

Bei jedem Schleifendurchlauf geschieht dann Folgendes: Mit checkSize() würde ich prüfen, ob nach Platz bis zum Rand ist und entsprechende Variablen fortschreiben und in paintImage auch nur ein g.drawImage(....) aufrufen.

Und in paintComponent(Graphics g) würde dann auch nur paintImage(g) der Instanz von MyImage aufgerufen.

Und zu dem was Du vorhast wäre es interessant, was Du eigentlich willst. Wenn das periodisch durchgeführt werden soll, wäre es vermutlich sinnvoll, das nur einmal zu machen: Nämlich indem Du ein BufferedImage mit geeignerter Größe erzeugst, Dein Bilder das reinmalst und danach nur noch das BufferedImage zeichnest.

 

[Marco13]

Hm. In diesem Fall ist das "while" IMHO weniger kritisch. Man sollte in der paintComponent keine Logik unterbringen, aber das bißchen Logik, was entscheidet, ob ein Image gemalt wird, steht in keinem Verhältnis zum Aufwand, das Image tatsächlich zu zeichnen. (Wie du dieseSchleife aus der paintComponent raus ziehen willst, ist mir aber sowieso nicht klar ... ???:L ).

 

[Verjigorm]

Und zu dem was Du vorhast wäre es interessant, was Du eigentlich willst. Wenn das periodisch durchgeführt werden soll, wäre es vermutlich sinnvoll, das nur einmal zu machen: Nämlich indem Du ein BufferedImage mit geeignerter Größe erzeugst, Dein Bilder das reinmalst und danach nur noch das BufferedImage zeichnest.

Danke für den Tipp, ich habs jetzt mal wie folgt realisiert:

	  public void update(Graphics g) 
	  {
		  imageBuffer = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
		  graphicsBuffer = imageBuffer.createGraphics();
		  int width = img.getWidth();
		  //System.out.println(width + " " + getWidth() + " " + getHeight());
		  while(width < getWidth()-25)
		  {
			  graphicsBuffer.drawImage(img , 25 + width - img.getWidth(), (getHeight()-img.getHeight())/2, null);
			  width += img.getWidth();
		  }
		  graphicsBuffer.setColor(Color.RED);
		  graphicsBuffer.drawString("Test", 50, 50);
		  g.drawImage(imageBuffer, 0, 0, this);
	  }
	  
	  public void paintComponent(Graphics g) 
	  {
		  super.paintComponent(g);
		  update(g);
	  }

wäre das besser?

 

[byte]

Sehe nicht, was daran besser sein soll. Sehe auch nicht was dagegenspricht, es einfach in der paintComponent() zu lassen.
Solang sich der Code nur aufs eigentliche zeichnen bezieht (kein Business Code, keine Manipulation des Datenmodells), dann kann der ruhig in die paintComponent. Erst wenn der Zeichencode vom Umfang sehr mächtig wird, würde ich mir überlegen, wie man den sinnvoll kapseln kann.

 

[Quaxli]

In die update-Methode würde ich's nicht packen.

Außerdem erzeugst Du dort das Image ja auch bei jedem Schleifendurchlauf. Die Idee ist aber das Image vorher zur erzeugen und dann in der Verarbeitungsschleife das fertige Image nur zu zeichnen. Mit der Lösung oben hast Du keine Performance gewonnen.

 

[Verjigorm]

In die update-Methode würde ich's nicht packen.

Außerdem erzeugst Du dort das Image ja auch bei jedem Schleifendurchlauf. Die Idee ist aber das Image vorher zur erzeugen und dann in der Verarbeitungsschleife das fertige Image nur zu zeichnen. Mit der Lösung oben hast Du keine Performance gewonnen.

Jo, das habe ich auchschon gemerkt,
aber das Problem ist, dass ich vorher noch keiner Angabe über die Panel-Größe habe, da ist getWidth() und getHeight)= = 0.
Ich habe keine Möglichkeit gefunden, die Werte des BufferedImage später noch zu verändern.

 

[Marco13]

Brauchst du auch nicht. Du kannst ein neues BufferedImage anlegen, wenn die Größe sich geändert hat (das passiert ja nicht so oft...)

class Foo
{
    BufferedImage imageBuffer = null;

    private void updateImage()
    {
        if (imageBuffer == null || imageBuffer.getWidth() != this.getWidth() || imageBuffer.getHeight() != this.getHeight())
        {
             imageBuffer = new BufferedImage(this.getWidth(), this.getHeight(), ...);
        }
        // Hier ist imageBuffer immer gültig und hat die richtige größe...
}

BTW: Ich würde das auch nicht in der update-Methode machen....