Swing Variable Elemente für GroupLayout

[Gerald]

Hallo Ihr Experten!
Auf einem Frame lasse ich farbige Rechtecke (zu x Spalten und y Zeilen )
anzeigen (JPanel). Das funktioniert einwandfrei.

      GroupLayout layout = new GroupLayout(p);
      p.setLayout(layout);

      JPanel p1 = new JPanel();
      JPanel p2 = new JPanel();
      ...
      p1.setBackground(new java.awt.Color(255, 0, 0));
      p2.setBack ...

      SequentialGroup verticalGroup = layout.createSequentialGroup();
      verticalGroup.addGroup(layout.createParallelGroup())
                            .addComponent(p1)
                            .addComponent(p2)
                            ...
      ParallelGroup horizontalGroup = layout.createParallelGroup();
      horizontalGroup.addGroup(layout.createSequentialGroup()
                            .addComponent(p1)
                            .addComponent(p2)
                            ...
      layout.setVerticalGroup(verticalGroup);
      layout.setHorizontalGroup(horizontalGroup);
      ...

Nun will soll aber die Anzahl Spalten und Zeilen beliebig wählbar sein (Abfrage
vor Rechteckanzeige).
Verschiedenes habe ich probiert, bin aber zu keinem brauchbaren Ergebnis
gekommen.

Folgendes ist keine Lösung:
horizontalGroup.addGroup(layout.createSequentialGroup());
horizontalGroup.addComponent(p1);
horizontalGroup.addComponent(p2);
...
Das auch nicht:
horizontalGroup.addGroup(layout.createSequentialGroup().addComponent(p1));
horizontalGroup.addGroup(layout.createSequentialGroup().addComponent(p2));
...
Das wohl auch nicht:
layout.addLayoutComponent("p1", p1);
layout.addLayoutComponent("p2", p2); ...

Wie kann man beliebig viele Elemente (in einer Schleife [Array, Zähler]) zu
einer Gruppe hinzufügen? Wie kann ich Elemente "addieren"?

Im Java-Forum habe ich (noch) keine Antwort gefunden. Das Problem ist aber wohl
kein allzu großes.?

Im Voraus vielen Dank für "Eure" Bemühungen!
Mit freundlichen Grüßen
Gerald

 

[mihe7]

Wenn Dein Code oben funktioniert, dann würde ich spontan sagen:

ParallelGroup verticalSubGroup = layout.createParallelGroup();
SequentialGroup horizontalSubGroup = layout.createSequentialGroup();
for (JPanel p : panels) {
    verticalSubGroup.add(p);
    horizontalSubGroup.add(p);
}
verticalGroup.addGroup(verticalSubGroup);
horizontalGroup.addGroup(horizontalSubGroup);

 

[Gerald]

Hallo mihe7,
danke für Deine Antwort. Aber leider funktioniert es nicht.
"verticalSubGroup.add(p1);" wird nicht angenommen, meine Entwicklungsumgebung bemängelt es als Fehler.
Es wird nur "addComponent" und "addGroup" angenommen.

Ich sollte wohl für die Interessierten noch ein wenig ausführlicher sein.
Die Aufgabe besteht darin, daß "addComponent" immer separat in einer einzigen Quelltextzeile notiert werden soll. (Ja, so wie es mihe7 gemacht hat.)
Etwa so:

      horizontalGroup.addGroup(layout.createSequentialGroup());
      for (int i; i < 10; i++) {
          ???.addComponent(p[i]);
    }

An welches Code-Schnipselchen sollte ich "addComponent(?)" ranhängen? An "...addGroup" muß ausfallen, da sonst immer noch eine neue Gruppe erstellt würde, oder nicht?
Man bräuchte so etwas wie "getGroup".
Oder man hängt es an "layout...", aber wie?

 

[mihe7]

Es wird nur "addComponent"

Sorry, muss addComponent heißen:

ParallelGroup verticalSubGroup = layout.createParallelGroup();
SequentialGroup horizontalSubGroup = layout.createSequentialGroup();
for (JPanel p : panels) {
    verticalSubGroup.addComponent(p);
    horizontalSubGroup.addComponent(p);
}
verticalGroup.addGroup(verticalSubGroup);
horizontalGroup.addGroup(horizontalSubGroup);

 

[Gerald]

Hallo mihe7.
Es funktioniert (noch) nicht. In Deiner "for"-Schleife wird jedes JPanel sowohl der verticalSubGroup als auch der horizontalSubGroup zugeordnet. Detailproblem: Ich wollte mit Array in der Schleife arbeiten. Deinen Vorschlag verstehe ich nicht ganz (,habe mich bis jetzt davor gedrückt). Was ist für "panels" zu notieren (irgendeine Liste?)?

 

[Gerald]

Mal abgesehen von der Frage zu "panels", müßte es doch auch so funktionieren:

verticalSubGroup.addComponent(p1).addComponent(p2);
horizontalSubGroup.addComponent(p1).addComponent(p2);

... sofern p1 und p2 vorher vereinbart wurden?

 

[mihe7]

In Deiner "for"-Schleife wird jedes JPanel sowohl der verticalSubGroup als auch der horizontalSubGroup zugeordnet.

Ja, das hab ich von Dir übernommen (s. Dein ersten Post):

layout.createParallelGroup())
                            .addComponent(p1)
                            .addComponent(p2)
