Die paintChildren-Methode ist wie der Name schon sagt, zuständig dafür die Kind-Komponenten zu zeichnen.
Beispielsweise kannst du, wenn du diese Methode überschreibst und den super-Aufruf in eine if-Anweisung packst, vehindern, dass die Kind-Komponenten gezeichnet werden.

Falls ich heute noch dazu komme, mach ich dir noch ein Beispiel fertig.

Gruß

Sascha

Okay. Cool, Danke!
Kannst du mir auch beim Ersetzen des Graphics-Objektes helfen?

Was meinst du damit?

Gruß

Sascha

Um für längere Fades eine korrekte Überblendung hinzubekommen reicht mir die Methode mit g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER), opacity) leider nicht. Deshalb habe ich mir folgedes Überlegt (die Ausführung klappt aber leider nicht):

Zitat von mjkraus

Für die größeren Fades könnte ich da folgendes machen: Das ganze [Graphics-Objekt der Komponente] würde ich auf ein BufferedImage zeichnen, die enthaltenen Components entfernen und in einer Variablen zwischenparken [oder eben mit der paintChildren-Methode garnicht erst zeichnen lassen], das Graphics-Objekt durch das des BufferedImages ersetzen (da stellt sich die Frage wie kann ich das Ersetzen bewerkstelligen?) und dann die Komponente ausfaden (Für einfaden das ganze dann umgekert). Ist das so überhaupt realistisch?

Zitat von mjkraus

Bei der Ersetzung des Graphics-Objekt der Komponente mit dem des BufferedImages hätte ich zuerst das Graphics-Objekt geleert [...] und dann das Image mit der aktuellen Transparenz des Fading-Prozesses gezeichnet.

Zitat von mjkraus

ich hab mal etwas rumgespielt: Leider hat sich ein kleines Problem ergeben! Ich schaff es nicht das Graphics-Objekt komplett Tranparent zu löschen, diese beiden Möglichkeiten führen beide zu einer komlett schwarzen Fläche:

Code java:

1 2 3

g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC)); g2d.setColor(new Color(255, 255, 255, 0)); g2d.fillRect(0, 0, 100, 100);

Code java:

1 2	g2d.setBackground(new Color(255, 255, 255, 0)); g2d.clearRect(0, 0, 100, 100);

Muss ich den Code irgendwie modifizieren oder einen komplett anderen Lösungsweg einschlagen? Gerade auch im Hinblick auf die Performance. Ich hoffe es ist verständlich ausgedrückt.

Verwendest später nur du das Programm oder auch andere? Daie aller einfachste aber nicht unbedingt beste Lösung wäre AWTUtilities. In jedem JDK ab 6u10 enthalten (im JRE vllt auch?). Damit kann man ganz einfach die Transparenz des ganzen Frames einstellen!

Siehe: http://download.oracle.com/javase/tu...d_windows.html

Leider hilft mir die Lösung bei meinem aktuellen Problem nicht weiter, da ich nur einzelne Components faden möchte.

Zitat von mjkraus

Okay. Cool, Danke!
Kannst du mir auch beim Ersetzen des Graphics-Objektes helfen?

Warum möchtest du denn das Graphics-Objekt ersetzen? Ich hab verstanden was du machen möchtest, aber nicht was du mit Graphics-Objekt ersetzen meinst. Da bringt es nichts wenn du mir nochmal zitierst, was du schon geschrieben hast.
Wenn du bei paintChildren, wie ich oben geschrieben habe, eine if-Anweisung reinpackst und den super-Aufruf in dieser hast, kannst du das Zeichnen der Kind-Objekte abschalten.

Code :

1 2 3 4 5 6

protected void paintChildren(){       if(showChildren)         super.paintChildren();   }

Wenn showChildren == false, werden die Kind-Komponenten nicht gezeichnet. Da machst du dann einfach ein else und zeichnest dein Image.

Und damit das transparent wird, nimmst du wieder das AlphaComposite.

Am besten nimmst du dann noch ein TimingFramework, welches gut für Animationen ist und setzt da dann den Alpha-Wert für dein AlphaComposite runter.

Gruß

Sascha

Okay. Da hab ich dich wohl falsch verstanden. Sorry!

Ich hab mal folgendes ausprobiert:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

protected void paintChildren(){       if(showChildren)         super.paintChildren();     else{         BufferedImage img = new BufferedImage(this.getWidth(), this.getHeight(),                                               BufferedImage.TYPE_INT_ARGB);         this.paintComponent(img.getGraphics());         Graphics2D g2d = (Graphics2D) g;         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,                                                     this.opacity));         g2d.drawImage(img, null, 0, 0);     }     }

