Coordonnées dans la peinture

Question

Lorsque vous cliquez dans une zone, elle doit créer un cercle dans cette zone à partir de la coordonnée désignée. Sauf si c'est déjà là alors c'est supprimé. Comment puis-je obtenir des coordonnées currentx et currenty dans l'ovale de remplissage?

public class Grid extends Applet{ 

boolean click; 

public void init() 
{ 
    click = false; 
    addMouseListener(new MyMouseListener()); 
} 

public void paint(Graphics g) 
{ 
    super.paint(g); 

    g.drawRect(100, 100, 400, 400); 
    //each box 
    g.drawRect(100, 100, 100, 100); 
    g.drawRect(200, 100, 100, 100); 
    g.drawRect(300, 100, 100, 100); 
    g.drawRect(400, 100, 100, 100); 
    //2y 
    g.drawRect(100, 200, 100, 100); 
    g.drawRect(200, 200, 100, 100); 
    g.drawRect(300, 200, 100, 100); 
    g.drawRect(400, 200, 100, 100); 
    //3y1x 
    g.drawRect(100, 300, 100, 100); 
    g.drawRect(200, 300, 100, 100); 
    g.drawRect(300, 300, 100, 100); 
    g.drawRect(400, 300, 100, 100); 
    //4y1x 
    g.drawRect(100, 400, 100, 100); 
    g.drawRect(200, 400, 100, 100); 
    g.drawRect(300, 400, 100, 100); 
    g.drawRect(400, 400, 100, 100); 


    if (click) 
    { 
     g.fillOval(currentx, currenty, 100, 100); // problem HERE 
    } 

} 
private class MyMouseListener implements MouseListener 
{  
     public void mouseClicked(MouseEvent e) 
     { 
      int nowx = e.getX(); 
      int nowy = e.getY(); 

      nowx = nowx/100; 
      String stringx = Integer.toString(nowx); 
      stringx = stringx+"00"; 
      int currentx = Integer.parseInt(stringx); 

      nowy = nowy /100; 
      String stringy = Integer.toString(nowy); 
      stringy = stringy+"00"; 
      int currenty = Integer.parseInt(stringy); 

      click = true; 
      repaint(); 
     } 

    @Override 
    public void mousePressed(MouseEvent e) { 
     // TODO Auto-generated method stub 

    } 

    @Override 
    public void mouseReleased(MouseEvent e) { 
     // TODO Auto-generated method stub 

    } 

    @Override 
    public void mouseEntered(MouseEvent e) { 
     // TODO Auto-generated method stub 

    } 

    @Override 
    public void mouseExited(MouseEvent e) { 
     // TODO Auto-generated method stub 

    } 
} 
} 

Answer 1

Votre principal problème est, la peinture dans Swing/AWT est destructeur, qui est, chaque fois que votre méthode paint est appelée, vous attend à repeindre l'état actuel du composant.

Dans ce cas, ce dont vous avez réellement besoin est de modéliser l'état du jeu. Lorsque vous appelez paint, vous pouvez le repeindre de manière significative. Ceci est un concept de base d'un paradigme Model-View-Controller, où vous séparez la responsabilité du programme en couches distinctes.

Le problème devient alors, comment traduisez-vous de la vue à modéliser?

L'idée de base est de prendre les coordonnées x/y actuelles de la souris et de la diviser par la taille de la cellule. Vous devez également vous assurer que les résultats sont dans les limites prévues, que vous pourriez obtenir un résultat qui est au-delà des colonnes/lignes de grilles

import java.awt.Color; 
import java.awt.Dimension; 
import java.awt.EventQueue; 
import java.awt.FontMetrics; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.Point; 
import java.awt.event.MouseAdapter; 
import java.awt.event.MouseEvent; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.UIManager; 
import javax.swing.UnsupportedLookAndFeelException; 

public class Test { 

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

    public Test() { 
     EventQueue.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       try { 
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
       } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) { 
        ex.printStackTrace(); 
       } 

