Aus Array Container Panel an Tabbedpane zuweisen

H

hasocuk

Mitglied
Hallo zusammen,

ich lerne mit einem Java Buch ein Kompositum Beispiel. Hierbei wird im Beispiel über eine abstracte Komponente, eine Hauptkomponente und mehrere Unterkomponenten dazu erzeugt und dieser an AlleKomponenten zugewiesen. Ich lasse schon beim durchlaufen des Standard Konstruktors einen Container Variable mit GridBagLayout befüllen. Aktuell schaffe ich es, wenn die Ausgabe() Methode iteriert wird, in einem JFrame den Container der Hauptkomponente und deren Unterkomponenten aufzusammeln.

Ich möchte seit 2 Tagen einen Tabbedpane in der aufrufenden Klasse (Kelnerin) erzeugen der alle Hauptkomponenten (Speisekarten + Speisen) als Panels hat. Ich kann keinen Container, JPanel zurückgeben aus der oberen Klasse abholen, bzw. diese auch nicht mit Iteration abholen. Bin langsam verzweifelt. Ich hab das ganze aktuell vermasselte Projekt im Anhang. Bitte um einen Ansatz, wie ich das JFrame zentral steuern kann.

Vielen Dank im Voraus
hasocuk
 

Anhänge

Endlich mal wieder Swing 🙂 Da schau ich später doch glatt mal drüber, Deine Beschreibung lässt jedoch Böses ahnen...
 
mihe7 hat gesagt.:
Endlich mal wieder Swing 🙂 Da schau ich später doch glatt mal drüber, Deine Beschreibung lässt jedoch Böses ahnen...
Zum Vergrößern anklicken....
Danke schon mal vorab. Ich habe hier eine neue Version hier werden jetzt die einzelnen Panels auch erzeugt, einige Passagen habe ich auskommentiert. Damit es läuft wird noch ein kleines Icon auf den Laufwerk benötigt der eingebunden wird --> mein Pfad "D:\\L3_Icon2.jpg".

Eigentlich möchte ich einen kleinen Konfigurator Programmieren. Daher möchte ich nach dem eine Vorauswahl getroffen wurde zu einem Produkt in einem getrennten Frame (später zu programmieren). Durch das Kompositum Beispiel die Struktur aufbauen in dem ich aus der Produktstruktur, die Hauptauswahlfenster erzeuge und zu diesen die Unterkomponenten erzeuge. Die Unterkomponenten sollen die Auswahl darstellen, aktuell sind es nur 4 Buttons (Später werden es 3 Button und eine Auswahlliste sein). Daher möchte ich dynamisch in den erzeugten Hauptfenster die Unterkomponenten zuweisen und diese Hauptfenster dann in ein Tabbedpane.
 

Anhänge

Entschuldigt, die Nachfrage war mehr als gerechtfertigt, ich habe nicht drauf aufgepasst gehabt das es gar nicht mehr ging.

Im Enddefekt bin ich davon Abhängig meiner Meinung nach, ich möchte ActionListener einsetzen, wenn Werte gesetz werden, sollen Regeln prüfen, ob Teil a mit Teil b kombiniert werden kann usw. Eines der Buttons soll später ein Subfenster mit Optionen in der Unterkomponente aufmachen.

Aber aktuell kann ich wie im Test-Beispiel zu sehen ist, nur Einzelfenster aufmachen. Bin ich überhaupt für das vorhaben im richtigem Entwurfsmuster unterwegs, da ich keine Statische Prozedur Programmieren möchte, sondern Produktklassen mit unterschiedlichen Hauptfenstern und Unterkomponenten zur Anzeige bringen möchte und wiederum auf die einzelnen Komponenten zugreifen möchte zwecks Regelprüfungen?

Danke im Voraus für alle Anregungen!
hasocuk
 
Dein Code lässt sich nicht einmal übersetzen:
  1. Kellnerin.java, Zeil 41: Variable a existiert nicht (EDIT: sie existiert, hat aber falschen Typ)
  2. Kellnerin.java, Zeile 105: catch (e)
  3. Speise.java, Zeile 11: import Start.Layout; -> Paket Start existiert nicht
  4. NullIterator.java, Zeile 5: next() hat falschen Rückgabetyp
  5. SpeisekartenKomponente.java, Zeile 38: Versuch, über Klasse auf eine Instanzmethode zuzugreifen
 
Hallo zusammen,

