LayoutManager Komponent vergrößert sich beim kleiner Ziehen?

[Pumpkin]

Hallo,

ich habe ein JPanel, in welches ich beliebig viele Komponenten einfügen möchte. Wenn nur eine Komponente da ist, soll dieser das ganze Panel ausfüllen. Wenn mehrere hinzukommen, sollen sie sich den Platz teilen, wobei jede gleich viel bekommen soll. Wenn so viele Komponenten im Panel sind, dass eine Mindestgröße unterschritten wird, soll eine Scrollbar auftauchen und jede Komponente soll ihre Mindestgröße haben.
Gemacht habe ich das so:

übergeordnetes Panel:

GridBagConstraints constraints = new GridBagConstraints();
constraints.gridx = 0;
constraints.gridy = nummerDerKomponente;
constraints.fill = GridBagConstraints.BOTH;
constraints.weightx = 0.5; // hat mein Kollege gemacht, lustigerweise wird dann die ganze Breite genommen (was auch gewollt ist)
constraints.anchor = GridBagConstraints.NORTH;
constraints.weighty = 1.0;

in allen Komponenten:

setMinimumSize(new Dimension(50, mindestgroesse));
setPreferredSize(new Dimension(50, standardgroesse));

Das Verhalten ist folgendermaßen:
-Wenn die erste Komponente hinzugefügt wird, füllt diese das ganze Panel aus (wie gewünscht). Wenn nun per Maus gezogen wird und die Größe der Komponente verkleinert werden soll, wird diese stattdessen größer (nicht gewünscht).
-Wenn Komponenten hinzugefügt werden, teilen sie sich das Panel zu gleichen Teilen (gewünscht). Beim Verkleinern tritt das gleiche Verhalten auf (nicht gewünscht).

Woran liegt das?

Danke

 

[L-ectron-X]

Könnte sein, dass du mit GridLayout besser dran bist.

 

[Pumpkin]

Habe ich auch überlegt, aber ich füge die Komponenten in das Panel immer nacheinander ein und wenn ich das richtig sehe, muss ich für das Gridlayout die Anzahl der Zellen vorher bereits festlegen.
Wäre es denn eine Möglichkeit, ein Layout zu erstellen und jedesmal, wenn eine Komponente hinzu kommt oder entfernt wird, das alte Layout zu überschreiben und ein neues mit der entsprechenden Größe einzufügen?

 

[Michael...]

Habe ich auch überlegt, aber ich füge die Komponenten in das Panel immer nacheinander ein und wenn ich das richtig sehe, muss ich für das Gridlayout die Anzahl der Zellen vorher bereits festlegen.

Nicht unbedingt:

	JFrame frame = new JFrame();
	frame.getContentPane().setLayout(new GridLayout(0, 3));
	for (int i=0; i<7; i++)
		frame.getContentPane().add(new JLabel("Label " + i));
	frame.setBounds(0, 0, 200, 200);
	frame.setVisible(true);

 

[Pumpkin]

Dann muss ich noch dazu sagen, dass die Komponenten auch unterschiedlich groß sein dürfen/sollen.

 

[Michael...]

Kannst da mal ein kompilierbares Bsp posten?
Ich denke, das könnte mit

setMinimumSize()

zusammenhängen.

 

[Pumpkin]

So, ich hab mal Teile des Quelltextes extrahiert, sodass es ungefähr so aussieht wie bei mir. Das Verhalten ist übriegns das gleiche. Der Quelltext ist so groß, weil die Klasse benötigt wird, um die Resize-Leiste zu benutzen, die nötig ist.

import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import javax.swing.*;
import javax.swing.plaf.ComponentUI;

public class LayoutTest
{

    public static void main(String[] args)
    {
        JFrame f = new JFrame("This is a test");
        f.setSize(1000, 1000);
        Container content = f.getContentPane();

        JPanel panel = new JPanel();

        content.add(panel);

        panel.setLayout( new GridBagLayout());
        panel.setBackground(Color.white);

        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridy = 0;
        constraints.fill = GridBagConstraints.BOTH;
        constraints.weightx = 1.0; //Traumhaft!
        constraints.anchor = GridBagConstraints.NORTH;
        constraints.weighty = 1.0;


        panel.add(newPanel(), constraints);

        constraints.gridy = 1;
        panel.add(newPanel(), constraints);

        f.setVisible(true);
    }

