resizen eines NULL-Layouts einschränken

[Reinhold]

Hallo,

ich habe ein NULL-Layout bei dem auf der rechten Seite 5 Buttons sind. Beim Verändern der Fensterhöhe (die Breite ist erstmal egal, die funktioniert analog) sollen die oberen drei Buttons immer in einem bestimmten Abstand zur oberen Grenze des Fensters bleiben und die unteren zwei Buttons in einem bestimmten Abstand zur unteren Grenze. Das heisst, wenn ich die Fensterhöhe vergrößere, dann wandern die unteren Buttons immer weiter von den oberen weg. Das funktioniert mit einem ComponentListener soweit auch ganz gut. Nun ist es aber noch so, dass man beim Verkleinern der Fensterhöhe die Buttons 'zusammenschieben' kann. Das möchte ich gerne verhindern, indem ich eine minimal erlaubte Fensterhöhe definieren will. Vorgestellt habe ich es mir so:

if (event.getComponent().getHeight() == 165) {
//mache hier irgendwas, dass die Höhe nicht mehr weiter verkleinert werden kann
//also in der Art setHeight(165)
}

Weiss jemand einen Rat für mich?

Danke,
Reinhold

 

[Reinhold]

Das mit den Buttons funktioniert jetzt so wie ich es haben möchte: Wenn ich die Fesnterhöhe vergrößere, dann wandern die unteren zwei Buttons von den oberen drei weg und wenn ich das Fenster verkleinere und die Höhe unter 165 schrumpft, dann bleiben die unteren zwei an einer festen Position und werden nicht mehr über die oberen geschoben:

contentPane.addComponentListener(new ComponentAdapter() {
    public void componentResized(ComponentEvent event) {

         // Position der oberen drei Buttons:  x-Richtung dynamisch zur Fensterbreite, y-Richtung feste Position
         hinzufuegenButton.setBounds(event.getComponent().getWidth()-120,15,100,20);
         bearbeitenButton.setBounds(event.getComponent().getWidth()-120,45,100,20);
         loeschenButton.setBounds(event.getComponent().getWidth()-120,75,100,20);
                
         // Position der unteren zwei Buttons: x-Richtung dynamisch zur Fensterbreite, y-Richtung dynamisch zur Fensterhöhe
         // beim Vergrößern der Höhe wandern sie von den oberen drei Buttons weg
         aktualisierenButton.setBounds(event.getComponent().getWidth()-120,event.getComponent().getHeight()-60,100,20);
         schliessenButton.setBounds(event.getComponent().getWidth()-120,event.getComponent().getHeight()-30,100,20);
         
         // Falls beim Verkleinern die Fensterhöhe 165 erreicht wird, setze y-Position der unteren zwei Buttons auf feste Werte 
         // die unteren zwei können nicht mehr über die oberen drei Buttons geschoben werden      
         if (event.getComponent().getHeight() <=165) {
             aktualisierenButton.setBounds(event.getComponent().getWidth()-120,105,100,20);
             schliessenButton.setBounds(event.getComponent().getWidth()-120,135,100,20);
         }
    }
});

Das Problem ist hier aber noch, dass man den Rahmen des Fenster trotzdem noch weiter nach oben schieben kann. Das möchte ich irgendwie unterbinden, d.h. sobald beim Verkleinern des Fensters die Höhe von 165 erreicht wird, soll der RAHMEN nicht mehr weiter verkleinert werden können, so dass alle Buttons sichtbar bleiben. Habe aber absolut keinen Plan, wie ich das hinkriegen soll...

Freue mich über jeden Tip!!

Gruß,
Reinhold

 

[Solour]

nur so ne idee..

event.getComponent().setBounds(event.getComponent().getX(),event.getComponent().getY(),event.getComponent().getWidth(),165);

 

[SnooP]

bzw. direkt immer auf .setHeight(165); setzen... - hab ich glaub ich auch schonmal so gemacht ...

 

[Reinhold]

Hallo,

