# Problem mit JScrollPane und JPane(FlowLayout)



## Nick_Spick (7. Nov 2005)

Hallo zusammen,

habe gestern abend viel Zeit damit verbracht im Internet nach ner Lösung zu suchen, aber leider nix hilfreiches gefunden. Ich vermute auch, dass ich einfach was übersehen habe oder schlicht die Bedeutung noch nicht so erfasst. 

Und zwar geht es um folgendes:
Ich habe mir eine Klasse AnalogControllPanel implements ControllInterface extends Jpane gemacht. Hierin wird einfach ein Schieberegler und eine Digitalanzeige angezeigt. Das ganze hat eine preferedSize und ist 230*230 groß. 
Hiervon möchte ich nun beliebig viele Elemente auf einem weiteren JPane (JPaneControllPanel) anordnen und zwar von Links nach rechts und von oben nach unten. Das allein klingt ja schonmal nach Flowlayout für das JPaneControllPanel. Sehr praktisch, das dies ja auch alles genau nach dem Schema anordnet. Das JPaneControllPanel muss dabei natürlich seine größe an die Elementeanzahl anpassen. Und weil ich jetzt noch nicht weiß, wie viele von den AnalogControllPanels da rein kommen, muss das ganze eben in ein JScrollPane (JScrollPaneControllPanel). Hab ja schließlich nur einen kleinen Monitor.

Ich habe es bisher geschaft, das ganz an zu ordnen und in das JScrollPaneControllPanel einzubauen. Problem hierbei ist jedoch, das er im Flowlayout auf dem JPaneControllPanel zwar die AnalogControllPanels richtig anordnet, aber der Scrollbalken des übergeordneten JScrollPaneControllPanels nicht scrollbar ist. Ich kann also schlicht den Viewport Inhalt nicht verschieben. Ich habe das ganze schonmal mit null Layout probiert, da ging es sofort, nur da muss ich mich leider um die Anordnung der Elementer selber kümmern, und das ist ja echer sinnlos, wenn es einen Layoutmanager gibt der es schon genau so macht, wie ich mir das vorstelle.

Wer sich da ein Bild von machen will, was ich meine:
http://imode.ba-stuttgart.de/prozess/NetVis/Applet/

Mann sieht zwar, dass der FlowLayourManager die AnalogControllPanels alle schön neben einander anordnet und auch umbricht, da er ja eine MaxSize hat, die ihn in der x-Achse einschränkt, aber die Scrollingfunktion wird nicht aktiev. Warum?

Der Relevante Code dazu ist der hier:


```
import javax.swing.JPanel;
import javax.swing.JApplet;
import javax.swing.JScrollPane;
import javax.swing.JToggleButton;
import javax.swing.JTextField;
import javax.swing.JViewport;
import java.awt.FlowLayout;


public class NetProzessGUI extends JPanel {

	private JPanel jContentPaneControllPanel=null;
	private JScrollPane jScrollPaneControllPane = null;
	private JToggleButton jToggleButtonProzessHoheit = null;
	private JTextField jTextFieldStatus = null;
	private Konfiguration konfig=new Konfiguration();
	/**
	 * This is the default constructor
	 */
	public NetProzessGUI(Konfiguration konfig) {
		super();
		this.konfig=konfig;				//Beinhaltet Datensätze zur Konfiguration der AnalogControllPanels
		initialize();
	}

	/**
	 * This method initializes jContentPane
	 * 
	 * Initialisiert das HauptPanel
	 * 
	 * @return javax.swing.JPanel
	 */
	private void initialize(){
			this.setLayout(null);
			this.setSize(800, 600);
			this.setPreferredSize(new java.awt.Dimension(800,600));
			this.setLocation(new java.awt.Point(0,0));
			this.setSize(new java.awt.Dimension(800,600));
			this.setMinimumSize(new java.awt.Dimension(800,600));
			this.setMaximumSize(new java.awt.Dimension(800,600));
			this.setName("MainControllPanel");
			this.add(getJScrollPaneControllPane(), null);
	}

	/**
	 * This method initializes jScrollPaneControllPane	
	 * 	
	 * Initialisiert das ScrollPanel
	 * 
	 * @return javax.swing.JScrollPane	
	 */
	private JScrollPane getJScrollPaneControllPane() {
		
		try{
			if (jScrollPaneControllPane == null) {
				jScrollPaneControllPane = new JScrollPane();
				jScrollPaneControllPane.setMaximumSize(new java.awt.Dimension(490,580));
				jScrollPaneControllPane.setLocation(new java.awt.Point(300,10));
				jScrollPaneControllPane.setSize(new java.awt.Dimension(490,580));
				jScrollPaneControllPane.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
				jScrollPaneControllPane.setViewportView(getJContentPaneControllPanel());
				jScrollPaneControllPane.setMinimumSize(new java.awt.Dimension(490,580));
				jScrollPaneControllPane.setVerticalScrollBarPolicy(javax.swing.JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
				jScrollPaneControllPane.setHorizontalScrollBarPolicy(javax.swing.JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
			}
			return jScrollPaneControllPane;
		}
		catch(Exception e){
			System.out.println("Fehler bei Panelerstellung: "+e);
			return null;
		}
	}

	
	
	/**
	 * This method initializes JContentPaneControllPanel	
	 * 	
	 * Initialisiert das ControllPanel, welches die Steuerelemente beinhaltet und im ScrollPanel angezeigt wird. 
	 * 
	 * @return javax.swing.JTextField	
	 */	
	
	private JPanel getJContentPaneControllPanel() {
	
		if (jContentPaneControllPanel == null) {
			jContentPaneControllPanel = new JPanel();
			//jContentPaneControllPanel.setLayout(null);
			jContentPaneControllPanel.setLayout(new FlowLayout());
			jContentPaneControllPanel.setLocation(new java.awt.Point(0,0));
			//jContentPaneControllPanel.setSize(new java.awt.Dimension(500,600));
			//jContentPaneControllPanel.setMinimumSize(new java.awt.Dimension(240,250));
			jContentPaneControllPanel.setMaximumSize(new java.awt.Dimension(240,32000));
			jContentPaneControllPanel.setPreferredSize(new java.awt.Dimension(240,250));
			jContentPaneControllPanel.setName("ScrollControllPanel");
			
			//Hinzufügen der Controllelemente
			int xpos=0;
			int ypos=0;
			/*for(int anz=0;anz<konfig.getNrOfProzesses();anz++){
				JPanel cp;
				jContentPaneControllPanel.add(cp=(JPanel)ControllPanel.select(konfig.getParameter(anz),xpos,ypos));
			
			//Der Fersuch im null Layout die ControllPanels selber anzuordnen
				xpos=xpos+cp.getWidth();
				if(xpos>=460){
					xpos=0;
					ypos=ypos+cp.getHeight();
				}			
			}*/
				//So gehts besser mit FlowLayout
			for(int anz=0;anz<konfig.getNrOfProzesses();anz++){
				jContentPaneControllPanel.add((JPanel)ControllPanel.select(konfig.getParameter(anz),0,0));
			}
		}
		return jContentPaneControllPanel; 
	}

}
```


----------



## Illuvatar (7. Nov 2005)

Entferne mal das
jContentPaneControllPanel.setPreferredSize(new java.awt.Dimension(240,250));

damit sagst du der scrollpane nämlich, dass dein dingi nur 250 px hoch sein soll


----------



## André Uhres (7. Nov 2005)

