NetBeans PanelhintergrundZeichnen

[SuperJavaMan]

Hallo Leute

Ich arbeite an einem eher einfacherem Zeichenprogramm mit NetBeans.
Also meine Hauptfrage: Wie kann ich ein Panelhintergrund setzen auf dem ich dann auch Zeichnen kann?
Das JMenuItem paste (oder public void pastepic, hab es sowieso gekennzeichnet ) soll ein Hintergrund setzen.
Und jetzt zum Zweiten ich hab erst vor kurzem mit Java programmierung begonnen also hab ich den ganzen source code reingeschrieben. Falls ihr Tipps habt wie ich "schöner" schreiben könnte lasst es mich bitte wissen .
Nochmal bin nur ein anfänger erklärt auch bitte einfach .

So ich hoffe ihr könnt mir helfen bedanke mich auch schon im Vorraus

package Paint;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import javax.imageio.ImageIO;
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;


public class paint extends JPanel implements MouseListener, MouseMotionListener, ActionListener {

    private JFrame jf = new JFrame("Draw");
    private JPanel jp = new JPanel();
    private JMenuBar jmb = new JMenuBar();
    private JMenu thickness = new JMenu("Thickness"), data = new JMenu("Data"), colors = new JMenu("Colors"), pic = new JMenu("Pictures"), forms = new JMenu("Forms");
    private JMenuItem ul = new JMenuItem("Ultralight"), light = new JMenuItem("Light"), med = new JMenuItem("Medium"), fat = new JMenuItem("Fat"), ud = new JMenuItem("Userdefined"),
            save = new JMenuItem("Save"), open = new JMenuItem("Open"), del = new JMenuItem("Delete"),
            pen = new JMenuItem("Pencil"), backg = new JMenuItem("Background"), paste = new JMenuItem("Paste"),
            rect = new JMenuItem("Rect"), circ = new JMenuItem("Circle"), arc = new JMenuItem("Arc"), pic1 = new JMenuItem("pic");
    private int x, y, thick = 5, form = 1;
    private Color col = Color.BLACK, c = Color.WHITE;
    private Image img = Toolkit.getDefaultToolkit().getImage("lala.jpg");
    private ArrayList<Point> points = new ArrayList<Point>(37);
    private Point p;
    private Image pic12;

    public void createFrame() {
        jf.setDefaultCloseOperation(EXIT_ON_CLOSE);
        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setJMenuBar(jmb);
        jf.add(jp);
        jmb.add(forms);
        jmb.add(thickness);
        jmb.add(data);
        jmb.add(colors);
        jmb.add(pic);
        forms.add(rect);
        forms.add(circ);
        forms.add(arc);
        forms.add(pic1);
        thickness.add(ul);
        thickness.add(light);
        thickness.add(med);
        thickness.add(fat);
        thickness.add(ud);
        data.add(save);
        data.add(open);
        data.add(del);
        colors.add(pen);
        colors.add(backg);
        pic.add(paste);
        jf.setVisible(true);
    }

