LookAndFeel auf Gui Layout (externe Klasse) zugreifen

[Redclipse]

Hi Leute,

wie der Titel schon sagt möchte ich einen GUI Layout in Java (Eclipse) erstellen.

Einleitend:
- Für meine Studienarbeit soll ich ein Flugbuchungssystem erstellen
- ich möchte ein Design für mehrere Screens verwenden
- ich bitte euch mal die JPG Datei im Anhang zu öffnen



Bild:
- auf dem Bild sieht man mein Layout (mit Qualitätsverlust dank Paint ) so wie ich es mir
ungefähr vorstelle
- Die Grün umkreisten Felder sind JLabels, die ich individuell übergeben möchte
- Die türkisen Rechtecke stellen Panels dar, die ich auch individuell übergeben möchte

Problem:
- da ich in Java, was Klassen betrifft nicht so fit bin benötige ich Eure Hilfe bei der Umsetzung.

Frage:
- Ist es möglich, dass ich eine Klasse erstelle mit dem Layout. Dieses Layout beinhaltet den Container im Hintegrund, das darauf liegende Panel mit Design und die Positionen (Größe) der übergebenen Labels, Panels.
- Kann ich viele verschiedene Klassen erstellen und dafür dieses Design verwenden? Ich möchte nur die Textfelder für jedes einzelne Screen Übergeben und den Transparenten Panel mit Inhalt, sowie den durchsichtigen Panel mit den Buttons.

Wie mache ich das am besten?
Vielen Dank im Voraus

 

[javimka]

Ich würde dir empfehlen, Layouts zu kombinieren.
Aus deiner Zeichnung heraus, sehe ich z.B. auf den ersten Blick ein Hauptpanel mit einem BorderLayout. Im NORTH Teil kommt ein Panel mit "Willkommen" und dem Text rechts. In den SOUTH Teil kommt ein Panel mit den beiden Buttons (vielleicht ein EmptyBorder drumherum). In den mittleren CENTER Teil kommt ein Panel, das z.B. ein BoxLayout haben könnte in dem dann "Induvidual Airline" und des weisse Feld enthalten sind. Die Texte sind natürlich alle austauschbar.
Um das Bild im Hintergrund zu zeichnen, liesst du es mit der Klasse ImageIO ein und übergibst es dann deinem Hauptpanel. Das Hauptpanel ist natürlich eine eigene Klasse, die von JPanel erbt und wo du paintComponent(Graphics g) überschreibst. In diesem paintComponent, muss dann das Bild mit g.drawImage gezeichnet werden.

 

[KrokoDiehl]

Spontan würde ich sagen, dass du dir eine abstrakte Klasse machst, die von JPanel erbt und darauf alles layoutest, bzw. alle grundsätzlichen Dinge dort erstellst. Via Getter / Setter / etc. kannst du dann die jeweiligen Texte und Teile setzen. Etwa so:

public abstract class BasicBookingPanel extends JPanel
{
    protected JLabel lblTitle   = null;
    protected JLabel lblWelcome = null;
    //...

    protected JPanel pnlMain    = null;
    protected JPanel pnlButtons = null;        

    // Konstruktor(en) und Layouting ...

    public void setWelcomeText(String welcomeText)
    {
        lblWelcome.setText(welcomeText);
    }

    public void setMainPanel(JPanel mainPanel)
    {
        //altes MainPanel entfernen
        if (pnlMain != null)
            this.remove(pnlMain);

        pnlMain = mainPanel;
        this.add(pnlMain, LayoutContraints); // je nach LayoutMgr
    }

    // usw.
}

Das mal so als Anreiz. Es ist an vielen Stellen sicherlich noch ausbaufähig

Warum abstrakt? Ich habe dein Vorhaben so verstanden, dass du aufbauend auf dieser Basis mehrere (konkrete) Ansichten ableiten willst, daher halte ich das Prinzip der abstrakten Klasse hier für angebracht.

Wenn du solche Ansichten dann hast, kannst du sie z.B. in einem JFrame wie folgt benutzen:

BasicBookingPanel view = new ConcreteBookingPanel();
view.set ...

JFrame mainWindow = new JFrame("Mein tolles Fluch- ...äh, Flugbuchungssystem");
mainWindow.add(view, BorderLayout.CENTER);
mainWindow.pack();
...

 

[Redclipse]

Hi Leute danke für Eure Antworten.
Also ich verwende ein Null Layout. Und setze die größen + Positionen.
Ich möchte eine Klasse erstellen die auf mein Layout zugreift. Als übergabe soll er die 3 individuellen texte geben, den transparenten panel, und den ButtonPanel.
So dass ich immer dieses Layout verwende, aber individuell für mein persönliches Screen anpasse.

Hier mein Code:
(Ich weiß die Struktur etc. ist nicht fein, an manchen Stellen muss ich noch einiges verbessern)


[Java] package gui;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

/**...
* Login Version 1.0
*
* Das Layout zum Flugbuchungssystem
*
* */

