# CardLayout in BorderLayout?



## Cygan (5. Mrz 2012)

Schönen guten Abend!

Für ein Programm habe ich ein Borderlayout erstellt.
Dieses beinhaltet WEST und CENTER.

Im westlichen JPanel habe ich drei Buttons. Diese sollen immer da bleiben, egal, was im Programm passiert.

Im zentrierten JPanel "spielt sich alles ab". Je nach Aktion und Buttonklick soll sich das Center-Fenster öffnen.

Dementsprechend habe ich verschiedene JPanels, die alle als Ausgabewert ein Center ausgeben.
Nun könnte ich entsprechend je nach Aktion "setVisible(true/false)" je nach Wunsch einstellen, aber bei sehr vielen Fenstern würden sich da sehr viele Bedingungen ansammeln.

Meine Frage/Problem:

Ist ein CardLayout hierfür von Nutzen bzw. ist dies so umsetzbar, wie ich es mir vorstelle?
Ich habe bereits herumprobiert, weiß aber nicht wie ich die als Methoden definierte JPanels, die ich als CENTER zurückgebe, in einem CardLayout verpacke bzw. ob dies überhaupt möglich ist.

Ich habe z.B Folgendes:


```
public class Window {
.
.
.
   public Window() { 
        JFrame frame = new JFrame("Cocktail-Datenbank");
        frame.setLayout(new BorderLayout());
        frame.add(hinzufuegenPanel(), BorderLayout.CENTER);
   }

    private JPanel hinzufuegenPanel() {
                
        JPanel center = new JPanel();
        GroupLayout layout = new GroupLayout(center);
        center.setLayout(layout);
        layout.setAutoCreateGaps(true);
        layout.setAutoCreateContainerGaps(true);
        center.setVisible(false);
    .
    .
    .
        return center;
    }  

    public static void main( String[] args ) {
        new Window();
    }
```


Wie man sieht, hat mein Fenster ein Borderlayout mit einem Grouplayout im Center und alle Center-Panels will ich in einem CardLayout unterbringen und anschließend "durchblättern" können.

Ist dies möglich? Falls ja, wie?


----------



## vanny (5. Mrz 2012)

Zum ersten würde ich dir empfehlen, deine verschiedenen JPanel in eigene Klassen zu packen, welche von JPanel erben.
Ist IMHO für die Übersicht nützlich.

Das CardLayout ist ja genau dafür da, mehrere Cards zu halten und bei Bedarf anzuzeigen.
Den SubContainer mit dem CardLayout kannst du natürlich im Center deiner ContentPane oder wo auch immer hinzufügen.

Gruß Vanny

//EDIT: ups müsste natürlich Card 1 2 3 heissen ^^


----------



## SlaterB (5. Mrz 2012)

grundsätzlich gilt: eine GUI-Komponente, vom kleinsten Label bis zum größten CardLayout mit 100.000 Unterseiten, braucht sichtbaren Platz irgendwo,
ob du nun Center im BorderLayout meinst, oder danach noch von GroupLayout sprichst, etwas verstehen kann man da nur schwer, aber letzlich geht alles

sobald du einen Platz für CardLayout gefunden hast ist CardLayout selber dann ein Standard-Thema,
was soll man dazu sagen, Durchblättern und alles ist überall erklärt, wobei du hier selber das Durchblättern durch interne Steuerung oder Buttons oder ähnliches bauen müsstest,
willst du lieber JTabbedPane?

How to Use CardLayout (The Java™ Tutorials > Creating a GUI With JFC/Swing > Laying Out Components Within a Container)

How to Use Tabbed Panes (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)


----------



## Cygan (5. Mrz 2012)

Danke für die schnellen Antworten!

Ok nun weiß ich also, dass es möglich ist.

Soll ich sämtliche JPanels in EINE Klasse stecken oder soll ich die JPanels alle einzeln klassifizieren?

Ich habe bisher so gut wie immer mit einer einzigen Klasse für ALLES gearbeitet.
Ich würd aber gerne lernen, wie ich dann beispielsweise in meiner Klasse "Window" nun auf die JPanel-Klasse "JPanel-Klassenname" zugreifen kann.


----------



## SlaterB (5. Mrz 2012)

da gibt es nichts zu lernen, 
deine andere Klasse kann von JPanel erben oder ein solches als Attribut enthalten, welches abgefragt wird,
wie auch immer, ein Objekt der anderen Klasse ist zu erstellen, dessen JPanel abzuholen und irgendwo einzufügen


----------



## Camino (6. Mrz 2012)

Cygan hat gesagt.:


> Soll ich sämtliche JPanels in EINE Klasse stecken oder soll ich die JPanels alle einzeln klassifizieren?
> 
> Ich habe bisher so gut wie immer mit einer einzigen Klasse für ALLES gearbeitet.
> Ich würd aber gerne lernen, wie ich dann beispielsweise in meiner Klasse "Window" nun auf die JPanel-Klasse "JPanel-Klassenname" zugreifen kann.



Ich würde für jedes JPanel eine eigene Klasse erstellen und dann in der Klasse mit dem CardLayout die Objekte davon erstellen und dem CardLayout hinzufügen. Ist vielleicht übersichtlicher, vor allem wenn die JPanels dann umfangreicher werden.


----------



## Cygan (6. Mrz 2012)

Okay Danke. 
Wie ich sehe, hakt es grad bei mir bei der OOP.
Ich habe nun also meine Klasse "HinzufuegenPanel" mit folgendem Code:



```
public class HinzufuegenPanel extends JPanel {
    
    public JPanel hinzufuegenPanel() {
                
        JPanel center = new JPanel();
        GroupLayout layout = new GroupLayout(center);
        center.setLayout(layout);
        layout.setAutoCreateGaps(true);
        layout.setAutoCreateContainerGaps(true);
        center.setVisible(false);
        return center;
    }  

}
```


Meine Hauptklasse "Window" (Eigentlich wie oben bereits gepostet):

```
public class Window {
    ...
    private HinzufuegenPanel HinzufuegenPanel;
    ...
    public Window() { 
        JFrame frame = new JFrame("Cocktail-Datenbank");
        frame.setLayout(new BorderLayout());
        frame.add(HinzufuegenPanel.hinzufuegenPanel(), BorderLayout.CENTER); <--Fehlermeldung
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.setSize(800, 600);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);

    public static void main( String[] args ) {
        new Window(); <--Fehlermeldung
    }
}
```

Ich steht grad echt auf dem Schlauch...
Weiß momentan nicht, wie ich auf das JPanel "hinzufuegenPanel" der Klasse "hinzufuegenPanel" zugreifen kann.

Tut mir Leid, dass ich so ein Härtefall bin :bahnhof:



> Exception in thread "main" java.lang.NullPointerException
> at GUI.Window.<init>(Window.java:95)
> at GUI.Window.main(Window.java:230)


----------



## jgh (6. Mrz 2012)

deine hinzufuegen-Methode ist natürlich nicht static, also musst du erst ein Objekt davon erstellen.

[java=8]frame.add(new HinzufuegenPanel().hinzufuegenPanel(),
				BorderLayout.CENTER);[/code]


----------



## Cygan (6. Mrz 2012)

Wow danke es klappt! 

Eine Frage aus reiner Neugier:

Warum klappt das überhaupt?
Wieso brauch ich keine Getter/Setter etc, wie es eigentlich "üblich" wäre?


----------



## SlaterB (6. Mrz 2012)

die Methode hinzufuegenPanel() ist doch eine Art getter, gibt jedenfalls zurück,
ob nun 'get' im Methodennamen auftaucht kann nicht wichtig sein,
dass intern ein neues Objekt erzeugt wird statt ein Attribut ist für die Funktionalität auch kein strukturelles Hindernis

wenn die Klasse HinzufuegenPanel ein JPanel != this per Methode zurückgibt, dann besser NICHT von JPanel erben,
das kann dann doch gar keinen Vorteil,

und
> private HinzufuegenPanel HinzufuegenPanel;
ist ganz schrecklich, Variablen immer klein schreiben


----------



## Cygan (6. Mrz 2012)

Soooo...

Window-Klasse:


```
public class Window {
.
.
.
    public Window() { 
        JFrame frame = new JFrame("Cocktail-Datenbank");
        frame.setLayout(new BorderLayout());
        
        frame.getContentPane().add(BorderLayout.CENTER,new MainCards().mainCards());
        frame.add(new MainButtonPanel().mainButtonPanel(), BorderLayout.WEST);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.setSize(800, 600);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
   
    }

    public static void main( String[] args ) {
        new Window();
    }
}
```


```
package GUI;

import java.awt.BorderLayout;
import java.awt.CardLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class MainCards extends JFrame {
    
    private int currentCard = 1;
    private JPanel cardPanel;
    private CardLayout mainCards;
    
    public JPanel mainCards() {
        cardPanel = new JPanel();
        
        mainCards = new CardLayout();
        cardPanel.setLayout(mainCards);
        JPanel card1 = new HinzufuegenPanel();
        JPanel card2 = new AnzeigenPanel();
        JPanel card3 = new SuchenPanel();
        cardPanel.add(card1, "1");
        cardPanel.add(card2, "2");
        cardPanel.add(card3, "3");
        
        getContentPane().add(cardPanel, BorderLayout.CENTER);
        setVisible(true);
        return cardPanel;

    }

}
```