```
/*
 * Control_Panels.java
 */
import java.awt.*;
import java.awt.event.*;
import java.math.*;
import javax.swing.*;
public class Control_Panels extends JApplet {
    public void init() {
        try {
            EventQueue.invokeAndWait(new Runnable() {
                public void run() {
                    initComponents();
                }
            });
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    private void initComponents(){
        //JComponents erzeugen:
        toolbar = new JToolBar();
        addBtn = new JButton("Add Panel");
        mainPanel = new JPanel();
        //Layout:
        toolbar.setFloatable(false);
        toolbar.add(addBtn);
        getContentPane().add(toolbar, BorderLayout.NORTH);
        mainPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
        getContentPane().add(new JScrollPane(mainPanel), BorderLayout.CENTER);
        //Listener:
        addBtn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                JPanel panel = new JPanel();
                panel.setBorder(BorderFactory.createLineBorder(new Color(0, 0, 0)));
                panel.setPreferredSize(new Dimension(150, 150));
                mainPanel.add(panel);
                mainPanel.setPreferredSize(calcMainpanelSize(mainPanel, panel));
                validate();
            }
        });
    }
    private Dimension calcMainpanelSize(JPanel mainPanel, JPanel addedPanel){
        componentCount = new BigDecimal(""+mainPanel.getComponentCount());
        rows = componentCount.divide(COLUMN_COUNT, BigDecimal.ROUND_UP);
        int vGap = ((FlowLayout)mainPanel.getLayout()).getVgap();
        rowHeight = new BigDecimal(""+(addedPanel.getPreferredSize().getHeight()+vGap));
        return new Dimension(((int)addedPanel.getPreferredSize().getWidth()
        + ((FlowLayout)mainPanel.getLayout()).getHgap())*COLUMN_COUNT_INT,
                rowHeight.multiply(rows).intValue());
    }
    private final int COLUMN_COUNT_INT = 2;
    private final BigDecimal COLUMN_COUNT = new BigDecimal(""+COLUMN_COUNT_INT);
    private BigDecimal componentCount, rows, rowHeight;
    private JButton addBtn;
    private JPanel mainPanel;
    private JToolBar toolbar;
}
```


----------



## Nick_Spick (13. Nov 2005)

@Illuvatar,

damit hast du ja grundsätzlich recht, aber leider macht er dann keinen Zeilenumbruch nach z.b. 240 Pixeln. Die Elemente sind dann einfach hinter einander aufgreit. Man kann zwar von Links nach rechts scrollen, aber ich möchte es halt gerde so haben dass es maximal 240 breit und beliebig hoch ist. Ich habe ja schon versucht es dann durch setMaximumSize(240,32000) zu erzwingen. Macht er aber auch nicht. 

@Andre_Uhres
Hm, was soll mir das jetzt sagen? Vielleicht kannst du das ein bischen Kommentieren, damit ich weiß, worauf ich mein haupt Augenmerk zu legen habe?

MfG, Nick


----------



## André Uhres (13. Nov 2005)

Das "JPaneControllPanel" muss seine Größe an die Elementeanzahl anpassen.
In meinem vereinfachten Beispiel entspricht "mainPanel" dem "JPaneControllPanel" und
"addedPanel" entspricht dem "AnalogControllPanel".
Die Methode auf die es hauptsächlich ankommt ist "calcMainpanelSize(..)
welche die Größe vom "mainPanel" (= "JPaneControllPanel") an die Elementeanzahl anpasst
wenn ein neues "addedPanel" (= "AnalogControllPanel") hinzugefügt wird:

```
private Dimension calcMainpanelSize(JPanel mainPanel, JPanel addedPanel){ 
        //Elementeanzahl:
        componentCount = new BigDecimal(""+mainPanel.getComponentCount()); 

        //Zeilenanzahl = Elementeanzahl / Anzahl Spalten:
        rows = componentCount.divide(COLUMN_COUNT, BigDecimal.ROUND_UP); 

        //vertikaler Zwischenraum:
        int vGap = ((FlowLayout)mainPanel.getLayout()).getVgap(); 

        //Zeilenhöhe (inklusive vertikaler Zwischenraum):
        rowHeight = new BigDecimal(""+(addedPanel.getPreferredSize().getHeight()+vGap)); 

        //angepasste Panelgröße: 
        //Breite = (Breite vom "addedPanel" + horizontaler Zwischenraum) * Anzahl Spalten
        //Höhe = Zeilenhöhe * Zeilenanzahl
        return new Dimension(((int)addedPanel.getPreferredSize().getWidth() 
        + ((FlowLayout)mainPanel.getLayout()).getHgap())*COLUMN_COUNT_INT, 
                rowHeight.multiply(rows).intValue()); 
    }
```


----------

