Intelligente Anordnung von Frames in einer Fläche

[ankmanu]

Hi,

ich steht zurzeit vor dem folgenden Problem:
Ich habe einen Desktop (jDesktopPane) und kann darauf nun einige JInternalFrames platzieren. Diese Frames kann ich in Höhe und Breite beliebig verändert (bevorzugt bei einen Fenstertypen aber breite > höhe, bei anderen höhe > breite). Nun habe ich schon Funktionen um Sie "cascadiert" anzuzeigen und untereinander.
Code zu cascade:

public void cascadeFrames() {
        int x = 0;
        int y = 0;
        JInternalFrame allFrames[] = desktop.getAllFrames();

        setNormalSize();
        int frameHeight = (desktop.getBounds().height - 5) - allFrames.length * 20;
        int frameWidth = (desktop.getBounds().width - 5) - allFrames.length * 20;
        for (int i = allFrames.length - 1; i >= 0; i--) {
            allFrames[i].setSize(frameWidth,frameHeight);
            allFrames[i].setLocation(x,y);
            x = x + 20;
            y = y + 20;
        }
        if(allFrames.length*20 > desktop.getBounds().width){
            JOptionPane.showMessageDialog(null, "Achtung! Das Fenster ist zu klein, um die Funktion 'cascade' anzuzeigen! Bitte vergrößern Sie das Fenster!", "Fenster zu klein", JOptionPane.WARNING_MESSAGE);
        }
    }

Code zu untereinander:

 public void tileFrames() {
        java.awt.Component allFrames[] = desktop.getAllFrames();
        setNormalSize();
        int frameHeight = desktop.getBounds().height/ allFrames.length;
        int y = 0;
        for (int i = 0; i < allFrames.length; i++) {
            allFrames[i].setSize(desktop.getBounds().width, frameHeight);
            allFrames[i].setLocation(0, y);
            y = y + frameHeight;
        }
    }

Jetzt will ich es schaffen, dass die Fenster noch in einer Art Grid angezeigt werden können, also ein Raster mit einer bestimmten Anzahl an Frames in der Breite und in der Höhe, sodass schließlich quasi der ganze Desktop ausgefüllt ist.
Mein Ansatz war der:

public void gridFrames() {
        java.awt.Component allFrames[] = desktop.getAllFrames();
        setNormalSize();
        int frameHeight = desktop.getBounds().height/ (allFrames.length/2);
        int frameWidth = desktop.getBounds().width/ 4;
        int y = 0;
        int x = 0;
        int q = 0;
        for (int i = 0; i < allFrames.length; i++) {
            allFrames[i].setSize(frameWidth, frameHeight);
            allFrames[i].setLocation(x, y);
            if(q>=4){ x=0; q=0; }else{ x = x + frameWidth; }
            if(x==0){y=y+frameHeight;}else{ y = y; }
            q++;
        }
    }

Aber er stimmt nochnicht ganz. Denn in der ersten "Zeile" ist das letzte Fenster außerhalb des Desktops (es fängt bei dem letzten x des Desktops an). Und außerdem wird der Desktop nicht komplett
ausgefüllt.
Wie kann ich das bewerkstelligen?
Es müsste eben zB so aufgeteilt werden:
Bei 6 Fenstern: 3 Fenster breit + 2 Fenster hoch oder umgekehrt
Bei 20 Fenstern: 5 Fenster breit + 4 Fenster hoch oder umgekehrt

Bei ungeraden Zahlen an Fenstern müsste es logischerweise in der letzten Zeile ein (bzw. mehrere) leere Felder geben.
Hat jemand schonmal einen solchen Code geschrieben bzw. weiß jemand, wie man das Mathematisch macht?

Gruß
manu

 

[Firephoenix]

Hi,
einfach mal ein Ansatz der mir gerade einfällt:
-Du hast x Felder und du musst ein y² finden, das möglichst nah an x aber >= x ist.
Bsp:
du hast 3 Felder, der gesuchte wert y = 2 da 2² =4 und in 4 Felder 3 passen.
Jetzt hast du also irgendwie deinen gesuchten Quadratwert und kennst auch die Größe
deiner Hauptanwendung.
Also kannst du die Koordinaten von z.b. der oberen Linken ecke jedes Feldes berechnen.
Du berechnest z.b. die 1. Obere Linke Ecke (0/0 i.d.R.) und plazierst dort das 1. Frame mit der Größe FensterBreite/y, FensterHöhe/y. Damit wäre das 1. Feld bedeckt.
Jetzt gehst du einst nach rechts und plazierst an (0+FensterBreite/y,0) das nächste Frame mit der Größe FensterBreite/y, FensterHöhe/y.
Das machst du bis die Zeile durch ist (also y mal).
Dann gehst du in die nächste Zeile und plazierst an (0,0+FensterHöhe/y) wieder ein Fenster usw.
Hoffe das ist so verständlich, falls nicht schreib ich das morgen gerne mal in pseudo oder komplettcode runter.
Gruß