Habe nun wie angesprochen sämtliche Panels ausgelagert. Dies klappt auch soweit, wenn ich diese seperat aufrufen will in meinem Window.

Ich hab nun das CardLayout erstellt und ins Window eingefügt, es wird jedoch nicht angezeigt. Es ist komplett leer.


----------



## SlaterB (6. Mrz 2012)

du kannst nicht in Window ein normales JFrame erzeugen und gleichzeitig eine andere Klasse von JFrame erben lassen,
das sind doch garantiert zwei JFrames, schon liegt ohne Auswege eine unnötige Situation vor, 
die entweder (vorerst) nicht auffällt, oder gleich zum Fehler führt, wie bei dir der Fall

das JFrame aus Window wird angezeigt, das Panel der mainCards()-Methode fügst du aber in das MainCards-JFrame ein, welches nicht angezeigt wird, für die Katz,

stattdessen könntest du wie vorher die  mainCards()-Methode ein Panel zurückgeben lassen welches in Window in das dortige richtige JFrame eingefügt wird,
mit dem Aufbau wäre dann genau wie zuletzt angemerkt die Vererbung unnütz, 'extends JFrame' könnte gestrichen werden,

oder du bleibst bei 'extends JFrame', dann sollte das aber die Hauptklasse sein, nicht irgendwo noch 'new JFrame()'


----------



## Cygan (6. Mrz 2012)

Das mit "extends JFrame" war wohl ein Schreibfehler - Habs nun in "extends JPanel" geändert.

Deine zweite Aussage versteh ich nicht so recht.

JFrame aus Window wird angezeigt
Die mainCards()-Methode gibt cardPanel aus. cardPanel beinhaltet ja das CardLayout samt den hinzugefügten Karten.

In Windows greife ich über den Befehl drauf zu und übergebe doch das Panel oder nicht?

```
frame.getContentPane().add(BorderLayout.CENTER,new MainCards().mainCards());
```

In der mainCards()-Methode habe ich folgendes geändert.

```
getRootPane().add(cardPanel, BorderLayout.CENTER);
```

Ich greife auf die ursprüngliche Oberfläche zu und gebe ihr das cardPanel, das ich ja gleichzeitig als Übergabewert habe.

Ich versteh da nicht so recht, wo der Fehler steckt.


----------



## SlaterB (6. Mrz 2012)

ok, ich habe nur das neue JFrame gesehen, gar nicht auch den Rückgabewert,
wenn du beides drin hast ist das nicht noch komischer? welchen Sinn hat das für dich?

> Das mit "extends JFrame" war wohl ein Schreibfehler - Habs nun in "extends JPanel" geändert.
warum überhaupt erben? beides unnötig,
für jede Codezeile bzw. wichtigen Bestandteil die Frage stellen ob er seinen Nutzen hat

der Fehler könnte hier die Reihenfolge sein
> frame.getContentPane().add(BorderLayout.CENTER,new MainCards().mainCards());
das CENTER erst als zweites Argument? werde ich morgen testen,
natürlich nicht sehr schön dass der Compiler überhaupt beide Varianten akzeptiert

wenn du direkt hintereinander

```
frame.getContentPane().add(BorderLayout.CENTER,new MainCards().mainCards());
frame.add(new MainButtonPanel().mainButtonPanel(), BorderLayout.WEST);
```
stehen hast, müsste dir die Ungleichheit der Parameter doch auffallen,
vom einfachen add() gegenüber getContentPane().add() ganz zu schweigen, 
nimmst du all diese Kuriositäten in deinem Code ungefragt hin?


----------



## vanny (6. Mrz 2012)

Also funktional macht es zumindest bei der add(); im JFrame keinen Unterschied ob getContentPane();
benutzt wird oder nicht. Man sollte sich aus Gründen der Lesbarkeit aber für eine Variante entscheiden.

Die Positionierungsangabe im BorderLayout kann sowohl als erster als auch als zweiter Parameter übergeben werden. Auch hier bitte nur eine Variante.

Wie aber schon erwähnt solltest du dir wirklich mal Gedanken machen, was du das eigentlich basteln willst.
Wie Mr. B schon sagte und es auch in meiner kleinen Grafik zu sehen ist, sollte das CardLayout als Layout eines JPanels (eine Art SubPanel(also UnterPanel))gesetzt sein. 
Dann wird nur dieses SubPanel im Center der ContentPane deines *einen* und einzigen JFrames per add(BorderLayout.CENTER, subPanel); zugefügt und fertig.

Gruß Vanny


----------



## Cygan (11. Mrz 2012)

vanny hat gesagt.:


> Wie Mr. B schon sagte und es auch in meiner kleinen Grafik zu sehen ist, sollte das CardLayout als Layout eines JPanels (eine Art SubPanel(also UnterPanel))gesetzt sein.
> Dann wird nur dieses SubPanel im Center der ContentPane deines *einen* und einzigen JFrames per add(BorderLayout.CENTER, subPanel); zugefügt und fertig.



Habe versucht mich meiner Meinung nach an die Grafik gehalten, aber weiter komm ich einfach nicht .
Ich wette die Lösung ist so einfach, dass ich am Schluss mit dem Kopf gegen die Wand haue und mir denke, wie blöd ich doch eigentlich bin :bloed:


```
public Window() { 
        frame.setLayout(new BorderLayout());    
        frame.add(new MainCards().mainCards(),BorderLayout.CENTER);
        frame.add(new MainButtonPanel().mainButtonPanel(), BorderLayout.WEST);
    }
```


```
package GUI;

import java.awt.BorderLayout;
import java.awt.CardLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class MainCards extends JPanel {
    
    private int currentCard = 1;
    private JPanel cardPanel;
    private CardLayout mainCards;
    
    public JPanel mainCards() {
        cardPanel = new JPanel();
        
        mainCards = new CardLayout();
        cardPanel.setLayout(mainCards);
        JPanel card1 = new HinzufuegenPanel();
        JPanel card2 = new AnzeigenPanel();
        JPanel card3 = new SuchenPanel();
        cardPanel.add(card1, "1");
        cardPanel.add(card2, "2");
        cardPanel.add(card3, "3");
        
        setVisible(true);
        return cardPanel;

    }

}
```

Ich weiß einfach wirklich nicht weiter


----------



## SlaterB (11. Mrz 2012)

was funktioniert denn aktuell nicht?
du postest auch unvollständigen Code, oder hast du alles zum JFrame, wie früher,


```
frame.setResizable(false);
        frame.setSize(800, 600);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
```
nun nicht mehr? 
wenn an andere Stelle verschoben, dann ist das wert gepostet zu werden,
wenn entfernt dann Erklärung nötig oder oder oder

unnötig dagegen sind 
- Sätze wie 'Ich weiß einfach wirklich nicht weiter'  aber gut wenn es das Posting abrundet..
- setVisible(true) auf ein JPanel in 99% aller Fälle


----------



## bERt0r (11. Mrz 2012)

Die Benennung deiner Variablen ist auch nicht grade toll. Eine Klasse MainCards, die ein JPanel ist, eine Variable mainCards in der Klasse, die ein CardLayout ist und eine Variable cardPanel die auch ein JPanel ist.
Dann noch eine Funktion mainCards, die ein JPanel zurückgibt und das cardPanel belegt.

Wenn du in deiner Haupt GUI new MainCards() schreibst, dann wird deine Funktion mainCards nicht ausgeführt.


----------



## Cygan (11. Mrz 2012)

@SLaterB: Ich habs nur hier im Forum auf das reduziert, was für das CardLayout wichtig ist bzw für die Implementierung. In meine mCode sind diese Sachen noch selbstverständlich drin. Das andere ist auch noch drin, wie in den Posts zuvor. Es immer und immer wieder zu posten wollte ich nicht, um den Thread nicht unnötig in die Länge zu ziehen.

Das Problem ist: Es kommt keine Fehlermeldung, aber in meinem Center-Panel wird einfach nix angezeigt. Es ist komplett leer.

@bERt0r: Okay die Benennung kann ich ändern. Ändert dies dann aber auch die Funktionalität? Ich wäre ja heilfroh, wenns Hauptsache erstmal laufen würde 

Habs es nun so geändert und CardLayout und JPanel voneinander getrennt:


```
package GUI;

import java.awt.BorderLayout;
import java.awt.CardLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class MainCards extends JPanel {
    
    private int currentCard = 1;
    private JPanel cardPanel;
    private CardLayout mainCards;
    
    public CardLayout mainCards() {
        mainCards = new CardLayout();
        setVisible(true);
        return mainCards;
    }

    
    public JPanel cardPanel() {
        cardPanel = new JPanel();       
        cardPanel.setLayout(mainCards);
        JPanel card1 = new HinzufuegenPanel();
        JPanel card2 = new AnzeigenPanel();
        JPanel card3 = new SuchenPanel();
        cardPanel.add(card1, "1");
        cardPanel.add(card2, "2");
        cardPanel.add(card3, "3");
        setVisible(true);
        return cardPanel;
    }
    
}
```

Ich erstelle das CardLayout und gebe es als Übergabewert an cardPanel.
cardPanel benutzt das Cardlayout als sein Eigenes.
Das cardPanel wird dann zurückgegeben und in Window aufgerufen.