layout.createSequentialGroup()
                            .addComponent(p1)
                            .addComponent(p2)[/QUOTE]

Wobei ich gerade sehe, dass Du im ersten Fall nicht zu layout.createParallelGroup() hinzufügst sondern zur verticalGroup.

Neuer Versuch (sorry, ich schreibe das nur hier nebenbei rein, da übersehe ich leicht was):

verticalGroup.addGroup(layout.createParallelGroup());
SequentialGroup horizontalSubGroup = layout.createSequentialGroup();
for (JPanel p : panels) {
    verticalGroup.addComponent(p);
    horizontalSubGroup.addComponent(p);
}
horizontalGroup.addGroup(horizontalSubGroup);

Was ist für "panels" zu notieren (irgendeine Liste?)?

Irgendwas, worüber iterierbar ist Kann eine Collection sein, oder auch ein Array sein.

 

[Gerald]

Hallo mihe7.
Tut mir leid, es funktioniert nicht. Habe den Fehler gemacht mir nicht alle Zwischenstände mit dem Code aufzuheben. So bin ich wohl durcheinandergekommen. Eventuell ist doch etwas falsch vertauscht worden.
Ich liste hier mal den Gesamttext. Wenn Du das so nebenbei machst, dann lass Dir Zeit. Es ist nicht eilig, aber wichtig.

import java.awt.Dimension;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.ParallelGroup;
import javax.swing.GroupLayout.SequentialGroup;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test5 {
    public static void main(String[] args) {
        JFrame f = new JFrame("Test 5");
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   
        JPanel pnl = new JPanel();
        GroupLayout layout = new GroupLayout(pnl);
        layout.setAutoCreateGaps(true);
        pnl.setLayout(layout);
   
        JPanel p1 = new JPanel();        JPanel p2 = new JPanel();
        JPanel p3 = new JPanel();        JPanel p4 = new JPanel();
        p1.setPreferredSize(new Dimension(60, 70));
        p2.setPreferredSize(new Dimension(60, 70));
        p3.setPreferredSize(new Dimension(60, 70));
        p4.setPreferredSize(new Dimension(60, 70));
        p1.setBackground(new java.awt.Color(255, 0, 0));
        p2.setBackground(new java.awt.Color(0, 255, 0));
        p3.setBackground(new java.awt.Color(127, 0, 0));
        p4.setBackground(new java.awt.Color(0, 127, 0));
       
        SequentialGroup horizontalGroup = layout.createSequentialGroup();
        ParallelGroup verticalGroup = layout.createParallelGroup();
       
        ParallelGroup verticalSubGroup = layout.createParallelGroup();
        SequentialGroup horizontalSubGroup = layout.createSequentialGroup();
       
        JPanel panels[] = {p1, p2, p3, p4};
        for (JPanel p : panels) {
            verticalSubGroup.addComponent(p);
            horizontalSubGroup.addComponent(p);
        }
        verticalGroup.addGroup(verticalSubGroup);
        horizontalGroup.addGroup(horizontalSubGroup);
       
        f.add(pnl);
        f.pack();
        f.setVisible(true);
    }
}

 

[Gerald]

Ich grüble, es sollten doch 2 x 2 Panels angezeigt werden. Müßten da nicht auch jeweils 2 vert. und horz. Gruppen aufgemacht werden? Die Auflistung "{p1, p2, p3, p4}" ist doch nicht richtig, oder?

 

[Gerald]

Hallo!
Ich hatte etwas vergessen:

        layout.setVerticalGroup(verticalGroup);
        layout.setHorizontalGroup(horizontalGroup);