public class Layout extends JFrame{
//Komponenten die benötigt werden (Variablen deffinieren)
Container backContainer; //Hintergrund in grau
JPanel LayoutPanel; //Panel auf dem Hintergrund mit Bild
JPanel IndividualPanel; //Transparenter Panel
JPanel ButtonPanel; //Panel für die Buttons

JLabel LayoutText, LayoutStrich, LayoutHelp, LayoutHeadline, LayoutBackground, LayoutBackground2;

public Layout() {
//Container bestimmen, Layout und Hintergrundfarbe setzen
backContainer = getContentPane();
backContainer.setLayout(null);

//LayoutPanel bestimmen, Layout setzen, Rahmen und Hintergrundfarbe setzen, dem Container hinzufügen
LayoutPanel = new JPanel();
LayoutPanel.setLayout(null);
LayoutPanel.setBackground(new Color(230,230,200));
LayoutPanel.setBorder(new SoftBevelBorder(SoftBevelBorder.RAISED, Color.red.darker(), Color.red));
backContainer.add(LayoutPanel);
LayoutPanel.setBounds(5,5,784,585);

//Komponenten erstellen
LayoutText = new JLabel("Willkommen");
LayoutHelp = new JLabel("Hilfe");
LayoutStrich = new JLabel("___________________________________________________________________" +
"___________________________________________");
LayoutHeadline = new JLabel("Individual Airline 2009");

//Schriftarten setzen
LayoutText.setFont(new Font("SansSerif", Font.PLAIN,18));
LayoutHelp.setFont(new Font("SansSerif", Font.ITALIC, 12));
LayoutHeadline.setFont(new Font("Calligraphic", Font.BOLD, 40));
LayoutHeadline.setHorizontalAlignment(SwingConstants.LEFT);
LayoutHeadline.setForeground(Color.white);

//Farben setzen
LayoutText.setForeground(Color.white);
LayoutHelp.setForeground(Color.blue);
LayoutStrich.setForeground(Color.red.darker());

//Positionen bestimmen und dem LayoutPanel hinzufügen
LayoutText.setBounds(7,5,500,35);
LayoutPanel.add(LayoutText);

LayoutHelp.setBounds(750,17, 50, 15);
LayoutPanel.add(LayoutHelp);

LayoutStrich.setBounds(7, 15, 800, 20);
LayoutPanel.add(LayoutStrich);

LayoutHeadline.setBounds(18,85,784,200);
LayoutPanel.add(LayoutHeadline);


// Individuellen Panel erstellen und transparent machen:
IndividualPanel = new Transparent(0.5f); //aus Transparent Klasse
IndividualPanel.setBounds(20,210,745,315); //Position, größe
IndividualPanel.setBorder(BorderFactory.createLineBorder(Color.red.darker())); //Rahmen
LayoutPanel.add(IndividualPanel); //dem Panel hinzufügen

//Button Panel erstellen
ButtonPanel = new JPanel();
ButtonPanel.setLayout(null);
ButtonPanel.setBounds(20,530, 745,50);
ButtonPanel.setBackground(Color.white);
ButtonPanel.setOpaque(false);
LayoutPanel.add(ButtonPanel);


// Notlösung für Hintergrundbild (im JPanel)
Icon Background = new ImageIcon("flugzeug11.jpg"); // weitere: flugzeug11.jpg , flugzeug, Background,
LayoutBackground = new JLabel(Background);
LayoutBackground.setBounds(2,2,781,582);
LayoutPanel.add(LayoutBackground);


/** Hier endet das Layout, ab jetzt beginnt die Füllung des individuellen und des Button panels */

//Button für "ButtonPanel" erstellen:
JButton Next = new JButton("Weiter");
Next.setFont(new Font("SansSerif", Font.BOLD,14));
Next.setBounds(590,5,100,30);
ButtonPanel.add(Next);


}
public static void main(String[] args) {
Layout fenster = new Layout();
fenster.setTitle("Hauptmenu");
fenster.setSize(800,625);
fenster.setLocationRelativeTo(null);
fenster.setVisible(true);
fenster.setResizable( false );
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

}
[/code]

 

[KrokoDiehl]

Was genau ist denn die Frage?

Generell rate ich aber von Null-Layouts ab, auch wenn es zu Beginn mit den absoluten Angaben einfacher aussieht. Aber was ist z.B. wenn das Fenster vergrößert/verkleinert wird? Was wenn du einen Text setzt, der viel größer ist, alls der JLabel Platz hat, usw. ... Null-Layouts stoßen schnell an ihre Grenzen und dann muss man manuell eingreifen, was definitiv nicht bequemer ist

javimka hat z.B. schon ein paar Hinweise genannt, wie man es auch mit (kombinierten) LayoutManagern hinbekommt.
Tendentiell solltest du deinen Vorgabe-Frame (willst du wirklich einen Frame oder eher ein Panel?) allgemeiner aufbauen. Z.B. dein LayoutPanel in eine extra Klasse packen und dann via Getter + Setter die Texte / Objekte verfügbar machen (so wie in meinem ersten Beispiel).

 

[Redclipse]

Hi hab jetzt nochmals versucht es so zu machen wie du es beschrieben hast (mit der abstrakten Klasse.) Jedoch habe ich Probleme beim aufrufen dieser Klasse.
Habe jetzt noch nicht viel gemacht... nur paar kleinigkeiten zum testen.

meine abstrakte Layout Klasse:

package guiNeu;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

public abstract class Layout extends JPanel{
    // Komponente, die von anderen Klassen individuell übergeben werden
	protected JLabel lblTitle = null;
    protected JLabel lblWelcome = null;
    protected JLabel lblHelp = null;
    
