Eine paint-Methode, 2 Welten?

[Goldi]

Hallo zusammen!
Ich bin einem Mysterium auf der Spur, im Zweifel dem meiner eigenen Unwissenheit, aber das ist wirklich komisch. Ich möchte gerne wissen, ob ich zu blöd bin oder ob's diesmal an Duke liegt. Ich habe zur Problembeschreibung ein einfaches Programm geschrieben und fange am besten mit dem Ergebnis an. In einem mehr oder weniger verschachtelten und komplexen Fenster soll folgende Grafik erscheinen:



Der Aufbau: Die 2 Quadrate werden von einem JPanel in ein- und derselben paintComponent-Methode gemalt. Das JPanel liegt hier auf einem einfach JFrame. So weit, so gut. Nun ein Fenster, das halt noch andere Komponenten und ein BorderLayout haben:



Aufbau: Auf dem JFrame liegt ein BorderLayout: Der Norden nimmt nun mit irgendwelchen Komponenten Platz weg, der Süden enthält das alt bekannte JPanel mit den zwei Quadraten.

Das rote Quadrat verhält sich unauffällig, so wie erwartet. Dagegen das gelbe Quadrat, dessen einzige Besonderheit es ist transformiert zu sein (Drehung), hat seine Grenze nicht an der Oberkante des Containers, der es beherbergt, sondern exakt an der Oberkante des JFrames. Und doch wurden beide "im gleichen Atemzug" erzeugt!

Wie zum Henker 😕 kann es sein 😱, dass diese beiden Quadrate 😵, die in ein- und derselben paintComponent-Methode in ein- und demselben JPanel gemalt wurden 😳, vom Layout-Manger des aufnehmenden JFrames unterschiedlich behandelt werden??😕????😱?????😵????😳???? Übrigens: Wenn ich das Fenster nach unten vergrößere, zieht das rote Quadrat und auch das JPanel mit, das gelbe bleibt stehen und wandert im Umkehrschluss aus seinem eigenen JPanel raus:



Ich hab's übrigens auch mit deinem GridBagLayout probiert: Das gleiche Ergebnis.

Und hier der Programmcode:

Zunächst zur Klasse, die die Quadrate malt (sie ist von JPanel abgeleitet):

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;

/** Diese Panel erzeigt einfach nur 2 Quadraten mit Seitenlänge 250 Pixel,
 * eines davon gedreht um 45°. Diese werden in der überlagerten paintComponent-
 * Methode realisiert. Damit die Grafiken auf der JFrame später vollständig angezeigt
 * werden,müssen die Methoden getPreferredSize und getMinimumSize überlagert werden.
 * Sie geben genau die Ausmaße zurück, die die grafiken brauchen. */
public class TestPanel
extends JPanel {

   private static final long serialVersionUID = 1L;

   @Override
   public Dimension getPreferredSize() {
     return new Dimension(354, 354);     // Errechnet mit dem guten alten Pythagoras
   }
   
   @Override
   public Dimension getMinimumSize() {
     return getPreferredSize();
   }
   
   @Override
   protected void paintComponent(Graphics g) {
     Graphics2D g2d = (Graphics2D)g;
     
     // Ein rotes, nicht transformiertes Quadrat wird im Bezug auf das nächste gelbe
     // Quadrat genau mittig gemalt
     g2d.setColor(new Color(255, 0, 0));
     g2d.fillRect(52, 52, 250, 250);
     
     // Das gelbe Quadrat soll um 45° gedreht werden:
     AffineTransform trans = new AffineTransform();
     trans.rotate(45d * Math.PI / 180d,   // Bogenmaß zu 45°
         177, 0);           // Die Anker (x: 177, y: 0) sollen identisch sein
                       // mit den Koordinaten des gelben Quadrats, so dass
                       // es durch die Rotation keine x-/y-Verschiebungen gibt.
     g2d.setTransform(trans);
     
     g2d.setColor(new Color(255, 255, 0));
     g2d.fillRect(177, 0, 250, 250);      // x=177, y=0 => identisch mit Anker (s. o.)
     
   }
}