Das Problem mit 2 x 2 Elementen wird auch lösbar sein.
Vielen Dank an mihe7!

 

[Gerald]

Bin begeistert! Es funktioniert!
(Es mußte doch etwas zurückgetauscht werden.)
Hier der vollständige Quelltext, für Leute die es interessiert:

import java.awt.Dimension;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.ParallelGroup;
import javax.swing.GroupLayout.SequentialGroup;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test5 {
    public static void main(String[] args) {
        JFrame f = new JFrame("Test 5");
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   
        JPanel pnl = new JPanel();
        GroupLayout layout = new GroupLayout(pnl);
        layout.setAutoCreateGaps(true);
        pnl.setLayout(layout);
   
        JPanel p1 = new JPanel();        JPanel p2 = new JPanel();
        JPanel p3 = new JPanel();        JPanel p4 = new JPanel();
        p1.setPreferredSize(new Dimension(60, 70));
        p2.setPreferredSize(new Dimension(60, 70));
        p3.setPreferredSize(new Dimension(60, 70));
        p4.setPreferredSize(new Dimension(60, 70));
        p1.setBackground(new java.awt.Color(255, 0, 0));
        p2.setBackground(new java.awt.Color(0, 255, 0));
        p3.setBackground(new java.awt.Color(127, 0, 0));
        p4.setBackground(new java.awt.Color(0, 127, 0));

        ParallelGroup horizontalGroup = layout.createParallelGroup();
        SequentialGroup verticalGroup = layout.createSequentialGroup();
       
        ParallelGroup verticalSubGroup1 = layout.createParallelGroup();
        SequentialGroup horizontalSubGroup1 = layout.createSequentialGroup();
       
        ParallelGroup verticalSubGroup2 = layout.createParallelGroup();
        SequentialGroup horizontalSubGroup2 = layout.createSequentialGroup();
       
        JPanel panels1[] = {p1, p2};
        for (JPanel p : panels1) {
            verticalSubGroup1.addComponent(p);
            horizontalSubGroup1.addComponent(p);
        }
        JPanel panels2[] = {p3, p4};
        for (JPanel p : panels2) {
            verticalSubGroup2.addComponent(p);
            horizontalSubGroup2.addComponent(p);
        }
       
        verticalGroup.addGroup(verticalSubGroup1)
                     .addGroup(verticalSubGroup2);
        horizontalGroup.addGroup(horizontalSubGroup1)
                       .addGroup(horizontalSubGroup2);
        layout.setVerticalGroup(verticalGroup);
        layout.setHorizontalGroup(horizontalGroup);
        f.add(pnl);
        f.pack();
        f.setVisible(true);
    }
}

 

[mihe7]

Huch, das mit dynamischer Spaltenzahl hatte ich ganz übersehen.

Nicht schön, aber selten:

import java.awt.Dimension;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.ParallelGroup;
import javax.swing.GroupLayout.SequentialGroup;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test5 {
    public static void main(String[] args) {
        JFrame f = new JFrame("Test 5");
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        JPanel pnl = new JPanel();
        GroupLayout layout = new GroupLayout(pnl);
        layout.setAutoCreateGaps(true);
        pnl.setLayout(layout);

        JPanel p1 = new JPanel();        JPanel p2 = new JPanel();
        JPanel p3 = new JPanel();        JPanel p4 = new JPanel();
        JPanel p5 = new JPanel();        JPanel p6 = new JPanel();
        p1.setPreferredSize(new Dimension(60, 70));
        p2.setPreferredSize(new Dimension(60, 70));
        p3.setPreferredSize(new Dimension(60, 70));
        p4.setPreferredSize(new Dimension(60, 70));
        p5.setPreferredSize(new Dimension(60, 70));
        p6.setPreferredSize(new Dimension(60, 70));
        p1.setBackground(new java.awt.Color(255, 0, 0));
        p2.setBackground(new java.awt.Color(0, 255, 0));
        p3.setBackground(new java.awt.Color(127, 0, 0));
        p4.setBackground(new java.awt.Color(0, 127, 0));
        p5.setBackground(new java.awt.Color(255, 127, 0));
        p6.setBackground(new java.awt.Color(0, 127, 255));

        JPanel panels[] = {p1, p2, p3, p4, p5, p6};

        layout(layout, panels, 3);

        f.add(pnl);
        f.pack();
        f.setVisible(true);
    }

    private static void layout(GroupLayout layout, JPanel[] panels, int cols) {
        SequentialGroup verticalGroup = layout.createSequentialGroup();
        SequentialGroup horizontalGroup = layout.createSequentialGroup();

        int rows = panels.length / cols;
        if (rows * cols != panels.length) {
            throw new IllegalArgumentException("All rows must be filled");
        }

        ParallelGroup[] stacked = new ParallelGroup[cols];
        ParallelGroup[] aside = new ParallelGroup[rows];

        initLayout(layout, horizontalGroup, stacked);
        initLayout(layout, verticalGroup, aside);
        for (int i = 0; i < cols; i++) {
            for (int j = 0; j < rows; j++) {
                stacked[i].addComponent(panels[j*cols + i]);
                aside[j].addComponent(panels[j*cols + i]);
            }
        }

        layout.setHorizontalGroup(horizontalGroup);
        layout.setVerticalGroup(verticalGroup);
    }

    private static void initLayout(GroupLayout layout, SequentialGroup group,
                            ParallelGroup[] init) {
        for (int i = 0; i < init.length; i++) {
            init[i] = layout.createParallelGroup();
            group.addGroup(init[i]);
        }
    }
}

 

