Estoy tratando de dibujar un rectángulo. Pero no estoy seguro de cómo, pinta en cierto panel. Me gustaría ver un ejemplo de cómo puedo suministrar el panel y la posición para dibujar el rectángulo. Tengo la siguiente plantilla, me gustaría ver qué modificaciones necesito hacer para usar esta clase para dibujar rectángulos en cualquier Panel. Mi intención es usar paneles de ancho y alto y agregar un rectángulo a esa posición. El objetivo es poder usar esta clase en cualquier lugar con cualquier JPanels.

import java.awt.Color;
import java.awt.Graphics;    
import javax.swing.JPanel;    

public class DrawRectangle{

    private int startX;
    private int startY;
    private int width;
    private int height;
    private Color color;
    private JPanel panel;

    public DrawRectangle(JPanel panel, int startX, int startY, int width, int height, Color color) {
        this.startX = startX;
        this.startY = startY;
        this.width = width;
        this.height = height;
        this.color = color;
            this.panel = panel; 
    }

    public void paint(Graphics g) {
        g.setColor(this.color);
        g.fillRect(this.startX, this.startY, this.width, this.height);
        g.drawRect(this.startX, this.startY, this.width, this.height);
    }
}
0
suste88 10 feb. 2020 a las 17:20

2 respuestas

La mejor respuesta

Echa un vistazo a la clase Graphics2D, está diseñada exactamente para lo que estás tratando de hacer y es más adecuada para dibujar que el método normal paintComponent. Puede leer acerca de cómo usar Graphics2D aquí.

En primer lugar, tenga en cuenta que no puede tener un objeto Graphics2D sin lanzarlo desde un objeto Graphics como lo hice aquí Graphics2D g2 = (Graphics2D) g;.

Este es un ejemplo que debería ayudarlo a comenzar, tenga en cuenta que estoy usando un diseño absoluto, por lo que no hay un administrador de diseño. Este es el código que estaba usando para crear un juego de blackjack, por eso las cosas son nombres que no son genéricos.

También agregué suavizado para que sus formas con Graphics2D se vean realmente bien y los métodos centren las formas en la pantalla, lo que probablemente funcionará bien con sus JPanels.

Observe cómo creé métodos específicos para los objetos Graphics2D que quería dibujar y luego los dibujé usando la clase Graphics. Eso pareció funcionar mejor para mí, de modo que mi paintComponent no estaba lleno de código repetido sin fin. frame en mi código estaba obteniendo el ancho y la altura del JFrame Tenía el JPanel, así que simplemente refiérase al JPanel en el que lo tendría.

class DrawTable extends JPanel
{

    DrawTable()
    {
        super();
        System.out.println("Looks good to me pal!");
    }

    @Override
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);

        //Setup background
        drawRectangle(g, Color.BLACK,
                frame.getWidth() / 2, frame.getHeight() / 2,
                frame.getWidth(), frame.getHeight());

        // Create table at center
        drawRectangle(g, new Color(206, 187, 158),
                frame.getWidth() / 4, frame.getHeight(), //left table leg
                50, 600);
        drawRectangle(g, new Color(206, 187, 158),
                frame.getWidth() / 1.5, frame.getHeight(), //right table leg
                50, 600);
        drawEllipse(g, new Color(153, 154, 104),
                frame.getWidth() / 2, frame.getHeight() / 2, //Draws outer circle
                1200, 400);
        drawEllipse(g, new Color(53, 101, 77),
                frame.getWidth() / 2, frame.getHeight() / 2, //Draws inner circle
                1125, 350);
    }

    private void drawEllipse(Graphics g, Color color, double x, double y, double width, double height) //centers ellipse
    {
        Graphics2D g2 = (Graphics2D) g;
        double centerX = (double) x - width / 2;
        double centerY = (double) y - height / 2;
        Ellipse2D ellipse = new Ellipse2D.Double(centerX, centerY, width, height);
        RenderingHints render = new RenderingHints(
                RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        render.put(
                RenderingHints.KEY_RENDERING,
                RenderingHints.VALUE_RENDER_QUALITY);
        g2.setRenderingHints(render);
        g2.setColor(color);
        g2.fill(ellipse);
        g2.draw(ellipse);
    }

    private void drawRectangle(Graphics g, Color color, double x, double y, double width, double height) //centers rectangle
    {
        Graphics2D g2 = (Graphics2D) g;
        double centerX = (double) x - width / 2;
        double centerY = (double) y - height / 2;
        Rectangle2D rect = new Rectangle2D.Double(centerX, centerY, width, height);
        RenderingHints render = new RenderingHints(
                RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        render.put(
                RenderingHints.KEY_RENDERING,
                RenderingHints.VALUE_RENDER_QUALITY);
        g2.addRenderingHints(render);
        g2.setColor(color);
        g2.fill(rect);
    }
}

¡Avísame si necesitas más ayuda!

0
ErlichBachman 10 feb. 2020 a las 19:46

Tendría que modificar el JPanel de interés para usar ese código:

  • Reemplazar su método paintComponent
  • Primero llamando al método paintComponent del super en su anulación
  • Y luego dibujando su propio método de pintura de la clase DrawRectangle
  • Si quieres poder dibujar múltiples rectángulos, entonces dale al JPanel un List<DrawRectangle> y dibuja esos en un bucle for dentro de paintComponent

Por ejemplo, para un rectángulo:

public class DrawingPanel extends JPanel {
    private DrawRectangle drawRectangle;

    public DrawingPanel(DrawRectangle drawRectangle) {
        this.drawRectangle = drawRectangle;
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (drawRectangle != null) {
            drawRectangle.paint(g);
        }
    }
}

Y para muchos rectángulos:

public class DrawingManyRectPanel extends JPanel {
    private List<DrawRectangle> drawRectangles;

    public DrawingManyRectPanel(List<DrawRectangle> drawRectangles) {
        this.drawRectangles = drawRectangles;
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (drawRectangles != null) {
            for (DrawRectangle rectangle : drawRectangles) {
                rectangle.paint(g);
            }
        }
    }
}

En estas clases, el constructor se anula para permitir la inyección de rectángulos en la clase a través de la llamada del constructor. Para la segunda clase, también agregaría un método que permite agregar más rectángulos:

public void addRectangle(DrawRectangle rectangle) {
    drawRectangles.add(rectangle);
    repaint();
}

Similar para eliminar rectángulos


Una forma alternativa de hacer esto, si no planea eliminar rectángulos o modificar los que ya están dibujados, es dibujarlos en una BufferedImage, y luego dibujar esa imagen en el método paintComponent de JPanel.

1
Hovercraft Full Of Eels 10 feb. 2020 a las 14:28