    public void dragged() {
        jp.addMouseMotionListener(new MouseMotionListener() {
            @Override
            public void mouseMoved(MouseEvent e) {
            }

            @Override
            public void mouseDragged(MouseEvent e) {
                p = new Point(e.getX(), e.getY());
                System.out.println(p);
                points.add(p);
                Graphics g = ((JPanel) e.getComponent()).getGraphics();
                g.setColor(col);
                if (form == 1) {
                    g.fillRect(p.x, p.y, thick, thick);
                } else if (form == 2) {
                    g.fillOval(p.x, p.y, thick, thick);
                } else if (form == 3) {
                    g.fillArc(p.x, p.y, thick, thick, thick, thick);
                    //hier wollte ich versuchen dass man bilder zeichnet aber beachtet das nicht
                    
                } else if (form == 4) {
//                    try {
//                        pic12 = ImageIO.read(new File("lala.jpg"));
//                    } catch (Exception ex) {
//                        ex.getStackTrace();
//                    }
                    
                }
                g.dispose();
            }
        });
    }
    
//    public void paintComponent(Graphics g2){
//        g2.drawImage(pic12, p.x, p.y, pic12.getWidth(this),pic12.getHeight(this),this);
//    }

//    public void paintComponent(){
//        
//  g.setColor(col);
//        if (form == 1) {
//            g.fillRect(x, y, thick, thick);
//        } else if (form == 2) {
//            g.fillOval(x, y, thick, thick);
//        } else if (form == 3) {
//            g.fillArc(x, y, thick, thick, thick, thick);
//        }
//        else if(form == 4){
//        }
//}
//    public void draw() {
//        Graphics g = jp.getGraphics();
//        g.setColor(col);
//        if (form == 1) {
//            g.fillRect(x, y, thick, thick);
//        } else if (form == 2) {
//            g.fillOval(x, y, thick, thick);
//        } else if (form == 3) {
//            g.fillArc(x, y, thick, thick, thick, thick);
//        }
//        else if(form == 4){
//        }
//    }
    public void ultral() {
        ul.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                thick = 5;
            }
        });
    }

    public void light1() {
        light.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                thick = 10;
            }
        });
    }

    public void medium() {
        med.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                thick = 15;
            }
        });
    }

    public void fat1() {
        fat.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                thick = 20;
            }
        });
    }

    public void userdefined() {
        ud.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                thick = Integer.parseInt(JOptionPane.showInputDialog("Type in the thickness"));
            }
        });
    }

    public void pencil() {
        pen.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                col = JColorChooser.showDialog(null, "Colorchooser", null);
            }
        });
    }

    public void background() {
        backg.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                c = JColorChooser.showDialog(null, "Colorchooser", null);
                jp.setBackground(c);
            }
        });
    }

    public void drawRect() {
        rect.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                form = 1;
            }
        });
    }

    public void drawCircle() {
        circ.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                form = 2;
            }
        });
    }

    public void drawArc() {
        arc.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                form = 3;
            }
        });
    }

    public void drawPic() {
        arc.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                form = 4;
            }
        });
    }

    public void delete() {
        del.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                points.clear();
            }
        });
    }
    
    //hier fängt die hauptfrage an (EINER meiner versuche)
    
    public void pastepic(){
        paste.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent ae) {
                paint();
            }
        });
    }
    
    public static BufferedImage load(String name){
        try {
           BufferedImage img = ImageIO.read(paint.class.getResourceAsStream(name));
           return img;
        } catch (IOException e) {
           e.printStackTrace();
        }
        return null;
    }
    
    public Bilder(){ 
        setLayout(null);
        setPreferredSize(new Dimension(800,600));
    }
    
     public void paint(){
         Graphics g = jp.getGraphics();
         Graphics2D g2d = (Graphics2D) g;
         g2d.drawImage(load("lala.jpg"),0,0,null);
     }
     
     // und hier endet sie

    public static void main(String[] args) {
        paint obj = new paint();
        obj.createFrame();
        obj.dragged();
        obj.ultral();
        obj.light1();
        obj.medium();
        obj.fat1();
        obj.userdefined();
        obj.pencil();
        obj.background();
        obj.drawRect();
        obj.drawCircle();
        obj.delete();
        obj.drawArc();
        obj.drawPic();
        obj.pastepic();
    }

    @Override
    public void mouseClicked(MouseEvent me) {
    }

    @Override
    public void mousePressed(MouseEvent me) {
    }

    @Override
    public void mouseReleased(MouseEvent me) {
    }

    @Override
    public void mouseEntered(MouseEvent me) {
    }

    @Override
    public void mouseExited(MouseEvent me) {
    }

    @Override
    public void mouseDragged(MouseEvent me) {
    }

    @Override
    public void mouseMoved(MouseEvent me) {
    }

    @Override
    public void actionPerformed(ActionEvent ae) {
    }
}

 

[lord239123]

Wenn du mit mehreren Ebenen arbeiten willst, kannst du einfach erst die untere Ebene zeichnen und dann die Ebene darüber.
Beides muss dabei in der paintComponent() Methode passieren.

 

[SuperJavaMan]

Danke für die schnelle antwort

Aber kannst du es mir vielleicht bitte in einem ausführlicherem Beispiel zeigen.
Und wenn ich es mit paintComponent mache wie schreibe ich das in public static main(so wie ich es in meinem beispiel mache)?

 

[kaoZ]

Meinst du sowas in der Art ?

Hier wird allerdings Aktiv gezeichnet, man kann es auch passiv realisieren und dann immer nur neuzeichnen, allerdings wird dann auch immer alles übermalt

Hier mal ein Beispiel, wenn du eines mit passivem Zeichnen haben möchtest lass es mich wissen ,
dies hier ist ziemlich rudimentär :