ich bin dem Rat gefolgt und habe den Code Komplett umgebaut und den Code nach bestem Gewissen gesäubert. Im neu aufgebauten Code, würde ich gerne mit der Klasse Steuerung über alle Komponenten iterieren und über die Komponenten Struktur einen TabbedPane aufbauen, in dem die Button der Unterkomponenten Zeilenweise auf deren Hauptkomponenten geaddet und die Hauptrahmen schließlich in einem TabbedPane aufgesammelt werden.

Der Schnipsel aus meinem Beispiel zur Iteration liegt in der Klasse Steuerung auskommentiert vor, diesen konnte ich nicht zum laufen bringen um die Rahmen aufzusammeln. Aktuell werden beim Codelauf Frames erzeugt, aber die Buttonblöcke aus den Unterkomponenten nur nebeneinander aufgereiht, ich habe auch ein Bild eingefügt, mit Hinweisen.

Vielen Dank Nochmals für den guten Rat zum Umbau mihe7

Gruß

hasocuk
 

Anhänge

Der Code lässt sich noch immer nicht übersetzen:
  1. in HauptKomponente.java, Zeile 32 überschreibst Du die Methode Komponente#getKind(); die überschriebene Methode besitzt jedoch keinen Rückgabewert. Du müsstest in Komponente.java die Zeile 28 ändern zu public Komponente getKind(int i) {
  2. in HauptKomponente.java, Zeile 33 rufst Du Komponente.get(i) auf. Ich vermute, dass dort komponenten.getKind(i); stehen sollte.
Unabhängig davon ist das Problem nach wie vor, dass UI und Model immer noch miteinander vermischt sind und Code enthalten ist, der nirgends Verwendung findet.

AWT und Swing setzen bereits das Composite Pattern um: ein Container ist eine Component, die andere Component-Instanzen enthalten kann. Das musst Du nicht nochmal einbauen.

Leider weiß ich immer noch nicht, was Du wirklich machen willst. Meine Glaskugel meint, dass Du mit dem Composite Pattern etwas wie Produktgruppen darstellen willst, die selbst Produkte sind und andere Produkte enthalten können. Außerdem soll das UI Produktgruppen als Tab einer JTabbedPane anzeigen, während "Einzelprodukte" innerhalb eines Tabs als JButton (oder JLabel) dargestellt werden sollen. Liegt die Glaskugel richtig? Wenn nicht, dann beschreibe doch bitte mal Dein Vorhaben.
 
Ja im Grunde ist es richtig.
Allgemeinbeispiel: Das Hauptfenster enthält z.B. den Golf (Klasse Produkt1) oder den Passat (Klasse Produkt2), User soll nach Klick ein JTabbedPane bekommen. Im TabbedPane sind verschiedene Gruppierungen (Klasse Hauptkomponenten) als Tabs enthalten wie Innenausstattung, Reifen usw.. Im Tab Reifen sind dann die Reifengröße, Felgen (Klasse Unterkomponenten) enthalten (Inhalt / Funktion Zukunft) mit einem Button um ein Subfenster mit Eigenschaften aufzumachen, ein Auswahlfeld um z.B. dessen Größe zu setzen und ein weiteres Button, um ein weiteres Subfenster für Sondereinträge zu öffnen.


Aus meiner Unwissenheit, kann mein Model und UI vermischt sein. Mit der Klasse Produkt1 (oder 2) will ich ja die Struktur vorgeben und die Inhalte dynamisch individuell aufbauen. Nun wie kann ich das UI zentral steuern bzw. wie kann ich z.B. auch im UI zentrale Buttons einbauen, die z.B. Funktionen vom oberen Knoten aus ansteuern wie Drucke aus, speichere usw.

Vielen Dank für deine / eure Zeit
 
hasocuk hat gesagt.:
Allgemeinbeispiel: Das Hauptfenster enthält z.B. den Golf (Klasse Produkt1) oder den Passat (Klasse Produkt2), User soll nach Klick ein JTabbedPane bekommen. Im TabbedPane sind verschiedene Gruppierungen (Klasse Hauptkomponenten) als Tabs enthalten wie Innenausstattung, Reifen usw.. Im Tab Reifen sind dann die Reifengröße, Felgen (Klasse Unterkomponenten) enthalten (Inhalt / Funktion Zukunft) mit einem Button um ein Subfenster mit Eigenschaften aufzumachen, ein Auswahlfeld um z.B. dessen Größe zu setzen und ein weiteres Button, um ein weiteres Subfenster für Sondereinträge zu öffnen.
Zum Vergrößern anklicken....
Aha, jetzt kommen wir der Sache näher. Was unterscheidet denn Hauptkomponenten von Unterkomponenten?

