[Java] Problema posizionamento JPanel in JPanel

[UnknownSoldier]

Salve a tutti. Vorrei inserire dei piccoli JPanel che hanno una dimensione fissa, all'interno di un JPanel, e vorrei fare in modo che quelli che si trovano all'interno, vadino a capo quando lo spazio della finestra finisce, ed evitare che questi continuino a stare uno affianco all'altro fino al punto di creare una lunga barra da scrollare in orizzontale.

Qualche idea?

[*andre*]

Originariamente inviato da UnknownSoldier

Salve a tutti. Vorrei inserire dei piccoli JPanel che hanno una dimensione fissa, all'interno di un JPanel, e vorrei fare in modo che quelli che si trovano all'interno, vadino a capo quando lo spazio della finestra finisce, ed evitare che questi continuino a stare uno affianco all'altro fino al punto di creare una lunga barra da scrollare in orizzontale.

Qualche idea?

potresti usare un gridlayout per il panel contenitore, che dispone gli altri secondo una griglia e li inserisce per default da sinistra a destra andando a capo quando raggiunge il numero di colonne che hai impostato. http://java.sun.com/javase/6/docs/api/ qui cerca gridlayout e c'è tutto spiegato

[UnknownSoldier]

Grazie ma io vorrei che i JPanel andassero a capo quando non c'è più spazio nella finestra! E se allargo la finestra questi si adattano alle nuove dimensioni.

[MEMon]

Un semplice flowlayout non la fa già di suo?

[UnknownSoldier]

Purtroppo non è così, continua ad aggiungermi i JPanel uno dopo l'altro senza mai andare a capo...

[MEMon]

Metti un flowlayout con allineamento a sinistra, va a capo per forza quando finisce lo spazio.

[UnknownSoldier]

Ho provato a non utilizzare lo JScrollPane e funziona! Però purtroppo in questo modo non compare la barra laterale per scrollare o_O

[MEMon]

ah ecco, è un problema del JScrollPane (usi quello vero?) che non restituisce la dimensione preferredsize corretta.

Per risolvere prova a settare (setPreferredSize) la dimensione dinamicamente quando il panello viene ridimensionato.

[UnknownSoldier]

Originariamente inviato da MEMon

ah ecco, è un problema del JScrollPane (usi quello vero?) che non restituisce la dimensione preferredsize corretta.

Per risolvere prova a settare (setPreferredSize) la dimensione dinamicamente quando il panello viene ridimensionato.

Ma se imposto le dimensioni, sono costretto a fissare anche l'altezza, che varia in base agli elementi contenuti!

[MEMon]

Hai ragione non ci avevo pensato.

Potresti allora utilizzare una JScrollBar e scrivere tu il codice per lo scroll, come la vedi?

[UnknownSoldier]

Originariamente inviato da MEMon

Hai ragione non ci avevo pensato.

Potresti allora utilizzare una JScrollBar e scrivere tu il codice per lo scroll, come la vedi?

Cioè? o_O

[MEMon]

Invece di usare uno scroll pane usi una JScrollbar e scrivi a mano il codice per fare lo scroll, in pratica ti fai un componente apposta per quello che ti serve.

La scrollbar quando viene mossa lancia l'evento adjustmentValueChanged, te devi catturare quell'evento e "scrollare" il tuo pannello con flowlayout.

[PGI-Bis]

Sei incappato nel mitico problema del FlowLayout e del JScrollPane. E' veramente un incrocio straordinario di caratteri particolari.

Capita che il JViewport del JScrollPane faccia crescere a piacere, in larghezza, il componente incapsulato che usi un FlowLayout.

Una soluzione rapida sta nel fissare la dimensione del componente che usa FlowLayout (con setPreferredSize, che di norma non fissa ma in un JViewport ha questo effetto).

Una soluzione meno rapida ma più flessibile consiste nel creare un simil-FlowLayout che corregga quel conflitto.

Negli androni di un hard disk ho trovato questo LayoutManager che, se non ricordo male, affrontava esattamente quel problema. Non ricordo però se l'avesse anche risolto. Tentar non nuoce. Anzichè dire:

x = new JPanel() // o new JPanel(new FlowLayout())

basta dire:

x = new JPanel(TableLayout.newInstance());

Segue codicillo.

package it.tukano.jupiter.modules.basic.common;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.util.LinkedList;

/**
 * A layout manager similar to FlowLayout but that will not cause the container to
 * grow in width.
 * @author pgi
 */