[Gerald]

Nachtrag:
Habe den Kode nochmal geändert. Der von mihe7 ist zwar kompakter, aber für das bessere Verständnis ist ein bisschen länger wahrscheinlich besser.
Aber, mein neuer Kode hat einen Fehler. Habe lange probiert, finde ihn jedoch nicht nicht.
Der wohl unkritische Teil hier:

import java.awt.Dimension;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.ParallelGroup;
import javax.swing.GroupLayout.SequentialGroup;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class GroupLayoutDemo {
    private void go(int xSize, int ySize, boolean colors, int cols, int rows) {
        int zPanel, i, xP, yP; JPanel panels[];
      
        JFrame f = new JFrame("GroupLayoutDemo");
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        JPanel pnl = new JPanel();
        GroupLayout layout = new GroupLayout(pnl);
        pnl.setLayout(layout);
        f.add(pnl);

        xP = xSize / cols;
        yP = ySize / rows;
      
        zPanel = cols * rows;
        panels = new JPanel[zPanel];
        for (i = 0; i < zPanel; i++) {
            panels[i] = new JPanel();
            panels[i].setPreferredSize(new Dimension(xP, yP));
            JLabel l = new JLabel(String.valueOf(i));
            panels[i].add(l);
            if (colors) {//Alles bunt:
                int col1 = getCol(); int col2 = getCol(); int col3 = getCol();
                panels[i].setBackground(new java.awt.Color(col1, col2, col3));
            }
            else {//Alles Grautöne:
                int col = getCol();                    
                panels[i].setBackground(new java.awt.Color(col, col, col));
            }
        }
        layoutGl(layout, panels, cols, rows);
        f.setSize(xSize, ySize);
        f.setVisible(true);
    }

    private static int getCol () {
        return (int) (Math.random() * 255);
    }

    public static void main(String[] args) {
        GroupLayoutDemo gl = new GroupLayoutDemo();
        gl.go(240, 180, true, 2, 5);   //dims, color?, cols, rows
    }
}

Die Fehlerquelle muß hier liegen (Fehlermöglichkeit A oder Fehlermöglichkeit B):

    private static void layoutGl(GroupLayout layout, JPanel[] panels
                                                   , int cols, int rows) {
        SequentialGroup seqGroup = layout.createSequentialGroup();
        ParallelGroup parGroup = layout.createParallelGroup();

        SequentialGroup[] seqGroup2 = new SequentialGroup[cols];
        ParallelGroup[] parGroup2 = new ParallelGroup[rows];
      
        initLayoutSeq(layout, seqGroup, parGroup2);
        initLayoutPar(layout, parGroup, seqGroup2);
      
        for (int i = 0; i < cols; i++)    //Fehlermöglichkeit A
            for (int j = 0; j < rows; j++) {
                parGroup2[j].addComponent(panels[i * rows + j]);
                System.out.println("col(i):" + i + " row(j):" + j
                                 + "   panel:" + (i * rows + j));
            }
                                            System.out.println();
        for (int j = 0; j < rows; j++)    //Fehlermöglichkeit A
            for (int i = 0; i < cols; i++) {
                seqGroup2[i].addComponent(panels[j * cols + i]);
                System.out.println("row(j):" + j + " col(i):" + i
                                 + "   panel:" + (j * cols + i));
            }
        layout.setVerticalGroup(seqGroup);
        layout.setHorizontalGroup(parGroup);
    }
  
    private static void initLayoutSeq(GroupLayout layout
                                    , SequentialGroup seqGroup
                                    , ParallelGroup[] parGroup2) {//Fehlermöglichkeit B
        for (int i = 0; i < parGroup2.length; i++) {
            parGroup2[i] = layout.createParallelGroup();
            seqGroup.addGroup(parGroup2[i]);
        }
    }
  
    private static void initLayoutPar(GroupLayout layout
                                    , ParallelGroup parGroup
                                    , SequentialGroup[] seqGroup2) {//Fehlermöglichkeit B
        for (int i = 0; i < seqGroup2.length; i++) {
            seqGroup2[i] = layout.createSequentialGroup();
            parGroup.addGroup(seqGroup2[i]);
        }
    }