Hier die JFrame mit den Zusatz-Komponenten; ich habe die Unterschiede im Code zum aller ersten Screenshot (einfaches JFrame) kommentiert:

import javax.swing.*;
import java.awt.*;

public class TestFrame2
extends JFrame {

   private static final long serialVersionUID = 1L;
   
   public TestFrame2() {
     
     super("Testfenster mit BorderLayout");
     addWindowListener(new myWindowListener());
     
     Container cp = getContentPane();
     
     // --------------------------------------------------------------------
     // Hier der Programmteil, der sich von TestFrame1 unterscheidet:
     
     setLayout(new BorderLayout());
     
     // Panel mit zusätzlichen Komponenten im Norden:
     JPanel irgendwasPanel = new JPanel(new BorderLayout());
     irgendwasPanel.add(new JTextArea("Ein paar\nbedeutungslose\nZeilen", 3, 100), BorderLayout.NORTH);
     irgendwasPanel.add(new JButton("Irgendein Button ohne Funktion"), BorderLayout.SOUTH);
     
     cp.add(irgendwasPanel, BorderLayout.NORTH);
     
     // Der grafische Teil (2 Quadrate) steht im Süden:
     TestPanel testpanel = new TestPanel();
     cp.add(testpanel, BorderLayout.SOUTH);
     
     // ------------- Unterschied Ende --------------------------------------
     
     pack();
     setVisible(true);
   }
   
   
   public static void main(String[] args) {
     new TestFrame2();
   }
}

Den WindowListener kann ich mir denke ich sparen 🙂.

Jetzt bin ich ja mal gespannt, was die Gemeinde dazu sagt: Welche Nachhilfe brauche ich noch oder ist das tatsächlich ein Fehler in Java?

Herzlichen Gruß
Stefan

 

[JCODA]

Interessant! Ich kannte diese Interaktion auch noch nicht. Scheint als wäre die AffineTransform etwas "Globales" ... naja, mit

 g2d.rotate(45d * Math.PI / 180d, 177, 0);

statt der AffineTransform geht es.

Eine Erklärung wäre, dass die "Welten", wie du sie nennst, ebenfalls du AffineTransform erzeugt werden, und wenn du sie selbst "setzt" machst du sie kaputt.
Oh, ich hab gerade nachgeschaut: tatsächlich, siehe: https://docs.oracle.com/javase/7/do...l#setTransform(java.awt.geom.AffineTransform)

public abstract void setTransform(AffineTransform Tx)
Overwrites the Transform in the Graphics2D context. WARNING: This method should never be used to apply a new coordinate transform on top of an existing transform because the Graphics2D might already have a transform that is needed for other purposes, such as rendering Swing components or applying a scaling transformation to adjust for the resolution of a printer.
To add a coordinate transform, use the transform, rotate, scale, or shear methods.

 

[Goldi]

Vielen herzlichen Dank, das war der richtige Hinweis! Klar ... die Doku 🙄. Zu meiner Verteidigung: Die Vorgehensweise, das AffineTrans-Dings auf das Graphics2D-Objekt direkt anzuwenden, kam aus einem Java-Fachschmöker in meinem Bücherregal. Das hätte ich nie in Frage gestellt. Ich sollte dem Autoren mal eine Email schreiben😉.

Übrigens für Interessierte: Habe jetzt in der AffineTrans-Klasse die createTransformedShape-Methode entdeckt, mit deren Hilfe man die u. U. geschachtelte Transformationen auf ein Shape (grafische Formen aus Java2D, z. B. RectAngle2D) anwenden kann.

 

[AndyJ]

Ich wuerde mal sagen, du hast einfach vergessen die alte transformation zu speichern und wieder herzustellen:

// Get the current transform 
AffineTransform saveAT = g2.getTransform(); 
// Perform transformation 
g2d.transform(...); 
// Render 
g2d.draw(...); 
// Restore original transform 
g2d.setTransform(saveAT);