danke für Eure Ideen. Es funktioniert jetzt,.. aber nur halbwegs (und nur bei einem JInternalFrame). Wenn man den Rahmen auf irgendeiner Seite des Frames größer oder kleiner zieht und dann auf der gegenüberliegenden Seite was verändert, dann verschiebt sich der Frame plötzlich. Sehr merkwürdig.. Vielleicht hat ja jemand Zeit und Lust, sich es mal anzukucken und kann mir sagen, woran das jetzt nun wieder liegen könnte...

Grüße,
Reinhold

Anm.: das ist die leicht modifizierte Form eines Bsp. aus dem Java-Handbuch.

import java.awt.Component;
import java.awt.event.ComponentListener;
import java.awt.event.ComponentEvent;

import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JDesktopPane;
import javax.swing.DefaultDesktopManager;

public class TestDesktop {
    public static void main(String args[]) {
        Desktop desk = new Desktop();
        desk.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        desk.setLocation(10,10);
        desk.setSize(600,600);
        desk.setVisible(true);
        desk.addChild(new ChildFrame("TEST"),100,100);
    }
}

class Desktop extends JFrame{
    
private JDesktopPane desk;

    public Desktop() {
        super("TEST");
        this.desk = new JDesktopPane();
        desk.setDesktopManager(new DefaultDesktopManager());
        setContentPane(desk);
    }
    
    /**
     * erzeugt ein JInternalFrame
     * @param x x-Position
     * @param y y-Position
     */
    public void addChild(JInternalFrame child, int x, int y) {
        child.setLocation(x,y);
        child.setSize(300,300);
        child.setDefaultCloseOperation(JInternalFrame.DISPOSE_ON_CLOSE);
        desk.add(child);
        //fuege Listener mit den min und max-Groeßen des ChildFrame hinzu
        child.addComponentListener(new FrameSizeChecker(200,200,400,400));
        child.setVisible(true);
    }
}

class ChildFrame extends JInternalFrame {
    
    public ChildFrame(String titel) {
        super("InternalFrame" + titel,true,true);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
}

class FrameSizeChecker implements ComponentListener {
    
    private int minBreite = 0;
    private int minHoehe  = 0;
    private int maxBreite = 0;
    private int maxHoehe  = 0;

    /**
     * Definiert die min. und max Groesse eines Frames
     * @param minBreite, minHoehe, maxBreite, maxHoehe
     */
    public FrameSizeChecker(int minX, int minY, int maxX, int maxY) {
        init(minX, minY, maxX, maxY);
    }
    
    // pruefe, ob gueltige Werte uebergeben wurden
    private void init (int minX, int minY, int maxX, int maxY) {
        if (maxX < minX || maxY < minY) {
            throw new IllegalArgumentException ("Max.-Wert kleiner Min.-Wert!");
        }
        
        minBreite = minX;
        minHoehe  = minY;
        maxBreite = maxX;
        maxHoehe  = maxY;
    }
    
    public void componentResized(ComponentEvent e) {
        
        Component aktuelleComponente = (Component)e.getSource();
        int aktuelleBreite = aktuelleComponente.getWidth();
        int aktuelleHoehe  = aktuelleComponente.getHeight();
        
        boolean aktualisiere = false;
        
        //pruefe, ob minimum unterschritten
        if (aktuelleBreite < minBreite) {
            aktualisiere = true;
            aktuelleBreite = minBreite;
        }
        
        if (aktuelleHoehe < minHoehe) {
            aktualisiere = true;
            aktuelleHoehe = minHoehe;
        }
        
        //pruefe, ob maximum ueberschritten
        if (aktuelleBreite > maxBreite) {
            aktualisiere = true;
            aktuelleBreite = maxBreite;
        }
        
        if (aktuelleHoehe > maxHoehe) {
            aktualisiere = true;
            aktuelleHoehe = maxHoehe;
        }
        
        if (aktualisiere) {
            aktuelleComponente.setSize(aktuelleBreite, aktuelleHoehe);
        }
    }
    
    // folgende Methoden werden nicht benoetigt
    public void componentMoved(ComponentEvent e) { }
    public void componentShown(ComponentEvent e) { }
    public void componentHidden(ComponentEvent e) { }
}