Es ist jedoch ohne Fehlermeldung nachwievor alles leer.

Und um meinen Post nochmals abzurunden:

Danke für die Geduld, die ihr mir gegenüber aufbringt und mich nicht als hoffnungslosen Fall abstempelt.


----------



## Camino (11. Mrz 2012)

Warum so kompliziert?

```
public class MainPanel extends JPanel {
    
    private CardLayout cardLayout;
    
    public MainPanel() {

        cardLayout = new CardLayout();
        setLayout(cardLayout);

        JPanel panel1 = new JPanel();
        JPanel panel2 = new JPanel();
        JPanel panel3 = new JPanel();
        JPanel panel4 = new JPanel();

        add(panel1, "Panel 1");
        add(panel2, "Panel 2");
        add(panel3, "Panel 3");
        add(panel4, "Panel 4");
    }

}
```
Das erste Panel liegt dann zu Beginn automatisch ganz oben und ist sichtbar. Die anderen Panel im CardLayout kannst du dann mit dieser Methode anzeigen lassen: 
	
	
	
	





```
cardLayout.show(Container parent, String name);
```


----------



## Cygan (11. Mrz 2012)

Muss ich denn nix aus der Klasse herausgeben?


----------



## Camino (11. Mrz 2012)

Keine Ahnung, was du damit meinst. Aber eigentlich setzt du das CardLayout bei dem MainPanel und fügst dort deine Cards (weitere Panels) hinzu. Du musst dann halt eine öffentliche Methode haben, um von ausserhalb die gewünschten Cards setzen zu können.


----------



## Cygan (11. Mrz 2012)

das mein ich ja. du hast kein "return" in der Methode, hat mich verwirrt.


----------



## Camino (11. Mrz 2012)

Welche Methode? Für das CardLayout oder die Panels brauchst du kein "return", die kannst du ja direkt in deinem MainPanel setzen und hinzufügen. Um dann deine Cards aufzurufen (anzeigen zu lassen) brauchst du dann in deiner Klasse MainPanel eine Methode, die du von ausserhalb des MainPanels aufrufen kannst, so z.B.:

```
public void setCards(String cardname) {
		cardLayout.show(this, cardname);
	}
```

Dazu brauchst du dann aber auch auserhalb eine Referenz auf das MainPanel und kannst das dann z.B. so aufrufen/setzen: 
	
	
	
	





```
mainPanel.setCards("Panel 1");
```


----------



## Cygan (11. Mrz 2012)

Auf diese Methode wäre ich nie im Leben gekommen.

Ich habe die MainPanel-Klasse nun so, wie du geschildert hast und ich versuche nun in meiner Window-Klasse das Panel 1 aufzurufen.


```
package GUI;


public class Window {
...
    public Window() { 
        JFrame frame = new JFrame("abc");
        frame.setLayout(new BorderLayout());
        
        frame.add(new MainPanel().setCards("Panel 1"),BorderLayout.CENTER);
        frame.add(new MainButtonPanel().mainButtonPanel(), BorderLayout.WEST);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.setSize(800, 600);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        
    }
 
    public static void main( String[] args ) {
        new Window();
    }
}
```

Ich versuche nun das Panel an mein Frame zu übergeben.


```
frame.add(new MainPanel().setCards("Panel 1"),BorderLayout.CENTER);
```

"add" ist unterstrichen und sagt: 
	
	
	
	





```
The method add(String, Component) in the type Container is not applicable for the arguments (void, String)
```


----------



## Camino (11. Mrz 2012)

Du musst deinem Frame auch erstmal nur das MainPanel übergeben:

```
frame.add(new MainPanel(), BorderLayout.CENTER);
```
Dann musst du dort, wo du steuerst, welches Panel in dem CardLayout denn nun angezeigt werden soll, die Methode im MainPanel aufrufen.
Möglich wäre z.B. so etwas:

```
...
MainPanel mainPanel = new MainPanel();
frame.add(mainPanel, BorderLayout.CENTER);
...
mainPanel.setCards("Panel 3");
...
```


----------



## Cygan (11. Mrz 2012)

So mit einer letzten Hilfe von EikeB im Chat klappt es nun endlich!

Es wird mit den Fuktionen der "Factory" alles angezeigt.
Da dies aber noch einfacher geht werd ich nun versuchen das ohne Factory zu machen.

Ich danke euch allen für die großartige, geduldige, aktive und kompetente Hilfe.

Ihr seid einfach klasse!


----------



## vanny (11. Mrz 2012)

Vielleicht noch etwas zur Namensgebung deiner Klassen.
"Window" ist eine schlechte Wahl für deine Klasse, die den JFrame instanziert, da es in AWT schon eine Klasse mit diesem Namen gibt.
Benutze lieber einen völlig eigenen Namen, wie MeinFrame o.ä.

