Getting the (starting) X and Y coordinates of a Path2D shape drawn on Jpanel

Question

So, I have a program where I can add shapes to JPanel using Path2D objects and then I can click and drag them around. What I want to do is be able to find the final X and Y coordinates of the shape AFTER it has been drug. The coordinates need to be the top-left coordinates. Any ideas?

// add a circle to center of the screen
public void addCircle(int width, int height) {
    Path2D circ = new Path2D.Double();
    circ.append(new Ellipse2D.Double(getWidth() / 2 - width / 2,
            getHeight() / 2 - height / 2, width, height), true);
    shapes.add(circ);
    repaint();
}
            ..................
//paint all shapes
@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    this.setOpaque(true);
    this.setBackground(Color.WHITE);
    Graphics2D g2 = (Graphics2D) g;
    g2.setStroke(new BasicStroke(2));
    for (Path2D shape : shapes) {
        g2.draw(shape);
    }
}
            ..................
    // if the mouse click is in the circle, set pressed=true
    @Override
    public void mousePressed(MouseEvent e) {
        if (e.getButton() != MouseEvent.BUTTON1) {
            return;
        }
        for (int i = 0; i < shapes.size(); i++) {
            if (shapes.get(i) != null
                    && shapes.get(i).contains(e.getPoint())) {
                currentIndex = i;
                pressed = true;
                this.point = e.getPoint();
            }
        }
    }

    //if pressed=true, move circle with mouse
    @Override
    public void mouseDragged(MouseEvent e) {
        if (pressed && !lineSelected) {
            int deltaX = e.getX() - point.x;
            int deltaY = e.getY() - point.y;
            shapes.get(currentIndex).transform(
                    AffineTransform.getTranslateInstance(deltaX, deltaY));
            point = e.getPoint();
            //I need to find the new coordinates here!!!!!!!!!!!
            repaint();
        }
    }

Full Code

class Canvas extends JPanel {
private static final long serialVersionUID = 1L;

private List<Path2D> shapes = new ArrayList<Path2D>();
private int currentIndex;
private Point lineStartingPoint = new Point();
private Point lineEndingPoint = new Point();
private boolean drawing;
private boolean lineSelected;
private Path2D.Double linePath;
private Shapes myShapes = new Shapes();
private List<Path2D> circles = new ArrayList<Path2D>();

public Canvas() {
    MyMouseAdapter myMouseAdapter = new MyMouseAdapter();
    addMouseListener(myMouseAdapter);
    addMouseMotionListener(myMouseAdapter);
}

public void setList(ArrayList<UMLCircle> shapes) {

}

public List<UMLCircle> getList() {
    return null;
}

public void addSquare(int width, int height) {
    Path2D rect2 = new Path2D.Double();
    rect2.append(new Rectangle(getWidth() / 2 - width / 2, getHeight() / 2
            - height / 2, width, height), true);

    shapes.add(rect2);
    repaint();
}

public void addLine() {
    lineSelected = true;
    repaint();
}

public void addCircle(int width, int height) {
    myShapes.addCircle(getWidth() / 2 - width / 2, getHeight() / 2 - height
            / 2, width, height);
    Path2D circ = new Path2D.Double();
    circ.append(new Ellipse2D.Double(getWidth() / 2 - width / 2,
            getHeight() / 2 - height / 2, width, height), true);
    circles.add(circ);
    shapes.add(circ);
    repaint();
}

@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    this.setOpaque(true);
    this.setBackground(Color.WHITE);
    Graphics2D g2 = (Graphics2D) g;
    if (lineSelected) {
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setStroke(new BasicStroke(2));
        g2.drawLine(lineStartingPoint.x, lineStartingPoint.y,
                lineEndingPoint.x, lineEndingPoint.y);
    }
    g2.setStroke(new BasicStroke(2));
    for (Path2D shape : shapes) {
        g2.draw(shape);
    }
}

class MyMouseAdapter extends MouseAdapter {
    private boolean pressed = false;
    private Point point;

    @Override
    public void mousePressed(MouseEvent e) {
        if (e.getButton() != MouseEvent.BUTTON1) {
            return;
        }
        for (int i = 0; i < shapes.size(); i++) {
            if (shapes.get(i) != null
                    && shapes.get(i).contains(e.getPoint())) {
                currentIndex = i;
                pressed = true;
                this.point = e.getPoint();
            }
            if (circles.get(i) != null
                    && circles.get(i).contains(e.getPoint())) {
                currentIndex = i;
                pressed = true;
                this.point = e.getPoint();
            }
        }
        if (lineSelected) {
            drawing = true;
            lineStartingPoint = e.getPoint();
            lineEndingPoint = lineStartingPoint;
        }
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        if (pressed && !lineSelected) {
            int deltaX = e.getX() - point.x;
            int deltaY = e.getY() - point.y;
            shapes.get(currentIndex).transform(
                    AffineTransform.getTranslateInstance(deltaX, deltaY));
            point = e.getPoint();
            myShapes.updateCircleLocation(currentIndex, point.x, point.y);
            System.out.println(point.x + " " + point.y);
            repaint();
        }
        if (drawing) {
            lineEndingPoint = e.getPoint();
            repaint();
        }
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        if (drawing && lineSelected) {
            drawing = false;
            lineSelected = false;
            lineEndingPoint = e.getPoint();
            linePath = new Path2D.Double();
            linePath.moveTo(lineStartingPoint.getX(),
                    lineStartingPoint.getY());
            linePath.lineTo(lineEndingPoint.getX(), lineEndingPoint.getY());
            shapes.add(linePath);
            repaint();
        }
        pressed = false;
    }
}
}

