# Zwei Element auf ein Contentpane



## Mr.Bean (24. Mai 2007)

Also nochmal neu...
Wie kann ich denn, wenn ich ein Objekt Spielstein und ein Objekt Spielbrett, beide auf eine Contentpane hinzufügen, ohne das sie sich überlagern?
Danke


----------



## Fatal Error (24. Mai 2007)

hört sich nach Dame oder so was an?


----------



## merlin2 (24. Mai 2007)

Ohne dass sie sich überlagern?
Das heißt nebeneinander?
Formulier deine Frage doch mal etwas klarer.


----------



## Mr.Bean (24. Mai 2007)

Nein, es soll mal Mühle werden...   
Nur zu Übungszwecke...


----------



## icecreamman (24. Mai 2007)

Du kannst das Null-Layout benutzen. Müsste ungefähr so funktionieren:


```
...

pane = getContentPane();

pane.setLayout(null);

Spielbrett.setBounds(10,10,400,400);
Spielfigur.setBounds(410,410,40,40);

pane.add(Spielbrett);
pane.add(Spielfigur);

...
```


----------



## Mr.Bean (24. Mai 2007)

Also gezeichnet werden sie ja innerhalb ihrer Klasse, dort auch schon abhängig von der OS-Auflösung, sprich mit den Layoutmanager hab ich es nicht so richtig hinbekommen.
Jetzt hab ich was von einem Glasspane gelesen, nur leider bin ich mir nicht sicher ob dass das Richtige hierfür ist.


----------



## Mr.Bean (24. Mai 2007)

Von welchem Typ ist pane?


----------



## icecreamman (24. Mai 2007)

ich glaube Container, bin mir aber nicht sicher. Musst du einfach mal in der Doku nachschauen


----------



## Mr.Bean (24. Mai 2007)

Leider hatte ich keinen Erfolg, nur ein graues Fenster...???


----------



## merlin2 (24. Mai 2007)

Kann es sein, dass ein Aufruf von
	
	
	
	





```
setContentPane(pane);
```
fehlt?


----------



## Mr.Bean (24. Mai 2007)

führt leider auch nicht zum gewünschten Erfolg...


----------



## icecreamman (24. Mai 2007)

Hier etwas mehr Code:


```
public class Fenster extends JFrame 
{ 
   public Fenster() 
   { 
      setSize(600,600); 
       
      getContentPane().setLayout(null);        
        
      pane = getContentPane(); 

      pane.setLayout(null); 

      Spielbrett.setBounds(10,10,400,400); 
      Spielfigur.setBounds(410,410,40,40); 

      pane.add(Spielbrett); 
      pane.add(Spielfigur);         
                                
      setVisible(true); 
   } 
    
   public static void main (String argv[]) 
   { 
      new Fenster(); 
   } 
}
```

Brett und Figur müssen natürlich beide von JComponent erben


----------



## Mr.Bean (24. Mai 2007)

Könnte vielleicht dabei schon das Problem sein, ich habe sie von JPanel erben lassen?


----------



## icecreamman (24. Mai 2007)

Da JPanel ein Nachfahr von JComponent ist, sollte es kein Problem sein


----------



## Mr.Bean (25. Mai 2007)

...deswegen ist leider auch immer noch alles grau...???


----------



## icecreamman (26. Mai 2007)

Poste doch mal deinen Code!


----------



## André Uhres (26. Mai 2007)




----------



## Mr.Bean (29. Mai 2007)

Hier mal die Klasse wo die Elemente vom Typ JPanel eingefügt werden...


```
public class MainWindow extends JFrame{
	public MainWindow(){
		//erstellt ein Frame
		super("Muehle");
		//Ermittelt die bestehende Auflösung des Betriebsystems
		Dimension windowScreensize = Toolkit.getDefaultToolkit().getScreenSize();
		
		//ob das Aussehen des Fensters verändert werden soll
		JFrame.setDefaultLookAndFeelDecorated(false);
	
		this.getContentPane().setBackground(Color.LIGHT_GRAY);
		this.getContentPane().setMaximumSize(windowScreensize);
		//gibt die Größe des Frames an und macht es sichtbar
		this.setBounds(0, 0, windowScreensize.width, windowScreensize.height);
		SteinZeichnen stein = new SteinZeichnen();
		SpielBrett brett = new SpielBrett(); 
		
		this.getContentPane().add(stein); 
		//this.getContentPane().add(brett); 

		this.setVisible(true);
		//Aufruf der Klasse CloseWindow zum Schließen des Fensters und des Prozesses
		this.addWindowListener(new CloseWindow());
		
	}
}
```


