Welchen LayoutManager?

[Brainiac]

Also ich habe ein JPanel auf dem wird ein Rahmen gezeichnet. nun möchte ich, wenn ich Komponenten auf das Panel setze, das diese einen Abstand nach oben und links haben. Sonst liegen sie ja auf dem Rahmen. Der Abstand muss flexiebel sein, da der Rahmen jeweils ein anderer ist. Die benötigten Abstände sind aber bekannt.

Ich hab nun schon versucht ein Panel im "RahmenPanel" einzufügen, und das mit setBounds() zu verschieben geht aber alles irgendwie nicht. Am liebsten hätte ich einen Bereich vom Typ BoxLayout() der halt um den Rahmen nach rechts und nach unten verschoben ist.
Kann mir da wer weiterhelfen. Ich verschachtel mich hier in den Layouten.

Gruß Brainiac

 

[thE_29]

Schau dir mal das TableLayout an!

(google danach oder Forumsuche)

 

[André Uhres]

Also ich habe ein JPanel auf dem wird ein Rahmen gezeichnet.
nun möchte ich, wenn ich Komponenten auf das Panel setze, das diese einen Abstand nach oben und links haben...

//package layout;
/*
 * RahmenAbstand2.java
 */
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
public class RahmenAbstand2 extends JFrame {
    public RahmenAbstand2() {
        super("Rahmen Abstand");
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setSize(400,300);
        setLocationRelativeTo(null);
        mainPanel = new JPanel();
        panel1 = new JPanel();
        panel2 = new JPanel();
        mainPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
        mainPanel.setBorder(BorderFactory.createTitledBorder("Main Panel"));
        panel1.setBorder(BorderFactory.createTitledBorder(null, "Panel 1", 
                TitledBorder.DEFAULT_JUSTIFICATION, TitledBorder.DEFAULT_POSITION, 
                new Font("Tahoma", 0, 11), Color.red));
        panel1.setPreferredSize(new Dimension(350, 100));
        mainPanel.add(panel1);
        panel2.setBorder(BorderFactory.createTitledBorder(null, "Panel 2", 
                TitledBorder.DEFAULT_JUSTIFICATION, TitledBorder.DEFAULT_POSITION, 
                new Font("Tahoma", 0, 11), Color.red));
        panel2.setPreferredSize(new Dimension(350, 100));
        mainPanel.add(panel2);
        getContentPane().add(mainPanel, BorderLayout.CENTER);
    }
    public static void main(String args[]) {new RahmenAbstand2().setVisible(true);}
    private JPanel panel1;
    private JPanel panel2;
    private JPanel mainPanel;
}

 

[Guest]

Also ich habe ein JPanel auf dem wird ein Rahmen gezeichnet.

Hatte mich da wohl etwas unklar ausgedrückt. Ich meinte nicht den Rahmen mit setBorder(), sondern ich zeichne selber einen aus Grafiken.

Hab das aber hinbekommen:

setLayout(null);
container = new JPanel();
container.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS));
container.setOpaque(false);
container.setBounds(frameLeftWidth, panelTopHeight+topGap, frameCenterWidth, panelOpenHeight);
add(container);

 

[Brainiac]

s.o.

war von mir.

Gruß Brainiac

P.S: Warum klappt das automatischen einloggen nicht, auch wenn man den Cookie zuläßt?

 

[André Uhres]

Hatte mich da wohl etwas unklar ausgedrückt. Ich meinte nicht den Rahmen mit setBorder(),
sondern ich zeichne selber einen aus Grafiken.

setLayout(null);

Nimm BorderLayout.

 

[Brainiac]

Nimm BorderLayout.

Aber dann funktioniert das setBounds nicht mehr. Wie mach ich dann den benötigten Abstand? Auf dem eigentlichen JPanel zeichne ich durch überschreiben von paintComponent einen Rahmen. Und diese Rahmenbreite brauche ich dann halt als Abstand nach oben und links für das "container" JPanel.

 