public class TableLayout implements LayoutManager {

    /** Creator */
    public static TableLayout newInstance() {
        return new TableLayout();
    }

    /** Default empty constructor, not used. */
    protected TableLayout() {
    }

    /**
     * Unused
     * @param name
     * @param comp
     */
    public void addLayoutComponent(String name, Component comp) {
    }

    /**
     * Unused
     * @param comp
     */
    public void removeLayoutComponent(Component comp) {
    }

    /**
     * The preferred layout size depends upon the actual width of the container.
     * The size is the width and the minumum height sufficient to display all
     * the children of the container along their preferred size.
     * @param parent
     * @return the preferred size for the parent container.
     */
    public Dimension preferredLayoutSize(Container parent) {
        synchronized (parent.getTreeLock()) {
            int width = parent.getWidth();
            int height = parent.getHeight();
            Insets margins = parent.getInsets();
            int availableWidth = width - margins.left - margins.right;
            Component[] children = parent.getComponents();

            RowBuilder rowBuilder = new RowBuilder(availableWidth);
            for (Component c : children) {
                rowBuilder.push(c);
            }

            Dimension dim = rowBuilder.computeSize();
            dim.width += margins.left + margins.right;
            dim.height += margins.top + margins.bottom;
            return dim;
        }
    }

    /**
     * Returns the preferred layout size.
     * @param parent the component to layout
     * @return the minimum layout size.
     */
    public Dimension minimumLayoutSize(Container parent) {
        return preferredLayoutSize(parent);
    }

    /**
     * Assign bounds to the child of the given container.
     * @param parent the container to layout
     */
    public void layoutContainer(Container parent) {
        synchronized (parent.getTreeLock()) {

            int width = parent.getWidth();
            int height = parent.getHeight();
            Insets margins = parent.getInsets();

            int availableWidth = width - margins.left - margins.right;
            int availableHeight = height - margins.top - margins.bottom;

            RowBuilder rowBuilder = new RowBuilder(availableWidth);

            for (Component c : parent.getComponents()) {
                rowBuilder.push(c);
            }

            rowBuilder.assignBounds(margins.left, margins.top);
        }
    }

    private static class RowBuilder {

        private LinkedList<Row> rows = new LinkedList<Row>();
        private int currentX;
        private final int width;
        private Row currentRow = new Row();

        private RowBuilder(int width) {
            this.width = width;
            rows.add(currentRow);
        }

        void push(Component c) {
            Dimension dim = c.getPreferredSize();
            if (currentX + dim.width >= width) {
                currentRow = new Row();
                rows.add(currentRow);
                currentX = 0;
            }
            currentX += dim.width;
            currentRow.add(c);
        }

        void assignBounds(int originX, int originY) {
            int y = originY;
            for (Row r : rows) {
                r.assignBounds(originX, y);
                y += r.getHeight();
            }
        }

        Dimension computeSize() {
            Dimension dim = new Dimension();
            for (Row r : rows) {
                dim.width = Math.max(dim.width, r.getWidth());
                dim.height += r.getHeight();
            }
            return dim;
        }
    }

    private static class Row {

        private LinkedList<Component> components = new LinkedList<Component>();
        private int height = 0;
        private int width = 0;

        void assignBounds(int originX, int originY) {
            int x = originX;
            for (Component c : components) {
                Dimension dim = c.getPreferredSize();
                c.setBounds(x, originY, dim.width, dim.height);
                x += dim.width;
            }
        }

        void add(Component c) {
            Dimension dim = c.getPreferredSize();
            components.add(c);
            height = Math.max(height, dim.height);
            width += dim.width;
        }

        int getWidth() {
            return width;
        }

        int getHeight() {
            return height;
        }
    }
}

[UnknownSoldier]

Originariamente inviato da PGI-Bis

Sei incappato nel mitico problema del FlowLayout e del JScrollPane. E' veramente un incrocio straordinario di caratteri particolari.

Capita che il JViewport del JScrollPane faccia crescere a piacere, in larghezza, il componente incapsulato che usi un FlowLayout.

Una soluzione rapida sta nel fissare la dimensione del componente che usa FlowLayout (con setPreferredSize, che di norma non fissa ma in un JViewport ha questo effetto).

Una soluzione meno rapida ma più flessibile consiste nel creare un simil-FlowLayout che corregga quel conflitto.

