LayoutManager Größe + Positionen?!

[Tomate_Salat]

Hi,

Ich bezweifel es zwar, aber trotzdem frag ich mal nach: Ich habe eine "buttonbox" mit unbekannter Anzahl an Buttons (ich bestimme nur, dass aus übersichtlichkeitsgründen nur 20 angezeigt werden dürfen). Gibt es einen Layoutmanager, der mir nicht nur die Größe der Buttons, sondern auch die Position dieser festlegt. D.h. wenn nur ein Button da ist, soll der logischerweise groß und füllend sein. Sind z.B. 4 vorhanden sollen die sich wie in einer 2x2 Tabelle anordnen. Zudem sollte ein bestimmtes Größenverhältnis wenn möglich eingehalten werden.

Ich glaube zwar die Antwort zu kennen. Aber der algo hätte es wohl wahrscheinl. echt in sich. Würde das ganze sonst iwie mit Flächen-berechnung versuchen umzusetzen

MFG

Tomate_Salat

 

[Michael...]

Wie schaut denn die Anordnungslogik aus? Wie sollen z.B. fünf Objekte angeordnet werden?
Wenn man diese Logik eindeutig beschreiben kann, kann man einen eigenen LayoutManager schreiben, der diese Logik verwendet.

 

[Tomate_Salat]

Das ist noch ein Problem vor dem Ich stehe. Aber wahrscheinl. dann 3 oben 2 unten

habe die Buttongröße im verhältnis 5:1 [breite:höhe] gehalten und denke mit folgenden formeln hinzukommen:

Fläche gesamt Ages: getWidth() * getHeight(); [von der Buttonbox]
Fläche für Buttons Abtn: Ages / AnzahlButtons
Breite von einem Button: sqrt(Abtn * 5)
Höhe von einem Button: sqrt(Abtn / 5)

Die Problematiken die bleiben:
a) Zwischenräume zwischen den Buttons
b) ist noch nicht fertig getestet

... wer hätte gedacht das Mathe mal wichtig sein würde

Edit Ich hab das gefühl ich mache das (nicht zum ersten mal) komplizierter als es ist. Vllt ginge es ja mit einem vorhandenen Layoutmanager, wenn ich auf das Größenverhältnis verzichten würde. Die Buttons sollen erstmal einfach nur die größtmögliche Größe annehmen

 

[lumo]

SWT oder Swing?
wenn SWT dann schau dir mal den GridLayout an, bei dem kannst du angeben wieviele spalten du hast... danach wird automatisch gefüllt. du kannst bei den buttons dann mit angeben, per GridData, ob sie füllen sollen oder nicht.
des weiteren kannst du auch angeben ob die spalten die selbe breite haben sollen oder nicht...

 

[Tomate_Salat]

Swing, SWT hat mich bishere nicht wirklich interessiert, was sich aber gerade eben geändert hat. Werde es mir die nächste zeit mal anschauen, da es zumindest mal, was ich gesehen habe, doch weiter entwickelter ist als Swing...Schon alleine wenn ich sehe wie einfach es ist einen voll funktionsfähigen browser einzubauen ohne auf drittanbieter zurückgreifen zu müssen....Wenn die Tabelle dort einfacher zu händeln sind als in Swing....dann heist es bald byebye SWT

aber mal schaun, Swing hat auch ein GridLayout, wäre durchaus schonmal eine vereinfacherung wenn ich erstmal "nur" die Anzahl an spalten herausfinden muss

 

[lumo]

ich bin grad am kämpfen mit den tabellen... aber es ist schon mal viel einfacher als in Swing

brauche doch recht viel funktionalität drin... leider

 

[Tomate_Salat]

ja habs mitbekommen^^. Aber wenn ich bedenke, wieviel Kampf ich schon mit Swing hatte...naja, ich muss mal schaun, inwiefern ich da von 0 aus anfangen muss :-!.
kleines OT: Ist es mit SWT einfacher Komponenten Transparent zu machen? Die Transparenz in Swing ist ne katastrophe

Und btw, danke für den Tipp mit GridLayout, hat super funktioniert:

        int width   = getWidth();
        int height  = getHeight();
        
        // Fläche berechnen
        int A       = width * height;
        
        // SubFläche berechnen       
        int Asub    = A / ANZ;
        
        // Seitenberechnung
        int w       = (int) Math.sqrt(Asub * 5);
        
        // Spalten definieren
        int y       = 1;
        int x       = 1;
        int anz     = ANZ;
        
        while(width > w)
        {
            width -= w;
            y++;
        }        
        
        while(anz > y)
        {
            anz -= y;
            x++;
        }
        
        // Layout definieren
        GridLayout grd  = new GridLayout();
        grd.setColumns(y);
        grd.setRows(x);
        grd.setHgap(5);
        grd.setVgap(5);
        
        setLayout(grd);
        
        // Buttons einfügen
        for(int i = 0; i < ANZ; i++)
        {
            add(new Button( BTNS[i] ));
        }

Edit oder doch nicht...er zeigt mir die Columns total falsch an :-!. Ich sage: 2 Spalten und er macht alles in eine zeile mit x Spalten.
Edit2 muss glaub auch die Zeilen noch berechnen lassen...naja trotzdem ist die Ausgabe dann noch einfacher als wie ichs vorher hatte
Edit3 Ok iwie scheint es zu funktionieren, das Ergbniss ist auf jeden fall verwertbar

 

[lumo]

gib mal mehr her, dann helf ich mit!
hab deinen code kopiert, da fehlen aber noch ein paar variablen...
oder erklär was es werden soll... vereinfacht

 