(paintComponent haben ich hier zwar mit überschrieben , aber keine zusätzliche Funktionalität hinzugefügt)

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JFrame;
import javax.swing.JPanel;


@SuppressWarnings("serial")
public class DrawPane extends JPanel implements MouseListener{

	public final static String TITLE = "Zeichenbrett";
	
	public final static int WIDTH	 = 400;
	public final static int HEIGHT	 = 400;
	
	Shape currentShape;
	
	public DrawPane(){
		init();
	}
	
	private void init(){
		setPreferredSize(new Dimension(WIDTH, HEIGHT));
		addMouseListener(this);
	}
	
	private void draw(Graphics2D g2, Shape s, Color c){
		g2.setColor(c);
		g2.draw(s);
		g2.dispose();
	}
	
	@Override
	public void paintComponent(Graphics g){
		super.paintComponent(g);
	}

	@Override
	public void mouseClicked(MouseEvent e){
		
		currentShape = new Rectangle(e.getX(), e.getY(), 20, 20);
		draw((Graphics2D)getGraphics(), currentShape, Color.RED);
	}

	@Override
	public void mousePressed(MouseEvent e){}

	@Override
	public void mouseReleased(MouseEvent e){}

	@Override
	public void mouseEntered(MouseEvent e){}

	@Override
	public void mouseExited(MouseEvent e){}

	public static void main(String[] args){
		JFrame f = new JFrame(DrawPane.TITLE);
		f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		f.setContentPane(new DrawPane());
		f.pack();
		f.setLocationRelativeTo(null);
		f.setVisible(true);
	}
}

 

[lord239123]

Hier ist eine Klasse aus meinem Pokemon Spiel:

package maps;

import java.awt.*;

import javax.swing.*;

import main.*;

//Kontainer, in dem sich die aktuell Map befindet
public class Anzeige extends JPanel
{
	Kampf kampf;								//Aktueller Kampf
	public Player player = new Player("Ash");	//Spieler
	public Map aktuelleMap = new Map();		 	//Dies ist die Map, auf der sich der Spieler befindet
	public Dialogfeld dialog = new Dialogfeld();//Dialogfeld, das nur angezeigt wird, wenn es Text enthält
	
	public float schwärze = 0f; 				//Transparenz der Schwärze, die z.B. am Anfang und am Ende von Kämpfen benutzt wird
	
	
	public Anzeige(Map aktuelleMap)
	{
		//Startposition der Map
		setMap(aktuelleMap);
		this.aktuelleMap = aktuelleMap; //legt eine neue Map fest
		setSize(aktuelleMap.felder[0].length*40+40, aktuelleMap.felder.length*40+40);
	}
	
	public void setMap(Map aktuelleMap)
	{
		//legt eine neue Map und dessen Startposition
		this.aktuelleMap = aktuelleMap; 
		setLocation(aktuelleMap.startPosition.x*40*(-1)+200, aktuelleMap.startPosition.y*40*(-1)+200);
		
		//Position des Spielers setzen
		player.setX(getX()*(-1) + 200);
		player.setY(getY()*(-1) + 200);
	}
	