EDIT

Calculation for offset:

            int deltaX = e.getX() - point.x;
            int deltaY = e.getY() - point.y;
            shapes.get(currentIndex).transform(
                    AffineTransform.getTranslateInstance(deltaX, deltaY));
            point = e.getPoint();
            int newXPos = e.getX() - deltaX; // final X pos
            int newXPos = e.getX() - deltaX; // final Y pos

Answer 1

Before you can do anything, you need to know the offset of the mouse click from the corner of the shape, this will allow you to drag the object so it doesn't suddenly "jump" to your current mouse position...

@Override
public void mousePressed(MouseEvent e) {
    //...
    for (Shape shape : myShapes) {
            //...
            this.point = e.getPoint();
            int deltaX = point.x - shape.getBounds().x;
            int deltaY = point.y - shape.getBounds().y;
            offset = new Point(deltaX, deltaY);
            //...
        }
    }
}

Then, you would calculate the delta of change, between the current mouse position and the offset. Because you're applying a translate, you also need to subtract the shape's current location, as the translation is based on the shape's current location and we only want to apply the amount of change

@Override
public void mouseDragged(MouseEvent e) {
    if (pressed) {
        int index = myShapes.indexOf(clickedShape);
        myShapes.remove(index);

        int deltaX = e.getPoint().x - offset.x;
        int deltaY = e.getPoint().y - offset.y;

        clickedShape = new Path2D.Double(clickedShape,
                        AffineTransform.getTranslateInstance(
                                        deltaX - clickedShape.getBounds().x,
                                        deltaY - clickedShape.getBounds().y));
        myShapes.add(index, clickedShape);
        point = e.getPoint();
        repaint();
    }
}

Now, having said all that, don't do this...

protected void paintComponent(Graphics g) {
    //...
    this.setOpaque(true);
    this.setBackground(Color.WHITE);

Changing the state of the component from within the paint method can setup a infinite loop of repaint requests, which can chock your system. Also, the changes you make won't be applied to the current graphics context, as these properties are generally applied by the paint method...

And a working copy....

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Path2D;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

class Canvas extends JPanel {

    private static final long serialVersionUID = 1L;

    private boolean drawing;
    private List<Shape> myShapes = new ArrayList<Shape>();

    public static void main(String[] args) {
        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 Canvas());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public Canvas() {
        MyMouseAdapter myMouseAdapter = new MyMouseAdapter();
        addMouseListener(myMouseAdapter);
        addMouseMotionListener(myMouseAdapter);
        addSquare(100, 100);
    }

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

    public void setList(ArrayList<Shape> shapes) {

    }

    public List<Shape> getList() {
        return null;
    }

    public void addSquare(int width, int height) {
        Path2D rect2 = new Path2D.Double();
        rect2.append(new Rectangle(getWidth() / 2 - width / 2, getHeight() / 2
                        - height / 2, width, height), true);

        myShapes.add(rect2);
        repaint();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D) g;
        g2.setStroke(new BasicStroke(2));
        for (Shape shape : myShapes) {
            g2.draw(shape);
        }
    }

    class MyMouseAdapter extends MouseAdapter {

        private boolean pressed = false;
        private Point point;
        private Point offset;
        private Shape clickedShape;

        @Override
        public void mousePressed(MouseEvent e) {
            if (e.getButton() != MouseEvent.BUTTON1) {
                return;
            }
            for (Shape shape : myShapes) {
                if (shape != null
                                && shape.contains(e.getPoint())) {
                    System.out.println("Clicked");
                    pressed = true;
                    clickedShape = shape;
                    this.point = e.getPoint();
                    int deltaX = point.x - shape.getBounds().x;
                    int deltaY = point.y - shape.getBounds().y;
                    offset = new Point(deltaX, deltaY);
                    System.out.println(point + "x" + offset);
                    repaint();
                    break;
                }
            }
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            if (pressed) {
                int index = myShapes.indexOf(clickedShape);
                myShapes.remove(index);

                int deltaX = e.getPoint().x - offset.x;
                int deltaY = e.getPoint().y - offset.y;

                clickedShape = new Path2D.Double(clickedShape,
                                AffineTransform.getTranslateInstance(
                                                deltaX - clickedShape.getBounds().x,
                                                deltaY - clickedShape.getBounds().y));
                myShapes.add(index, clickedShape);
                point = e.getPoint();
                repaint();
            }
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            offset = null;
            pressed = false;
        }
    }
}