JPanel paintComponents() wird nicht aufgerufen

[Razzonk]

Hallo zusammen,

ich habe folgendes kleines Programm geschrieben (soll später für weiter Übungen herhalten), allerdings habe ich das Problem, das die paintComponents-Methode des GamePanels nie aufgerufen wird und somit der Text auch nicht erscheint. Bei anderen Versuchen hat es schon geklappt. Fehlermeldungen gibt es keine und beim vergleichen mit den anderen Programmen find ich auch keinen Fehler. Woran könnte es liegen?

Main.java:

package main;

public class Main {

	public static void main(String[] args) {
		new Game(200 , 200 , "JaRTest");
	}

}

Game.java

package main;

import javax.swing.JFrame;

public class Game extends JFrame {
	private static final long serialVersionUID = 1L;
	
	private GamePanel gamePanel;
	
	
	public Game(int width, int height, String title) {
		super(title);
		
		gamePanel = new GamePanel(width , height , this);
		
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
		this.setResizable(false);
		this.add(gamePanel);
		this.pack();
		this.setLocationRelativeTo(null);
		this.setVisible(true);
		
		Thread th = new Thread(gamePanel);
		th.start();
	}

}

GamePanel.java

package main;

import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JPanel;

public class GamePanel extends JPanel implements Runnable {
	private static final long serialVersionUID = 1L;
	
	private Game parent;
	
	
	public GamePanel(int width, int height, Game parent) {
		this.parent = parent;
		
		this.setPreferredSize(new Dimension(width , height));
	}
	
	
	@Override
	public void paintComponents(Graphics g) {
		super.paintComponents(g);
		
		g.drawString("Test" , 50 , 50);
	}
	