Auffallend ist, daß bei Angabe von 2 Spalten dann die Programmausgabe (angeordnete Panels) bei jeweils 2 vertikalen Panels "nach rechts springt"; die Ausgabe wird "zerwürfelt".
Ich glaube, daß kein prinzipieller Entwurfsfehler vorliegt, sondern ein Verdreher im Kode. Ich lasse mich aber gerne belehren.
Im Voraus vielen Dank für hilfreiche Hinweise.

 

[mihe7]

Der Fehler liegt vermutlich darin, dass Du parallele und sequentielle Gruppen hinzufügst (initLayoutPar/Seq) bzw. vertauschst.

Jede Spalte besteht aus einer Menge vertikal parallel angeordneter Komponenten. Diese werden sequentiell hintereinander angeordnet. Umgekehrt besteht jede Zeile aus einer Menge horizontal parallel angeordneter Komponenten, diese werden sequentiell untereinander angeordnet.

 

[Gerald]

Hallo mihe7,
sollte Deiner Meinung nach das Auftrennen in eindeutig parallele und sequentielle Gruppen die Fehlerursache sein? Das glaube ich aber nicht. Mit dem Aufteilen wird mir und eventuell anderen Lesern doch die Funktion besser verständlich, oder nicht?
Da bei einer "symmetrischen" Angabe von Spalten und Zeilen (z. B.: cols=3, rows=3) alles (scheinbar?) in Ordnung ist, bin ich von der prinzipiellen Richtigkeit der Aufteilung überzeugt.

        for (int i = 0; i < cols; i++)
            for (int j = 0; j < rows; j++) {
                parGroup2[j].addComponent(panels[i * rows + j]);
                System.out.println("col(i):" + i + " row(j):" + j + "   panel:" + (i * rows + j));
            }

Ich versuche mal, Deine letze Antwort präzise wiederzugeben:
Jede Spalte (cols) besteht aus einer Menge vertikal (übereinander) angeordneter paralleler Komponenten parGroup2 (wird mit dem Schleifenzähler j (rows) durchlaufen) .
In jeder neuen Zeile (j) werden die Komponenten (panels) angehangen. Erhöht sich der Wert i (cols) werden erneut an parGroup2 Panels (Zugriff auf weitere P.) angehangen.

Für die Zeilenauffüllung sollte Analoges gelten.

        for (int j = 0; j < rows; j++)
            for (int i = 0; i < cols; i++) {
                seqGroup2[i].addComponent(panels[j * cols + i]);
                System.out.println("row(j):" + j + " col(i):" + i
                                 + "   panel:" + (j * cols + i));
            }

Jede Zeile (rows) besteht aus einer Menge horizontal (nebeneinander) angeordneter sequentieller (?) Komponenten seqGroup2 (wird mit dem Schleifenzähler i (cols) durchlaufen).
In jeder neuen Spalte (i) werden die Komponenten (panels) angehangen.

Ist das korrekt (sequentieller (?)...)?
Werden die Panels durch:

              seqGroup2[i].addComponent(panels[j * cols + i]);

untereinander angehangen?

 

[mihe7]

Wenn ich mir https://docs.oracle.com/javase/tutorial/uiswing/layout/group.html ansehe, dann würde ein Layout für die erste Zeile so aussehen:

horizontalLayout = sequential_group(c_00, c_01, ... c_0m)
verticalLayout = parallel_group(c_00, c_01, ... c_0m)

Resultat: c_00 c_01 c_02 ... c_0m

Will man z. B. zwei Zeilen

c_00 c_01 c_02 ... c_0m
c_10 c_11 c_12 ... c_1m

haben, würde das Layout aber so aussehen:

horizontalLayout = sequential_group(
parallel_group(c_00, c_10),
parallel_group(c_01, c_11),
parallel_group(c_02, c_12),
...
parallel_group(c_0m, c_1m)
)
verticalLayout = sequential_group(
parallel_group(c_00, c_01, ..., c_0m),
parallel_group(c_10, c_11, ..., c_1m)
)

Hier sind die Komponenten immer in einer parallelen Gruppe - Du fügst sie aber teilweise in einer sequentielle Gruppe ein.

Mit dem Aufteilen wird mir und eventuell anderen Lesern doch die Funktion besser verständlich, oder nicht?

Das kann ich nicht beurteilen

 

[Gerald]

Habe Zeit gehabt nachzudenken. Das Ergebis: der folgende Kode reiht die Komponenten (panels) wohl doch nicht untereinander, sondern fügt die Panels jeweils neu horizontal an.

seqGroup2[i].addComponent(panels[j * cols + i]);

Auch die Annahme sequentiell heißt immer senkrecht, stimmt wohl nicht.

Ich bitte um Bestätigung oder Ablehnung dieser meiner Annahmen.
Mich hatte immer gewurmt, daß horizontalLayout = sequential_group und auch verticalLayout = sequential_group gelten sollte.
Falls Jemand meine Annahmen bestätigt, finde ich wieder meinen Frieden.

 

[mihe7]

Sequentiell heißt einfach nacheinander, unabhängig von der Richtung.

Nehmen wir mal

c1
c2
c3

Dann sind die Komponenten in vertikaler Richtung sequentiell, in horizontaler Richtung parallel.
horizontal = parallel_group{c1, c2, c3}
vertical = sequential_group{c1, c2, c3}

Parallele und sequentielle Gruppe sind somit wie im Beispiel aus meinem letzten Beitrag - jedoch vertauscht.

Will ich jetzt eine zweite Spalte mit c4, c5, c6, dann hat man horizontal zwei parallele Gruppen: parallel_group{c1, c2, c3} (wie gehabt), parallel_group{c4, c5, c6}. Die beiden Gruppen sollen aber nebeneinander stehen, also sequentiell eingefügt werden:
horizontal = sequential_group{
parallel_group{c1, c2, c3}
parallel_group{c4, c5, c6}
}

In vertikaler Richtung ist es ähnlich: durch die zweite Spalte, entstehen drei parallele Gruppen parallel_group{c1, c4}, parallel_group{c2, c5}, parallel_group{c3, c6}. Da diese in vertikaler Richtung nacheinander kommen sollen, werden sie ebenfalls sequentiell eingefügt:

vertical = sequential_group{
parallel_group{c1, c4},
parallel_group{c2, c5},
parallel_group{c3, c6}
}

Insgesamt erhält man also

c1 c4
c2 c5
c3 c6

Mit deinem Code erzeugst Du, wenn ich nichts übersehen habe, für die sechs Komponenten folgendes Layout

horizontal = parallel_group{
sequential_group{c1, c2, c3}
sequential_group{c4, c5, c6},
}

vertical = sequential_group{
parallel_group{c1, c4},
parallel_group{c2, c5},
parallel_group{c3, c6},
}

D. h. horizontal liegen c1, c2, c3 nebeneinander, auch c4, c5, c6. Diese beiden "Blöcke" liegen in der gleichen "Spalte"

+--------------+
| c1 | c2 | c3 |
| c4 | c5 | c6 |
+--------------+

Gleichzeitig sagst Du in vertikaler Richtung, dass c1 und c4 in einer Zeile liegen sollen, ebenso c2, c5 und c3, c6. Die drei Zeilen sollen untereinander stehen:

+-------+
| c1 c4 |
+-------+
| c2 c5 |
+-------+
| c3 c6 |
+-------+

Das passt nicht zusammen.

EDIT: wenn ich es mir recht überlege, müsste eigentlich etwas in der Richtung rauskommen:

+-------+
| c1 c4 |
+-------+-------+
        | c2 c5 |
        +-------+-------+
                | c3 c6 |
                +-------+

 

[Gerald]

An mihe7: Danke für Deine hilfreichen Erklärungen! Mir hätte schon ein einfaches "Ja" oder "Nein" gereicht. Aber auch Andere wollen etwas lernen, deßhalb sind Deine Erklärungen einfach klasse.

Man könnte fragen, wie ich zu meiner Fehlinterpretation gekommen bin. Durch ein Tutorial! Das war offensichtlich nicht so einleuchted.