Swing Dynamische Größenanpassung

[flodo]

also folgende Frage wie kann man eigentlich erkennen z.b. das während das Programm läuft die größe des GUI Fenster ändert (also wenn ich es selbst verändere mit der Maus). Finde einfach keinen Listener oder ähnliches welche ich auf den Frame legen könnte. Ich will wenn sich die größe der GUI ändert zur Laufzeit auch dynamisch die Größe von ein paar Panels anpassen

 

[L-ectron-X]

Wenn du deine GUI mit LayoutManagern aufgebaut hast, ist das in den meisten Fällen auch völlig unnötig.
Die LayoutManager übernehmen die automatische Positionierung und Dimensionierung in einer GUI, auch, wenn sie sich in ihrer Größe ändert

 

[flodo]

hmm okay hab eh Miglayout im einsatz, mir geht es darum ich hab ein Image welches ich dann halt auch dynamisch kleiner machen möchte deswegen

 

[L-ectron-X]

Dann kannst du eine Klasse schreiben, die bspw. von JPanel erbt und dein Image zeichnet. In dieser Klasse stellst du auch fest, welche Größe das Panel gerade hat und dimensionierst an Hand der ermittelten Werte dein Image, bevor du es neu zeichnest.
Das sollte also nicht so schwer sein, weil die paintComponent()-Methode, welche du überschreibdn musst, um dein Bild zu zeichnen, von der VM automatisch aufgerufen wird, wenn es Größenveränderungen am Panel gab.

 

[twseitex]

Hallo,

Hinweise zu JApplet unter Java SE

public void paint(Graphics X00)


paint() nur notwendig, wenn Graphic oder Graphic2D benutzt wird.
paint() wird nur aktiviert, wenn das Applet-Fenster sich ändert,
Aktivierung erfolgt durch Java selbst.
kann zusätzlich paralle extern aufgerufen werden.
sollte aber vor parallelem Aufruf geschützt werden
Flag benutzen, das anzeigt, ob paint-Routine aktiv ist.

// ###########################################################################
// paint()
// ###########################################################################
//
// JFrame Fenster
// java.lang.Object
// java.awt.Component
// java.awt.Container
// java.awt.Window
// java.awt.Frame
// javax.swing.JFrame
// paint() von Container geerbt
// ausgelöst von Java-Swing
// paintComponents() von Container geerbt
//
// JComponent Element im JFrame
// java.lang.Object
// java.awt.Component
// java.awt.Container
// javax.swing.JComponent
// paint() überschreibt paint() von Container
// ausgelöst von Java-Swing
// paintComponents() von Container geerbt
// paintComponent() benutzt paint()
//
// Grafik, die NICHT in paint() erzeugt wird sondern z.B. in einem
// Eventhandler, muss am Ende per dispose() freigegben werden.
// Grafik, die als Parameter von paint() verwendet wird, wird automatisch
// mit dispose() versehen.
// Grafik, die innerhalb paint() neu erzeugt wird, sollte mit dispose()
// versehen werden