	//aktuelle Map zeichnen
	public void paintComponent(Graphics g) 
	{			
		/*
		 * Graphics auf Graphics2D ändern und einen Buffer einfügen, 
		 * damit das Bild erst gezeichnet wird, wenn es fertig
		 * gerendert ist
		 */
	    Graphics2D g2 = (Graphics2D)g;
        setDoubleBuffered(true);
	    
		/*
		 * Ebene: 0
		 * Zeichnen der Felder
		 */
		for (int i = player.getX()/40-6; i < player.getX()/40+7; i++) 
		{
			for (int j = player.getY()/40-6; j < player.getY()/40+7; j++) 
			{
				//Bild des Feldes in einem Bild speichern und ausgeben
				Image feldBild = aktuelleMap.felder[j][i].getIcon().getImage(); 
				g2.drawImage(feldBild, i*40, j*40, null);
			}
		}
			
		/*
		 * Ebene: 1
		 * Zeichnen des Players & der NPCs
		 */
		Image playerBild = ((ImageIcon) player.getIcon()).getImage(); 
		g2.drawImage(playerBild, player.getX(), player.getY(), null);
			
		//Zeichnen der NPCs
		if(aktuelleMap.npcs != null)
		{
			for (NPC npc : aktuelleMap.npcs) 
			{
				Image npcBild = ((ImageIcon) npc.getIcon()).getImage(); 
				g2.drawImage(npcBild, npc.getX(), npc.getY(), null);
			}
		}
			
		/*
		 * Ebene: 2
		 * Zeichnen der transparenten Felder über dem Spieler
		 */
		for (int i = player.getX()/40-6; i < player.getX()/40+6; i++) 
		{
			for (int j = player.getY()/40-6; j < player.getY()/40+6; j++) 
			{
				//Bild des Feldes in einem Bild speichern und ausgeben
				if(aktuelleMap.felderoben[j][i] != null)
				{
					Image feldBild = aktuelleMap.felderoben[j][i].getIcon().getImage(); 
					g2.drawImage(feldBild, i*40, j*40, null);
				}
			}
		}

		
		/*
		 * Ebene: 3
		 * Zeichnen des Dialogfeldes, falls es Text enthält
		 */
		if(!dialog.getZeile1().equals(""))
		{
			g2.setFont(new Font("Arial", Font.PLAIN, 30));
			g2.setColor(Color.WHITE);
			g2.fillRect(player.getX()-200, player.getY()+120, 439, 112);
			g2.setColor(Color.DARK_GRAY);
			g2.drawRect(player.getX()-200, player.getY()+120, 439, 112);
			g2.setColor(Color.BLACK);
			g2.drawString(dialog.getZeile1(), player.getX()-190, player.getY()+150);
			g2.drawString(dialog.getZeile2(), player.getX()-190, player.getY()+180);
		}
		
		
		/*
		 * Ebene: 4
		 * Schwärze zeichnen, die vor und nach einem Kampf auftaucht 
		 * Die Transparenz dieser Schwärze ändert sich
		 */
		g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, schwärze)); 
		g2.setColor(new Color(0, 0, 0));
		g2.fillRect(Spiel.anzeige.player.getX()-200, Spiel.anzeige.player.getY()-200, 440, 440);
		g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0f)); //Transparenz erschaffen
		
	}
}

Für dich ist zwar in diesem Beispiel nur die paintComponent() Methode wichtig.
Den Rest der Klassen kann ich dir hier leider nicht ins Forum stellen, da es über 50 sind.

Wie du siehst, werden hier in dem Beispiel 5 Ebenen gezeichnet, die alle übereinander liegen.
Hier ist auch noch die main Methode:

	public static void main(String[] args) 
	{
		//JFrame einstellen
		f.setSize(448, 475);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setResizable(false);
		f.setLayout(null);
		f.setLocationRelativeTo(null);
		f.setVisible(true);
		
		//Taktgeber
		taktgeber = new Taktgeber();

		//Die Stadt dem JFrame hinzufügen und ihre Größe ändern
		f.add(anzeige);
		
		
		//Neuer Keylistener
		f.addKeyListener(new KeyListener()
		{

			@Override
			public void keyPressed(KeyEvent e)
			{
				switch(e.getKeyChar())
				{
				case 'w': anzeige.player.laufen(1);break;
				case 's': anzeige.player.laufen(2);break;
				case 'a': anzeige.player.laufen(3);break;
				case 'd': anzeige.player.laufen(4);break;
				case 'e': if(anzeige.player.kannReden){new Thread(){public void run(){anzeige.player.reden();}}.start();} anzeige.dialog.klick = true; break;
				}
			}
			public void keyReleased(KeyEvent e){}		
			public void keyTyped(KeyEvent e){}
		});
		
		//Die Variable klick wird bei jedem Mausklick auf true gesetzt
		f.addMouseListener(new MouseListener()
		{
			public void mouseClicked(MouseEvent arg0) 
			{
				Spiel.anzeige.dialog.klick = true;
			}

			@Override
			public void mouseEntered(MouseEvent arg0) {}
			public void mouseExited(MouseEvent arg0) {}
			public void mousePressed(MouseEvent arg0) {}
			public void mouseReleased(MouseEvent arg0) {}		
		});
	}

In diesem Beispiel konfiguriert die main die Anzeige des Spieles und erstellt die Listener.

Die paintComponent Methode wird im Hintergrund in einer Dauerschleife immer wieder von einem Thread per repaint() aufgerufen, sodass Animationen ermöglicht werden.

 

[SuperJavaMan]

Danke für die Antwort...

..Aber eine Frage habe ich noch: Warum musst du die ganzen Methoden nicht in die public static main schreiben?
Wenn es dir nichts ausmacht würde ich auch gerne die passive weise sehen nur zum lernen

 

[SuperJavaMan]