[André Uhres]

..Wie mach ich dann den benötigten Abstand? Auf dem eigentlichen JPanel zeichne ich durch überschreiben von paintComponent einen Rahmen. Und diese Rahmenbreite brauche ich dann halt als Abstand nach oben und links für das "container" JPanel.

Versuch's mit setPreferredSize(..)

 

[Brainiac]

setPreferredSize(..)

damit setze ich ja nur die benötigte Größe. was ich aber von setBounds brauche ist das verschieben auf eine neue X/Y Coordinate, um den Abstand links und oben zu erreichen.

 

[Wildcard]

Setz doch einfach eine EmptyBorder

 

[Brainiac]

Setz doch einfach eine EmptyBorder

die Abstände nach links und oben unterscheiden sich, wie erreiche is das bei der Border? zusätzlich mit nem Abstand zur Border?

 

[André Uhres]

Ich glaub wir verlieren uns hier in Spekulationen. Ich hab dir oben ein funktionierendes Beispiel gegeben,
obschon es nicht das ist was du wirklich willst. Von dir hab ich jedoch kein funktionierendes Beispiel
dessen gesehen was du wirklich willst :cry:

EDIT: wieso ist das Thema überhaupt abgehakt :?

 

[Wildcard]

die Abstände nach links und oben unterscheiden sich, wie erreiche is das bei der Border? zusätzlich mit nem Abstand zur Border?

Wüsstest du wenn du in der API nachgeschaut hättest :###

 

[Brainiac]

Von dir hab ich jedoch kein funktionierendes Beispiel
dessen gesehen was du wirklich willst

Also den Code den ich oben geposted habe funktioniert bei mir wunderbar und macht genau das was ich möchte. Werde später mal die ganze Klasse posten.

 

[Brainiac]

So hier mal die Klasse:

package de.brainiac.sudoku.controller;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;
import java.awt.BorderLayout;
/**
 * GraphicExtendContainer erzeugt ein JPanel welches mit einem Graphischen Rahmen umrahmt ist. Der Rahmen kann zusammengeschoben werden.
 * Auf dem Panel können andere Componenten angebracht werden addComponent(). Beim zusammengeklappent Rahmen werden die enthaltenen
 * Componenten nicht angezeigt. Diese sind nur sichtbar wenn der Rahmen ausgefahren ist.
 *
 * @author Brainiac
 */

public class GraphicExtendContainer extends JPanel implements ActionListener {
    private ImageIcon panelTop, panelBottom, frameTop, frameBottom, frameLeft, frameCenter, frameRight;
    private boolean isOpend, isOpening, isClosing, isOpeningUppwards;
    private int panelTopHeight, panelTopWidth, panelBottomHeight, panelBottomWidth, panelOpenHeight, panelClosedHeight, panelOpendHeight, panelWidth;
    private int frameTopHeight, frameTopWidth, frameBottomHeight, frameBottomWidth, frameLeftWidth, frameCenterWidth, frameRightWidth;
    private int currentPanelOpendHeight;
    private int currentFrameTopPosition, currentFrameBottomPosition, currentCenterHeight, topGap, bottomGap, containerHeight;
    private int actualPosPanelTop, actualPosPanelBottom, actualPosFrameTop, actualPosFrameBottom, actualPosFrameCenter;
    private int animationDelay = 100;
    private Timer animationTimer;
    private JPanel container;