    protected JPanel pnlMain    = null;
    protected JPanel pnlButtons = null;        
 
    
    public void setWelcomeText(String welcomeText)
    {
    	lblWelcome.setText(welcomeText);
    	lblWelcome.setForeground(Color.red);
    }
    
    public void setHelpText(String helpText)
    {
    	lblHelp.setText(helpText);
    	lblHelp.setForeground(Color.blue);
    }
    
    public void setTitleText(String titleText)
    {
    	lblTitle.setText(titleText);
    	lblTitle.setForeground(Color.white);
    }
 
    public void setMainPanel(JPanel mainPanel)
    {
        //altes MainPanel entfernen
        if (pnlMain != null)
            this.remove(pnlMain);
 
        pnlMain = mainPanel;
        this.add(pnlMain); // je nach LayoutMgr
    }
    	
    public void setButtonPanel(JPanel buttonPanel)
    {
    	//altes ButtonPanel entfernen
    	if (pnlButtons != null)
    		this.remove(pnlButtons);
    	
    	pnlButtons = buttonPanel;
    	this.add(pnlButtons);
    }
    
    /**----------------------  Beginn des Layouts --------------------*/
    
    protected JPanel pnlBackground; 		//Hintergrund
    protected JPanel pnlLayout;				//Das Layout Panel
    
    public Layout(){
    	
    	//Background Panel erstellen (in grau)
    	pnlBackground = new JPanel();
    	pnlBackground.setLayout(null);
    	pnlBackground.setBackground(Color.gray.brighter());		
    	pnlBackground.setBounds(0,0,800,600);
    	
    	//Layout Panel erstellen (auf dem BackgroundPanel)
		pnlLayout = new JPanel();
		pnlLayout.setLayout(null);	
		pnlLayout.setBackground(new Color(230,230,200));		
		pnlLayout.setBorder(new SoftBevelBorder(SoftBevelBorder.RAISED, Color.red.darker(), Color.red));
		pnlBackground.add(pnlLayout);	
		pnlLayout.setBounds(5,5,784,585);
		
		//Übergebene Panels & Labels ins Layout einbinden
		pnlLayout.add(lblWelcome);
		pnlLayout.add(lblTitle);
		pnlLayout.add(lblHelp);
		lblWelcome.setBounds(20,20,200,100);
		lblTitle.setBounds(100,300, 200,100);
    	lblHelp.setBounds(300,300,200,100);
    	
    	
    }
    
}

meine Beispiel Klasse mit der ich Layout aufrufen will und Werte übergeben will

package guiNeu;
import java.awt.*;
import javax.swing.*;

public class Beispiel extends JFrame{
	
	Layout view = new test();				// Fehlermeldung
	test.setWelcomeText("hallo");			// Fehlermeldung
	test.setTitleText("hey");				// Fehlermeldung
	test.setHelpText("Hilfe...");			// Fehlermeldung
	
	
	public static void main(String[] args) {
		Beispiel fenster = new Beispiel();
		fenster.setTitle("Hauptmenu");
		fenster.setSize(800,625);
		fenster.setLocationRelativeTo(null);
		fenster.setVisible(true);
		fenster.setResizable( false );
		fenster.add(view);					// Fehlermeldung
		fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
	}
	
}

 

[KrokoDiehl]

Abstrakte Klassen dienen eher der Konzeption. Du kannst von ihnen keine Instanz bilden, sondern nur erben:

abstract class AbstractThing
{
}

class Thing extends AbstractThing
{
}

AbstractThing instance = new AbstractThing(); // das geht nicht, weil abstrakt
AbstractThing instance = new Thing(); // das geht

Für dein Beispiel kannst du das Wörtchen "abstract" weglassen. Mit abstrakter Klasse ist die Idee, dass du eine Basisklasse mit dem grundlegenden Layout verfasst, und dann von ihr konkrete Erben anlegst:

public abstract class BookingPanel; // abstrakte Oberklasse mit grundlegendem Layout
public class WelcomePanel extends BookingPanel; // konkrete Impl. vom Willkommensbildschirm
public class FlightSelection extends BookingPanel; // konkrete Impl. der Flugauswahl
...

Musst du selbst entscheiden, ob du das brauchst/willst oder ob dir eine nicht-abstrakte Klasse genügt.