Edit:
Wahnsinn zu was für medientechnisch hochwertigen Präsentationsvorlagen ich um die Uhrzeit noch tauge:
http://www.java-forum.org/attachment.php?attachmentid=2713&stc=1&d=1303078475

 

[ankmanu]

Hi,
danke schonmal, vom Ansatz her müsste es stimmen!
Ich hab jetzt folgenden Code, aber irgendwas stimmt nochnicht ganz:

 public void gridFrames() {
        java.awt.Component allFrames2[] = desktop.getAllFrames();
        System.out.println(allFrames2.length);
        setNormalSize();

        int i=0;
        int f=0;        
        do{
           f= i*i;
           i++; 
        }while(f<allFrames2.length);
        f= (int) Math.sqrt(f);
        System.out.println(f);
        
        int frameHeight = desktop.getBounds().height/f;
        int frameWidth = desktop.getBounds().width/f;
        

        int y = 0;
        int h = 0;
        do{
            int x = 0;
        
            for(e=0; e<f; e++){
                System.out.println(e);
                allFrames2[e].setSize(frameWidth, frameHeight);
                allFrames2[e].setLocation(x, y);
                x = x+frameWidth;
                y = y;
                
                System.out.println("x= "+x);
                System.out.println("y= "+y);
            }
            x=0;
            y=y+frameHeight;
            h++;
        }while(h < f);
    }

Bei 21 Fenster rechnet er richtig als f = 5 aus. Es wird eine Reihe von fünf Fenstern aber am unteren Desktoprand angezeigt!? Aber eigentlich müssten die Fenster richtig platziert sein, in der Konsole kommt:

21
5
0
x= 298
y= 0
1
x= 596
y= 0
2
x= 894
y= 0
3
x= 1192
y= 0
4
x= 1490
y= 0
0
x= 298
y= 189
1
x= 596
y= 189
2
x= 894
y= 189
3
x= 1192
y= 189
4
x= 1490
y= 189
0
x= 298
y= 378
1
x= 596
y= 378
2
x= 894
y= 378
3
x= 1192
y= 378
4
x= 1490
y= 378
0
x= 298
y= 567
1
x= 596
y= 567
2
x= 894
y= 567
3
x= 1192
y= 567
4
x= 1490
y= 567
0
x= 298
y= 756
1
x= 596
y= 756
2
x= 894
y= 756
3
x= 1192
y= 756
4
x= 1490
y= 756

(also die x- und y-werte stimmen!)
Wenn ich die do-while Schleife entferne (also quasi nur die erste Reihe anzeigen lasse) dann klappt alles. Fenster an der richtigen Position etc. Aber ich kann meinen Fehler in der Schleife nicht finden...

Gruß
manu

 

[Firephoenix]

Hi,
schau dir die Schachtelung der Schleifen nochmal genau an.
Du änderst einmal die Werte nachdem du sie zum plazieren verwendest und gibst sie erst dann aus,

allFrames2[e].setSize(frameWidth, frameHeight);
                allFrames2[e].setLocation(x, y);
                x = x+frameWidth;
                y = y;
                
                System.out.println("x= "+x);
                System.out.println("y= "+y);

außerdem werden deine Frames so nie fortlaufend plaziert, da e bei jedem innerem durchlauf wieder 0 ist.
Prüfe nochmal genauer was der Code macht und versuch mal die Schleifenstruktur etwas zu verbessern.
Gruß

 

[ankmanu]

Hi,

super, jetzt klappts! Für die, die den Code haben wollen:

 public void gridFrames() {
        java.awt.Component allFrames2[] = desktop.getAllFrames();
        setNormalSize();

        int i=0;
        int f=0;        
        do{
           f= i*i;
           i++; 
        }while(f<allFrames2.length);
        f= (int) Math.sqrt(f);
        
        int frameHeight = desktop.getBounds().height/f;
        int frameWidth = desktop.getBounds().width/f;
        
        int y = 0;
        int j = 0;
        int x = 0;
        for(int h=0;h<f;h++){ 
            for(e=0; e<f; e++){
                if(j < allFrames2.length){
                    allFrames2[j].setSize(frameWidth, frameHeight);
                    allFrames2[j].setLocation(x, y);
                }
                x = x+frameWidth;
                y = y;
                j++;                
            }
            j = j++;
            x = 0;
            y = y+frameHeight;
            
        }
    }

Nur eine Frage noch: Jetzt ist es wie folgt: Wenn ich zB 21 Fenster hab, sieht das Raster perfekt aus, denn f wäre in dem Fall 5 (also 5 Fenster breite, 5 Fenster Höhe). Damit ist auch in der letzten Reihe ein Fenster vorhanden:


Wenn ich aber zB nur 19 Fenster habe, dann ist ja f auch 5 (also auch 5 Reihen breit, 5 hoch) und damit ist in der letzten Zeile kein Frame mehr!

Man müsste also zB alle Fenster in der letzten Reihe in der Höhe soweit vergrößern, bis der Desktop komplett ausgefüllt ist...
Hat jemand ne Idee, das umzusetzen?

Gruß und danke nochmal
manu