Kreis mit gedrückter Maus bewegen

[Mr.Bean]

Hi,
ich würde ganz gerne einen gezeichneten Kreis innerhalb meines Frames bewegen (bei gedrückter Maustaste) und ihn dann irgendwo ablegen, kann mir da jemand weiter helfen?
Danke

 

[Wildcard]

Ist dein Kreis eine JComponent oder wird er nur auf eine JComponent gezeichnet?

 

[Mr.Bean]

	public void paint(Graphics 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;
	
		
		//Zeichnen der Spielsteine
		g2d.setColor(Color.WHITE);
		g2d.fillOval(mitteX+windowScreensize.width / 3, mitteY, windowScreensize.width / 17, windowScreensize.width / 17);

		g2d.setColor(Color.BLACK);
		g2d.fillOval(mitteX+windowScreensize.width / 3, mitteY+windowScreensize.width / 17, windowScreensize.width / 17, windowScreensize.width / 17);

		
	}

Hier mal der Quellcode...

 

[Wildcard]

So wird's nicht funktionieren.
Du brauchst ein Datenmodell das deine Kreise repräsentiert.
Jeder Kreis muss ein Objekt sein.
Mit einem MouseMotionListener kannst du dann die Objekte verschieben.
Vorher musst du die Entscheidung treffen ob du 'Kreis' von JComponent erben lassen willst, oder du eine einzige JComponent hast die eine Collection von Kreisen besitzt.

 

[Mr.Bean]

Ich brauch ja zweimal 9 Kreise, dann wäre doch die zweite Variante sinvoller, oder geht auch die erstere?

 

[Wildcard]

Ich brauch ja zweimal 9 Kreise, dann wäre doch die zweite Variante sinvoller, oder geht auch die erstere?

Warum sinnvoller?

 

[Mr.Bean]

Das ist ja meine Frage...

Müßte ich nicht dann jedes Mal ein neues objekt anlegen?

 

[Marco13]

Du solltest die Klasse "Kreis" NICHT von JComponent erben lassen. Ein Kreis hat erstmal genu ZWEI Eigenschaften: Einen Mittelpunkt und einen Radius. Eine JComponent hat erstmal ein paar Eigenschaften mehr...

    private boolean isAlignmentXSet;
    private float alignmentX;
    private boolean isAlignmentYSet;
    private float alignmentY;
    protected transient ComponentUI ui;
    protected EventListenerList listenerList = new EventListenerList();
    private transient ArrayTable clientProperties;
    private VetoableChangeSupport vetoableChangeSupport;
    private boolean autoscrolls;
    private Border border;
    private int flags;
    private InputVerifier inputVerifier = null;
    private boolean verifyInputWhenFocusTarget = true;
    transient Component         paintingChild;
    private JPopupMenu popupMenu;
    private InputMap focusInputMap;
    private InputMap ancestorInputMap;
    private ComponentInputMap windowInputMap;
    private ActionMap actionMap;
    private boolean aaText;
    int ncomponents;
    Component component[] = new Component[0];
    LayoutManager layoutMgr;
    private LightweightDispatcher dispatcher;
    private transient FocusTraversalPolicy focusTraversalPolicy;
    private boolean focusCycleRoot = false;
    private boolean focusTraversalPolicyProvider;
    private transient Set printingThreads;
    private transient boolean printing = false;
    transient ContainerListener containerListener;
    transient int listeningChildren;
    transient int listeningBoundsChildren;
    transient int descendantsCount;
    transient ComponentPeer peer;
    transient Container parent;
    transient AppContext appContext;
    int x;
    int y;
    int width;
    int height;
    Color       foreground;
    Color       background;
    Font        font;
    Font        peerFont;
    Cursor      cursor;
    Locale      locale;
    transient GraphicsConfiguration graphicsConfig = null;
    transient BufferStrategy bufferStrategy = null;
    boolean ignoreRepaint = false;
    boolean visible = true;
    boolean enabled = true;
    boolean valid = false;
    DropTarget dropTarget;
    Vector popups;
    private String name;
    private boolean nameExplicitlySet = false;
    private boolean focusable = true;
    private int isFocusTraversableOverridden = FOCUS_TRAVERSABLE_UNKNOWN;
    Set[] focusTraversalKeys;
    private boolean focusTraversalKeysEnabled = true;
    Dimension minSize;
    boolean minSizeSet;
    Dimension prefSize;
    boolean prefSizeSet;
    Dimension maxSize;
    boolean maxSizeSet;
    transient ComponentOrientation componentOrientation= ComponentOrientation.UNKNOWN;
    boolean newEventsOnly = false;
    transient ComponentListener componentListener;
    transient FocusListener focusListener;
    transient HierarchyListener hierarchyListener;
    transient HierarchyBoundsListener hierarchyBoundsListener;
    transient KeyListener keyListener;
    transient MouseListener mouseListener;
    transient MouseMotionListener mouseMotionListener;
    transient MouseWheelListener mouseWheelListener;
    transient InputMethodListener inputMethodListener;
    transient RuntimeException windowClosingException = null;
    long eventMask = AWTEvent.INPUT_METHODS_ENABLED_MASK;
    private static final DebugHelper dbg = DebugHelper.create(Component.class);
    private PropertyChangeSupport changeSupport;
    boolean isPacked = false;