    public static JPanel newPanel()
    {
        JPanel panel = new JPanel();
        panel.setLayout( new BorderLayout());
        panel.setPreferredSize(new Dimension(50, 150));
        panel.setMaximumSize(new Dimension(1000, 1000));

        JPanel centerPanel = new JPanel();
        centerPanel.add(new JButton("Button"));

        DragBar resizeDragger = new DragBar(panel);

        panel.add(centerPanel, BorderLayout.CENTER);
        panel.add(resizeDragger, BorderLayout.SOUTH);

        return panel;
    }
}



class DragBar extends JComponent
        implements MouseListener,
                   MouseMotionListener
{
   private Point pointPressed;
   private Point pointReleased;

   private JPanel panel;

   /**
    * Create new DragBar and add to a panel.
    *
    * @param panel  The panel that should extend the drag bar to resize.
    */
   public DragBar(JPanel panel)
   {
     this.panel = panel;

     setBackground(Color.BLACK);
     setOpaque(true);
     setUI(new ComponentUI() {});
     setPreferredSize(new Dimension(5,5));

     addMouseListener(this);
     addMouseMotionListener(this);
   }

   @Override
   public void mousePressed(MouseEvent e)
   {
     pointPressed = e.getLocationOnScreen();
     updateCursor(true);
   }

   private void updateCursor(boolean on)
   {
     if (on) {
         setCursor(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));
     } else {
       setCursor(null);
     }
   }
    @Override
    public void mouseReleased(MouseEvent e)
    {
        pointReleased = e.getLocationOnScreen();

        int deltaY = pointReleased.y - pointPressed.y;

        Dimension size = panel.getSize();

        size.height += deltaY;

        Dimension minSize = panel.getMinimumSize();
        if (minSize != null) {
            if (size.width < minSize.width) {
                size.width = minSize.width;
            }
            if (size.height < minSize.height) {
                size.height = minSize.height;
            }
        }

        panel.setPreferredSize(new Dimension(panel.getWidth(), size.height));

        ((JPanel) panel.getParent()).revalidate();

        pointPressed = null;
        pointReleased = null;
   }

    @Override
    public void mouseEntered(MouseEvent e)
    {
        updateCursor(true);
    }

    @Override
    public void mouseDragged(MouseEvent e)
    {
        mouseReleased(e);
        pointPressed = e.getLocationOnScreen();
    }

    @Override
    public void mouseClicked(MouseEvent e)
    {
    }

    @Override
    public void mouseExited(MouseEvent e)
    {
    }

    @Override
    public void mouseMoved(MouseEvent e)
    {
    }

}

 

[Michael...]

Kann das leider so nicht direkt beim mir ausführen, da ich kein JDK 1.6 auf meinem Rechner habe.
Aber wenn ich das richtig sehe, ist das GridLayout für den Vorhaben nicht unbedingt geeignet.
Da macht es eventuell sogar Sinn einen eigenen LayoutManager zu schreiben.

Nach welchen Kriterien sollen denn bei einer Änderung der Containergröße die Komponentengrößen angepasset werden? Soll das "Höhen"verhältnis bei behalten werden?

 

[Pumpkin]

Also es gibt das Panel in das die Komponenten (K) eingefügt werden und die Größe der K soll sich nach folgenden Punkten richten (Die Breite der K ist immer gleich, nur die Höhe ist relevant):

-Jede K hat eine Mindestgröße
-Wenn das Panel leer ist und die erste K hinzugefügt wird, soll sie das ganze Panel ausfüllen
-Wenn eine weitere K hinzugefügt wird, sollen sich alle das Panel teilen. Wenn der Platz für eine K kleiner ist als die Mindestgröße, soll ein Scrollbalken eingeführt werden und jede K hat ihre Mindestgröße.
-Die Größe der K soll verändert werden können über die Resize-Leiste, der Spielraum soll hier die Mindest- und Maximilgröße sein.
-Wenn eine K verkleinert worden ist und eine zweite hinzugefügt wird, soll sie den restlichen freien Platz des Panels einnehmen.

 

[Michael...]

-Wenn das Panel leer ist und die erste K hinzugefügt wird, soll sie das ganze Panel ausfüllen

Das heisst der LayoutManager muss sich nicht an die Maximalgröße eine Komponente halten?
Kann diese Komponente dann über die Resizeleiste verkleinert werden?
Bzw. Kann es grundsätzlich vorkommen, dass das Containerpanel manchmal nicht komplett gefüllt ist?