Danke für das sehr ausführliche beispiel
Damit kann ich sicher was anfangen
Aber um es besser zu verstehen. Könntest du mir Ebene 0 besser erklären bitte?
Zeile 75 auch bitte näher erklären ich kenne nur die 0815 for schleifen zB for(int i = 0; i < 10; i++)

 

[kaoZ]

..Aber eine Frage habe ich noch: Warum musst du die ganzen Methoden nicht in die public static main schreiben?

weil genau das nicht Objektorientiert wäre, du erzeugst nur eine Instanz also ein Objekt deines ZeichenPanels und setzt dieses als Content eines JFrames.

Wenn es dir nichts ausmacht würde ich auch gerne die passive weise sehen nur zum lernen

Beim passiven Zeichnen überschreibst du paintComponent mit der Funktionalität die du bereitstellen willst, hier das Zeichnen des Shapes beim Mouseklick,
allerdings wird dir auffallen , das du um deine shape dann zu zeichnen, repainten musst, das bedeutet aber auch das wenn du z.B ein Rechteck zeichnest, und dann eines an einer anderen stelle, das vorherige übermalt wird, da der komplette panel neu gezeichnet wird, willst du dies nicht musst du z.B ein Datenfeld (Array) anlegen
und die gezeichneten Formen zwischenspeichern und beim aufrufen alle formen darin zeichnen.

Du bittest hier sozusagen beim aufrufen von repaint() das Toolkit bzw. deine gewünschte Komponente neu zu zeichnen und zwar komplett, ohne das du Einfluss darauf wann das Toolkit dies macht. ( passiv )

deshalb geht man bei z.B Spielen auch dazu über und zeichnet aktiv, da man erstens nur das zeichnen muss was man zeichnen will, ( z.B einen bestimmte Bereich ) und man einfluss darauf hat wann dies passiert, und wie oft.

@SuppressWarnings("serial")
public class DrawPane extends JPanel implements MouseListener{

	public final static String TITLE = "Zeichenbrett";
	
	public final static int WIDTH	 = 400;
	public final static int HEIGHT	 = 400;
	
	Shape currentShape;
	
	public DrawPane(){
		init();
	}
	
	private void init(){
		setPreferredSize(new Dimension(WIDTH, HEIGHT));
		addMouseListener(this);
	}
	
//	Aktives Zeichnen
	
//	private void draw(Graphics2D g2, Shape s, Color c){
//		g2.setColor(c);
//		g2.draw(s);
//		g2.dispose();
//	}
	
//	Passives Zeichnen
	
	@Override
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		
		Graphics2D g2 = (Graphics2D) g;
		
		if(currentShape != null) {
			g2.draw(currentShape);
		}
	}

	@Override
	public void mouseClicked(MouseEvent e){
		currentShape = new Rectangle(e.getX(), e.getY(), 20, 20);
		repaint();
	}

	@Override
	public void mousePressed(MouseEvent e){}

	@Override
	public void mouseReleased(MouseEvent e){}

	@Override
	public void mouseEntered(MouseEvent e){}

	@Override
	public void mouseExited(MouseEvent e){}

	public static void main(String[] args){
		JFrame f = new JFrame(DrawPane.TITLE);
		f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		f.setContentPane(new DrawPane());
		f.pack();
		f.setLocationRelativeTo(null);
		f.setVisible(true);
	}
}

 

[SuperJavaMan]

Danke kaoz für deine hilfe
ich hab es schon geschafft
aber es gibt ein weiteres problem XD
wenn ich ein jMenu öffne löscht sich ein teil des bildes
wie kann ich das beständiger machen?

 

[kaoZ]

wenn ich ein jMenu öffne löscht sich ein teil des bildes

Wie ist dein JMenu realisiert, normalerweise übergibst du dein Menu direkt dem contentPane

JFrame myFrame = new JFrame();

myFrame.setJMenuBar(xxx);

ich vermute mal hier wird repaint aufgerufen und diese übermalt dann deine Komponenten / zeichnungen.

 

[SuperJavaMan]

Schau dir den source code den ich am anfang aufgeschrieben hab an dan verstehst du es vielleicht besser
schreib auch bitte den repaint code

Danke

 

[kaoZ]

btw. der einfachste weg , wenn ich nach dem Threadtitle gehe ist folgender

wenn du das Image zeichnen willst ( dieses als resource vorliegt )

