Thema: Java: Auf JPanel mit Freihand-Pinsel malen

Hallo!
Ich muss ein Programm in Java schreiben, bei dem man Labyrinthe zeichnen kann.
Eine Vorlage ist bereits gegeben.
Es existiert bereits ein JFrame auf welchem ein JPanel ist, auf das man wiederum zeichen können soll.
Ich habe nun schon 2 Stunden rumgegoogelt und nix brauchbares gefunden...
Das Problem ist nämlich, dass das JPanel bereits privat in der Main-Klasse deklariert ist, somit kann man nicht

public void paintComponent(Graphics g){
super.paintComponent(g){
g.drawLine.(x1,y1,x2,y2);
}

oder so benutzen. (die Funktion wird eh grad falsch sein, aber sie soll nur zeigen, dass man nicht mit super auf die Elemente über sich zugreifen kann)

Außerdem soll das Panel in 8x8 große Pixel Quadrate eingeteilt sein, um die Pixel größer zu erscheinen lassen.

Vllt hier mal noch die komplette Aufgabenstellung:

Es soll mit Java Swing ein Programm geschrieben werden, das den kürzesten Weg (im Sinne der Manhattan-Distanz) zwischen zwei Punkten grafisch darstellt. Der Nutzer soll dabei Start- und Endpunkt (je einer) festlegen sowie beliebig viele Hindernisse zeichnen können (Vergleich Stift-Werkzeug aus Microsoft Paint). Die Größe einer "Zelle" des Feldes soll 8x8 Pixel betragen. Das Auswählen der drei Werkzeuge "Startpunkt", "Endpunkt" und "Hindernis" soll über eine Toolbar geschehen.
(Der A* Algorithmus ist glücklicherweise schon implementiert, man muss sich also nur um den grafischen Teil kümmern)

Hat sich erledigt, habe das ganze einfach folgendermaßengemacht:

class Sowieso{
private int lastX, lastY;
private JPanel drawPanel = new JPanel;

.
.
.
.
.
.

drawPanel.addMouseListener(new MouseAdapter()
{
public void mousePressed(MouseEvent e)
{
lastX = e.getX();
lastY = e.getY();
}
});

drawPanel.addMouseMotionListener(new MouseAdapter()
{
public void mouseDragged(MouseEvent e)
{
Graphics g = drawPanel.getGraphics();
int x = e.getX(), y = e.getY();
g.drawLine(lastX,lastY,x,y);
}
});

.
.
.
.
}

Und schon geht der ganze Quatsch

Kannst du mir zufälligerweise dein Programm geben?

wäre nett wenn du die ganze Main methode hier man hinsetzt habe auch son problem.... krieg aber ne nullpointer

danke

dao

wäre nett wenn du die ganze Main methode hier man hinsetzt habe auch son problem.... krieg aber ne nullpointer

na dann würd ich mal den sourcecode hier posten dann wird einem geholfen

Also in der main Methode wird nur die init() Methode aufgerufen (hab das Ganze zu nem Applet umgeschrieben, war Aufgabenstellung). Diese hier zu posten wäre auch nicht sehr sinnvoll, ich poste lieber die Methode, die aufgerufen wird, wenn mouseClicked oder mouseDragged aufgerufen werden:

EDIT:
Hab noch vergessen zu sagen:
Es ist besser den Konstruktor des JPanels zu über schreiben, in etwa so:

JPanel drawPanel = new JPanel
{
@Override
//diese Methode ist vordefiniert und wird von der repaint Methode aufgerufen
paintComponent(Graphics g)
{
//doStuff();
};
}

somit muss man mit "Graphics g = drawPanel.getGraphics();"
sondern man ruft einfach in den mouseClicked bzw mouseDragged Methoden nur die repaint methode von dem drawPanel auf

--------------------------------------------------------------

weiter mit der Methode die ich eigentlich posten wollte

public void myMouseEvents(MouseEvent e)
{
//Graphics der drawPanel speichern
Graphics g = drawPanel.getGraphics();

//geklickte Koordinaten zwischenspeichern
int x = e.getX(), y = e.getY();

//Koordinaten in Raster der 8X8 Kästchen bringen
x = x - (x % 8);
y = y - (y % 8);

//Koordinaten gegebenenfalls anpassen
if ((x) < 0)
x = 0;
if ((x) > 8*64)
x = 8*64;
if ((y) < 0)
y = 0;
if ((y) > 8*64)
y = 8*64;

//x- und y-Koordinaten für Point bestimmen
int pX = x/8, pY = y/8;

//dieser wird für den A*-Algorithmus gebraucht
Point pnt = new Point(pX, pY);


/*obstacle, start, end, und delete sind bool'sche variablen,
die jeweils auf true und false gesetzt werden, wenn der
entsprechende Button geklickt wird.
Mein Tutor hat mir allerdings schon erklärt, dass eine
type-Variable mit den Elementen {OBSTACLE, START, END,
DELETE} besser gewesen wäre*/

//Bei ausgewählten Hindernissen
if (obstacle)
{
//Falls alter Pfad vorhanden, grafisch löschen
if (!Map.getPath().isEmpty())
{
g.setColor(Color.WHITE);
for (Point n : Map.getPath())
{
g.fillRect(n.x*8, n.y*8, 8,8);
}
Map.resetPath();
}

//End- oder Startpunkt dürfen nicht überschrieben werden
if (!pnt.equals(Map.getStart()) && !pnt.equals(Map.getEnd()) )
{
//schwarze Farbe
g.setColor(Color.BLACK);
g.fillRect(x,y,8,8);
//in der Map ein Hindernis erstellen
Map.createObstacle(pnt);
}
}

//Bei ausgewähltem Radiergummi
if (delete)
{
//Falls alter Pfad vorhanden, grafisch löschen
if (!Map.getPath().isEmpty())
{
g.setColor(Color.WHITE);
for (Point n : Map.getPath())
{
g.fillRect(n.x*8, n.y*8, 8,8);
}
Map.resetPath();
}


if (delete && !pnt.equals(Map.getStart()) && !pnt.equals(Map.getEnd()) )
{
//weiße Farbe
g.setColor(Color.WHITE);
useEraser(pnt);
//Hindernis in der Map löschen
Map.deleteObstacle(pnt);

}
}

if (start)
{
//Falls alter Pfad vorhanden löschen
if (!Map.getPath().isEmpty())
{
g.setColor(Color.WHITE);
for (Point n : Map.getPath())
{
g.fillRect(n.x*8, n.y*8, 8,8);
}
Map.resetPath();
}

if (Map.getStart() != null)
{
//alten Startpunkt grafisch löschen
g.setColor(Color.WHITE);
Point oldStartPnt = Map.getStart();
g.fillRect(oldStartPnt.x*8,oldStartPnt.y*8,8,8);
}


//Startpunkt kann keinen Endpunkt überzeichnen
if (!pnt.equals(Map.getEnd()))
{
//rote Farbe
g.setColor(Color.RED);
g.fillRect(x,y,8,8);
//Startpunkt in Map setzen
Map.setStart(pnt);
}
}

if (end)
{
//Falls alter Pfad vorhanden, grafisch löschen
if (!Map.getPath().isEmpty())
{
g.setColor(Color.WHITE);
for (Point n : Map.getPath())
{
g.fillRect(n.x*8, n.y*8, 8,8);
}
Map.resetPath();
}

if (Map.getEnd() != null)
{
//alten Endpunkt grafisch löschen
g.setColor(Color.WHITE);
Point oldEndPnt = Map.getEnd();
g.fillRect(oldEndPnt.x*8,oldEndPnt.y*8,8,8);
}


//Endpunkt kann keinen Startpunkt überzeichnen
if (!pnt.equals(Map.getStart()))
{
//blaue Farbe
g.setColor(Color.BLUE);
g.fillRect(x,y,8,8);
//Endpunkt in Map setzen
Map.setEnd(pnt);
}
}

//Falls ein Start- UND ein Endpunkt existieren,
//dann wird der Weg berechnet und gezeichnet
if ( Map.getEnd() != null && Map.getStart() != null)
{
g.setColor(Color.GREEN);
Map.findPath();
for (Point n : Map.getPath())
{
g.fillRect(n.x*8, n.y*8, 8,8);
}
}
}


Bie Fragen, postet einfach noch mal...

niemals ein Grafik-Objekt mit getGraphics() holen!!!! NIEMALS!!!
Überschreibe lieber die "public void paint(Graphics g)"-Methode...
Da ahst du das entsprechende Graphics-Objekt der Komponente!

Muss man mal richtig lesen^^

Häh? Was meinst du jetzt?
Du kannst mir das gerne mal per Mail schicken! Bin relativ fit was Standard-Grafikprogrammierung mit Java angeht!
Hab schon ein paar Minigames programmiert, die auf dem Prinzip basieren...

Naja ich hab doch oben bereits editiert, dass es besser ist den Konstruktor und dann die paintComponent()-Methode zu überschreiben und dann per repaint()-Methode die eben überschriebene paintComponent()-Methode aufzurufen (halt ohne die Methode getGraphics()).

Okay... bei dem Satz fehlte wohl das ein oder ander Wort!
Reicht allerdings wenn du die paint-Methode überschreibst! Kenn zwar grad nicht den 100%igen Unterschied allerdings wird überschreibt man für gewöhnlich einfach nur die paint-Mehtode! Ist halt Styleguide auch wenn es der Funktionalität keinen Abbruch tut!

Gruß manuche

ps: Würd trotzdem gern mal das gesamte sehen... Oder schick einfach mal die komplette Aufgabe!