       JFrame frame = new JFrame("Testing"); 
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
       frame.add(new TestPane()); 
       frame.pack(); 
       frame.setLocationRelativeTo(null); 
       frame.setVisible(true); 
      } 
     }); 
    } 

    public static class TestPane extends JPanel { 

     protected static final int CELL_COUNT = 3; 

     private int[][] board; 
     private int[] cell; 

     private boolean isX = true; 

     public TestPane() { 
      board = new int[CELL_COUNT][CELL_COUNT]; 

      addMouseListener(new MouseAdapter() { 
       @Override 
       public void mouseClicked(MouseEvent e) { 
        int[] cell = getCellAt(e.getPoint()); 
        if (board[cell[0]][cell[1]] == 0) { 
         board[cell[0]][cell[1]] = isX ? 1 : 2; 
         isX = !isX; 
         repaint(); 
        } 
       } 
      }); 

      addMouseMotionListener(new MouseAdapter() { 
       @Override 
       public void mouseMoved(MouseEvent e) { 
        cell = getCellAt(e.getPoint()); 
        repaint(); 
       } 
      }); 
     } 

     protected int[] getCellAt(Point p) { 
      Point offset = getOffset(); 
      int cellSize = getCellSize(); 

      int x = p.x - offset.x; 
      int y = p.y - offset.y; 

      int gridx = Math.min(Math.max(0, x/cellSize), CELL_COUNT - 1); 
      int gridy = Math.min(Math.max(0, y/cellSize), CELL_COUNT - 1); 

      return new int[]{gridx, gridy}; 
     } 

     protected Point getOffset() { 
      int cellSize = getCellSize(); 
      int x = (getWidth() - (cellSize * CELL_COUNT))/2; 
      int y = (getHeight() - (cellSize * CELL_COUNT))/2; 
      return new Point(x, y); 
     } 

     protected int getCellSize() { 
      return Math.min(getWidth()/CELL_COUNT, getHeight()/CELL_COUNT) - 10; 
     } 

     @Override 
     public Dimension getPreferredSize() { 
      return new Dimension(200, 200); 
     } 

     @Override 
     protected void paintComponent(Graphics g) { 
      super.paintComponent(g); 
      Graphics2D g2d = (Graphics2D) g.create(); 

      Point offset = getOffset(); 
      int cellSize = getCellSize(); 
      if (cell != null) { 
       g2d.setColor(new Color(0, 0, 255, 128)); 
       g2d.fillRect(
         offset.x + (cellSize * cell[0]), 
         offset.y + (cellSize * cell[1]), 
         cellSize, 
         cellSize); 
      } 

      g2d.setColor(Color.BLACK); 

      FontMetrics fm = g2d.getFontMetrics(); 
      for (int col = 0; col < CELL_COUNT; col++) { 
       for (int row = 0; row < CELL_COUNT; row++) { 
        int value = board[col][row]; 
        int x = offset.x + (cellSize * col); 
        int y = offset.y + (cellSize * row); 
        String text = ""; 
        switch (value) { 
         case 1: 
          text = "X"; 
          break; 
         case 2: 
          text = "O"; 
          break; 
        } 
        x = x + ((cellSize - fm.stringWidth(text))/2); 
        y = y + ((cellSize - fm.getHeight())/2) + fm.getAscent(); 
        g2d.drawString(text, x, y); 
       } 
      } 

      int x = offset.x; 
      int y = offset.y; 
      for (int col = 1; col < CELL_COUNT; col++) { 
       x = offset.x + (col * cellSize); 
       g2d.drawLine(x, y, x, y + (cellSize * CELL_COUNT)); 
      } 
      x = offset.x; 
      for (int row = 1; row < CELL_COUNT; row++) { 
       y = offset.x + (row * cellSize); 
       g2d.drawLine(x, y, x + (cellSize * CELL_COUNT), y); 
      } 
      g2d.dispose(); 
     } 

    } 

} 

Answer 2

Tout d'abord, si vous voulez tronquer une nombre à 100 près, par exemple 142 devient 100, tout ce que vous avez à faire est:

num = (num/100)*100; 

c'est parce que quand on divise 2 entiers tronque automatiquement, et vous pouvez simplement multiplier en arrière pour obtenir le numéro. Et ce que je pense que vous voulez dans ce cas est de créer des variables de champs et des méthodes d'accesseurs. Au sommet de votre classe MouseListener, vous devez ajouter:

private int mouseX=0; 
private int mouseY=0; 

alors pour pouvoir accéder à ces variables à l'extérieur de la classe MouseListener vous devez ajouter des méthodes accesseurs:

public int getMouseX(){ 
    return mouseX; 
} 

dans votre classe Grille, vous pouvez ajouter le champ:

private MyMouseListener listener; 

puis l'initialiser dans init en faisant:

listener = new MyMouseListener(); 
addMouseListener(listener); 

alors vous pouvez faire la même chose pour mouseY, et enfin de votre méthode de peinture que vous pouvez ensuite appeler:

int mouseX = listener.getMouseX(); 
int mouseY = listener.getMouseY(); 

et de là il est aussi simple que de faire if statements ou switch statements pour trouver quelle boîte vous avez cliqué dans!