hasocuk hat gesagt.:
Nun wie kann ich das UI zentral steuern bzw. wie kann ich z.B. auch im UI zentrale Buttons einbauen, die z.B. Funktionen vom oberen Knoten aus ansteuern wie Drucke aus, speichere usw.
Zum Vergrößern anklicken....
Später.
 
1. Soll die Gruppe darstellen und die ihm untergeordneten Unterkomponenten aufsammeln in ein Tab zur Darstellung.
2. Unter diesen Hauptkomponenten würde ich auch generell Unterscheidungen für einbindbare Funktionen und für einen späteren Druck sehen. Hauptkomponente Druckt einen Einleitungstext und die Unterkomponente stellt sich als UnterPositon dar.
3. Die aktuell vorhandene Hauptkomponente und Unterkomponente sehe ich nicht als Endstand, sondern von allen möchte ich mehrere haben können, um z.B. mit der Hauptkomponente die Unterkomponenten 2 Spaltig anstatt 1 Spaltig darzustellen, andererseits die Darstellung der Unterkomponenten wiederum zu differenzieren, um nun diesen entweder als eine Auswahlbox oder als Checkbox oder eher als eine Mehrfachliste auszugeben.

Das wäre meine Motivation zur Auswahl.
 
Revidiere Punkt 1. Da du schon gesagt hast UI und Model sind vermischt. Die muss nicht den Rahmen enthalten, sondern soll diesen aufbauen lassen können. Wie gesagt, suche hier nach einer Lösung und bin offen für ein richtiges vorgehen und daher versuche es auch so gut wie Möglich zu beschreiben.
 
Wir sind beim Modell, Deine Beschreibung (Punkte 1 bis 3) sind alle auf die Darstellung (UI) bezogen.

Aus Sicht des Modells: worin unterscheiden sich Haupt- und Unterkomponenten?
 
Gefällt mir, anständige Vorplanung erspart lange Nacharbeit, Vielen Dank.

Folgende Forderungen entstehen an das Model.
1. Eine aktuell genannte Hauptkomponente kann tatsächlich eine Baugruppe / Modul sein und die Unterkomponenten dessen Bauteile sein.
2. Die Hauptkomponente kann auch direkt die diversen Teile für das Produkt enthalten
3. Eine Baugruppe könnte auch aus 2 Hauptkomponenten (Baugruppen) bestehen
3. Andererseits kann die Hauptkomponente Unterkomponenten enthalten die nur Eigenschaften des Produktes beschreiben soll.
4. Der Punkt setzt daher voraus, das eine Unterkomponente entweder ein Teil oder eine Eigenschaft auch sein kann.
 
Bevor du zurückschreibst, in meinen Aufzählungen gehe ich immer davon aus, das der Inhalt der Hauptkomponente, immer über die aktuell genannte Unterkomponente/n Arten zugewiesen wird.
 
hasocuk hat gesagt.:
Bevor du zurückschreibst, in meinen Aufzählungen gehe ich immer davon aus, das der Inhalt der Hauptkomponente, immer über die aktuell genannte Unterkomponente/n Arten zugewiesen wird.
Zum Vergrößern anklicken....
Danke für den Hinweis.

Sieht das dann so aus?
Code: 
+-Produkt
|
+-Hauptkomponente 1
| +
| |
| +- Unterkomponente 1.1
| |
| +- Unterkomponente 1.2
|
+-Hauptkomponente 2
| +
| |
| +- Unterkomponente 2.1
| |
| +- Unterkomponente 2.2
|
+-Hauptkomponente 3 (ohne Unterkomponenten)
|
+-Hauptkomponente 4
| +
| |
| +- Hauptkomponente 4.1
| |  |
| |  +- Unterkomponente 4.1.1
| |  |
| |  +- Unterkomponente 4.1.2
| |
| +- Hauptkomponente 4.2 (ohne Unterkomponenten)
 
hasocuk hat gesagt.:
Ja Perfekt, genau das ist mein Plan. Wie geht mein Weg dahin, ist mein Kompositum Beispiel dafür überhaupt dafür geeignet?
Zum Vergrößern anklicken....
Naja, das ist erstmal einfach eine Baumstruktur. Prinzipiell kann jede Komponente andere Komponenten enthalten. Es gibt zwei Arten von Komponenten, die sich letztlich nicht großartig unterscheiden. Man kann das mit Vererbung machen, muss man aber nicht. Auf die Implementierung kommen wir später zurück.