-Wenn eine weitere K hinzugefügt wird, sollen sich alle das Panel teilen. Wenn der Platz für eine K kleiner ist als die Mindestgröße, soll ein Scrollbalken eingeführt werden und jede K hat ihre Mindestgröße.

Heisst: Wenn der sichtbare Ausschnitt der ScrollPane nicht mehr ausreicht um alle Komponenten in deren Mindestgröße darzustellen.

-Die Größe der K soll verändert werden können über die Resize-Leiste, der Spielraum soll hier die Mindest- und Maximilgröße sein.

Die anderen Komponenten behalten dabei ihre Größe bei?

-Wenn eine K verkleinert worden ist und eine zweite hinzugefügt wird, soll sie den restlichen freien Platz des Panels einnehmen.

Ist das die Antwort auf meine 2. und 3. Frage? (z.B. Panel ist leer. K1 wird eingefügt. K1 nimmt nun das komplette Panel ein. User verkleinert K1. K2 wird eingefügt. K1 bleibt in der Größe unverändert. K2 nimmt den noch freien Raum ein. Was ist wenn der Raum für K2 kleiner als dessen Mindestgröße ist?)
Ausserdem muss sich die Komponente merken, ob sie manuell in Ihrer Größe verändert wurde.

Wenn ich das so richtig überblicke, wird man da wohl um einen eigenen LayoutManager nicht herumkommen.

 

[Pumpkin]

So,

ich habe mir tatsächlich meinen eigenen Layoutmanager geschrieben und bin soweit auch zufrieden, das Verhalten ist so, wie ich es mir gewünscht habe.
Ein Problem habe ich dennoch:
Wenn eine Komponente sagen wir 800px von 1000px belegt und eine neue mit 300px hinzugefügt wird, werden 1100px von 1000px belegt.

Folgendermaßen wird die Position der Komponenten festgelegt:

for (Component com : parent.getComponents())
{
    com.setBounds(0, sizeAdded, width, heights.get(com));
    sizeAdded += heights.get(com);
}

Im o.g. Fall soll nun nach Hinzufügen der 300px-Komponente der Scrollbalken erscheinen, tut er aber nicht. Testweise lasse ich mir folgendes Ausgeben:

System.out.println(sizeAdded+" "+parent.getSize().getHeight());

Der Container hat immernoch die Größe 1000px, die Summe der Komponenten hat 1100px. Wenn ich über meine Resize-Leiste die Größe einzelner Komponenten verändere, ändern sich die Größen von Container und Komponente mit, jedoch ist die Gesamtgrößen der Komponenten nie gleich der Größe des Containers, der Container ist immer kleiner.
Ich habe folgendes versucht ganz am Ende von LayoutContainer() aufzurufen:

parent.setSize(width, sizeAdded);

Damit wollte ich, dass der Container immer an die Größe der Komponenten angepasst wird. Es entsteht aber eine Endlosschleife, weil die Methode setSize anscheinend nochmal LayoutContainer() aufruft.

Was kann ich tun?

 

[Michael...]

Welche Größe gibt's Du denn bei der

public Dimension preferredLayoutSize(Container parent)

des LayoutManagers zurück? Wenn hier die 1100 als bevorzugte Höhe angegeben werden, dann sollte die ScrollPane den Scrollbalken anzeigen. (glaube ich mich zu erinnern)

 

[Pumpkin]

Danke für den Hinweis, das war auch falsch. Der Ursprungsfehler war aber, dass ich kein

((JPanel) parent).revalidate();

gemacht habe.

Nun stehe ich aber vor dem nächsten Problem:
Ich möchte, dass man die Komponenten per Drag&Drop verschieben kann. Dazu will ich, dass die Komponente, die gerade verschoben wird vom Benutzer, immer oben ist, die anderen immer drunter.

Ich hatte vorher folgendes:

_componentPanel = new JPanel(MyOwnLayoutManager());
_scrollPane = new JScrollPane(_componentPanel);

Dies habe ich so abgeändert, dass ich ein Zwischenpanel habe, wo ich dann die Komponente zeichnen wollte, die gerade verschoben wird:

_componentPanel = new JPanel(MyOwnLayoutManager());
_movingPanel = new JPanel();
_movingPanel.add(_componentPanel);
_scrollPane = new JScrollPane(_movingPanel);

Nur irgendwie klappt es nicht so wie erhofft, es werden dann nämlich keine Komponenten mehr gezeichnet.

 

[Pumpkin]

Ok war nicht schwer, man kann es auch einfach mit

parent.setComponentZOrder(_componentBeingMoved, 0);

machen.