Moving clickedShapes and only clickedShapes on a panel

[Kieran Murray]

Hi Guys,

I can not find a way of only moving the clickedShape in my code.
The code allows you to scale some drawn objects and add rectangles.
You can also move the panel around.
What would be useful now would be to just move the object that is clicked.
Unfortunately the code below does not do this.

package baseDrawing;
 
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
 
import javax.swing.*;
 
public class ShapeDraw extends JFrame  {
    int[] zoomvalues = {1,2,3,5,10};
    int x0, y0, x1, y1;
    double cx, cy;
    double zoom;
    int x,y;
   
 
    int ValueUpdate=1;
    JComboBox zoommenu = new JComboBox();
 
    ShapeDrawZoomPanel ZoomPanel = new ShapeDrawZoomPanel();
    Rectangle2D Rectangel1 = new Rectangle2D.Double(100,100,100,100);
 
    public ShapeDraw() {
        JMenuBar mb = new JMenuBar();
 
        JMenu addShapeMenu = new JMenu("Add");
        addShapeMenu.setMnemonic('A');
        mb.add(addShapeMenu);
        mb.add(zoommenu);
        setJMenuBar (mb);
        setSize (100,100);
        for(int x= 0; x<=zoomvalues.length-1; x++) {
            zoommenu.addItem(new Integer( zoomvalues[x]));
        }
        zoommenu.addActionListener(lst1);
        
      
      
      JMenuItem rect = new JMenuItem("Rectangle");
    rect.setAccelerator( KeyStroke.getKeyStroke("ctrl R") );
    addShapeMenu.add(rect);
   rect.addActionListener(lst2);
 
        setContentPane(ZoomPanel);
        repaint();
    }
 
    ActionListener lst1 = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            JComboBox cb = (JComboBox)e.getSource();
            Integer Value = (Integer)cb.getSelectedItem();
            ValueUpdate = Value.intValue();
            ZoomPanel.zoomup(ValueUpdate);
        }
    };
    
    ActionListener lst2 = new ActionListener()
    {
    public void actionPerformed(ActionEvent evt) {
// Called to respond to action events from the
// menus or pop-up menu.
String command = evt.getActionCommand();

if (command.equals("Rectangle"))
{
ZoomPanel.rectangleshapes.add(Rectangel1);
repaint();
}
    }

};
    
  
    public int getScale() {
        return ValueUpdate;
    }
 
    public static void main(String[] args) {
        SD Drawing = new SD();
        Drawing.setDefaultCloseOperation(EXIT_ON_CLOSE);
        Drawing.pack();
        Drawing.setSize(765,690);
 
        Drawing.setBackground(Color.white);
        Drawing.setVisible(true);
    }
}

package baseDrawing;
 
import java.awt.*;
 
import javax.swing.*;
 
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.*;
import java.awt.Shape;
import java.util.*;
 

