JLayeredPane Elemente auf gleicher Position

[keNNy42]

Hallo.

Ich habe folgendes Problem:

Mein Projekt ist das Programmieren eines Routenplaners. Das Einblenden der Routen funktioniert folgendermaßen:

Ich habe eine JLayeredPane. Auf das unterste Layer (DEFAULT_LAYER) packe ich die Karte des Gebiets. Auf die darüberliegenden Layer packe ich jeweils ein Bild mit einem Streckenabschnitt (gleiche Größe wie die Karte, der Rest transparent).
Nachdem ein Weg geroutet wurde, wird der passende Weg angezeigt.
Die JLayeredPane hat die selbe Größe wie die Karte.

Siehe hierzu auch die Bilder:

Die Karte:

Ein Streckenabschnitt:

Mein Problem ist nun die Positionierung der Bilder. Ich positioniere die Elemente mit setBounds. Da alle Bilder die Größe der Karte haben, positioniere ich sie mit setBounds(0,0,[Breite der Karte],[Höhe der Karte]).

Zuerst einmal vorweg das was mich am meisten verwirrt: Wenn ich die Bilder der Wege alle unterschiedlich positioniere dann funktioniert alles problemlos (außer eben, dass die Strecken verschoben sind).
Die Probleme passieren erst, wenn ich alle auf die vorgesehene selbe Position (ALLERDINGS AUF UNTERSCHIEDLICHEN LAYERS) lege.

Ist das eine bekannte Eigenschaft/Problem von JLayeredPanes? Muss man in dem Fall etwas besonderes beachten?

Nun zu den Problemen selbst.
Zuerst einmal muss ich in der Breite [Breite der Karte]-1 einstellen, denn sonst wird nichts mehr außer dem angezeigten Streckenabschnitt mit der höchsten Layerposition angezeigt. Nicht einmal die Karte.
Das komische ist hier wieder, dass die Breite egal ist, sobald ich die Bilder unterschiedlich positioniere. In dem Fall kann ich auch eine riesige Breite nehmen, die über den Bildschirm reicht und es macht keine Probleme.
Benutze ich [Breite der Karte]-1 so wird zwar die Karte, aber weiterhin nur die Strecke auf dem höchsten Layer angezeigt. Blende ich diese aus wird lediglich die auf dem nächstniedirgeren Layer angezeigt.

In Bildern sieht mein Problem so aus:

Positioniere ich die Streckenabschnitte alle unterschiedlich sieht es so aus:



Alles wird angezeigt, nur eben verschoben. Hier ist es auch egal, welche Breite ich bei setBounds für die eingefügten Bilder nehme. Es geht trotzdem.

Positioniere ich alle an der selben Stelle und lege als Breite [Kartenbreite]-1 fest sieht es so aus:



Nur der auf dem höchsten Layer gelegene Streckenabschnitt wird angezeigt, aber zumindest noch die Karte.

Positioniere ich alle an der selben Stelle und lege als Breite die Kartenbreite oder eine größere fest sieht es so aus:



Es wird nichts mehr angezeigt außer dem obersten Streckenabschnitt (Die Kreise sind Teil des Streckenbildes). Nicht einmal die Karte.


Ich habe schon alles an Positionierungen probiert, mit repaint() rumprobiert und es läuft immer wieder auf das selbe hinaus.
Über allem schwebt für mich aber immer die Frage, warum es keine Probleme macht, wenn sich die Bilder an unterschiedlichen Positionen befinden. Die Probleme treten erst auf, wenn sie sich an der gleichen X- und Y-Position befinden.
Das sollte doch eigentlich völlig egal sein, da sie sich doch alle auf verschiedenen Layern befinden.

An der Transparenz liegt es ziemlich sicher nicht, da auch diese bei unterschiedlichen Positionen funktioniert.


Ich bin gerade total am verzweifeln. Ich habe keine Idee mehr, wie man das beheben könnte außer alle (über 100!!!) Einzelbilder jeweils oben oder links um 1 Pixel zu verkleinern.


Ich hoffe irgendjemand kann mir helfen und es ist vielleicht wirklich nur eine Eigenart des JPanels, die man kennen muss.


Hoffnungsvolle Grüße, Lars



PS: Den ganzen Code zu posten wird schwierig, da der sich über 14 Dateien und 1000e Zeilen Code erstreckt. Vielleicht noch falls es hilft hier die Klasse, die zum anzeigen der Bilder dient:

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

public class ImagePanel extends JPanel
{
    private Image img;

    public ImagePanel(String img)
    {
        this(new ImageIcon(img).getImage());
    }
    public ImagePanel(Image img)
    {
        this.img = img;
        Dimension size = new Dimension(img.getWidth(null), img.getHeight(null));
        setPreferredSize(size);
        setMinimumSize(size);
        setMaximumSize(size);
        setSize(size);
    }
    @Override
    public void paintComponent(Graphics g)
    {
        g.drawImage(img, 0, 0, null);
    }
}

 

[Marco13]

