Can move shapes individually but not as a group

[Kieran Murray]

Hi Guys,

Hopefully as Mr Churchill said "This is the end of the beginning".

This code is supposed to drag both shapes individually and shapes as a group.

The boolean dragging works fine as a signal to move the shapes individually.

The boolean draggingScreen DOES NOT work for dragging all the object.
This should happen when a shape is not clicked. Everything should then be dragged.

I am not sure that I am using the AffineTransform properly.

Any help would be gratefully appreciated because I have been at this for four days and am going around in circles.

 
package Translation;
 
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 MyInterpretation extends JPanel{
    ArrayList paths = new ArrayList();
    PathWranglerNew wrangler = new PathWranglerNew(this);
 
    public MyInterpretation() {
        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((Path2D.Double)paths.get(j));
        }
    }
 
    public void transformPath(Path2D.Double path, AffineTransform at) {
    path.transform(at);
    repaint();
    }
 
    public void movePrimitives(int x, int y, AffineTransform at) {
        at.translate(x, y);
        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 PathWranglerNew extends MouseInputAdapter {
    MyInterpretation 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;
    boolean draggingScreen = false;
 
    public PathWranglerNew(MyInterpretation 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 list = component.paths;
        for(int j = 0; j < list.size(); j++) {
            Path2D.Double path = (Path2D.Double)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;
                draggingScreen = false;
                System.out.println("Here we do not  go");
                System.out.println("Got you");
                break;
            }
            else
            {
            draggingScreen=true;
            }
        }
       
        
        
        
           
        }
            
     
    public void mouseReleased(MouseEvent e) {
        dragging = false;
        draggingScreen=false;
    }
 
    public void mouseDragged(MouseEvent e) {
     if(draggingScreen)
         {
         System.out.println("What now");
          int x = e.getX() - offset.x;
              int y = e.getY() - offset.y;
             
              component.movePrimitives(x, y, at);
         }
        if(dragging) {
        System.out.println("What is up doc");
            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);
        }
       
    }
}

Kind regards,

The apprentice

[Craig Wood]

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;
 
// Turn off generics warnings given by compiler for
// not using generic type parameters in Collections.
@SuppressWarnings("unchecked")  // j2se 1.5+
 
public class MyInterp extends JPanel{
    ArrayList paths = new ArrayList();
    PathWrangler2 wrangler = new PathWrangler2(this);
    // Used to move all paths uniformly.
    private AffineTransform at = new AffineTransform();
 
    public MyInterp() {
        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++) {
            Path2D.Double path = (Path2D.Double)paths.get(j);
            // Since you want to move all paths uniformly we
            // can use a transform to keep track of them.
            Shape s = at.createTransformedShape(path);
            g2.draw(s);
        }
    }
 
    public void transformPath(Path2D.Double path, AffineTransform at) {
        path.transform(at);
        repaint();
    }
 
    public void movePrimitives(int x, int y) {
        at.translate(x, y);
        repaint();
    }
 
    public AffineTransform getTransform() {
        // Send a defensive copy.
        return new AffineTransform(at);
    }
 
    public static void main(String[] args) {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//        f.add(new SDRx());
        f.add(new MyInterp());
        f.setSize(400,400);
        f.setLocation(100,100);
        f.setVisible(true);
    }
}
 
class PathWrangler2 extends MouseInputAdapter {
    MyInterp component;
    // Used to move individual paths.
    AffineTransform at = new AffineTransform();
    final int S = 6;
    Rectangle2D.Double net = new Rectangle2D.Double(0, 0, S, S);
    Path2D.Double selectedPath;
    Point offset = new Point();
    boolean dragging = false;
    boolean draggingScreen = false;
 
    public PathWrangler2(MyInterp sdr) {
        component = sdr;
        component.addMouseListener(this);
        component.addMouseMotionListener(this);
    }
 
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        List list = component.paths;
        Point2D xp = getXformedPoint(p);
        net.setFrame(xp.getX()-S/2, xp.getY()-S/2, S, S);
        for(int j = 0; j < list.size(); j++) {
            Path2D.Double path = (Path2D.Double)list.get(j);
            if(path.contains(xp) || path.intersects(net)) {
                selectedPath = path;
                Rectangle r = selectedPath.getBounds();
                offset.x = p.x - r.x;
                offset.y = p.y - r.y;
                dragging = true;
                break;
            }
        }
        if(!dragging) {
            offset.setLocation(p);
            draggingScreen = true;
        }
    }
 
    public Point2D getXformedPoint(Point p) {
        // Transform a point in the component coordinate system
        // to a point in the transformed path coordinate system
        // so mousePressed points can find the transformed shapes
        // drawn to the screen in component view.
        AffineTransform xform = component.getTransform();
        double determinant = xform.getDeterminant();
        if(determinant != 0) {            // okay to invert
            AffineTransform inv = null;
            try {
                inv = xform.createInverse();
            } catch(NoninvertibleTransformException e) {
                System.out.println("can't invert: " + e.getMessage());
                return null;
            }
            return inv.transform(p, null);
        }
        return null;
    }
 
    public void mouseReleased(MouseEvent e) {
        dragging = false;
        draggingScreen = false;
    }
 
    public void mouseDragged(MouseEvent e) {
     if(draggingScreen) {
             Point p = e.getPoint();
             int x = p.x - offset.x;
             int y = p.y - offset.y;
             component.movePrimitives(x, y);
             offset.setLocation(p);
        } else 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);
        }
    }
}