... die man man alle nicht braucht - ebensowenig wie die etlichen hundert Methoden.

Von deiner Klasse "Kreis" könntes du dann zwei mal 9 Objekte anlegen, und die nacheinander auf EIN JPanel zeichnen.

 

[Wildcard]

2*9 = 18 Kreis Objekte. Die brauchst du bei beiden Alternativen.

 

[Mr.Bean]

Wie fange ich denn da am Besten an?

 

[KSG9|sebastian]

An deiner Zeichenfläche registrierst du nen MouseListener/MouseMotionListener. Dadrin fängst du ab

1. ob auf einen Kreis geklickt wurde
2. auf welchen Kreis geklickt wurde
3. wie die Maus bewegt wird

Wenn auf ein Kreis geklickt wurde musst du dir den merken, z.B. in einer Instanzvariable. Bei loslassen der Maus wird die Instanzvariable wieder auf null gesetzt.
Bei einer Mausbewegung musst du abfragen ob ein Kreis noch angeklickt ist. Falls ja musst du den Mittelpunkt und/oder den Radius deines Kreises ändern und repaint() aufrufen.
Repaint zeichnet nur deine Kreise anhand von Mittelpunkt und Radius.
Die Logik sollte in den Listenern sein bzw. von den Listenern aus angesteuert werden, NICHT im paint.

Edit:

class Kreis{
  private int x;
  private int y;
  private int radius;

  public Kreis(int x, int y, int radius){
    this.x = x;
    this.y = y;
    this.radius = radius;
  }
  public void getX(){
     return x;
  }
  public void setX(int x){
    this.x = x;
  }
  public void getY(){
     return y;
  }
  public void setY(int y){
    this.y = y;
  }
  public void getRadius(){
     return radius;
  }
  public void setRadius(int radius){
    this.radius = radius;
  }
  public void containsPoint(int x, int y){
     if(Math.abs(this.x - x) <= radius && Math.abs(this.y - y) <=radius)
        return true;
     return false;
  }
}
class Zeichnen extends JPanel{
  private List<Kreis> kreise = new ArrayList<Kreis>();
  private Kreis selectedKreis = null;
  private int oldX = 0;
  private int oldY = 0;
  public Zeichnen(){
     kreise.add(new Kreis(4, 4, 5));    
     kreise.add(new Kreis(5, 5, 4));
     kreise.add(new Kreis(6, 6, 3));
     kreise.add(new Kreis(7, 7, 2));

     addMouseListener(new MouseAdapter(){
         public void mousePressed(MouseEvent e){
            Kreis sel = getKreis(e.getX(), e.getY());
            if(sel != null){
               selectedKreis = sel;
               oldX = sel.getX();
               oldY = sel.getY();
               setCursor(Cursor.Hand);
            }
         }
         public void mouseReleased(MouseEvent e){
            selectedKreis = null;
            setCursor(Cursor....);
         }
     });
    addMouseMotionListener(new MouseMotionListener(){
        public void mouseMoved(MouseEvent e){
           if(selectedKreis != null){
              selectedKreis.setX(Math.abs(selectedKreis.getX() - e.getX()));
              selectedKreis.setY(Math.abs(selectedKreis.getY() - e.getY()));
              repaint();
           }
        }
    });
  }
  public Kreis getKreis(int x, int y){
     for(Kreis k : kreise){
        if(k.containsPoint(x, y))
           return k;
     }
     return null;
  }
  public void paint(Graphics g){
     for(Kreis k : kreise){
        g.fillOval(k.getX(), k.getY(), k.getRadius(), k.getRadius());
     }
  }
}

Ist nur blind runtergetippt, diverse Listener müssen vervollständigt werden, logik überprüft u.s.w....

EDIT2: Kreis eingefügt, Methode containsPoint muss noch sauber implementiert werden

 

[Mr.Bean]

Aber wie mache ich eine eigene Klasse Kreis wenn ich sie nicht erben lasse, und wie kann ich sie dann in meinem Frame hinzufügen?

 

[Wildcard]

Du solltest die Klasse "Kreis" NICHT von JComponent erben lassen. Ein Kreis hat erstmal genu ZWEI Eigenschaften: Einen Mittelpunkt und einen Radius. Eine JComponent hat erstmal ein paar Eigenschaften mehr...