    /**
     * GraphicExtendContainer constructor erzeugt das aufklappbare JPanel.
     * @param panelTop der obere Rand des Bildes/Rahmen der auch im geschlossenen Zustand angezeigt wird.
     * @param frameTop der obere Rand des Bildes/Rahmen der nur im geoeffneten Zustand angezeigt wird.
     * @param frameLeft der linke Rand des Bildes/Rahmen der nur im geoeffneten Zustand angezeigt wird.
     * Er wird beliebig verlängert umd die benötigte Größe zu erreichen.
     * @param frameCenter der zentrale Hintergrund des Bildes/Rahmen der nur im geoeffneten Zustand angezeigt wird.
     * Er wird beliebig verlängert umd die benötigte Größe zu erreichen.
     * @param frameRight der rechte Rand des Bildes/Rahmen der nur im geoeffneten Zustand angezeigt wird.
     * Er wird beliebig verlängert umd die benötigte Größe zu erreichen.
     * @param frameBottom der untere Rand des Bildes/Rahmen der nur im geoeffneten Zustand angezeigt wird.
     * @param panelBottom der untere Rand des Bildes/Rahmen der auch im geschlossenen Zustand angezeigt wird.
     */
    public GraphicExtendContainer(ImageIcon panelTop, ImageIcon panelBottom, ImageIcon frameTop, ImageIcon frameBottom, ImageIcon frameLeft, ImageIcon frameCenter, ImageIcon frameRight) {
        this.panelTop = panelTop;
        this.panelBottom = panelBottom;
        this.frameTop = frameTop;
        this.frameBottom = frameBottom;
        this.frameLeft = frameLeft;
        this.frameLeft = frameLeft;
        this.frameCenter = frameCenter;
        this.frameRight = frameRight;
        calculateDimensions();
        
        setLayout(null);
        container = new JPanel();
        container.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS));
        container.setOpaque(false);
        container.setBounds(frameLeftWidth, panelTopHeight+topGap, frameCenterWidth, panelOpenHeight);
        add(container);
        
        isOpend = false;
        currentPanelOpendHeight = 0;
        currentFrameTopPosition = panelTopHeight-frameTopHeight;
        currentFrameBottomPosition = 0;
        currentCenterHeight = 1;
        animationTimer = new Timer(animationDelay, this);
        //setOpaque(false);
        isOpeningUppwards = true;
        
        addMouseListener(
                new MouseAdapter() {
            public void mouseClicked(MouseEvent event) {
                int mousex = event.getX();
                int mousey = event.getY();
                if (isOpend) {
                    if ( (mousex > -1 && mousex < panelTopWidth && mousey > -1 && mousey < panelTopHeight) ||
                            (mousex > -1 && mousex < panelBottomWidth && mousey > panelTopHeight+frameTopHeight+panelOpenHeight+frameBottomHeight-1 && mousey < panelOpendHeight+1) ) {
                        isOpend = false;
                        isClosing = true;
                        currentPanelOpendHeight = panelOpenHeight;
                        //currentFrameTopPosition = panelTopHeight;
                        //currentFrameBottomPosition = panelTopHeight+panelOpenHeight-frameBottomHeight;
                        //currentFrameRightLeftHeight = panelOpenHeight - frameTopHeight - frameBottomHeight;
                        animationTimer.start();
                    }
                } else {
                    if (isOpeningUppwards) {
                        if (mousex > -1 && mousex < panelWidth && mousey > panelOpendHeight-panelClosedHeight-1 && mousey < panelOpendHeight) {
                            isOpening = true;
                            currentPanelOpendHeight = 0;
                            actualPosPanelTop = panelOpendHeight-panelBottomHeight-panelTopHeight;
                            actualPosFrameTop = panelOpendHeight-panelBottomHeight-frameTopHeight;
                            actualPosFrameCenter = panelOpendHeight-panelBottomHeight;
                            actualPosFrameBottom = panelOpendHeight-panelBottomHeight;
                            actualPosPanelBottom = panelOpendHeight-panelBottomHeight;
                            animationTimer.start();
                        }
                    } else {
                        if (mousex > -1 && mousex < panelWidth && mousey > -1 && mousey < panelClosedHeight) {
                            isOpening = true;
                            currentPanelOpendHeight = 0;
                            actualPosPanelTop = 0;
                            actualPosFrameTop = panelTopHeight-frameTopHeight;
                            actualPosFrameCenter = panelTopHeight-1;
                            actualPosFrameBottom = panelTopHeight;
                            actualPosPanelBottom = panelTopHeight;
                            animationTimer.start();
                        }
                    }
                }
                repaint();
            }
        }
        );
    }
    
    public void actionPerformed(ActionEvent event) {
        if (isOpening)
            doCenterOpenAnimation();
        else if (isClosing)
            doCloseAnimation();
    }
    
    public void addComponent(Component component) {
        container.add(component);
        setComponentsVisible(false);
        calculateDimensions();
    }
    
    public void addGap(int i) {
        container.add(Box.createVerticalStrut(i));
        calculateDimensions();
    }
    
    public Dimension getMaximumSize() {
        return new Dimension(panelWidth, panelOpendHeight);
    }
    
    public Dimension getMinimumSize() {
        return new Dimension(panelWidth, panelOpendHeight);
    }
    
    public Dimension getPreferredSize() {
        return new Dimension(panelWidth, panelOpendHeight);
    }
    
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        
        if (isOpend) {
            paintOpend(g);
        } else if (!isOpening && !isClosing) {
            paintClosed(g);
        } else if (isOpening) {
            paintOpening(g);
        } else if (isClosing) {
            //paintClosing(g);
        }
    }
    
    public void paintOpend(Graphics g) {
        panelTop.paintIcon(this, g, 0, 0);
        frameTop.paintIcon(this, g, 0, panelTopHeight);
        for (int x = 0; x < panelOpenHeight; x++) {
            frameLeft.paintIcon(this, g, 0, panelTopHeight+frameTopHeight+x);
            frameCenter.paintIcon(this, g, frameLeftWidth, panelTopHeight+frameTopHeight+x);
            frameRight.paintIcon(this, g, frameLeftWidth+frameCenterWidth, panelTopHeight+frameTopHeight+x);
        }
        frameBottom.paintIcon(this, g, 0, panelTopHeight+frameTopHeight+panelOpenHeight);
        panelBottom.paintIcon(this, g, 0, panelTopHeight+frameTopHeight+panelOpenHeight+frameBottomHeight);
    }
    
    public void paintClosed(Graphics g) {
        if (isOpeningUppwards) {
            panelTop.paintIcon(this, g, 0, panelOpendHeight-panelBottomHeight-panelTopHeight);
            panelBottom.paintIcon(this, g, 0, panelOpendHeight-panelBottomHeight);
        } else {
            panelTop.paintIcon(this, g, 0, 0);
            panelBottom.paintIcon(this, g, 0, panelTopHeight);
        }
    }
    
    public void paintOpening(Graphics g) {
        if (isOpeningUppwards) {
            panelTop.paintIcon(this, g, 0, actualPosPanelTop);
            frameTop.paintIcon(this, g, 0, actualPosFrameTop);
            for (int x = 0; x < currentCenterHeight; x++) {
                frameLeft.paintIcon(this, g, 0, actualPosFrameCenter-x);
                frameCenter.paintIcon(this, g, frameLeftWidth, actualPosFrameCenter-x);
                frameRight.paintIcon(this, g, frameLeftWidth+frameCenterWidth, actualPosFrameCenter-x);
            }
            frameBottom.paintIcon(this, g, 0, actualPosFrameBottom);
            panelBottom.paintIcon(this, g, 0, actualPosPanelBottom);
        } else {
            for (int x = 0; x < currentCenterHeight; x++) {
                frameLeft.paintIcon(this, g, 0, actualPosFrameCenter+x);
                frameCenter.paintIcon(this, g, frameLeftWidth, actualPosFrameCenter+x);
                frameRight.paintIcon(this, g, frameLeftWidth+frameCenterWidth, actualPosFrameCenter+x);
            }
            frameTop.paintIcon(this, g, 0, actualPosFrameTop);
            panelTop.paintIcon(this, g, 0, actualPosPanelTop);
            frameBottom.paintIcon(this, g, 0, actualPosFrameBottom);
            panelBottom.paintIcon(this, g, 0, actualPosPanelBottom);
        }
        /*System.out.println("panelTopHeight:    " + panelTopHeight + " | panelTopStartPosition: " + 0);
        System.out.println("frameTopHeight:    " + frameTopHeight + " | frameTopStartPosition: " + panelTopHeight);
        int frameCenterStartPosition = panelTopHeight+frameTopHeight;
        System.out.println("frameCenterHeight: " + panelOpenHeight + " | frameCenterStartPosition: " + frameCenterStartPosition);
        int frameBottomStartPosition = panelTopHeight+panelOpenHeight-frameBottomHeight;
        System.out.println("frameBottomHeight: " + frameBottomHeight + " | frameBottomStartPosition: " + frameBottomStartPosition);
        int panelBottomStartPosition = panelTopHeight+panelOpenHeight;
        System.out.println("panelBottomHeight: " + panelBottomHeight + " | panelBottomStartPosition: " + panelBottomStartPosition);*/
    }
    
    public void setOpend(boolean b) {
        isOpend = b;
        repaint();
        setComponentsVisible(b);
    }
    
    public void setTopGap(int i) {
        topGap = i;
        calculateDimensions();
    }
    
    public void setBottomGap(int i) {
        bottomGap = i;
        calculateDimensions();
    }
    
    private void calculateDimensions() {
        panelTopHeight = panelTop.getIconHeight();
        panelTopWidth = panelTop.getIconWidth();
        panelBottomHeight = panelBottom.getIconHeight();
        panelBottomWidth = panelBottom.getIconWidth();
        
        frameTopHeight = frameTop.getIconHeight();
        frameTopWidth = frameTop.getIconWidth();
        frameBottomHeight = frameBottom.getIconHeight();
        frameBottomWidth = frameBottom.getIconWidth();
        frameLeftWidth = frameLeft.getIconWidth();
        frameCenterWidth = frameCenter.getIconWidth();
        frameRightWidth = frameRight.getIconWidth();
        
        panelClosedHeight = panelTopHeight + panelBottomHeight;
        if (container != null) {
            containerHeight = 0;
            for (int i = 0; i < container.getComponents().length; i++)
                containerHeight += container.getComponents()[i].getMinimumSize().height;
            container.setBounds(frameLeftWidth, panelTopHeight+topGap, frameCenterWidth, containerHeight);
            if (containerHeight + topGap + bottomGap < frameTopHeight + frameBottomHeight + 1) {
                panelOpenHeight = frameTopHeight + frameBottomHeight + 1;
            } else {
                panelOpenHeight = containerHeight - frameTopHeight - frameBottomHeight + topGap + bottomGap;
            }
        } else
            panelOpenHeight = frameTopHeight + frameBottomHeight + 1;
        
        panelOpendHeight = panelClosedHeight + frameTopHeight + frameBottomHeight + panelOpenHeight;
        
        if (panelTopWidth > panelBottomWidth)
            panelWidth = panelTopWidth;
        else
            panelWidth = panelBottomWidth;
    }
    
    private void doCenterOpenAnimation() {
        if (currentPanelOpendHeight < panelOpenHeight+frameTopHeight+frameBottomHeight) {
            currentPanelOpendHeight++;
            if (isOpeningUppwards) {
                //PanelTop
                if (actualPosPanelTop > 0)
                    actualPosPanelTop--;
                //FrameTop
                if (actualPosFrameBottom == panelOpendHeight-panelBottomHeight-frameBottomHeight && actualPosFrameTop > panelTopHeight)
                    actualPosFrameTop--;
                //frameCenter
                if (currentPanelOpendHeight >= frameTopHeight+frameBottomHeight) {
                    actualPosFrameCenter = panelOpendHeight-frameBottomHeight-panelBottomHeight-1;
                    currentCenterHeight = currentPanelOpendHeight - frameTopHeight - frameBottomHeight + 1;
                }
                //frameBottom
                /*if (currentPanelOpendHeight < frameTopHeight * 2) {
                    actualPosFrameTop++;
                    actualPosFrameBottom--;
                }*/
                if (actualPosFrameBottom > panelOpendHeight - panelBottomHeight - frameBottomHeight)
                    actualPosFrameBottom--;
            }
            else {
                //frameTop
                if (actualPosFrameTop < panelTopHeight)
                    if (currentPanelOpendHeight%2 == 1) {
                        actualPosFrameTop++;
                        actualPosFrameBottom--;
                    }
                //frameCenter
                if (currentPanelOpendHeight >= frameTopHeight+frameBottomHeight) {
                    actualPosFrameCenter = panelTopHeight+frameTopHeight;
                    currentCenterHeight = currentPanelOpendHeight - frameTopHeight - frameBottomHeight + 1;
                }
                //frameBottom
                if (actualPosFrameTop == panelTopHeight && actualPosFrameBottom < panelTopHeight+frameTopHeight+panelOpenHeight)
                    actualPosFrameBottom++;
                //panelBottom
                if (actualPosPanelBottom < panelTopHeight+frameTopHeight+panelOpenHeight+frameBottomHeight)
                    actualPosPanelBottom++;
            }
        }
        else {
            setComponentsVisible(true);
            animationTimer.stop();
            isOpening = false;
            isOpend = true;
        }
        repaint();
    }
    
    private void doCloseAnimation() {
        setComponentsVisible(false);
        
        if (currentFrameTopPosition > panelTopHeight-frameTopHeight)
            if (currentPanelOpendHeight%2 == 0)
                currentFrameTopPosition--;
        
        if (currentFrameBottomPosition > 0)
            if (currentPanelOpendHeight%2 == 0)
                currentFrameBottomPosition--;
        
        if (currentPanelOpendHeight > frameTopHeight + frameBottomHeight)
            currentCenterHeight--;
        
        if (currentPanelOpendHeight > 0)
            currentPanelOpendHeight--;
        else {
            animationTimer.stop();
            isClosing = false;
            isOpend = false;
        }
        repaint();
    }
    
    private void setComponentsVisible(boolean b) {
        for (int x = 0; x < container.getComponents().length; x++) {
            container.getComponents()[x].setVisible(b);
            container.getComponents()[x].setEnabled(b);
        }
    }
    
    public void setOpenUppwards(boolean b) {
        isOpeningUppwards = b;
    }
}