Gruß Vanny


----------



## core_85 (22. Mai 2012)

hallo,

hab auch so ein Ansatz verfolgt wo es ganz gut geklappt hat, nur allerding treten hier 2 Probleme auf zum 
1. werden die cards net richtig durchgezählt 
2. kann ich bliebig swing componenten auf die cards setzen  bzw farbe ändern 6 buttons erzeugen ..

evtl. jem der weiterhelfen kann ?  


```
package borderlayout;

import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;




public class borderlayout extends JFrame {
	
    private int currentCard = 1;
   // private JPanel CardPanel;
	
 public  borderlayout() {
	 
	//super( borderlayout.class.getName());  
	 
	 getContentPane().setLayout(new BorderLayout());
	 //JFrame f1 = new JFrame();
	 
   /* Panels im Hauptfenster*/
   
   final JPanel p1 = new JPanel();
   final JPanel p2 = new JPanel();
   final JPanel p3 = new JPanel();
   final JPanel p4 = new JPanel();
   final JPanel p5 = new JPanel();
   
   
   getContentPane().add(p1, BorderLayout.NORTH);
   getContentPane().add(p2, BorderLayout.WEST);
   getContentPane().add(p3, BorderLayout.EAST);
   getContentPane().add(p4, BorderLayout.SOUTH);
   getContentPane().add(p5, BorderLayout.CENTER);
  // getContentPane().add(c1, BorderLayout.CENTER);
   
   
   JLabel l1 = new JLabel("Ich bin eine Überschrift im Norden");
   p1.add(l1);
   p1.setBackground(Color.gray);
   
   /* Panel im Westen p2*/
  
   p2.setPreferredSize(new Dimension(250,0));
   p2.setBackground(Color.LIGHT_GRAY);
   
   /* Panel im Osten p3*/
   
   p3.setBackground(Color.lightGray);
   p3.setPreferredSize(new Dimension(250,0));
   p3.setBackground(Color.LIGHT_GRAY);
   
   /* Panel im Süden p4*/
   
   /* Buttons zum weiterschalten*/
   final JButton go = new JButton("<<");
   final JButton back = new JButton(">>");
      
   p4.add(go);
   p4.add(back);
   p4.setBackground(Color.gray);
   
   // CardLayout in Westen gelegt 
   
   final CardLayout c1 = new CardLayout();
   p5.setLayout(c1);
   
   // c1.setHgap(20); Abstand der Objekte horizonatl
   // c1.setVgap(20); Abstand der objekte vertikal

  // p2.setLayout(new GridLayout(0,1));
   
   JButton b1 = new JButton("test1");
   //p2.add(b1, "test");
   
   JButton b2 = new JButton("test2");
   //p2.add(b2, "test1");
   
   
   for(int i=0;i<10;i++){
	   
	   p5.add(new JTextArea("Karte " + i), "" + i);
	  //p2.setBackground(Color.BLUE);
	  // p2.add(new JTextArea("Karte2" + i++), "" + i);
	  // p2.add(new JButton("sd"));
   }
   
   
   
   /***********************************************************************/
   
   /* Panel im Zentrum p5*/
   
   JLabel l2 = new JLabel("Ich bin eine Überschrift im Zentrum");
   p5.add(l2, "");
   
   p5.setBackground(Color.LIGHT_GRAY);
   //p5.setLayout(new GridLayout(0,1,20,15));
   
//   FlowLayout layout = new FlowLayout(FlowLayout.LEFT);
//   p5.setLayout(layout);
   
      
   
  								 /*Logic*/											
     
   
   back.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent arg0) {
      
    	   
      try
         {
    	  back.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent arg0) {
                      if (currentCard < 10) {
                              currentCard += 1;
                              c1.show(p5, "" + (currentCard));
                      }
              }
      });}

      catch(Exception se)
         {
          System.out.println( "Fehler:" + se) ;
       }
       }});

   		
   go.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent arg0) {
      
    	   
      try
         {
    	  go.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent arg0) {
                      if (currentCard > 1) {
                              currentCard -= 1;
                              c1.show(p5, "" + (currentCard));
                      }
              }
      });}
      

      catch(Exception se)
         {
          System.out.println( "Fehler:" + se) ;
       }
       }});
   
   
   

   // Größe setzen (oder pack() aufrufen)
   setSize(1000, 700);
   setLocationRelativeTo(null);
   setVisible(true);
   
 }

 public static void main(String[] argv) {
   new  borderlayout();
 }
}
```


----------



## SlaterB (22. Mai 2012)