Ich würde es auch nicht machen.
Mr.Bean hat aber vermutlich in diesem Umfeld weniger Erfahrung aufzuweisen.
JComponents zu verwenden würde also dahingehend den großen Vorteil bieten, das einem sehr viel Arbeit abgenommen wird und es daher erstmal leichter zu implementieren ist.

 

[KSG9|sebastian]

Schau mal meinen Post von oben an, hab n kleines Codesnippet angehängt..ist aber blind runtergetippt mit n paar Fehlern

 

[KSG9|sebastian]

nochmal editiert

 

[Mr.Bean]

Jetzt habe ich den Kreis eingefügt bekommen, nur leider kann ich auf dem "ContentPane" nur ein gezwichnetes Objekt einfügen, entweder das Spielbrett oder den Spielstein. Habs mal mit dem Glasspane probiert hat aber so nicht funktioniert, könnt ihr mir da weiter helfen?

Und mein zweites Problem ist, das der Kreis(Spielstein) leider nicht auf dem Tastendruck reagiert, vielleicht hat ja auch da jemand eine Lösung für mich?

 

[KSG9|sebastian]

Kannst mal deinen Code zeigen? Und was heißt "entweder Spielbrett oder Spielstein"? Du kannst soviel auf dem Contentpane zeichnen wie du willst...

Zeig mal die Listener und die paint-Methode. Ebenso die Methode welche den angeklickten Kreis rausfinden soll

 

[Mr.Bean]

class SteinZeichnen extends JComponent
{  
	  
	 
	//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 int oldX = 0; 
	private int oldY = 0; 
	