----------



## André Uhres (30. Mai 2007)

Das Problem hängt vom Layout und/oder den Constraints ab.
JFrame hat BorderLayout als default. Da du beim add keine Constraints angibst, 
kommt alles in den CENTER-Bereich. Dort kann aber immer nur eine Komponente angezeigt werden.
Man könnte das Problem z.B. so lösen:

```
this.getContentPane().add(stein, BorderLayout.NORTH);
```
Damit geben die Constraints an, daß der Stein im NORTH-Bereich vom BorderLayout angezeigt werden soll.
Das Brett kann dann problemlos im CENTER-Bereich angezeigt werden.


----------



## Mr.Bean (30. Mai 2007)

Nun setzt er immer nur das, was im Zentrum "BorderLayout.Center" liegt in den Vordergrund, also entweder den Stein oder das Brett.
Vielleicht liegt es ja auch daran, weil ich das Zeichnen schon in einer eigenen Klasse vornehme und dort auch die Maße im Verhältnis zur Betriebssystemauflösung wähle?


----------



## André Uhres (30. Mai 2007)

Mr.Bean hat gesagt.:
			
		

> Nun setzt er immer nur das, was im Zentrum "BorderLayout.Center" liegt in den Vordergrund..


Achja, was im CENTER ist, das dehnt sich immer aus um allen verfügbaren Platz einzunehmen.
Dem kannst du entgegenwirken, indem du der Komponente, die nach NORTH kommt, eine PreferredSize gibst.


----------



## Mr.Bean (30. Mai 2007)

Wo kann ich das denn einsetzen?


----------



## André Uhres (30. Mai 2007)

Mr.Bean hat gesagt.:
			
		

> Wo kann ich das denn einsetzen?


stein.setPreferredSize(..) oder in der Klasse selbst, dort könntest du auch getPreferredSize überschreiben.


----------



## Mr.Bean (30. Mai 2007)

Verspricht leider keinen Erfolg, ich denke mal da ich Größe und Lage schon in der jeweiligen Klasse selbst festgelegt habe..., oder?


----------



## Leroy42 (30. Mai 2007)

Mr.Bean hat gesagt.:
			
		

> Größe *und Lage* schon in der jeweiligen Klasse selbst festgelegt habe..., oder?



So kommen wir hier nicht weiter!

Ich versuche mal rauszubekommen, was du vorhast:







Soll es so aussehen?

Du willst also das Brett darstellen, und die Steine
_darübermalen_? Richtig?

Dann mußt du da einen anderen Ansatz nehmen.

Deine Klasse _Spielbrett_ besitzt eine Referenz
auf die aktuell gelegten Steine, die *keine* eigenen JPanels
sind, und zeichnet diese, *nach* Zeichnen des Spielbretts
(jetzt egal ob _handgemalen_ oder ein fixes Bild) in der
paintComponent-Methode einfach zusätzlich.

Komme ich da der Sache etwas näher?  ???:L


----------



## Mr.Bean (30. Mai 2007)

Soweit bin ich ja noch gar nicht...   

Also zunächst möchte ich erst einmal, so wie das Bild zuvor schon zeigt, links das Brett und Rechts den Stein (die Steine)...

Beide sind in jeweils eigenen Klassen realisiert und von JPanel abgeleitet...

Dort werden sie dann schon komplett gezeichnet, als grundlage der Ausrichtung dient hier Die aktuelle Bildschirmauflösung...

Im Prinzip, suche ich zum Einen eine Lösung die mir die Stein links und das Brett rechts darstellt, eben so wie auf der zeichnung und zum Anderen, das ich natürlich hinterher die Steine auf das Brett verschieben kann...


----------



## Leroy42 (30. Mai 2007)

Mr.Bean hat gesagt.:
			
		

> eine Lösung die mir die Stein links und das Brett rechts darstellt



Das ist einfach:

Im CENTER-Bereich das Spielbrett.
Im EAST-Bereich ein JPanel mit GridLayout(2, 0) (oder (0,2), verwechsele das immer)
in das die Steine eigefügt werden.



			
				Mr.Bean hat gesagt.:
			
		