An dem korrekten zeichnen wird noch gearbeitet. Aber die Positionierung aus der ursprünglichen Frage geht. (Zeile 61-66)

 

[André Uhres]

Huch, das ist aber lang, und nicht mal selbständig :shock:

Versuch's mal so:

       setLayout(new BorderLayout());
        container = new JPanel();
        container.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
...

 

[Brainiac]

       setLayout(new BorderLayout());
        container = new JPanel();
        container.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
...

funzt auch. Warum ist das besser? Weil damit das "setLayout(null)" umgangen wird?

noch ne Frage was ist besser:

import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;
import java.awt.BorderLayout;

oder:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

 

[André Uhres]

       setLayout(new BorderLayout());
        container = new JPanel();
        container.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
...

funzt auch. Warum ist das besser? Weil damit das "setLayout(null)" umgangen wird?

In deiner Frage geht es ja um Layoutmanager. "null" ist einfach keiner

noch ne Frage was ist besser:

import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;
import java.awt.BorderLayout;

oder:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

Meistens sind globale importe genügend. Nur wenn zwei packages die gleichen Klassennamen verwenden
(z.B. java.util.Timer und javax.swing.Timer) muss man schon sagen welche man will, entweder durch
import der Klasse oder durch Angabe des ganzen Klassennamens im statement.