Swing JFrame resize-Möglichkeiten

J

Jinro

Mitglied
Hallo Zusammen,

ich habe folgendes Problem und habe im Netz leider keine passende Möglichkeit gefunden dieses zu Lösen.

Ich habe ein JFrame , in dem mein Inhalt ausgegeben werden soll. Der Inhalt ist Skalierbar und passt sich der Größe des JFrames an... der Inhalt wird durch eine paint()-Methode erzeugt:
Java: 
public void paintMerelfield(Graphics g) throws IOException {
        border = 50;
        int squaresize = (int) this.getSize().getHeight() - 2 * border;

Problem hierbei ist, dass sobald ich mein JFrame in der Vertikalen vergrößere, der Inhalt natürlich auch immer größer wird und i-wann das JFrame in horizontaler Richtung verlässt.

Ich habe mir versucht das Problem durch folgende Kunstgriffe zu beheben:

1. das Ziehen des JFrames nur in diagonaler Richtung erlauben --> ich habe keinen Befehl gefunden, der das erlaubt

2. ich habe versucht die setMaximizedBounds() zu setzen um das manuelle ziehen zu umgehen.. leider ändert das Fenster beim verschieben des Fenster dann wieder seine ursprüngliche größe (vor click auf maximierung). Außerdem kann ich (in der ursprungsgröße) das vertikale resizen nicht verhindern, da über setResizable(false); das Maximieren des Fensters nicht mehr fkt...


hier mal der gekürzte Code des JFrames

Java: 
public class BaseFrame extends JFrame {

    BaseFrame() {
        super();

        // set MinSize
        setMinimumSize(new Dimension(650, 650));

       // setResizable(false);

        // set MaxSize & define
        Rectangle bounds = new Rectangle(100, 100, 800, 800);
        setMaximizedBounds(bounds);
         }

Wenn mir Jemand dabei helfen könnte, eine meiner Ansätze zu vervollständigen, wäre das :toll:

viele Grüße und Danke
JinRo
 
Was wird den in dem Frame dargestellt und warum nimmst kein JPanel o.ä.?
Da könnte man sich solche Berechnungen u.U. sparen:
Java: 
int squaresize = (int) this.getSize().getHeight() - 2 * border;
 
Du könntest im Toolkit das hier mal auf false setzen: public void setDynamicLayout(boolean dynamic)

Dann wird nix gezeichnet on resize und dann guckst halt obs noch passt oder es einfach ein Berechnungsfehler war..
Anscheinend stimmt ja was bei der Berechnung nicht so ganz, weil es sollte halt nie größer werden..
 
Das soll mal ein Mühlespiel werden... und im JPanel hat man nicht so viele Möglichkeiten (bsp JMenu)
an der Berechnung ist ja nichts auszusetzen... es geht nur um die Darstellung und das das alles Skalierbar ist...
 
@thE_29

das hab ich nur testhalber eingesetzt, außerdem siehts schöner aus 😉

die Berechnung ist in dem Sinne "fehlerhaft", das sie sich nur an ".getHeight" orientiert.. habe es auch schon mal mit ".getHeight()/2"+".getWidth()/2" ,da hab ich das Problem, das es je nach ziehrichtung (vert. o. hor.) in beiden richtungen verschwindet... 🙁
 
Zuletzt bearbeitet:
Das JPanel dient ja nur zur Darstellung des Spielfeldes, das muss man dann sowies in einen Frame reinstecken.
Ansonsten würde ich auch wie thE_29 einen Fehler in der Berechnung vermuten. Zeig doch mal eine lauffähige Demo Deines Problems.
 
die paint() mal in ein JPanel.. ich fasse die benötigten klassen für die demo mal hier zusammen...

BaseFrame
Java: 
import javax.swing.*;
import java.awt.*;

public class BaseFrame extends JFrame {

    /**
     * Comment for <code>serialVersionUID</code>
     */
    private static final long serialVersionUID = 1L;

    BaseFrame() {
        super();

        setTitle("Merels-Game");

        // Reaktion auf "x"-Klick des Fensters
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // set MinSize
        setMinimumSize(new Dimension(650, 650));

        // set MaxSize & define
        Rectangle bounds = new Rectangle(100, 50, 900, 900);
        setMaximizedBounds(bounds);
      
        // dynamischer Inhalt
        Toolkit.getDefaultToolkit().setDynamicLayout(true);
         setLocationByPlatform(true);
        setVisible(true);

    }

}
Mühlefeld
Java: 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.awt.*;
import javax.imageio.ImageIO;
import javax.swing.JPanel;


public class Merelpainter extends JPanel {

    private static final long serialVersionUID = 2094854366018877430L;

    private int border;


    public Merelpainter() {


    }

    @Override
    public void paint(Graphics g) {
        // set Screen
        g.setColor(Color.LIGHT_GRAY);
       
        // paint a Merelfield
        try {
            paintMerelfield(g);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public void paintMerelfield(Graphics g) throws IOException {
        border = 50;
        int squaresize = (int) (((this.getSize().getHeight() - 2 * border)/2)+((this.getSize().getWidth() - 2 * border)/2));
        Graphics2D g2 = (Graphics2D) g;
        g.setColor(Color.blue);
        g2.setStroke(new BasicStroke(5));

        // 3. Viereck - innen
        g.drawRect((border + ((squaresize / 6) * 2)), (border + ((squaresize / 6) * 2)),
                (squaresize / 3), (squaresize / 3));

        // 2. Viereck - mitte
        g.drawRect((border + (squaresize / 6)), (border + (squaresize / 6)),
                ((squaresize / 3) * 2), ((squaresize / 3) * 2));

        // 1. Viereck - aussen
        g.drawRect(border, border, squaresize, squaresize);

        // line north
        g.drawLine((border + (squaresize / 2)), (border + ((squaresize / 6) * 2)),
                (border + (squaresize / 2)), (border));
        // line south
        g.drawLine((border + (squaresize / 2)), (border + ((squaresize / 6) * 4)),
                (border + (squaresize / 2)), (border + squaresize));
        // line west
        g.drawLine((border), (border + (squaresize / 2)), (border + ((squaresize / 6) * 2)),
                (border + (squaresize / 2)));
        // line east
        g.drawLine(((border + ((squaresize / 6) * 4))), (border + (squaresize / 2)),
                (border + squaresize), (border + (squaresize / 2)));

    }

}
UiBoard (ausgabe)
Java: 
public class UiBoard2 extends BaseFrame {

    UiBoard2() {
    //JMenu ...
    // Creates BorderLayout for Frame and inserts content
        JPanel content = new JPanel(new BorderLayout());
        add(content); // ohne ", BorderLayout.*" --> in CENTER

        JTextArea gI = new JTextArea("Hier stehen die Game Infos");
        gI.setSize(400, 50);
        gI.setBackground(Color.orange);
        content.add(gI, BorderLayout.NORTH);
        
        JTextArea t1 = new JTextArea("Player 1: stats");
        t1.setBackground(Color.yellow);
        content.add(t1, BorderLayout.EAST);
        
        // Start Merelpainter for MerelField

        Merelpainter mp = new Merelpainter();

        // Fill Panel "mp" into Panel "content"
        content.add(mp);

        this.pack();

    }

    public static void main(String[] args) {
        UiBoard2 b2 = new UiBoard2();
        b2.setVisible(true);
    }
}

das müsste eigentlich reichen...
 
Das liegt daran, dass Du etwas quadratisches in etwas nicht quadratisches zeichnen willst.
Du musst als Basislänge immer die kürzste Dimension des Panels verwenden.
Ausserdem überschreibt man bei Swing nicht paint sondern paintComponent.

Hier mal wie ich das Feld zeichnen würde. Persönlich würde ich für das Zeichnen des Spieldfelds ein Bild verwenden - man spart sich die Rechnerei und es sieht i.d.R schöner aus.
Java: 
	class Merelpainter extends JPanel {
		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			Graphics2D g2 = (Graphics2D) g;
			g2.setColor(Color.blue);
			g2.setStroke(new BasicStroke(5));
			int h = this.getHeight(), w = this.getWidth();
			int size = (h>w?w:h) - 50;
			g2.drawLine(w/2, (h-size)/2, w/2, (h+size)/2);
			g2.drawLine((w-size)/2, h/2, (w+size)/2, h/2);
			int l = size/3;
			g2.setColor(this.getBackground());
			g2.fillRect((w-l)/2, (h-l)/2, l, l);
			g2.setColor(Color.blue);
			for (int i=3; i>0; i--) {
				l = size*i/3;
				g2.drawRect((w-l)/2, (h-l)/2, l, l);
			}
		}
	}
 
@Michael...

vielen dank.. kannst du mir vllt noch verraten, wie ich die frame größe in einen mousemotionlistener reinbekomme?
momentan sieht das bei mir so aus:

Java: 
public class MerelFieldMouseMotionListener implements MouseMotionListener {

    // the coordinates of the mouse
   private Integer mx;

    private Integer my;
    
    //the heights/width of the outer square
    // TODO: get squaresize in dependece of jframe like in MP
    private Integer squaresize = 465;
    private Integer border = 50;
    // the coordinates of the upper-left corner from the box
    private Integer x;

    private Integer y;

 public void mouseMoved(MouseEvent e) {

        mx = e.getX();
        my = e.getY();
        
        //Field x2-y6
        x = (border+(squaresize/6)-(border/2));
        y = (((squaresize/ 6)+border)-(border/2));        
        if (x < mx && mx <= x + 50 && y < my && my <= y + 50) {
            System.out.println("Move: " + e.getX() + ", " + e.getY());
            //setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
        }

habe erstmal die felder mit koordinaten erstellt und wollte mich danach dem "squaresize" widmen..

könnte ich denn wie oben
int h = this.getHeight(), w = this.getWidth();
int squaresize = (h>w?w:h) - 50;
setzen??
und wieso fkt meine setCursor()-Methode nicht ... :bahnhof: --> wenn ich es mit nem Applet (extends Applet --> damit die setCursor() kompiliert) erweitere geht gar nix mehr...
 
Zuletzt bearbeitet:
Entweder der Listener kennt das Panel, dann kann er die Komponente nach der Größe fragen (s. Bsp getFieldSize()) oder man macht die Klasse selbst zum eigenen Listener.
Der Aufruf setCursor() muss an der Komponente aufgerufen werden, an welcher der Cursor gesetzt werden soll und ein MouseMotionListener ist nunmal keine Komponente ;-)
Java: 
	class Merelpainter extends JPanel implements MouseMotionListener {
		private int size = 0;
		private int posX, posY;
		private boolean prevActive;

		public Merelpainter() {
			size = 0;
			posX = 0;
			posY = 0;
			prevActive = false;
			this.addMouseMotionListener(this);
		}

		public int getFieldSize() {
			return size;
		}

		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			Graphics2D g2 = (Graphics2D) g;
			g2.setColor(Color.blue);
			g2.setStroke(new BasicStroke(5));
			int h = this.getHeight(), w = this.getWidth();
			size = (h > w ? w : h) - 50;
			g2.drawLine(w / 2, (h - size) / 2, w / 2, (h + size) / 2);
			g2.drawLine((w - size) / 2, h / 2, (w + size) / 2, h / 2);
			int l = size / 3;
			g2.setColor(this.getBackground());
			g2.fillRect((w - l) / 2, (h - l) / 2, l, l);
			g2.setColor(Color.blue);
			for (int i = 3; i > 0; i--) {
				l = size * i / 3;
				g2.drawRect((w - l) / 2, (h - l) / 2, l, l);
			}

			l = size / 15;
			g2.setColor(Color.ORANGE);
			if (prevActive)
				g2.drawOval(posX - l / 2, posY - l / 2, l, l);
		}

		public void mouseDragged(MouseEvent evt) {
		}

		public void mouseMoved(MouseEvent evt) {
			int x = evt.getX(), y = evt.getY();
			int w = this.getWidth(), h = this.getHeight();
			int tol = size / 15;

			int a = size / 2;
			int x1 = (x - (w / 2 - a)) % a;
			int y1 = (y - (h / 2 - a)) % a;

			prevActive = false;

			if ((x1 < tol || x1 > a - tol) && (y1 < tol || y1 > a - tol)) {
				int pX = (x - (w - size) / 2) / a;
				int pY = (y - (h - size) / 2) / a;
				if (x1 > a - tol)
					pX++;
				if (y1 > a - tol)
					pY++;
				posX = pX * a + (w - size) / 2;
				posY = pY * a + (h - size) / 2;
				if (!(pX==1 && pY==1)) {
					this.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
					prevActive = true;
				}
			} else
				this.setCursor(Cursor.getDefaultCursor());
			repaint();
		}
	}
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Resize von Image nach Resize von Button
Antworten: 1
JFrame resize in Echtzeit
Antworten: 3
schönes Resize bei eigenem JFrame
Antworten: 5
JFrame instante Resize
Antworten: 3
JTabbedPane: Resize des JFrame bei Tab wechsel
Antworten: 8

Zurück
Oben