> das ich natürlich hinterher die Steine auf das Brett verschieben kann...



Hier sehe ich Schwierigkeiten, wenn die Steine eigene JPanels sind,
da die Form von JPanels ja immer rechteckig ist, würde jeder Stein
die durchgezogenen Linien des Spielbretts ja unterbrechen!

Und hier helfen auch keine Gifs, die in ihrem Außenbereich 
(also außerhalb der Kreisfläche) transparent sind, da ja der
Hintergrund des JPanels (auf dein der Stein gezeichnet wird),
nicht transparent ist, oder geht das auch?

 ???:L 

Ich würde den Steinen eine eigene paint-Methode verpassen,
die ein Graphics und die Koordinaten, an denen sie sich ins
Graphic malen sollen, übergeben bekommen und *nicht*
von JPanel abeleitet sind. Der Aufruf erfolgt dann in etwa so


```
public void paintComponent(Graphics g) {
  super.paintComponent(g);
  // Zeichne Brett
  for (Stein stein : aktuelleSteine) 
    stein.paint(g, /*x-Koordinate*/, /*y-Koordinate*/);
}
```

Aber ich gebe zu, hier stoß ich an die Grenzen
meines GUI-Wissens  :bahnhof: 

Da empfehle ich dir dann doch unseren GUI-Schamanen.

Opi!, OOOPIII!: Aufwachen!

Dein Typ wird verlangt!

(  )


----------



## Mr.Bean (30. Mai 2007)

Also das Zeichnen des Steines übernimmt mein Objekt, wenn du das meinst:


```
class SteinZeichnen extends JPanel
{  
	  
	 
	//Ermittelt die bestehende Auflösung des Betriebsystems
	Dimension windowScreensize = Toolkit.getDefaultToolkit().getScreenSize();
		
	int mitteX = windowScreensize.width / 2;
	int mitteY = windowScreensize.height / 2;
	
	private Spielsteine stein = new Spielsteine(mitteX+windowScreensize.width / 3,mitteY);
	private Spielsteine selectedKreis = null; 
	private Cursor CURSOR_MOVE = new Cursor(Cursor.MOVE_CURSOR); 
	
	private MouseListener mouseListener = new MouseListener() 
	{ 
		public void mouseClicked(MouseEvent e) 
        { 

        } 

        public void mouseEntered(MouseEvent e) 
        { 

        } 

        public void mouseExited(MouseEvent e) 
        { 

        } 
        
    	public void mousePressed(MouseEvent e)
    	{ 
    		  stein = findKreis(e.getX(), e.getY()); 
              if (stein != null) 
              { 
                  selectedKreis = stein; 
                  repaint(); 
                  //getContentPane().setCursor(CURSOR_MOVE); 
              } 
           
    	} 
    	public void mouseReleased(MouseEvent e)
    	{ 
    		selectedKreis = null; 
            //getContentPane().setCursor(CURSOR_DEF); 
            repaint(); 
    	} 
    };
    
	private MouseMotionListener motionListener = new MouseMotionListener() 

    { 
        public void mouseMoved(MouseEvent e)
        { 
        }

		public void mouseDragged(MouseEvent e) {
			  if (selectedKreis != null) 
              {        
                  // koordinaten des kreis ändern 
                  selectedKreis.setX(e.getX()); 
                  selectedKreis.setY(e.getY()); 
                   
                  repaint(); 
              } 

			
		} 
    }; 


	public Spielsteine findKreis(int x, int y) 
	{ 
	   
        if (stein.containsPoint(x, y)) 
        { 
            return stein; 
        } 
	   
	    return null; 
	} 

	public void paint(Graphics g)
	{ 
		//Typcasting von Graphics zu Graphics2D
		Graphics2D g2d =  (Graphics2D)g;
		
		g2d.setColor(Color.WHITE);
		g2d.fillOval(stein.getX(), stein.getY(), stein.getRadius(), stein.getRadius()); 
    
	} 
}
```


----------



## André Uhres (31. Mai 2007)

Mr.Beans Ansätze sind durchaus brauchbar.
Mit ein paar Anpassungen kommt man zum gewünschten Ergebnis:

```
package muehle;
/*
 * MainWindow.java
 */
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
public class MainWindow extends JFrame{
    public MainWindow(){
        //erstellt ein Frame
        super("Muehle");
        //Ermittelt die bestehende Auflösung des Betriebsystems
        Dimension windowScreensize = Toolkit.getDefaultToolkit().getScreenSize();
        //ob das Aussehen des Fensters verändert werden soll
        JFrame.setDefaultLookAndFeelDecorated(false);
        this.getContentPane().setBackground(Color.LIGHT_GRAY);
        this.getContentPane().setMaximumSize(windowScreensize);
        //gibt die Größe des Frames an und macht es sichtbar
        this.setBounds(0, 0, windowScreensize.width, windowScreensize.height);
        SpielBrett brett = new SpielBrett();
        for (int i = 0; i < 9; i++) {
            brett.add(new SteinZeichnen(Color.WHITE));
            brett.add(new SteinZeichnen(Color.BLACK));
        }
        this.getContentPane().add(brett);
        this.setVisible(true);
        //Aufruf der Klasse CloseWindow zum Schließen des Fensters und des Prozesses
        this.addWindowListener(new CloseWindow());
    }
    public static void main(String[] args) {new MainWindow();}
    class CloseWindow extends WindowAdapter{
        public void windowClosing(WindowEvent e) {
            dispose();
        }
    }
}
/*
 * SteinZeichnen
 */
class SteinZeichnen extends JPanel {
    //Ermittelt die bestehende Auflösung des Betriebsystems
    Dimension windowScreensize = Toolkit.getDefaultToolkit().getScreenSize();
    int mitteX = windowScreensize.width / 2;
    int mitteY = windowScreensize.height / 2;
    private Spielsteine stein = new Spielsteine(mitteX+windowScreensize.width / 3,mitteY);
    private Spielsteine selectedKreis = null;
    private Cursor CURSOR_MOVE = Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR);
    private Cursor CURSOR_DEF = Cursor.getDefaultCursor();
    private int deltaX, deltaY;
    private Color color;
    private MouseListener mouseListener = new MouseListener() {
        public void mouseClicked(MouseEvent e) {}
        public void mouseEntered(MouseEvent e) {}
        public void mouseExited(MouseEvent e) {}
        public void mousePressed(MouseEvent e) {
            stein = findKreis(e.getX() + getX(), e.getY() + getY());
            if (stein != null) {
                selectedKreis = stein;
                deltaX = e.getX()+getX() - stein.getX();
                deltaY = e.getY()+getY() - stein.getY();
                setCursor(CURSOR_MOVE);
            }
        }
        public void mouseReleased(MouseEvent e) {
            selectedKreis = null;
            setCursor(CURSOR_DEF);
        }
    };
    private MouseMotionListener motionListener = new MouseMotionListener() {
        public void mouseMoved(MouseEvent e) {}
        public void mouseDragged(MouseEvent e) {
            if (selectedKreis != null) {
                // koordinaten des kreis ändern
                selectedKreis.setX(e.getX()+getX() - deltaX);
                selectedKreis.setY(e.getY()+getY() - deltaY);
                setLocation(selectedKreis.getX(), selectedKreis.getY());
            }
        }
    };
    public SteinZeichnen(Color color){
        this.color = color;
        setOpaque(false);
        setBounds(stein.getX(), stein.getY(), stein.getRadius(), stein.getRadius());
        addMouseListener(mouseListener);
        addMouseMotionListener(motionListener);
    }
    public Spielsteine findKreis(int x, int y) {
        if (stein.containsPoint(x, y)) {
            return stein;
        }
        return null;
    }
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        //Typcasting von Graphics zu Graphics2D
        Graphics2D g2d =  (Graphics2D)g;
        g2d.setColor(color);
        g2d.fillOval(0, 0, stein.getRadius(), stein.getRadius());
    }
}
/*
 * Spielsteine
 */
class Spielsteine{
    private int x;
    private int y;
    private int r = 60;
    public Spielsteine(int x, int y){
        this.x = x;
        this.y = y;
    }
    void setX(int i) {x = i;}
    void setY(int i) {y = i;}
    boolean containsPoint(int xP, int yP) {
        return (xP >= x && xP <= x+r && yP >= y && yP <= y+r);
    }
    int getX() {return x;}
    int getY() {return y;}
    int getRadius() {
        return r;
    }
}
/*
 * SpielBrett
 */
class SpielBrett extends JPanel{
    private BufferedImage img;
    private Graphics2D g2d;
    int s;
    public SpielBrett(){
        s = (Toolkit.getDefaultToolkit().getScreenSize().height-50) / 8;
        setLayout(null);
        setBackground(Color.ORANGE);
    }
    protected void paintComponent(final Graphics g) {
        super.paintComponent(g);
        if (img == null) {
            img = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
            g2d = (Graphics2D)img.getGraphics();
            g2d.setColor(getBackground());
            g2d.fillRect(0, 0, getWidth(), getHeight());
            g2d.setColor(Color.black);
            drawMe();
        }
        g.drawImage(img, 0, 0, getWidth(), getHeight(), null);
    }
    private void drawMe(){
        g2d.setColor(Color.BLUE);
        g2d.setStroke(new BasicStroke(4f));
        g2d.drawRect(1*s, 1*s, 6*s, 6*s);
        g2d.drawRect(2*s, 2*s, 4*s, 4*s);
        g2d.drawRect(3*s, 3*s, 2*s, 2*s);
        g2d.drawLine(1*s, 4*s, 3*s, 4*s);
        g2d.drawLine(5*s, 4*s, 7*s, 4*s);
        g2d.drawLine(4*s, 1*s, 4*s, 3*s);
        g2d.drawLine(4*s, 5*s, 4*s, 7*s);
    }
}
```