Kommen wir zurück zur Darstellung des Ganzen. Wenn ich Dich richtig verstanden habe, dann möchtest Du die in einer Komponente enthaltenen Hauptkomponenten (HKs) als Tabs darstellen. In jedem Tab soll die Einleitung der betreffenden HK angezeigt werden, außerdem ihre Unterkomponenten (UKs). Wie sollen denn die UKs angezeigt werden?
 
Guten Morgen
Die Texte hatte ich auf einen Druck / Auflistung bezogen gehabt und vorerst nicht für die Anzeige. Die Unterschiedlichen HKs (mehrere) und UKs (mehrere) wollte ich sowieso wegen Gruppierung und Darstellung haben, daher habe ich auch in meinem Beispiel versucht mit dem GridbagLayout die Anzeige aufzubauen. Aber nachdem du es so ansprichst, wäre es meiner nach Meinung Konzeptionell mit der Steuerung in Abhängigkeit zu HK Sinnvoll.

Layout HK Art1 ist einspaltig, daher holt er den Text zu UK mit ab und es wird die 2 Zeilige GridBagLayout Methode angesprochen
Layout HK Art 2 ist zweispaltig, daher wird nur die UK zu der 1 Zeiligen GridBagLayout Methode geschickt

Allgemein ist mir beim aufschreiben noch aufgefallen, das Bei HK Art 2, nach dem einlesen der UKs, wiederum in einer 2 Schleife alle Texte der UKs durch die HK abgeholt und als ein 2. Abschnitt unten drunter eingefügt werden könnte.
 
Sehe das ich noch zu kurz wach war. Wenn du dich mit den UKs nicht auf Texte bezogen hast, dann kann dieses entweder aus

- Label, 2 JButtons und einen Auswahlfeld haben
- Label, ein Mehrfachauswahlfeld mit einem Button haben
- Label ,eine Checkbox haben
 
Wir reden aneinander vorbei. Kannst Du mal aufmalen, wie das Ergebnis aussehen soll? Am besten anhand eines konkreten Beispiels.
 
Ok im Anhang sind die Beispiele und rechtzeitig nach dem ich alle Exemplare erstellt habe, glaube ich ein weiteres Kapitel der OOP und Abstraction begriffen zu haben 🙂. Somit begreife ich deinen Satz vielmehr --> Es gibt zwei Arten von Komponenten, die sich letztlich nicht großartig unterscheiden.

Mit der Erstellung der vielen HKs und UKs deren ihre Anzeigeeigenschaft zu steuern, daß ist glaube ich falsch, daher reden wir aneinander vorbei. Denke an dieser Stelle wirst du sagen, dass z.B. am HK oder an der UK z.B. bei der Objekterzeugung dem der Parameter zur Darstellungsform z.B. mit 1 oder 2 an einer Variable Hinterlegt werden muss. Damit dies durch den GUI beim Aufbau berücksichtigt werden kann.
 

Anhänge

  • HK2.png
    HK2.png
    50,2 KB · Aufrufe: 45
  • HK1.png
    HK1.png
    39,7 KB · Aufrufe: 47
  • HK3.png
    HK3.png
    35,8 KB · Aufrufe: 41
Das Muster der Hauptkomponenten:
- Zeige 1 Elementenreihe ohne Beschreibungstexte -> HK3
- Zeige 1 Elementenreihe mit Beschreibungstexte -> HK1
- Zeige 2 Elementenreihen ohne Beschreibungstexte -> HK2

Das Muster der Unterkomponenten, daher soll das reingeschickte Element wie folgt angezeigt werden:
- Auswahlliste mit 3 Buttons
- Auswahlliste mit 1 Button
- Mehrfachauswahlliste mit 1 Button
- Checkbox mit einem Button
- Eingabefeld

Die Unterkomponenten können Grundsätzlich Beschreibungstexte haben und diese werden nur unter der Ausgabe von HK1 angezeigt. In dem letzten zugeschickten Code würde ich an einer Variable daher festlegen, mit Ausgabe HK1, HK2 bzw. UK1, UK2 usw.. Die Bestückung selbst und der Anzahl der Elemente ist das manuelle das ich selbst dafür sorgen muss.

Meine Eingangsfrage, wie kann ich nun meine Anzeige steuern, wie sieht so ein Aufruf aus? Kann ich, wie in meinem Beispielcode mein Model nach dem Kompositum realisieren und das erarbeitete Model realisieren?
 
Ok, mal anders gefragt:

Woher weißt Du denn, dass
1. UK1 in HK1 mit drei Buttons, einem Auswahlfeld und einem Beschreibungsfeld,
2. UK1 in HK3 aber ohne Beschreibungsfeld,
3. UK2 in HK1 mit einer Mehrfachauswahl, einem Button und einem Beschreibungsfeld,
4. UK2 in HK3 aber ohne Beschreibungsfeld
dargestellt werden sollen?

Und weiso fehlt in HK2 die UK1, dafür taucht die UK3 doppelt auf und die UK1 fehlt ganz?!?
 
Die in den Darstellungen genannten UK1, UK2, UK3 sollten die angebundenen Unterkomponentenmuster wiederspiegeln, daher taucht auch in der Darstellung ein Muster mehrmals oder gar nicht auf. Ich hatte ja auch gemeint gehabt, das ich die OOP Lektion begriffen habe, das es falsch wäre mehrere Unterkomponentensorten zur Anzeigeart zu erzeugen.

Ich wäre der Meinung, die erstellten Haupt-Komponenten markieren zu müssen HKs mit HK1, HK2 und die unter den HKs erstellten Unter-Komponenten mit UK1, UK2, UK3 usw.. Je nach dem wie welches Haupt oder Unterkomponente angezeigt werden soll.

Ich glaube damit wird es deutlicher:

Festlegung in Produkt1 bzw. Produkt2 usw.

# Hauptpanele / Gruppierungen
Komponente hauptkomponente1 = new HauptKomponente("Register 1", "Einleitungstext", "HK1"); Anzeige-Muster nach HK1
Komponente hauptkomponente2 = new HauptKomponente("Register 2", "Einleitungstext", "HK2"); Anzeige-Muster nach HK2

// Hinzufügen der Hauptkomponenten (Anzeigefenster) an die Superkomponente
alleKomponenten.hinzufügen(hauptkomponente1);
alleKomponenten.hinzufügen(hauptkomponente2);

// Hinzufügen der Unterkomponenten an die Hauptkomponenten
int[] OptionBauteil1 = {1,2,3,4,5};
int[] OptionBauteil2= {1,2,3,4,5};
int[] OptionBauteil3= {1,2,3,4,5};
String Text TextTeil1 = "Bla Bla";
String Text TextTeil2 = "Bla Bla";

Parameterliste Auswahlliste
#### --> Parameter new UnterKomponente( Name, Optionsliste, EinleitungstextBauteil, Position, Anzeigemuster) ###
Parameterliste Checkbox und Eingabefeld
#### -->oder Parameter new UnterKomponente( Name, Position, Anzeigemuster) ###

# Tabregister 1

hauptkomponente1.hinzufügen(new UnterKomponente("Bauteil 1 von 1. Gruppe", OptionBauteil1, TextTeil1, 1, "UK1")); //Auswahlfeld mit 3 Buttons
hauptkomponente1.hinzufügen(new UnterKomponente("Bauteil 2 von 1. Gruppe",OptionBauteil2, TextTeil2, 2, "UK2")); //Mehrfachauswahlfeld
hauptkomponente1.hinzufügen(new UnterKomponente("Bauteil 3 von 1. Gruppe", OptionBauteil3, TextTeil1, 1, "UK1")); //Auswahlfeld mit 3 Buttons
hauptkomponente1.hinzufügen(new UnterKomponente("Eingabefeld von 1. Gruppe", 2, "UK3")); // Eingabefeld

# Tabregister 2

hauptkomponente2.hinzufügen(new UnterKomponente("Bauteil 1 von 2. Gruppe", OptionBauteil1 , TextTeil1, 1, "UK5" )); //Auswahlfeld mit 1 Button
hauptkomponente2.hinzufügen(new UnterKomponente("Bauteil 2 von 2. Gruppe", OptionBauteil1, TextTeil2, 2, "UK2")); //Mehrfachauswahlfeld
hauptkomponente2.hinzufügen(new UnterKomponente("Checkbox von 2. Gruppe", 2, "UK4")); // Checkbox mit 1 Button
 
Das kannst Du über eine Factory lösen, die je nach hinterlegtem "Anzeigemuster" eine entsprechende Komponente zusammenbaut und zurückgibt.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

TabbedPane: wie schalte ich auf ein bestimmtes panel?
Antworten: 2
Gleiche Session von EJB Container in JSF Container verwenden?
Antworten: 21
Instanzieren und Zuweisen vom BorderLayout an Container nicht notwendig ?
Antworten: 4
Panel in Container einfügen
Antworten: 7
Einem JFrame zur Laufzeit ein Panel zuweisen
Antworten: 5

Zurück
Oben