Negli androni di un hard disk ho trovato questo LayoutManager che, se non ricordo male, affrontava esattamente quel problema. Non ricordo però se l'avesse anche risolto. Tentar non nuoce. Anzichè dire:

x = new JPanel() // o new JPanel(new FlowLayout())

basta dire:

x = new JPanel(TableLayout.newInstance());

Segue codicillo.

package it.tukano.jupiter.modules.basic.common;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.util.LinkedList;

/**
 * A layout manager similar to FlowLayout but that will not cause the container to
 * grow in width.
 * @author pgi
 */
public class TableLayout implements LayoutManager {

    /** Creator */
    public static TableLayout newInstance() {
        return new TableLayout();
    }

    /** Default empty constructor, not used. */
    protected TableLayout() {
    }

    /**
     * Unused
     * @param name
     * @param comp
     */
    public void addLayoutComponent(String name, Component comp) {
    }

    /**
     * Unused
     * @param comp
     */
    public void removeLayoutComponent(Component comp) {
    }

    /**
     * The preferred layout size depends upon the actual width of the container.
     * The size is the width and the minumum height sufficient to display all
     * the children of the container along their preferred size.
     * @param parent
     * @return the preferred size for the parent container.
     */
    public Dimension preferredLayoutSize(Container parent) {
        synchronized (parent.getTreeLock()) {
            int width = parent.getWidth();
            int height = parent.getHeight();
            Insets margins = parent.getInsets();
            int availableWidth = width - margins.left - margins.right;
            Component[] children = parent.getComponents();

            RowBuilder rowBuilder = new RowBuilder(availableWidth);
            for (Component c : children) {
                rowBuilder.push(c);
            }

            Dimension dim = rowBuilder.computeSize();
            dim.width += margins.left + margins.right;
            dim.height += margins.top + margins.bottom;
            return dim;
        }
    }

    /**
     * Returns the preferred layout size.
     * @param parent the component to layout
     * @return the minimum layout size.
     */
    public Dimension minimumLayoutSize(Container parent) {
        return preferredLayoutSize(parent);
    }

    /**
     * Assign bounds to the child of the given container.
     * @param parent the container to layout
     */
    public void layoutContainer(Container parent) {
        synchronized (parent.getTreeLock()) {

            int width = parent.getWidth();
            int height = parent.getHeight();
            Insets margins = parent.getInsets();

            int availableWidth = width - margins.left - margins.right;
            int availableHeight = height - margins.top - margins.bottom;

            RowBuilder rowBuilder = new RowBuilder(availableWidth);

            for (Component c : parent.getComponents()) {
                rowBuilder.push(c);
            }

            rowBuilder.assignBounds(margins.left, margins.top);
        }
    }

    private static class RowBuilder {

        private LinkedList<Row> rows = new LinkedList<Row>();
        private int currentX;
        private final int width;
        private Row currentRow = new Row();

        private RowBuilder(int width) {
            this.width = width;
            rows.add(currentRow);
        }

        void push(Component c) {
            Dimension dim = c.getPreferredSize();
            if (currentX + dim.width >= width) {
                currentRow = new Row();
                rows.add(currentRow);
                currentX = 0;
            }
            currentX += dim.width;
            currentRow.add(c);
        }

        void assignBounds(int originX, int originY) {
            int y = originY;
            for (Row r : rows) {
                r.assignBounds(originX, y);
                y += r.getHeight();
            }
        }

        Dimension computeSize() {
            Dimension dim = new Dimension();
            for (Row r : rows) {
                dim.width = Math.max(dim.width, r.getWidth());
                dim.height += r.getHeight();
            }
            return dim;
        }
    }

    private static class Row {

        private LinkedList<Component> components = new LinkedList<Component>();
        private int height = 0;
        private int width = 0;

        void assignBounds(int originX, int originY) {
            int x = originX;
            for (Component c : components) {
                Dimension dim = c.getPreferredSize();
                c.setBounds(x, originY, dim.width, dim.height);
                x += dim.width;
            }
        }

        void add(Component c) {
            Dimension dim = c.getPreferredSize();
            components.add(c);
            height = Math.max(height, dim.height);
            width += dim.width;
        }

        int getWidth() {
            return width;
        }

        int getHeight() {
            return height;
        }
    }
}

Grazie mille, FUNZIONA! Certo che è strano il fatto che in Java per avere un effetto del genere bisogna ricorrere a simili stregonerie