----------



## Leroy42 (31. Mai 2007)

Ich wußte doch, das bei sowas, unser Opi, zur Höchstform
aufläuft. ==> Werd' mit das. bei Gelegenheit, rauskopieren 
und testen.

Weil wegen, unser André hat mich noch nie enttäuscht:

Bis denne mal


----------



## Mr.Bean (6. Jun 2007)

Danke erstmal für die Hilfe, da hatte ich wohl irgendwie den Konstruktor vergessen...

Leider besteht auch mit deiner Lösung immer noch das Problem, das ich die Komponente Stein nicht auf die Komponente Brett legen kann, sprich ich nur eines von beiden darstellen kann (immer das zuläßt aufgerufene). Hat da vielleicht jemand noch einen anderen Tip für mich?


----------



## merlin2 (6. Jun 2007)

(Eigentlich kein anderer Tipp Stein von Object erben lassen?


----------



## Mr.Bean (6. Jun 2007)

Ich lasse den Stein und das Brett von JPanel erben, füge dann das Objekt Stein dem Objekt Brett hinzu, und zuletzt das Brett auf getComponent...?


----------



## merlin2 (6. Jun 2007)

Leroy42 hat gesagt.:
			
		

> Ich würde den Steinen eine eigene paint-Methode verpassen,
> die ein Graphics und die Koordinaten, an denen sie sich ins
> Graphic malen sollen, übergeben bekommen und nicht
> von JPanel abeleitet sind.


Steine nicht von JPanel erben lassen.


----------



## Mr.Bean (6. Jun 2007)

Also mein Stein hat eine eigene paint Methode.

Und wovon sollte ich dann Stein erben lassen, damit ich ihn hinterher mit "add" hinzufügen kann?


----------



## merlin2 (6. Jun 2007)

Von Object erben lassen und nicht mit add() hinzufügen. In der paint-Methode von Brett die paint-Methode von Stein aufrufen.


----------



## Mr.Bean (6. Jun 2007)

Erbt der nicht automatisch von Object?

Dann müßte ich innerhalb von Brett sozusagen stein aufrufen?

Etwas weiter oben ist ein Lösung die so ähnlich ausschaut wie meine..., kannst ja mal schauen, warum der immer nur das Brett oder den Stein anzeigt, je nachdem was ich zuletzt hinzufüge?


----------



## merlin2 (6. Jun 2007)

```
public class Brett {
Stein[] steine = new Stein[5];
public Brett() {
  for(int i = 0; i < steine.length; i++) {
    steine[i] = new Stein();
    steine[i].setLocation(200, i*10);
  }
}
public void paint(Graphics g) {
  //Code für das Brett selbst:
  //...
  //Hier werden die Steine dargestellt:
  for(int i = 0; i < steine.length; i++) {
    steine[i].paint(g);
  }
}

public class Stein {
int x, y;
public void paint(Graphics g) {
  //Code
}
public void setLocation(int x, int y) {
   this.x = x;
   this.y = y;
}
}
```
so zumindest von der Struktur her.


----------



## André Uhres (6. Jun 2007)

Mr.Bean hat gesagt.:
			
		

> ..Leider besteht auch mit deiner Lösung immer noch das Problem, das ich die Komponente Stein nicht auf die Komponente Brett legen kann, sprich ich nur eines von beiden darstellen kann (immer das zuläßt aufgerufene)..


Mit *paintComponent *(statt paint) ist das kein Problem.
paintComponent zeichnet immer nur die eigene Komponente (das Brett).
Man kann dann dem Brett problemlos Kinder hinzufügen (Steine).
Die Steine können nicht vom Brett verdeckt werden
und das Brett bleibt zwischen den Steinen sichtbar :wink:


----------



## Mr.Bean (6. Jun 2007)

Also überall wo ich vorher paint hatte habe ich paintComponent draus gemacht, nur leider hats nicht geholfen... :?:  ???:L


----------



## André Uhres (6. Jun 2007)

Aber hier geht's doch: http://www.java-forum.org/de/viewtopic.php?p=299356#299356
Was ist denn bei dir anders?


----------



## Mr.Bean (6. Jun 2007)

Hier nochmal meinen Code, vielleicht ist es ja nur eine Kleinigkeit...

```
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Stroke;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;

import javax.swing.JComponent;
import javax.swing.JPanel;


public class SpielBrett extends JPanel {

	public SpielBrett(){  
        setLayout(null); 
        setBackground(Color.ORANGE); 
    } 

	
	public void paintComponent(Graphics g){
		super.paintComponent(g); 
		//Typcasting von Graphics zu Graphics2D
		Graphics2D g2d =  (Graphics2D)g;
		
		//Ermittelt die bestehende Auflösung des Betriebsystems
		Dimension windowScreensize = Toolkit.getDefaultToolkit().getScreenSize();
		
		int mitteX = windowScreensize.width / 2;
		int mitteY = windowScreensize.height / 2;
	
		
		//Farbe der Grafik
		g2d.setColor(Color.BLACK);
		//Dicke der Linien
		Stroke stroke = new BasicStroke( 8 ); 
		g2d.setStroke( stroke );
		
		//drei Rechecke werden gesetzt
		g2d.setPaint(Color.white);
		g2d.fillRect(mitteX - windowScreensize.width/3, mitteX - windowScreensize.width/3, windowScreensize.width / 2, windowScreensize.width/2);
		g2d.setPaint(Color.BLACK);
		g2d.drawRect(mitteX - windowScreensize.width/6, mitteX - windowScreensize.width/6, windowScreensize.width / 6, windowScreensize.width / 6);
		g2d.drawRect(mitteX - windowScreensize.width/4, mitteX - windowScreensize.width/4, windowScreensize.width / 3, windowScreensize.width / 3);
		g2d.drawRect(mitteX - windowScreensize.width/3, mitteX - windowScreensize.width/3, windowScreensize.width / 2, windowScreensize.width/2);
		
		
		//alle mögichen gekreutzten Setzpunkte
				//von Mitte links aussen nach Mitte links innen
		g2d.drawLine(mitteX - windowScreensize.width/3, (mitteX - windowScreensize.width/3)+((windowScreensize.width / 2)/2)-1, mitteX - windowScreensize.width/6, (mitteX - windowScreensize.width/6)+((windowScreensize.width / 6))/2);
		//von Mitte rechts aussen nach Mitte rechts innen
		g2d.drawLine((mitteX - windowScreensize.width/3)+ windowScreensize.width / 2, (mitteX - windowScreensize.width/3)+((windowScreensize.width / 2)/2)-1, (mitteX - windowScreensize.width/6)+windowScreensize.width / 6, (mitteX - windowScreensize.width/6)+((windowScreensize.width / 6))/2);
		//von Mitte oben aussen nach Mitte oben innen
		g2d.drawLine((mitteX - windowScreensize.width/3)+((windowScreensize.width / 2)/2)-1, (mitteX - windowScreensize.width/3), (mitteX - windowScreensize.width/6)+((windowScreensize.width / 6))/2, (mitteX - windowScreensize.width/6));
		//von Mitte unten aussen nach Mitte unten innen
		g2d.drawLine((mitteX - windowScreensize.width/3)+ (windowScreensize.width / 2)/2-1, (mitteX - windowScreensize.width/3)+windowScreensize.width / 2, (mitteX - windowScreensize.width/6)+(windowScreensize.width / 6)/2, (mitteX - windowScreensize.width/6)+windowScreensize.width / 6);		
	}
}
```


```
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.List;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseMotionListener;

import javax.swing.JComponent;
import javax.swing.JPanel;


class SteinZeichnen extends JPanel
{  	 
	//Ermittelt die bestehende Auflösung des Betriebsystems
	Dimension windowScreensize = Toolkit.getDefaultToolkit().getScreenSize();
	
	//der Mittelpunkt des Fensters
	int mitteX = windowScreensize.width / 2;
	int mitteY = windowScreensize.height / 2;
	
	//Anlegen eines neuen Steines
	//private Spielsteine stein = new Spielsteine(mitteX+windowScreensize.width / 3,mitteY);
	private Spielsteine stein = new Spielsteine();
	//Anlegen eines leeren Kreiselementes
	private Spielsteine selectedKreis = null;
	//Anlegen von Cursorobjekten
	private Cursor cursorHand = new Cursor(Cursor.HAND_CURSOR);
	private Cursor cursorDef = new Cursor(Cursor.DEFAULT_CURSOR);
	//Colorobjekt zur Unterscheidung der Spielsteine
	private Color color; 
	
	private MouseListener mouseListener = new MouseListener() 
	{ 
		public void mouseClicked(MouseEvent e) 
        { 

        } 

        public void mouseEntered(MouseEvent e) 
        { 

        } 

        public void mouseExited(MouseEvent e) 
        { 

        } 
        
    	public void mousePressed(MouseEvent e)
    	{ 
    		//wenn die Maus gedrueckt wird und ein Kreis sich innerhalb der Koordinaten befindet,
    		//dann setze diesen Stein auf stein
    		stein = findKreis(e.getX(), e.getY());
    		//wenn stein nicht leer, dann Zeichne bei gedrückte Maus den Stein neu
            if (stein != null) 
            { 
                selectedKreis = stein;
                //neuzeichnen des Kreises
                repaint(); 
                getRootPane().setCursor(cursorHand); 
            } 
           
    	}
    	//wenn die Maus losgelassen wird soll der markierte Kreis wieder auf Null gesetzt werden und 
    	public void mouseReleased(MouseEvent e)
    	{ 
    		selectedKreis = null; 
            getRootPane().setCursor(cursorDef);
            //neuzeichnen des Kreises
            repaint(); 
    	} 
    };
    
	private MouseMotionListener motionListener = new MouseMotionListener() 
    { 
        public void mouseMoved(MouseEvent e)
        { 
        }
        //wenn Maus in Bewegung, dann zeichne den Kreis für die aktuellen Koordinaten neu
		public void mouseDragged(MouseEvent e) {
			  if (selectedKreis != null) 
              {        
                  // Koordinaten des kreis ändern 
                  selectedKreis.setX(e.getX()); 
                  selectedKreis.setY(e.getY()); 
                   
                  repaint(); 
              } 	
		} 
    }; 
    //Konstruktor für das Stein zeichnen
    public SteinZeichnen(int x, int y,Color color){ 
        this.color = color; 
        stein.setX(x);
        stein.setY(y);
        setOpaque(false); 
        setBounds(stein.getX(), stein.getY(), stein.getRadius(), stein.getRadius()); 
        addMouseListener(mouseListener); 
        addMouseMotionListener(motionListener); 
    } 
    
	public Spielsteine findKreis(int x, int y) 
	{ 
		//überprüft, ob der Mauszeiger innerhalb des Steines ist
        if (stein.containsPoint(x, y)) 
        { 
            return stein; 
        }  
	    return null; 
	} 

	public void paintComponent(Graphics g)
	{ 
		super.paintComponent(g); 
		//Typcasting von Graphics zu Graphics2D
		Graphics2D g2d =  (Graphics2D)g;
		
		g2d.setColor(color);
		g2d.fillOval(stein.getX(), stein.getY(), stein.getRadius(), stein.getRadius());
		g2d.setColor(Color.BLACK);
		g2d.drawOval(stein.getX(), stein.getY(), stein.getRadius(), stein.getRadius());
		g2d.setColor(Color.BLACK);
		g2d.drawOval(stein.getX()+6, stein.getY()+6, stein.getInnenRadius(), stein.getInnenRadius());
		
		
    
	} 
}
```


```
import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.List;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.Toolkit;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Point2D;
import java.util.ArrayList;

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


public class MainWindow extends JFrame{
	public MainWindow(){
		//erstellt ein Frame
		super("Muehle");
		//Ermittelt die bestehende Auflösung des Betriebsystems
		Dimension windowScreensize = Toolkit.getDefaultToolkit().getScreenSize();
		
		//der Mittelpunkt des Fensters
		int mitteX = windowScreensize.width / 2;
		int mitteY = windowScreensize.height / 2;
		
		//ob das Aussehen des Fensters verändert werden soll
		JFrame.setDefaultLookAndFeelDecorated(false);
	
		this.getContentPane().setBackground(Color.LIGHT_GRAY);
		this.getContentPane().setMaximumSize(windowScreensize);
		//gibt die Größe des Frames an und macht es sichtbar
		this.setBounds(0, 0, windowScreensize.width, windowScreensize.height);
		
        SpielBrett brett = new SpielBrett(); 
        brett.add(new SteinZeichnen((mitteX+windowScreensize.width / 3)+windowScreensize.width / 17,mitteY,Color.ORANGE)); 
        this.getContentPane().add(brett); 
        this.setVisible(true); 

		
		//SteinZeichnen stein = new SteinZeichnen(Color.WHITE);
		//SpielBrett brett = new SpielBrett();
		
		//for (int i = 0; i < 9; i++) { 
			//this.getContentPane().add(new SteinZeichnen(mitteX+windowScreensize.width / 3,mitteY,Color.WHITE)); 
			//brett.add(new SteinZeichnen((mitteX+windowScreensize.width / 3)+windowScreensize.width / 17,mitteY,Color.ORANGE)); 
	    //} 	
		//brett.add(stein);
		//this.getContentPane().add(brett);
	
		//this.setVisible(true);
		//Aufruf der Klasse CloseWindow zum Schließen des Fensters und des Prozesses
		this.addWindowListener(new CloseWindow());
		
	}
```


----------



## André Uhres (6. Jun 2007)

Mr.Bean hat gesagt.:
			
		

> ..vielleicht ist es ja nur eine Kleinigkeit..


So ist es.
SteinZeichnen bekommt seine Position schon durch "setBounds".
In paintComponent darfst du demnach nicht nochmal die gleichen Koordinaten angeben,
sondern da fängst du wieder bei 0 an, also x = 0 und y = 0.
Dort gelten nämlich nicht mehr die Koordinaten innerhalb des Bretts,
sondern die Koordinaten innerhalb des Steins, denn die "paintComponent" vom Stein 
zeichnet ja nicht das Brett sondern nur den einzelnen Stein.


----------



## Mr.Bean (7. Jun 2007)

Ok, jetzt zeigt er mir den Kreis schon mal an, wenn auch nicht schön, da ich ja noch einen schwarzen Rand herum gezeichnet habe, und den verschiebt er jetzt so ein wenig..., nur reagiert dieser Kreis jetzt nicht mehr auf meine Mouseaktionen...  :?:


----------



## André Uhres (8. Jun 2007)

Mr.Bean hat gesagt.:
			
		

> ..nur reagiert dieser Kreis jetzt nicht mehr auf meine Mouseaktionen...  :?:


Du hast ein funktionierendes Beispiel bekommen!
Schau dir doch die Methoden in dem Beispiel mal etwas *genauer *an!
Was hält dich davon ab, *deine Methoden entsprechend anzupassen*?
Zum Positionieren musst du setLocation aufrufen.


----------



## Mr.Bean (8. Jun 2007)

Da hast du natürlich recht, und das hatte ich auch schon getan, nur mag ich es nicht wenn ich Dinge 1 zu 1 übernehme, ich muss ja auch verstahen was dahinter steckt. Bin jetzt soweit das eigentlich alles soweit funktioniert, es liegt wohl an meinen Listener, die noch auf dem Contentpane gut funktioniert hatten nur leider nicht mehr auf dem Spielbrett, woran es aber genau liegt, weis ich leider nicht, irgendwas passt innerhalb des Listeners nicht, ich denke mal es liegt an den Koordianten, die dann so wohl auch nicht mehr funktionieren, iwe du vorher das schon bei meiner paint Methde richtig erkannt hattest....


----------

