Button-Array überschreiben und dem Container zufügen?

[Guest]

Hoffe mal das ist hier richtig..

Folgendes: Habe ein Button-Array auf das von einigen Stellen und Klassen aus zugegriffen wird und will es mit einem neuen, benutzerdefinierten Array ueberschreiben. Die neuen Buttons sollen dann natuerlich auch angezeigt werden, wogegen die alten geloescht werden sollen. Jede Methode, die zuvor das erste Array aufgerufen hat, soll nun das zweite Aufrufen.


Etwas detaillierter als Beispiel:

Das zurzeit existierende Button-Array[3][3] enthaelt 9 Buttons, die quadratisch im Container angeordnet sind, also auch angezeigt werden. Nun soll der Benutzer die Wahl haben die Anzahl der Buttons innerhalb dieses Quadrats beliebig zu verkleinern oder zu vergroeßern. Es soll nur die Seitenlaenge (in Buttons) waehlbar sein.
Wenn also der Benutzer eine Seitenlaenge von 5 eingibt, dann soll das vorhandene Array[3][3] mit einem Array[5][5] überschrieben werden. Alle 25 Buttons des Arrays[5][5] sollen dann im Container im selben Quadrat angeordnet werden.
Das ganze soll auch von z.B. Array[5][5] auf Array[3][3] funktionieren, wobei wichtig ist, dass die Groeße nicht nur "simuliert" ist, also dass das Array[3][3] bei einem Aufruf mit z.B. [4][5] eine OutOfBoundsException liefert.
Zusaetzlich existieren Methoden, die die Eigenschaften der Buttons je nach geklicktem Button aendern (z.b. das Icon). Das heißt, dass das neue Array den selben Namen haben muss wie das vorherige, sonst wuerden die Aufrufe ja ins Leere gehn. Das vorherige Array soll also ueberschrieben werden.


Mein Problem ist nun hauptsaechlich, dass ich außerhalb der Initialisierung der Komponenten meinem Container mit container.add(Objekt); nichts mehr hinzufuegen kann. Ich kann zwar das Array in einer Methode ueberschreiben, kann aber in der Methode nicht die Buttons zum Container hinzufuegen.

Habe es bisher sogemacht

private JButton[][] oldarray = new JButton[oldsize][oldsize];

void resize() {
  JButton[][] newarray = new JButton[newsize][newsize];
  oldarray = newarray;
  for( i , j <newsize) {
    oldarray[i][j] = new JButton();
    ...
  }
}

Dann hab ich zwar ein Array mit neuer Groeße und dem selben Namen, kann aber die ganzen Buttons nicht anzeigen.
Gibt es nicht irgendwie eine moeglichkeit innerhalb des Programmablaufs Swing Ojekte zum Container hinzuzufuegen?
Keine Ahnung wie ich das sonst bewerkstelligen sollte..

 

[Marco13]

Das use-case ist jetzt nicht 100% klar. Falls irgendjemand (unschönerweise) eine echte Referenz auf das Array hat, wird das sowieso problematisch. Eine Möglichkeit wäre vielleicht eine Klasse der Art

class ButtonArray
{
    private Container container;
    private JButton array[][] = null;

    public ButtonArray(Container container, int sizeX, int sizeX)
    {
        this.container = container;
        resize(sizeX, sizeY);
    }

    public void resize(int sizeX, int sizeY)
    {
        if (array != null)
        {
            for (int x=0; x<array.length; x++)
            {
                for (int y=0; y<array[x].length; y++)
                {
                    container.remove(array[x][y];
                }
            }
        }
        array = new JButton[sizeX][sizeY];
        for (int x=0; x<array.length; x++)
        {
            array[x] = new JButton[sizeY];
            for (int y=0; y<array[x].length; y++)
            {
                array[x][y] = new JButton();
                container.add(array[x][y];
            }
        }
        container.validate();
    }
}

also die Funktionalität zu "kapseln" und den entsprechenden Container zu speichern, aber das ist nur der erste Gedanke - ob das für deinen Fall passt (oder ob man es vielleicht "aufbohren" sollte, zu etwas was (noch allgemeiner) mit Listenern arbeitet), musst du wissen....

 

[Zed]

Das Probelem was ich sehe ist wenn du die Buttons aus dem Array das erste mal ins Frame hinzugefügt hast dann wird eine referenz des Objectes im Frame gehalten und durch die wird auch dann das element dargestellt.

Überschreibst du das Array dann existieren die alten Objecte weiter und werden nicht vom GC gelöscht weil es noch im Frame referenzen gibt.

Um das zu realisieren würde ich die Buttons in einem unabhängigen Panel darstellen. Wenn du neu Buttons erstellen möchtet, musst du die alten Buttons aus dem Panel entfernen und die neuen Buttons hinzufügen. Der nächte Schritt wäre ein Repaint des Panels zu erzwingen um den neuen Content sichtbar zu machen.

Um das Panel sicher zu bekommen ist eine Lazy-Initialisierung das beste

public getButtonPanel(){
if (buttonPanel == null){
buttonPanel = new JPanel();

}
return buttonPanel;

buttonPanel.removeAll() entfernt alle Componenten mit add must du nurnoch die neunen hinzufügen und ein buttonPanel.repaint() ausführen um die Oberfläche zu aktuallisieren

Edit:
Zur laufzeit validate() nicht repaint