1.
kommt mir bekannt vor, auch Programm-Design mit den Buttons an sich, 
du fügst neue Listener hinzu, entfernst aber nicht die alten, so wirken bald mehrere Listener gleichzeitig auf einen Button-Klick

2.
inwiefern ist diese Standard-Funktionalität ein Problem?
ich sehe allerdings auch keinen Code in deinem Programm der etwa zur Laufzeit das Hinzufügen von Komponenten ermöglicht,
noch weniger Code der das manuell verhindert

oder ist deine Frage wie das zu bewerkstelligen ist? ziemlich allgemein..


----------



## core_85 (22. Mai 2012)

hallo,

naja das Problem ist einfach das ich das CardLayout im BorderLayout nutzen kann. Also will auf "card1" 6 buttons erzeugen dann weiterklicken dann "card 2" wieder swing komponeten draufsetzen. Frage ist ob das so überhaupt möglich ist. hatte ma zum spass das Panel 5 wo ist das card layout drauf ist. mit p5.add(new Button("hallo"),""); ein button erzeugen wollen nix passierte...


----------



## SlaterB (22. Mai 2012)

> p5.add(new Button("hallo"),"");

funktioniert bei mir (mit JButton) wenn dann auch irgendwann jemand
> c1.show(p5, "" );
aufruft,
besser aber keine leeren Namen verwenden..

----

bedenke die Möglichkeit, neue Panel in das CardLayout als Seiten zu setzen,
dann kannst du in diesen Paneln, pro Seite also, beliebig viele Komponenten anordnen


----------



## core_85 (22. Mai 2012)

mhhh bei mir passiert da nix ...

>bedenke die Möglichkeit, neue Panel in das CardLayout als Seiten zu setzen,
dann kannst du in diesen Paneln, pro Seite also, beliebig viele Komponenten anordnen 

das war das ziel was ich habe , wie sollte das codetechnisch aussehen ???:L .. steh etwas auf dem schlauch gerade


----------



## SlaterB (22. Mai 2012)

> mhhh bei mir passiert da nix ...
poste Code wenn du dazu noch was klären willst

----

JPanel erstellen, z.B. an Stelle der TextArea oder des Buttons einfügen, 
nachher oder besser vorher befüllen, Rest gleich


----------



## core_85 (22. Mai 2012)

super hab es gecheckt jetzt geht alles


----------



## core_85 (22. Mai 2012)

sry muss noch ma nerven die button 1-6 werden richtig dargestelllt aber wenn ich auf weiter klicke, sollen die nächsten buttons 6-11 auf der nächsten card abgebildet werden ... da kommt nur das leer cardlayout 