"Den ganzen Code" braucht man wohl nicht. Ein KSKB, wo das Problem auftritt würde schon helfen. Warum die Frage, was gezeichnet wird, in dieser Form von ein paar Pixeln Verschiebung abhängen soll, erschließt sich mir nämlich nicht... ???:L

Kann man eine Klasse mit einer LayeredPane und zwei Bildern (in diesen ImagePanels) machen, wo man das Problem sieht?

 

[keNNy42]

Ich werd mal ein Testbeispiel erstellen und posten, wenn ichs schaffe heut Abend noch, ansonsten morgen.

 

[keNNy42]

So, hab mal ne kleine Testklasse angelegt.
In diesem Code sind die Bilder in x-Richtung alle um 1 Pixel mehr verschoben, sodass alles angezeigt wird.
Es verhält sich wie im großen Beispiel. Sobald 2 Bilder (obwohl sie sich auf unterschiedlichen Ebenen befinden) sich auf der selber Position befinden wird nur noch das Bild angezeigt, das auf dem höheren Layer liegt.

Ist eben jetzt nur die Frage: Liegt das am JLayeredPane oder an meinem ImagePanel?
Und in beiden Fällen: Kann man das beheben?

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

public class JLayeredPaneTest extends JFrame
{
    JLayeredPane pane;
    ImagePanel karte;
    ImagePanel pfadLinks;
    ImagePanel pfadRechts;
    ImagePanel pfadMitte;

    public JLayeredPaneTest()
    {
        super("JLayeredPane-Test");
        setSize(800,700);
        setLayout(new FlowLayout());
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pane = new JLayeredPane();
        pane.setPreferredSize(new Dimension(684,600));
        karte = new ImagePanel("karte.png");
        pfadLinks = new ImagePanel("links.png");
        pfadRechts = new ImagePanel("rechts.png");
        pfadMitte = new ImagePanel("mitte.png");
        pane.add(karte,JLayeredPane.DEFAULT_LAYER);
        pane.add(pfadLinks,new Integer(JLayeredPane.DEFAULT_LAYER+1));
        pane.add(pfadRechts,new Integer(JLayeredPane.DEFAULT_LAYER+2));
        pane.add(pfadMitte,new Integer(JLayeredPane.DEFAULT_LAYER+3));
        karte.setBounds(0,0,karte.getWidth(),karte.getHeight());
        pfadLinks.setBounds(1,0,karte.getWidth(),karte.getHeight());
        pfadRechts.setBounds(2,0,karte.getWidth(),karte.getHeight());
        pfadMitte.setBounds(3,0,karte.getWidth(),karte.getHeight());
        add(pane);
    }
    
    public static void main(String[] args)
    {
        JLayeredPaneTest test = new JLayeredPaneTest();
        test.setVisible(true);
    }

    public class ImagePanel extends JPanel
    {
        private Image img;

        public ImagePanel(String img)
        {
            this(new ImageIcon(img).getImage());
        }
        public ImagePanel(Image img)
        {
            this.img = img;
            Dimension size = new Dimension(img.getWidth(null), img.getHeight(null));
            setPreferredSize(size);
            setMinimumSize(size);
            setMaximumSize(size);
            setSize(size);
        }
        @Override
        public void paintComponent(Graphics g)
        {
            g.drawImage(img, 0, 0, null);
        }
    }
}

 

[Marco13]

In die letzte Zeile des (zweiten) Konstruktors vom ImagePanel muss noch ein
setOpaque(false);

Ansonsten denkt er: "Hey, das ist ja opak, das hintere is komplett vom vordereren verdeckt - dann brauch ich's auch nich zeichnen..."

(dass es bei einer geringen Verschiebung richtig aussieht ist eigentlich auch eher Zufall - also ein Seiteneffekt davon, dass die erste Zeile der paintComponent NICHT
super.paintCompoent(g);
ist - was eigentlich "üblich" ist...)

 

[keNNy42]

Super, das wars. Danke!

Also muss die paintcomponent so aussehen?

@Override
public void paintComponent(Graphics g)
{
    super.paintComponent(g);
    g.drawImage(img, 0, 0, null);
}

 

[Marco13]

Hmja, da hab' ich selbst einen Moment überlegt Deswegen auch das "üblich" in Anführungzeichen.

Normalerweise ist das (bis auf wenigste Ausnahmen) immer so: Wenn man paintComponent überschreibt, macht man als erstes ein super.paintComponent. Das bewirkt bei einem JPanel eigentlich nicht viel mehr als dass der Hintergrund gelöscht (d.h. mit der Background-Color gefüllt) wird. Wenn das JPanel nicht opak ist, macht er aber nichtmal das. So gesehen könnte das super.paintComponent in diesem speziellen Fall(!) evtl. überflüssig sein. Da die letzte Entscheidung darüber, was dort gemacht wird, aber das PanelUI fällt, sollte man ihm zumindest die Möglichkeit geben, diese Entscheidung zu treffen - ich würde es also mal drin lassen, so, wie du es zuletzt geschrieben hast.

 

[keNNy42]

Super. Gut zu wissen, was genau man da eigentlich macht.

Damit wäre das Problem gelöst. Danke nochmal!