@Override
public void paintComponent(Graphics g){
  BufferedImage image = ImageIO.read(getClass().getResourceAsStream("/images/example.jpg"));

  g.drawImage(image, 0, 0 ,null);
}

wenn du es als Icon in einem JLabel verwenden möchtest.

BufferedImage image = ImageIO.read(new FileInputStream(new File("H:/Bilder/example.jpg")));

JLabel label = new JLabel("", new ImageIcon(image));

meinPanel.add(label);

wenn du nun auf deinem Image zeichnen willst, musst du dir dessen Grafik Kontext holen , dies kannst du über image.getGraphics(); bewerkstelligen.

Dann kannst du dieses Graphics Objekt quasi als deinen "Pinsel" verwenden um auf diesem Bild zu malen.


EDIT :

Das Zauberwort ist hier revalidate();

wenn du von außen deinem Content neue elemente ( z.B ein Hintergrundbild) hinzufügst , wird die Hierarchie deines Composits "verändert"
sprich du musst deiner Applikation mitteilen das alle Ihre Elemente neu ausgerichtet werden sollen.

 

[SuperJavaMan]

Danke aber das mit dem Zeichnen auf dem Bild funktioniert schon
wie schaffe ich es dass nichts gelöscht wird beim vergrößern oder wenn man JOptionPane aufruft?

 

[kaoZ]

das Problem ist hier wieder das beim vergrößern des Frames, oder das aufrufen eines anderen panes , alles überzeichnet wird, sprich es wird repaint() aufgerufen.

deine Elemente werden allso alle wieder überzeichnet, du könntest dann beigehen , und diese Elemente wie gesagt in einer Collection oder einem Array sammeln und diese dann beim Verändern des Frames mit neu zeichnen.

Zusätzlich würde ich double-buffering / einen extra Thread verwenden.

 

[SuperJavaMan]

ok danke vielmals für deine hilfe

 

[kaoZ]

Falls du noch probleme haben solltest mit dem neuzeichnen der Elemente wenn du dein Fenster veränderst.

(Ich habe hier bewusst keine Shapes verwendet )

Beim Resizeing der Frames wird immer auch paint() aufgerufen ( hier mal von JFrame abgeleitet ) und somit werden immer alle Elemente der ArrayList an der jeweiligen Position neu gezeichnet.

import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import javax.swing.JFrame;


@SuppressWarnings("serial")
public class Drawing extends JFrame implements MouseListener{

	ArrayList<int[]> list;
	
	public Drawing(){
		setSize(300,300);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		addMouseListener(this);
	
		list = new ArrayList<>();
	}
	
	private void drawAllElements(Graphics g){
		for (int i = 0; i < list.size(); i++) {
			int[] arr = list.get(i);
			g.fillRect(arr[0], arr[1], arr[2], arr[3]);
		}
	}
	
	@Override
	public void mouseClicked(MouseEvent e){
		Graphics g = getGraphics();
		g.fillRect(e.getX(), e.getY(), 30, 30);
		list.add(new int[]{e.getX(), e.getY(), 30, 30});
	}
	
	@Override
	public void paint(Graphics g){
		super.paint(g);
		
		drawAllElements(g);
	}

	@Override
	public void mousePressed(MouseEvent e){}

	@Override
	public void mouseReleased(MouseEvent e){}

	@Override
	public void mouseEntered(MouseEvent e){}

	@Override
	public void mouseExited(MouseEvent e){}

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

 

[lord239123]

Danke für das sehr ausführliche beispiel
Damit kann ich sicher was anfangen
Aber um es besser zu verstehen. Könntest du mir Ebene 0 besser erklären bitte?
Zeile 75 auch bitte näher erklären ich kenne nur die 0815 for schleifen zB for(int i = 0; i < 10; i++)

Die Ebene 0 besteht aus dem Hintergrund, also Gras und Wege.
Im Anhang findest du ein Bild, anhand dessen du den Code vermutlich besser verstehen willst.

In Zeile 75 wird eine so genannte foreach-Schleife verwendet.
Diese Schleifenart wird hier dazu benutzt, das Array npcs zu durchlaufen.
Falls du dich dafür interessieren solltest, ist hier eine genauere Definition:
Galileo Computing :: Java ist auch eine Insel – 3.7 Arrays

Wenn du die Sprache richtig lernen willst, kann ich dir nur empfehlen, das Buch "Java ist auch eine Insel" zu lesen.
Es hat zwar 1300 Seiten, aber es lohnt sich.