[Michael...]

... wer hätte gedacht das Mathe mal wichtig sein würde

Mir wurde das fast jede Mathestunde gesagt ;-)

Wenn das Seitenverhältnis fest und Spalten- oder Zeilenanzahl nicht vorgegeben ist und Du den Platz maximal nutzen möchtest hast Du da ja ein Optimierungsproblem, das Du lösen musst. Bei mir ist der Matheunterricht doch schon eine Weile her, daher muss ich ab hier leider passen...

 

[Tomate_Salat]

Joa hf:

Die ButtonBox

package comp;

import java.awt.GridLayout;

import javax.swing.JComponent;

public class ButtonBox 
    extends JComponent
{
    // Versionierung
    private static final long serialVersionUID = 1L;

    // Konstanten
    public static int MAX_BUTTONS   = 20;
    
    // Variablen
    private String[] BTNS;
    private int ANZ;
    
    /**
     * Erstellt eine Buttonbox
     * 
     * @param buttons Buttontitles
     */
    public ButtonBox(String... buttons) 
    {               
        // Einträge zählen
        int len = buttons.length;
        
        // Wenn mehr als 20 buttons vorhanden
        if(len > MAX_BUTTONS)        
        {
           System.out.println( "Es können nur " + MAX_BUTTONS + " von " + len + " angezeigt werden");
            len = 20;
        }                
        
        // Speichern
        BTNS    = buttons;
        ANZ     = len;
    }    
    
    public void calcButtonPositions()
    {
        // Resourcen sammeln
        int width   = getWidth();
        int height  = getHeight();
        
        // Fläche berechnen
        int A       = width * height;
        
        // SubFläche berechnen       
        int Asub    = A / ANZ;
        
        // Seitenberechnung
        int w       = (int) Math.sqrt(Asub * 5);
        
        // Spalten definieren
        int y       = 1;
        int x       = 1;
        int anz     = ANZ;
        
        while(width > w)
        {
            width -= w;
            y++;
        }        
        
        while(anz > y)
        {
            anz -= y;
            x++;
        }
        
        // Layout definieren
        GridLayout grd  = new GridLayout();
        grd.setColumns(y);
        grd.setRows(x);
        grd.setHgap(5);
        grd.setVgap(5);
        
        setLayout(grd);
        
        // Buttons einfügen
        for(int i = 0; i < ANZ; i++)
        {
            add(new Button( BTNS[i] ));
        }
    }
}

Die [c]Button[/c]'s sind keine AWT's, sondern selbst geschrieben und der quellcode ist 278 Zeilen lang^^. Ich denke da nimmste einfacher normale JButtons für

Mir wurde das fast jede Mathestunde gesagt ;-)

Wenn das Seitenverhältnis fest und Spalten- oder Zeilenanzahl nicht vorgegeben ist und Du den Platz maximal nutzen möchtest hast Du da ja ein Optimierungsproblem, das Du lösen musst. Bei mir ist der Matheunterricht doch schon eine Weile her, daher muss ich ab hier leider passen...

hehe, meiner auch und mein Mathelehrer war en vollidiot. Seine härsteste Aussage:

Ja, das Thema hab ich übersprungen weil ich das langweilig fand

 

[lumo]

lol
awt.gridlayout

und ich wunder mich schon, wie du die buttons addest...

hier mal 'n beispiel in SWT

import org.eclipse.swt.SWT;

public class GRIDD {

	protected Shell shell;

	/**
	 * Launch the application.
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			GRIDD window = new GRIDD();
			window.open();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Open the window.
	 */
	public void open() {
		Display display = Display.getDefault();
		createContents();
		shell.open();
		shell.layout();
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch()) {
				display.sleep();
			}
		}
	}

	/**
	 * Create contents of the window.
	 */
	protected void createContents() {
		shell = new Shell();
		shell.setSize(450, 300);
		shell.setText("SWT Application");

		// spalten
		int ANZ = 5;
		
		// Resourcen sammeln
		int width = shell.getSize().x;
		int height = shell.getSize().y;

		// Fläche berechnen
		int A = width * height;

		// SubFläche berechnen
		int Asub = A / ANZ;

		// Seitenberechnung
		int w = (int) Math.sqrt(Asub * 5);

		// Spalten definieren
		int y = 1;

		while (width > w) {
			width -= w;
			y++;
		}

		// Layout definieren
		GridLayout grd = new GridLayout(y, true);
		shell.setLayout(grd);

		// Buttons einfügen
		for (int i = 0; i < ANZ; i++) {
			Button btn = new Button(shell, SWT.NONE);
			btn.setText("Button "+i);
		}
	}
}

 

[Tomate_Salat]

lol
awt.gridlayout

und ich wunder mich schon, wie du die buttons addest...

Das ist erstmal auf die Schnelle. Das wird so sicherlich nicht bleiben, da jeder noch einen individuellen MouseListener braucht. Aber im Prinzip funktioniert das schon. Die Buttons sind ne eigene Klasse von mir und haben bereits die notwendigste Konfiguration bekommen.

hier mal 'n beispiel in SWT

Im prinzip das Gleiche wie ichs auch habe, nur sind meine Buttons iwie größer:

 

[lumo]

weil ich nicht eingestellt habe, dass er den vollen platz nimmt...

// Buttons einfügen
		for (int i = 0; i < ANZ; i++) {
			Button btn = new Button(shell, SWT.NONE);
			btn.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
			btn.setText("Button "+i);
		}

 

[Tomate_Salat]

stimmt, jz nimmt er den vollen Platz.