// paint() ruft intern auf
// paintComponent()
// paintBorder()
// paintChildren()
//
// Bei Elementen IM Fenster sollte paintComponent() überschrieben werden,
// da das Fenster selbst paint() hat.
//
// paint() sorgt u.a. für das Rendern von Graphic, aber nur dann, wenn es
// Java für nötig hält, also paint() selbst aktviert.
// AWT wird von Java selbst verwaltet.
// ansonsten siehe unten repaint()
//
// Man kann diese Methoden auch überschreiben (auch paint())
// Überschreiben per neuer Klasse oder direkt im Konstruktor
// Bsp. für paintComponent()
//
// paintComponent(Graphics g)
// {
// // Parameter ist Pflicht
// // Graphics2D ist aus Parameter abzuleiten bei Bedarf
//
// // immer super also Fläche rendern, auf der gemalt wird
// super.paintComponent(g);
//
// // Grafik auf Fläche malen
// // Es darf nicht paint() aktiviert werden !!
// GrafikMalen(); // aktualisiert die Grafikdaten und malt
// // z.B. per g.drawline(....)
//
// // NICHT paint() oder repaint() !!!
// }
//
// paint() wird von Java-AWT selbst aktiviert und kooperiert nur scheinbar
// mit Graphic. Vielmehr wird Grahpic auch noch ignoriert, wenn man
// nicht eine Logik anwendet, die der Java-Logik widerspricht.
// siehe ThisPaintThread_paint()
// Bezüglich Graphic muss man ausserhalb von paint() dafür
// sorgen, dass paint() aktiviert werden MUSS, also Java
// paint() schleunigst aufrufen soll.
// siehe ThisPaintThread_paint()
// Die Aktvierung von paint() per Befehlsfolge
// validate();
// repaint();
// muss nicht unbedingt Graphic rendern lassen, auch wenn in paint()
// die Malroutine aktiviert wird.
// siehe ThisPaintThread_paint()
//
// Es MUSS JEDE Malaktion innerhalb paint() oder dessen
// Untermethoden wie paintComponent() aktiviert werden,
// damit GUI-Änderungen sichtbar werden.
// Bei Malaktionen per Rekursion muss ebefalls innerhalb paint()
// gemalt werden.
// Der Haken: innerhalb paint() ist validate() UND repaint() verboten,
// da letztere selbst paint() aktvieren.
// Damit gilt am Beispiel von paintcomponent()
//
// paintComponent() malt
// ruft dann aber NICHT
// validate() und repaint() auf, da
// paintComponent() vom aktiven paint()
// gestartet wird, aber ein repaint()
// SOFORT paint() neu startet.
// Rekursion des Malens.
// Sobald malen beendet wurde, muss einer
// Routine, die NICHT in paintcomponent()
// aktiviert wird, mitgeteilt werden,
// dass diese repaint() aufrufen soll.
// repaint() darf nicht innerhalb paint()
// aktiviert werden !!
// Da paintComponent() von paint() aktiviert wird, aber
// Java selbst entscheidet, wann paint() startet, muss
// man nachhelfen: Die Rekursion des Malens umfasst
// Malen als 1 Methode aktiviert in
// paintComponent()
// Thread des repaint() als parallele Methode
// zu paint() und paintComponent()
// etc.
// Warnung: Java AWT und Swing und Graphic sind NICHT
// echtzeitfähig UND Java ist beim paint()-Aufruf
// komplett autark. Man kann per repaint() nur
// den paint()-Aufruf bestellen, aber nicht
// auslösen.

// Programmtechnische Lösung für fortlaufende GUI-Änderung und deren Anzeige
//
// ALLE AWT-Daten
// Aktualisierung ALLER AWT-Daten erfolgt komponentenweise per Thread
// und rekursiv.
// Daher lohnt es sich, für Fenster Komponenten je eine eigene Klasse
// und dort hinterlegter Threadverwaltung zu schreiben
// oder auch zentrale Threadverwaltung mit Instanz je Fensterkomponente.
// (in Java SE) - z.B. für ein animiertes Vordergrundbild im Panel
// also als animierte Fensterkomponente.
// Warnung: Da Java sollte von sich aus AWT rendert per paint(),
// sobald sich AWT-Elemente ändern.
// Kommt aber Graphic ins Spiel (z.B. Hintergrundbild)
// kann es sein, dass AWT falsch gerendert wird.
// Dann sollte - und wenn auch nur ein Hintergrundbild
// erzeugt wird (als Image und damit Graphic) - die
// Verwaltung der Graphic-Daten implementiert werden.
// AWT rendert die Elemente, wobei Vordergrund- und
// Hintergrundbild zerstört werden, also neu gerendert
// werden müssen. Erst Hintergrund dann Vordergrund.
// immer super also Fläche erzeugen, auf der NEU gemalt wird also immer
// super.paint(X00);
// update() kann paint() zusätzlich aktivieren (siehe unten)



public void update(Graphics X00)
es wird die update() Methode überschrieben. will man den
Vorgänger, dann super.update(...) nicht vergessen
update wird automatisch durch repaint() aktiviert
kann paint() aktivieren, dann aber mit Schutz vor Parallelaufruf (siehe oben)


// Grafik, die NICHT in paint() erzeugt wird sondern z.B. in einem
// Eventhandler, muss am Ende per dispose() freigegeben werden.
// Bsp:
/*
addMouseMotionListener
(new MouseMotionAdapter()
{
private Point p;

public void mouseDragged(MouseEvent e)
{

// Punkt speichern
Point p = new Point(e.getX(), e.getY());
points.add(p);

// An Mausposition Punkt zeichnen
Graphics g = ((JPanel) e.getComponent()).getGraphics();

g.setColor(Color.WHITE);
g.fillRect(p.x, p.y, 2, 2);

// Es gibt nichts mehr zu malen, also dispose()
g.dispose();
}
}
);
*/


Eine Beispiel-GUI, die sich laufend in der Anzeige per Threads automatisch aktualisiert,
findest Du auf meiner Webseite audio, flash and java und dort den Java-Player für Audio.
Das Applet arbeitet intensiv mit Threads und bemüht sich, die fehlende Echtzeitfähigkeit
von Java unter Windows auszugleichen. Ganz klar: Die paint-Strategie im Applet, die
Java von Hause aus fährt, reicht nicht aus, sondern MUSS um Threads erweitert werden.
Oder man nutzt ein anderes Java als nur die Standard Edition.

Ciao.