Das Bild wird allerdings nicht so darüber gelegt, dass das alles darunter Liegende überzeichnet wird, sondern durchscheint. Deshalb wollte ich das in den anderen Posts vorher immer leeren, bevor ich das Bild zeichne.

Das Schrittweise verändern des Transparenz-Wertes habe ich so gelöst:

Code java:

1 2 3 4 5 6 7 8 9 10 11

import java.util.Timer; import java.util.TimerTask; ... new Timer().schedule(new TimerTask(){       @Override         public void run(){             comp.fade(duration, toOpacity);         }       }, 2000);

Wäre da das Timing Framework (http://java.net/projects/timingframework) besser dafür geeignet?

Du musst das nicht leeren. Das geht auch nicht. Das wenn es neu gezeichnet wird ist das alte ja weg und da wird nicht einfach drüber gezeichnet sondern es wird komplett neu gezeichnet.

Du solltest das Image nicht in der paintChildren-Methode erstellen. Sondern unmittelbar vor dem Fade-Effekt. Dann musst du es da nur noch zeichnen.



Gruß

Sascha

Hallo!

Jetzt funktioniert das Faden! Danke! Bin mir bloß nicht ganz sicher, was Du du mit das Image "unmittelbar vor dem Fade-Effekt. Dann musst du es da nur noch zeichnen." genau meinst? Das habe ich aus deiner Anwort gemacht:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

class FadingComponent extends Component{   BufferedImage fade;   boolean fading = false;   float opacity = 1f;     public void fade(final int duration, final float opacity){     fade = new BufferedImage(getWidth(), getHeight(),                              BufferedImage.TYPE_INT_ARGB);     paintComponent(fade.getGraphics());     fading = true;         final int fps = 25;     new Timer().schedule(new TimerTask(){       Component comp = FadingComponent.this;       //Anzahl der Fading-Schritte       int i = (int) ((float) duration/1000*fps);       //Veränderung des Transparenz-Wertes pro Schritt       float step = (opacity - comp.opacity) / i;           @Override       public void run(){         i--;         //setzen des Transparenz-Werts und neuzeichnen der Komponente         comp.setOpaque(comp.opacity + step);           if(i <= 0){           this.cancel();           comp.fading = false;         }       }           }, 0, duration/fps);   }     @Override   public void paint(Graphics g){     if(!this.fading)       super.paint(g);     else{       Graphics2D g2d = (Graphics2D) g;       g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,                                                   this.opacity));       g2d.drawImage((Image) this.fade, 0, 0, null);     }   }     @Override   protected void paintChildren(Graphics g){     if(!this.fading)       super.paintChildren(g);   }   }

Du hast genau das gemacht, was ich meinte.
Du hattest in deinem alten Code die Erstellung des Images in der paintChildren. Das sollte einfach da raus. Das Image solltest du erstellen und zeichnen lassen, kurz bevor der Fading-Effekt gestartet wird und so hast du es jetzt auch gemacht.

Gruß

Sascha

Okay. Endlich hab ich es hin bekommen. Danke für die Hilfe! Ich hab noch etwas dran rum gebastelt und das wäre meine Lösung für das "Fading-Problem":

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

class FadingComponent extends Component{   private float opacity = 1f;     public FadingComponent(){     this.setOpaque(false);   }     public void setOpaque(float opacity){     //Transparenz-Wert setzen & repaint()   }     public void fade(final int duration, final float opacity){         final int fps = 25;     new Timer().schedule(new TimerTask(){       FadingComponent comp = FadingComponent.this;             //Anzahl der Fadingschritte       int i = (int) ((float) duration/1000*fps);       //Veränderung des Tranparenzwertes pro Schritt       float step = (opacity - comp.opacity) / i;           @Override       public void run(){         i--;         comp.setOpaque(this.opacity + step);         if(i <= 0){           this.cancel();         }       }       }, 0, duration/fps);   }     @Override   public void paint(Graphics g){     if(this.opacity < 1){       BufferedImage img = new BufferedImage(this.getWidth(), this.getHeight(),                                             BufferedImage.TYPE_INT_ARGB);       super.paint(img.getGraphics());             Graphics2D g2d = (Graphics2D) g;       g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,                                                   this.opacity));       g2d.drawImage(img, null, 0, 0);       }else{       super.paint(g);     }   }   }