```
package borderlayout;

import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;




public class borderlayout extends JFrame {
	
    private int currentCard = 1;
   // private JPanel CardPanel;
	
 public  borderlayout() {
	 
	//super( borderlayout.class.getName());  
	 
	 getContentPane().setLayout(new BorderLayout());
	 //JFrame f1 = new JFrame();
	 
   /* Panels im Hauptfenster*/
   
   final JPanel p1 = new JPanel();
   final JPanel p2 = new JPanel();
   final JPanel p3 = new JPanel();
   final JPanel p4 = new JPanel();
   final JPanel p5 = new JPanel();
   
   
   getContentPane().add(p1, BorderLayout.NORTH);
   getContentPane().add(p2, BorderLayout.WEST);
   getContentPane().add(p3, BorderLayout.EAST);
   getContentPane().add(p4, BorderLayout.SOUTH);
   getContentPane().add(p5, BorderLayout.CENTER);
  // getContentPane().add(c1, BorderLayout.CENTER);
   
   
   JLabel l1 = new JLabel("Ich bin eine Überschrift im Norden");
   p1.add(l1);
   p1.setBackground(Color.gray);
   
   /* Panel im Westen p2*/
  
   p2.setPreferredSize(new Dimension(250,0));
   p2.setBackground(Color.LIGHT_GRAY);
   
   /* Panel im Osten p3*/
   
   p3.setBackground(Color.lightGray);
   p3.setPreferredSize(new Dimension(250,0));
   p3.setBackground(Color.LIGHT_GRAY);
   
   /* Panel im Süden p4*/
   
   /* Buttons zum weiterschalten*/
   final JButton go = new JButton("<<");
   final JButton back = new JButton(">>");
      
   p4.add(go);
   p4.add(back);
   p4.setBackground(Color.gray);
  
   // Zentral Panel gelegt    
   
   final CardLayout c1 = new CardLayout();
   p5.setLayout(c1);
   
   // cardPanel == p5
   
   setTitle("dum di dum");   
   c1.setHgap(20); 
   c1.setVgap(20); 

   //c1.show(p5, "test");
   
   final JPanel pt1 = new JPanel();
   final JPanel pt2 = new JPanel();
   final JPanel pt3 = new JPanel();
   final JPanel pt4 = new JPanel();
   final JPanel pt5 = new JPanel();
   final JPanel pt6 = new JPanel();
   final JPanel pt7 = new JPanel();
   final JPanel pt8 = new JPanel();
   final JPanel pt9 = new JPanel();
   final JPanel pt10 = new JPanel();
      
   
   p5.add(pt1,"");
   p5.add(pt2,"");
   p5.add(pt3,"");
   p5.add(pt4,"");
   p5.add(pt5,"");
   p5.add(pt6,"");
   p5.add(pt7,"");
   p5.add(pt8,"");
   p5.add(pt9,"");
   p5.add(pt10,"");
     
   // soll auf "card 0" gesetzt werden 
   pt1.setBackground(Color.LIGHT_GRAY);
   pt1.setLayout(new GridLayout(0,1,20,20));
   pt1.add(new JButton("Button1"),"");
   pt1.add(new JButton("Button2"),"");
   pt1.add(new JButton("Button3"),"");
   pt1.add(new JButton("Button4"),"");
   pt1.add(new JButton("Button5"),"");
   pt1.add(new JButton("Button6"),"");
      
  
   // soll auf "card 1" gesetzt werden
   pt2.setBackground(Color.LIGHT_GRAY);
   pt2.setLayout(new GridLayout(0,1,20,20));
   pt2.add(new JButton("Button7"),"");
   pt2.add(new JButton("Button8"),"");
   pt2.add(new JButton("Button9"),"");
   pt2.add(new JButton("Button10"),"");
   pt2.add(new JButton("Button11"),"");
   pt2.add(new JButton("Button12"),"");
   
   
      
   for(int i=0 ;i <= 10; i++){
	   
	   p5.add(new JTextArea("Karte " + i), "" + i); 
	  
   }
   
   /***********************************************************************/
   
   /* Panel im Zentrum p5*/
   
   JLabel l2 = new JLabel("Ich bin eine Überschrift im Zentrum");
   p5.add(l2, "");
   
   p5.setBackground(Color.LIGHT_GRAY);
   //p5.setLayout(new GridLayout(0,1,20,15));
   
   
//   FlowLayout layout = new FlowLayout(FlowLayout.LEFT);
//   p5.setLayout(layout);
   
      
   
  /******************************************************************************************/ 
  /*										Logic											*/
  /******************************************************************************************/
   
   
   back.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent arg0) {
      
    	   
      try
         {
    	  back.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent arg0) {
                      if (currentCard <= 10) {
                              currentCard += 1;
                              c1.show(p5, "" + (currentCard));
                              
                          
                              
                      }
              }
      });}

      catch(Exception se)
         {
          System.out.println( "Fehler:" + se) ;
       }
       }});

   		
   go.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent arg0) {
      
    	   
      try
         {
    	  go.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent arg0) {
                      if (currentCard >= 0) {
                              currentCard -= 1;
                              c1.show(p5, "" + (currentCard));
                      }
              }
      });}
      

      catch(Exception se)
         {
          System.out.println( "Fehler:" + se) ;
       }
       }});
   
   /******************************************************************************************/ 
   /*									end of Logic											*/
   /******************************************************************************************/
   

   // Größe setzen (oder pack() aufrufen)
   setSize(1000, 700);
   setLocationRelativeTo(null);
   setVisible(true);
   
 }

 public static void main(String[] argv) {
   new  borderlayout();
 }
}
```


----------



## SlaterB (22. Mai 2012)

> da kommt nur das leer cardlayout
was ist ein 'leer cardlayout'?

was auf dem Button-Klick folgt ist anhand des Codes zweifelsfrei zu erkennen,
der erste Button-Klick macht nichts weiter als einen zweiten ActionListener zu adden, das erste CardPanel mit 6 Buttons bleibt zu sehen,

bei weiteren Button-Klicks werden wie früher schon angemerkt nun mehrere ActionListener aktiv,
was ziemlich fraglich wird,
es wird ein weiterer Listener geadded und einen von diesen zeigt dann die TextArea currentCard, so hast du es programmiert,

wenn du Code willst, der ein anderes 6 Button-Panel im CardLayout zeigt, dann musst du das auch programmieren,
und frag jetzt nicht einfach nur 'wie geht das?'..

dass du alle 6 Button-Panel mit demselben Key "" in das CardLayout einfügst, wird das vorerst ziemlich unmöglich machen,



für die Buttons in pt1 im GridLayout kannst du dir beim add das "" auf jeden Fall sparen, keine Funktion,
bedenklich wenn du anscheinend einfach nur Code kopierst..


----------