	@Override
	public void run() {
		while(parent.isVisible()) {
			this.repaint();
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

Ich habe es probeweise noch so versucht:

import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JFrame;
import javax.swing.JPanel;


public class Test extends JPanel {
	private static final long serialVersionUID = 1L;
	
	public Test() {
		JFrame frame = new JFrame("Test");
		
		this.setPreferredSize(new Dimension(200 , 200));
		
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setResizable(false);
		frame.add(this);
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
		
		this.repaint();
	}
	
	@Override
	public void paintComponents(Graphics g) {
		super.paintComponents(g);
		
		g.drawString("Test" , 50 , 50);
	}

	public static void main(String[] args) {
		new Test();
	}

}

Das ist ähnlich dem Beispiel von Quaxli's Tutorial, allerdings passiert auch hier nichts.

Finde einfach den Fehler nicht.
Hoffe ihr könnt mir helfen!

Gruß

 

[kaoZ]

mal abgesehen von anderen dingen die einem so ins Auge stechen

    public Test() {
        JFrame frame = new JFrame("Test");
        
        this.setPreferredSize(new Dimension(200 , 200));
        
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.add(this);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        
        this.repaint();  // <<---
    }

an dieser Stelle zeichnest du das Panel bevor es überhaupt auch nur einmal richtig initialisiert worden ist, zum anderen instanziierst du innerhalb eines JPanel's ( da du Test hiervon ableitest ) ein JFrame....o0

Was macht das für einen Sinn ?

Du stopfst hier quasi einen Container in eine Komponente, die Componente kann aber nicht existieren ohne einen Container der diese umschließt, also fügst du die Komponente dann wieder durch den Aufruf von add(this) dem Container hinzu..... strange sache das......

Zum anderen , wenn du ein Spiel Entwickelst, zeichne aktiv, und nicht passiv über paintComponent(), alleine schon weil du keinen Einfluss darauf hast, wann dein wunsch durch den Aufruf von repaint() vom darunterliegenden toolkit ausgeführt wird.

Hier mal ein Beispiel, wie ich es zzt. gelöst habe, hier kannst du für deinen Teil den GameStateManager erstmal ignorieren :

Das ganze ist möglichst OO gehalten, sprich ich habe den GameLoop gekapselt, den Panel , sowie die Gui, welche nur den Frame instanziert welcher als content den GamePanel gesetzt bekommt ( incl. doublebuffering, also wird erst alles auf ein image gemalt , und dann das image gezeichnet. )

(Hier sind erstmal nebensächliche dinge wie Framerate etc. noch nicht implementiert, es geht nur um das Prinzip dahinter, wie man sowas machen könnte.)

GameLoop.java

public class GameLoop implements Runnable{

	private GamePanel panel;
	private Thread gameThread;
	private boolean running;
	
	public GameLoop(GamePanel panel){
		this.panel = panel;
		
		if(gameThread == null){
			gameThread = new Thread(this);
			gameThread.start();
		}
	}
	
	public void start(){
		running = true;
	}

	@Override
	public void run(){
		panel.init();
		while(running){
			panel.update();
			panel.render();
			panel.draw();
			
			try {
				Thread.sleep(100);
			}
			catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}
}

GamePanel.java

import game.gamestate.GameStateManager;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;


@SuppressWarnings("serial")
public class GamePanel extends JPanel{

	// dimensions
	public final static int WIDTH	= 320;
	public final static int HEIGHT	= 240;
	public final static int SCALE	= 2;
	
	// image
	private BufferedImage image;
	
	// gameloop
	private GameLoop loop;
	
	// gamestatemanager
	private GameStateManager gsm;
	
	public GamePanel(){
		setPreferredSize(new Dimension(WIDTH * SCALE, HEIGHT * SCALE));
		setFocusable(true);
		requestFocus();
	}

	
	public void init(){
		loop.start();
		image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
		gsm = new GameStateManager();
	}
	public void update(){
		gsm.update();
	}
	public void render(){
		Graphics g = image.getGraphics();
		
		if(g != null){
			gsm.draw(g);
		}
	}
	public void draw(){
		Graphics g = getGraphics();
		
		if(g != null) {
			g.drawImage(image, 0, 0, WIDTH * SCALE, HEIGHT * SCALE, null);
		}
		else{
			System.exit(0);
		}
	}
	
	@Override
	public void addNotify(){
		super.addNotify();
		addKeyListener(new GameListener());
		loop = new GameLoop(this);
	}
	
	class GameListener implements KeyListener{

		@Override
		public void keyTyped(KeyEvent e){}

		@Override
		public void keyPressed(KeyEvent e){
			gsm.keyPressed(e.getKeyCode());
		}

		@Override
		public void keyReleased(KeyEvent e){
			gsm.keyReleased(e.getKeyCode());
		}
	}
}

Gui.java

import javax.swing.JFrame;


public class Gui{

	public static void main(String[] args){
		JFrame f = new JFrame("GameTest");
		f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		f.setContentPane(new GamePanel());
		f.setResizable(false);
		f.pack();
		f.setLocationRelativeTo(null);
		f.setVisible(true);
	}
}

 

[Razzonk]

Hallo,

danke erstmal!

Zu dem Test Beispiel:
Quaxli macht das in seinem Tutorial genauso, daher hier der versuch ob es so geht.
Da mir die Lösung aber auch nicht gefällt hab ich es im oberen Beispiel anderst gelöst.
Ok ich hab den Thread weggelassen, der immer wieder repaint() aufruft, weshalb ich es einmal da gesetzt habe, eigendlich auch zum testen ob es so geht, aber jetzt wo dus sagst fällt mir auch auf das es Blödsinn ist.

Aber zum eigendlichen Problem:
Warum funktioniert das obere Beispiel nicht?
Dort wird repaint() im Loop immer wieder aufgerufen, aber paintComponents() nicht. Hab es mit dem Debugger durchprobiert.


Werd mir das mit dem aktiv zeichnen mal anschauen, aber für meine zwecke sollte, es so eigendlich erst einmal ausreichen.

Gruß

 

[Razzonk]

Sorry für den Doppelpost, hab kein bearbeiten Button gefunden (??)!

Also das Hauptproblem ist behoben:
Habe anstelle von paintComponent -> paintCoponents geschrieben


Hab mir auch mal angeschaut was ich so zum aktiven Zeichnen finde, allerding habe ich keinen Weg ohne getGraphics() gefunden, aber genügend Aussagen, dass man doch lieber mit paintComponent() arbeiten soll.

Was ist nun der bessere Weg:
-passiv zeichnen mit paintComponent()
-oder aktiv zeichnen mit getGraphics()??

 

[kaoZ]

Das ist an sich auch richtig, wenn du einfache Anwendungen schreibst in welchen du zusätzliche elemente zeichnen möchtest, aber dies gilt nicht für spiele, da ist es blödsinn,

erstens hast du wie schon gesagt keinen Einfluss darauf wann gezeichnet wird

zweitens zeichnest du so immer alles, und das ist aufwendig und teilweise unnötig

also kannst du dir einfach merken :

Für normale Anwendungen
- passives zeichnen über paintComponent(Graphics g);

für Spiele
- aktives zeichnen der gewünschten Komponenten, welchen du einfach den Grafik kontext dessen übergibst auf was du zeichnen möchtest, z.B ein BufferedImage

zu

getGraphics()

du kannst nur zeichnen wenn du dies mit dem Grafik kontext der jeweiligen Komponente machst, sprich wenn du auf einem Bild ( BufferedImage ) etwas zeichnen möchtest, musst du dir den Grafikkontext dieses Bildes holen , dies machst du z.B mit

BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

Graphics g = image.getGraphics();

so erhälst du ein Graphics Object welches es dir ermöglichst damit auf dem Image selbst zu zeichnen.

das gleiche gilt für JPanel oder ähnliche Komponenten, wenn du z.B das Bild auf deinen Panel zeichnen möchtest, kannst du dies einfach mit dem Grafikkontext des Panels machen

JPanel panel = new JPanel();

Graphics g = panel.getGraphics();

g.drawImage(image, 0,0, width, height, null);

So würdest du z.B das voher gezeichnete Image unter verwendung des Graphic Objektes des Jpanels auf dein JPanel zeichnen, sprich einen art double buffering, erst zeichnest du alle komponenten auf dein Bild , und dann dein Bild auf den Panel, also das was dein Spiel darstellt.

Wenn noch unklarheiten dar sein sollten , immer raus damit

 

[Razzonk]

Ok!

Vielen dank!