class ShapeDrawZoomPanel extends JPanel implements MouseListener,
MouseMotionListener{

    int x0, y0, x1, y1;
    double cx, cy;
    double zoom;
    Line2D line0 = new Line2D.Double(200,100,50,50);
    Ellipse2D circle0 = new Ellipse2D.Double(200.0, 200.0, 50.0, 50.0);
    Rectangle2D Rectangel0 = new Rectangle2D.Double(300,500,300,300);
    AffineTransform atf = new AffineTransform();
    final int MIN_DIST = 5;
    boolean dragging = false;
    boolean draggingObject=false;
    Path2D.Double clickedShape = null;
   
    
   static  ArrayList lineshapes = new ArrayList();
   static  ArrayList circleshapes = new ArrayList();
   static  ArrayList rectangleshapes = new ArrayList();
 
   
   {
    lineshapes.add(line0);
    circleshapes.add(circle0);
    rectangleshapes.add(Rectangel0);
    }
 
   public ShapeDrawZoomPanel()
   {
   addMouseListener(this);
   addMouseMotionListener(this);
   
   }
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D) g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setPaint(Color.red);
        for(int x=0; x<=lineshapes.size()-1;x++)
        {
        Shape transformedLine = new Path2D.Double((Shape)lineshapes.get(x), atf);
        g2.draw(transformedLine);
        }
        for(int x=0;x<=circleshapes.size()-1;x++)
        {
        Shape transformedCircle = new Path2D.Double((Shape) circleshapes.get(x), atf);
        g2.draw(transformedCircle);
        }
        for(int x=0; x<=rectangleshapes.size()-1;x++)
        {
        Shape transformedRectangle = new Path2D.Double((Shape) rectangleshapes.get(x),atf);
        g2.draw(transformedRectangle);
        }
        g2.setStroke(new BasicStroke(1)); //Note: stroke not affected by atf
        g2.setPaint(Color.blue);
        g2.draw(line0);
        g2.draw(circle0);
    }
    
    public void mouseDragged(MouseEvent e) {
        if(dragging) {
            x1 = e.getX();
            y1 = e.getY();
            movePrimitives(x1-x0,y1-y0);
            x0 = x1;
            y0 = y1;
        }
        if(draggingObject)
        {
        System.out.println("What is up doc");
         x1 = e.getX();
             y1 = e.getY();
             clickedShape.moveTo(20,20);
          
             x0 = x1;
             y0 = y1;
             repaint();
        }
      
    }
 
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        for(int x=0;x<=lineshapes.size()-1;x++)
        {
        Shape transformedLine = new Path2D.Double((Shape)lineshapes.get(x), atf);
       if(transformedLine.contains(p))
       {
       
       clickedShape = (Path2D.Double) transformedLine;
       System.out.println("Hellllllllllllooo");
       draggingObject = true;
       }
       else
       {
     
           x0 = e.getX();
           y0 = e.getY();
           dragging = true;
       }
        }
        for(int x=0;x<=circleshapes.size()-1;x++)
        {
        Shape transformedCircle = new Path2D.Double((Shape) circleshapes.get(x), atf);
        if(transformedCircle.contains(p))
        {
        clickedShape = (Path2D.Double) transformedCircle;
        System.out.println("Did somebody call");
        draggingObject = true;
        }
        else
        {
      
            x0 = e.getX();
            y0 = e.getY();
            dragging = true;
        }
        }
        for(int x=0; x<=rectangleshapes.size()-1;x++)
        {
        Shape transformedRectangle = new Path2D.Double((Shape) rectangleshapes.get(x),atf);
        /*System.out.printf("hasHit(%d, %d) = %b%n",
                           p.x, p.y, ZoomPanel.hasHit(p));*/
      
        if(transformedRectangle.contains(p))
        {
        System.out.println("Somebody stop me");
        clickedShape = (Path2D.Double) transformedRectangle;
        draggingObject = true;
        }
        else
        {
      
            x0 = e.getX();
            y0 = e.getY();
            dragging = true;
        }
        }
    }
   
 
    public void mouseReleased(MouseEvent e) {
        dragging = false;
        draggingObject=false;
    }
 
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    public void mouseMoved(MouseEvent e) {}
    public void mouseClicked(MouseEvent e) {}
 
 
    public void zoomup(int p) {
        // This keeps the center of the component in place.
       cx = this.getWidth() / 2;
    
        cy = this.getHeight() / 2;
        atf.setToTranslation(cx, cy); //Reset atf
        atf.scale(p, p);
        atf.translate(-cx, -cy); 
        repaint(); 
    }
    
    
 
    public boolean hasHit(Point p) {
        double determinant = atf.getDeterminant();
        if(determinant != 0) {            // okay to invert atf
            AffineTransform inv = null;
            try {
                inv = atf.createInverse();
            } catch(NoninvertibleTransformException e) {
                System.out.println("can't invert: " + e.getMessage());
                return false;
            }
            Point2D xp = inv.transform(p, null);
            /*System.out.printf("xp = [%.1f, %.1f]%n", xp.getX(), xp.getY());*/
            if(circle0.contains(xp) || line0.ptSegDist(xp) < MIN_DIST)
                return true;
        }
        return false;
    }
 
    public void movePrimitives(int x, int y) {
        atf.translate(x, y);
        repaint();
    }
   
    
}

The aim is to move all the objects when I click on the panel and just move the clickedObject when I click on it.

Kind regards,

The Apprentice

[Craig Wood]

Here's a way to explore the dragging of the geom primitives.

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
 
public class SDRx extends JPanel {
    List<Path2D.Double> paths = new ArrayList<Path2D.Double>();
    PathWrangler wrangler = new PathWrangler(this);
 
    public SDRx() {
        paths.add(wrap(new Line2D.Double(50, 50, 200, 100)));
        paths.add(wrap(new Ellipse2D.Double(100, 150, 50, 50)));
        paths.add(wrap(new Rectangle2D.Double(150, 250, 75, 50)));
    }
 
    private Path2D.Double wrap(Shape s) {
        return new Path2D.Double(s);
    }
 
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setPaint(Color.blue);
        for(int j = 0; j < paths.size(); j++) {
            g2.draw(paths.get(j));
        }
    }
 
    public void transformPath(Path2D.Double path, AffineTransform at) {
        path.transform(at);
        repaint();
    }
 
    public static void main(String[] args) {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.add(new SDRx());
        f.setSize(400,400);
        f.setLocation(100,100);
        f.setVisible(true);
    }
}
 
class PathWrangler extends MouseInputAdapter {
    SDRx component;
    AffineTransform at = new AffineTransform();
    final int S = 6;
    Rectangle net = new Rectangle(S, S);
    Path2D.Double selectedPath;
    Point offset = new Point();
    boolean dragging = false;
 
    public PathWrangler(SDRx sdr) {
        component = sdr;
        component.addMouseListener(this);
        component.addMouseMotionListener(this);
    }
 
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        net.setLocation(p.x-S/2, p.y-S/2);
        List<Path2D.Double> list = component.paths;
        for(int j = 0; j < list.size(); j++) {
            Path2D.Double path = list.get(j);
            // Use the contains method to detect RectangluarShapes
            // and the intersects method with net to detect lines.
            if(path.contains(p) || path.intersects(net)) {
                selectedPath = path;
                Rectangle r = selectedPath.getBounds();
                offset.x = p.x - r.x;
                offset.y = p.y - r.y;
                dragging = true;
                break;
            }
        }
    }
 
    public void mouseReleased(MouseEvent e) {
        dragging = false;
    }
 
    public void mouseDragged(MouseEvent e) {
        if(dragging) {
            int x = e.getX() - offset.x;
            int y = e.getY() - offset.y;
            Rectangle r = selectedPath.getBounds();
            at.setToTranslation(x-r.x, y-r.y);
            component.transformPath(selectedPath, at);
        }
    }
}

[Kieran Murray]

Craig,

A tardy thank you. The code you provided is the basis of my drawing application. It is really excellent code.

Kind regards,

Kieran