	public SteinZeichnen()
	{ 
	   
    addMouseListener(new MouseAdapter()
    { 
    	public void mousePressed(MouseEvent e)
    	{ 
    		Spielsteine sel = new Spielsteine(e.getX(), e.getY()); 
            if(sel != null){ 
               selectedKreis = sel; 
               oldX = sel.getX(); 
               oldY = sel.getY(); 
               //setCursor(Cursor.HAND_CURSOR); 
            } 
    	} 
    	public void mouseReleased(MouseEvent e)
    	{ 
    		selectedKreis = null; 
    		//setCursor(Cursor....); 
    	} 
    }); 
    
    addMouseMotionListener(new MouseMotionAdapter()
    { 
        public void mouseMoved(MouseEvent e)
        { 
           if(selectedKreis != null)
           { 
              selectedKreis.setX(Math.abs(selectedKreis.getX() - e.getX())); 
              selectedKreis.setY(Math.abs(selectedKreis.getY() - e.getY())); 
              repaint(); 
           } 
        } 
    }); 
	} 
	  /*public Spielsteine getKreis(int x, int y){ 
	     for(Kreis k : kreise){ 
	        if(k.containsPoint(x, y)) 
	           return k; 
	     } 
	     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()); 
    
	} 
}

public class SpielBrett extends JComponent {

	public SpielBrett(){}
	
	public void paint(Graphics 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 oben links aussen nach oben links innen
		g2d.drawLine(mitteX - windowScreensize.width/3+1, mitteX - windowScreensize.width/3+1, mitteX - windowScreensize.width/6, mitteX - windowScreensize.width/6);
		//von unten links aussen nach unten links innen
		g2d.drawLine(mitteX - windowScreensize.width/3+1, (mitteX - windowScreensize.width/3)+ windowScreensize.width / 2-2, mitteX - windowScreensize.width/6, (mitteX - windowScreensize.width/6) + windowScreensize.width/6);
		//von oben rechts aussen nach oben rechts innen
		g2d.drawLine((mitteX - windowScreensize.width/3)+ windowScreensize.width / 2-2, mitteX - windowScreensize.width/3+1, (mitteX - windowScreensize.width/6)+windowScreensize.width / 6, mitteX - windowScreensize.width/6);
		//von unten rechts aussen nach unten rechts innen
		g2d.drawLine((mitteX - windowScreensize.width/3)+ windowScreensize.width / 2-2, (mitteX - windowScreensize.width/3)+windowScreensize.width / 2-2, (mitteX - windowScreensize.width/6)+windowScreensize.width / 6, (mitteX - windowScreensize.width/6)+windowScreensize.width / 6);
		//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);
	
		
	}
}

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);
	
		//JPanel right = new JPanel(new GridLayout(1,3,0,0));
		//this.getContentPane().add(left);
		//this.getContentPane().add(right);
		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();
		stein.setBounds(10,10,400,400); 
		//brett.setBounds(410,410,40,40); 

		
		
		Container pane = getContentPane(); 
		
		pane.setLayout(null); 

		
		pane.add(stein); 
		//pane.add(brett); 

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

So sieht das dann in etwa aus, die ausgabe auf dem Contentpane ist jetzt etwas durcheinander, da ich dort mehrere Tips ausprobiert hatte...

 

[KSG9|sebastian]

Ich seh nirgends Code mit dem deine Spielsteine gezeichnet werden.
Ist es absicht dass du in der mousePressed-Methode einen neuen Spielstein erstellst?

Beschreib bitte nochmal genau dein Ziel und gib kurz den Code für Spielstein.

 

[KSG9|sebastian]

Nimm mal folgenden Code, ist lauffähig. Benötigt natürlich ein paar verfeinerungen, aber ein paar Kreise mahlen, einen auswählen und den bewegen funktioniert.
Die bewegung ist nicht sonderlich toll gelöst (der Kreis erhält die Koordinaten der aktuellen Mausposition). Aber zum anschauen und Testen reicht es.

Main.java

package de.steine;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;

public class Main extends JFrame
{
    // standartcursor für bewegungen
    private Cursor              CURSOR_MOVE    = new Cursor(Cursor.MOVE_CURSOR);
    // defaultcursor
    private Cursor              CURSOR_DEF     = new Cursor(Cursor.DEFAULT_CURSOR);

    // liste mit kreisen
    private List<Kreis>         kreise         = new ArrayList<Kreis>();
    // aktuell ausgewählter kreis
    private Kreis               selectedKreis  = null;

    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)
                                                   {

                                                       // kreis finden auf den geklickt wurde
                                                       
                                                       Kreis k = findKreis(e.getX(), e.getY());
                                                       if (k != null)
                                                       {
                                                           selectedKreis = k;
                                                           repaint();
                                                           getContentPane().setCursor(CURSOR_MOVE);
                                                       }

                                                   }

                                                   public void mouseReleased(MouseEvent e)
                                                   {
                                                       // kein kreis mehr ausgewählt!
                                                       selectedKreis = null;
                                                       getContentPane().setCursor(CURSOR_DEF);
                                                       repaint();

                                                   }

                                               };

    private MouseMotionListener motionListener = new MouseMotionListener()
                                               {

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

                                                   }

                                                   public void mouseMoved(MouseEvent e)
                                                   {

                                                   }

                                               };

    public Main()
    {
        super("Spielsteine");

        super.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        super.setBounds(20, 20, 400, 400);

        // ein paar kreise erzeugen
        kreise.add(new Kreis(70, 130, 50));
        kreise.add(new Kreis(90, 110, 50));
        kreise.add(new Kreis(110, 90, 50));
        kreise.add(new Kreis(130, 70, 50));

        addMouseListener(mouseListener);
        addMouseMotionListener(motionListener);
        setVisible(true);
    }

    public void paint(Graphics g)
    {
        // weißes quadrat mahlen
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, 400, 400);

        // sämtliche kreise zeichnen
        for (Kreis k : kreise)
        {
            // der momentan ausgewählte kreis erhält zur besseren übersicht einen roten rand
            // die anderen kreise bekommen einen schwarzen rahmen
            if(k.equals(selectedKreis)){
                g.setColor(Color.RED);
            } else{
                g.setColor(Color.BLACK);
            }
            g.drawOval(k.getX(), k.getY(), k.getRadius(), k.getRadius());

        }

    }

    /**
     * Sucht einen Kreis mit den übergebenen Koordinaten
     * 
     * @param x der x-Wert
     * @param y der y-Wert
     * @return Kreis welcher den Punkt x/y enthält, sonst null
     */
    public Kreis findKreis(int x, int y)
    {
        for (Kreis k : kreise)
        {
            if (k.containsPoint(x, y))
            {
                return k;
            }
        }
        return null;
    }

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        new Main();

    }

}

Kreis.java

package de.steine;

public class Kreis
{
    private int x;
    private int y;
    private int radius;
    
    public Kreis(int x, int y, int radius){
        this.x = x;
        this.y = y;
        this.radius = radius;
    }
    
    public int getRadius()
    {
        return radius;
    }
    public void setRadius(int radius)
    {
        this.radius = radius;
    }
    public int getX()
    {
        return x;
    }
    public void setX(int x)
    {
        this.x = x;
    }
    public int getY()
    {
        return y;
    }
    public void setY(int y)
    {
        this.y = y;
    }
    public boolean containsPoint(int pX, int pY){
        return Math.abs(this.x - pX) <= radius && Math.abs(this.y - pY) <= radius;
    }
    
}

Die Klassen müssen beide im package "de.steine" liegen.

viel Spaß

Gruß Sebastian

 

[Mr.Bean]

Da bei mir eine eigene Klasse für das Zeichnen des Steines exestiert, und ich das Objekt in einer anderen Klasse dem Fenster (Contentpane) hinzufüge...., wie kann ich dann die Listener noch hinzufügen?