Swing maximale quadratische Größe

Status des Themas:
Es sind keine weiteren Antworten möglich.

Diskutiere maximale quadratische Größe im AWT, Swing, JavaFX & SWT Forum; Hallo, wenn ich eine Komponente in ein GridbagLayout eingeflechted habe, wie kann ich es erreichen, dass sie immer quadratisch, aber eben...

  1. banshee
    banshee Neues Mitglied
    Hallo,

    wenn ich eine Komponente in ein GridbagLayout eingeflechted habe, wie kann ich es erreichen, dass sie immer quadratisch, aber eben maximale Größe auf dem Anzeigebereich hat? Einfach mit setPreferredSize einen fixen Wert einzutragen bringt da ja nichts, weil es auf Monitoren anderer Größe dann wieder komplett anders aussieht.
    Meine theoretische Lösung wäre ja folgende: Komponente erstellen, Defaultsize berechnen lassen, an der längeren Achse so verkleinern, dass sie quadratisch ist. Allerdings scheint das berechnen der Defaultsize ja einer der letzten Schritte vor dem Anzeigen zu sein (auch wenn ich mich mit den internen Mechanismen jetzt nicht 100%ig auskenne)
     
  2. Vielleicht hilft dir dieser Kurs hier weiter --> (hier klicken)
  3. Guybrush Threepwood
    Guybrush Threepwood Neues Mitglied
  4. Marco13
    Marco13 Gesperrter Benutzer
    Hm ... ich hatte mal ein AspectLayout geschrieben, das eine einzelne Component mit einem bestimmten Seitenverhältnis (bei dir: 1.0) anzeigt - kann ich mal posten, wenn ich wieder am ensprechenden Rechner sitze...
     
  5. banshee
    banshee Neues Mitglied
    ja, das wäre prima. Ich hab mir die JGoodies Forms mal angeschaut und finde das auch für die Zukunft sehr interessant, aber das jetzt noch irgendwie in das Projekt zu quetschen, obwohl der Rest schon mit anderen Layout-Managern gemacht ist, sieht dann am Ende auch nicht schön aus.
    Außerdem hab ich es bis jetzt noch nicht raus, wie ich da eine Komponente quadratisch mache. Muss ich die columns dann in dlu so festlegen, dass sie quadratisch sind und die Komponente immer mitstauchen?

    Ich habe hier mal einen screenshot von dem Panel gemacht, wo ich das brauche:

    [​IMG]

    Hier sollten also das große Panel oben links und die 8 kleinen unten immer quadratisch sein. Ich sehe hier vor allen Dingen einen Konflikt mit dem rowspan aufkommen. Wenn ich nämlich einstelle, dass das obere Panel über den 7 kleinen liegt, wird es doch automatisch immer verlängert, auch wenn es schon nach 5 aufhören müsste, um quadratisch zu bleiben?!
     
  6. Marco13
    Marco13 Gesperrter Benutzer
    Aufgrund seiner Trivialität hiermit ins public domain entlassen:

    Code (Java):

    import java.awt.*;

    /**
     * An implementation of the LayoutManager interface, for containers
     * that contain a single component that should be as large as
     * possible under the constraint that a given aspect ratio
     * (width/height) is maintained.
     */

    public class AspectLayout implements LayoutManager
    {
        /**
         * The current aspect that should be maintained
         */

        private float aspect = 1.0f;
       
        /**
         * The alignment in horizontal or vertical direction.
         * If there is extra space in either direction, then
         * the component will aligned according to this value
         */

        private float alignment = 0.5f;
       
        /**
         * Creates a new AspectLayout for the given aspect
         *
         * @param aspect The aspect for the contained component
         */

        public AspectLayout(float aspect)
        {
            this.aspect = aspect;
        }

        /**
         * Creates a new AspectLayout for the given aspect and
         * alignment
         *
         * @param aspect The aspect for the contained component
         * @param alignment The alignment for the contained component
         */

        public AspectLayout(float aspect, float alignment)
        {
            this.aspect = aspect;
            this.alignment = alignment;
        }
       
        /**
         * {@inheritDoc}
         */

        public void addLayoutComponent(String name, Component comp)
        {
        }

        /**
         * {@inheritDoc}
         */

        public void layoutContainer(Container parent)
        {
            synchronized (parent.getTreeLock())
            {
                if (parent.getComponentCount() == 0)
                {
                    return;
                }
                Insets insets = parent.getInsets();
                int maxWidth = parent.getWidth() - (insets.left + insets.right);
                int maxHeight = parent.getHeight() - (insets.top + insets.bottom);
               
                int maxAspectW = (int)(maxHeight * aspect);
                int maxAspectH = (int)(maxWidth / aspect);
               
                //System.out.println("maxAspectW "+maxAspectW+" "+maxAspectH+" maxAspectH");
               
                Component component = parent.getComponent(0);
               
                if (maxAspectW > maxWidth)
                {
                    int w = maxWidth;
                    int h = maxAspectH;
                    int space = maxHeight - h;
                    int offset = (int)(alignment * space);
                    component.setBounds(insets.left, insets.top + offset, w, h);
                }
                else
                {
                    int w = maxAspectW;
                    int h = maxHeight;
                    int space = maxWidth - w;
                    int offset = (int)(alignment * space);
                    component.setBounds(insets.left+offset, insets.top, w, h);
                }
            }
        }

        /**
         * {@inheritDoc}
         */

        public Dimension minimumLayoutSize(Container parent)
        {
            if (parent.getComponentCount() == 0)
            {
                return new Dimension(0,0);
            }
            Component component = parent.getComponent(0);
            return component.getMinimumSize();
        }

        /**
         * {@inheritDoc}
         */

        public Dimension preferredLayoutSize(Container parent)
        {
            if (parent.getComponentCount() == 0)
            {
                return new Dimension(0,0);
            }
            Component component = parent.getComponent(0);
            return component.getPreferredSize();
        }

        /**
         * {@inheritDoc}
         */

        public void removeLayoutComponent(Component comp)
        {
        }

        /**
         * {@inheritDoc}
         */

        @Override
        public String toString()
        {
            return getClass().getName() + "[aspect=" + aspect + "]";
        }
       
        /*/
        public static void main(String args[])
        {
            javax.swing.JFrame f = new javax.swing.JFrame();
            f.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
            f.getContentPane().setLayout(new AspectLayout(2.0f));
            javax.swing.JPanel p = new javax.swing.JPanel()
            {
                public void paintComponent(Graphics g)
                {
                    super.paintComponent(g);
                    g.setColor(Color.BLACK);
                    g.drawString(""+getSize(), 10, 20);
                }
            };
            p.setPreferredSize(new Dimension(700,200));
            p.setBackground(Color.RED);
            f.getContentPane().add(p);
            f.pack();
            f.setVisible(true);
        }
        //*/

       
    }
     
     
  7. Marco13
    Marco13 Gesperrter Benutzer
    Noch als Nachtrag: Ich hatte das verwendet, um ein Spielfeld mit einem bestimmten Seitenverhältnis darzustellen. Bei dir wäre dann im oberen linken Panel das AspectLayout, und IN dem Panel dann der eigentliche Inhalt, der immer Quadratisch sein soll. Dass das bei der Anforderung, dass bestimmte Comonents immer Quadratisch sein sollen, zu Widersrpüchen kommen kann, ist klar, deswegen legt das AspectLayout immer nur EINE Component in ein (ansonsten leeres) Panel, und läßt ggf. links&rechts bzw. oben&unten ein bißchen Platz...
     
  8. banshee
    banshee Neues Mitglied
    Vielen Dank, funktioniert super. Ich habe allerdings das Gefühl, dass mir Swing einfach den nächst größeren Stein in die Bahn wirft, sobald ein Problem gelöst ist. Schaut euch zu folgendem unbedingt nochmal den Screenshot an.

    Ich zeichne also eine Matrix mit Java2D oben links. Wenn es gut läuft, passt sie genau ins Fenster und alle sind glücklich. Wenn es schlecht läuft, ist die Matrix allerdings so riesig, dass nur ein Teil ins Bild passt und der Rest per Scrollbalken angezeigt wird.
    Das wird zum Problem, wenn ich danach eine Matrix lade, die normalerweise wieder ins Bild passen würde. Ich schaue mir nämlich zuerst die Initialwerte des Panels an, versuche die Matrix dann erst so zu zeichnen, dass sie genau reinpasst und schalte eben die Scrollbalken ein, falls die Größe einer Zeller kleiner als x Pixel ist. Wenn ich die Größe dann durch eine Riesenmatrix aber verändert habe, zeichnet er auch z.B. eine 3x3 Matrix in dieses Riesenpanel mit den Scrollbalken. Ich bräuchte also einen Befehl, der das JPanel in seinen Ursprungszustand zurückversetzt, damit ich die wirklichen Initialwerte (= als das Panel noch komplett leer war) bekomme. Gibt es sowas?
     
  9. Marco13
    Marco13 Gesperrter Benutzer
    ???:L Häh? Man kann z.B. bei einer Scollbar die "policy" setzen, wann Scrollbalken angezeugt werden... ?! Poste notfalls mal ein Stück code...
     
  10. banshee
    banshee Neues Mitglied
    Ja ich benutze einfach das Std-Dingens mit VERT/HORZ_AS_NEEDED. Aber folgendermaßen:

    Code (Java):
    private void initPaint() {
            double minLen = (getWidth() < getHeight()) ? getWidth() : getHeight();
            rectSize = (float)minLen / colCount;

            if(rectSize < 10.0f)
                rectSize = 10.0f;

            Font font = new Font("Dialog", Font.PLAIN, 10);
            setFont(font);
        }
    Das ist der Code, der immer dann ausgeführt wird, wenn man eine neue Matrix zeichnet. Zeichne ich also eine Riesenmatrix, wird die Größe des JPanels verändert und wenn ich die Funktion oben das nächste mal aufrufe, rechnet sie eben mit der veränderten Größe weiter und er zeichnet auch kleine Matrizen in das Riesenpanel, was zur Folge hat, dass die Zellen riesig sind und trotzdem nur ein Teil sichtbar ist, obwohl die Matrix ganz in das Panel passen würde. Ich könnte natürlich einfach die Größe der ScrollPane abfragen, nur von der weiß das Panel, in dem die obere Funktion ist, nichts.

    Was ich übrigens auch festgestellt hab: Wenn die Matrix zu groß ist, verändere ich die Panelgröße einfach mit setPreferredSize(). Er zeigt dann auch Scrollbalken an, verschiebt aber trotzdem jedesmal das gesamte Layout.

    Erstellt wird das ganze einfach so:

    Code (Java):
    JScrollPane scrollPane = new JScrollPane(bigPanel);
                   
            layout.setConstraints(scrollPane, new GridBagConstraints(0, 0, 7, 1, 1, 4,
                    GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0,
                    0));
    Und wenn ich das große Panel einfach direkt mal auf 600x600 setze, schiebt er die restlichen Komponenten einfach weg, obwohl die ScrollPane einfach Balken anzeigen sollte, anstatt ihre Größe zu ändern. Wie verhindere ich das?

    [​IMG]
     
  11. Marco13
    Marco13 Gesperrter Benutzer
    Zusammengefasst würde das jetzt etwa lauten: Wenn ich etwas mache und dann noch etwas ist das Layout nicht so, wie ich es will.

    Ein KSKB würde evtl. wirklich helfen...
     
Die Seite wird geladen...

maximale quadratische Größe - Ähnliche Themen

quadratisches Sieb - Summe an maximalen Iterationen
quadratisches Sieb - Summe an maximalen Iterationen im Forum Mathematik
Maximale Anzahl offener Cursor überschritten
Maximale Anzahl offener Cursor überschritten im Forum Datenbankprogrammierung
Größe einer JComboBox im GridBagLayout aufgrund der maximalen Länge der enthaltenen Daten
Größe einer JComboBox im GridBagLayout aufgrund der maximalen Länge der enthaltenen Daten im Forum AWT, Swing, JavaFX & SWT
JVM Maximaler HeapSize
JVM Maximaler HeapSize im Forum Allgemeine Java-Themen
Maximale Teilsumme ermitteln
Maximale Teilsumme ermitteln im Forum Java Basics - Anfänger-Themen
Status des Themas:
Es sind keine weiteren Antworten möglich.
Thema: maximale quadratische Größe