Index: PrimitiveShape.java
===================================================================
--- PrimitiveShape.java	(revision 31298)
+++ PrimitiveShape.java	(working copy)
@@ -466,17 +466,15 @@
                     - oldToScreen.getDeterminant()) > 0.000001) {
                 return transformInternal(pointCoordCalculator);
             } else {
-
-                return translate(AffineTransform.getTranslateInstance(pointCoordCalculator.toScreen
-                        .getTranslateX()
-                        - oldToScreen.getTranslateX(), pointCoordCalculator.toScreen
-                        .getTranslateY()
-                        - oldToScreen.getTranslateY()));
+            	//pan
+                return translate(AffineTransform.getTranslateInstance(
+                		pointCoordCalculator.toScreen.getTranslateX()- oldToScreen.getTranslateX(), 
+                		pointCoordCalculator.toScreen.getTranslateY()- oldToScreen.getTranslateY()),
+                		pointCoordCalculator);
             }
         }
 
-        private HashMap<Point, List<Point>> transformInternal(
-                PointCoordCalculator pointCoordCalculator ) {
+        private HashMap<Point, List<Point>> transformInternal(PointCoordCalculator pointCoordCalculator ) {
             List<PointCoordMap> oldPoints = points;
 
             HashMap<Point, List<Point>> oldPointToNew = new HashMap<Point, List<Point>>();
@@ -494,16 +492,7 @@
                     Coordinate coord = c.get(oldPoint);
 
                     Point newPoint = pointCoordCalculator.toPoint(coord);
-                    // So that all the vertices don't make a big mess look around point in a 3x3
-                    // radius
-                    // if another point is there add to that point.
-                    Point overLappingPoint;
-                    overLappingPoint = getEditBlackboard().overVertex(newPoint,
-                            PreferenceUtil.instance().getVertexRadius());
 
-                    if (overLappingPoint != null && getEditBlackboard().isCollapseVertices())
-                        newPoint = overLappingPoint;
-
                     if (!newPoint.equals(oldPoint)) {
                         tmp = new PointCoordMap(newPoint);
                         tmp.coords.add(c);
@@ -560,7 +549,8 @@
             return oldPointToNew;
         }
 
-        private Map< ? extends Point, ? extends List<Point>> translate( AffineTransform oldToNew ) {
+
+        private Map< ? extends Point, ? extends List<Point>> translate( AffineTransform oldToNew, PointCoordCalculator pointCoordCalculator ) {
             List<PointCoordMap> oldPoints = points;
 
             HashMap<Point, List<Point>> oldPointToNew = new HashMap<Point, List<Point>>();
@@ -572,52 +562,67 @@
             int diffX = (int) oldToNew.getTranslateX();
             int diffY = (int) oldToNew.getTranslateY();
             for( PointCoordMap map : oldPoints ) {
+            	Point oldPoint = map.point;
+                for( Iterator<LazyCoord> iter = map.coords.iterator(); iter.hasNext(); ) {
+            		LazyCoord c = iter.next();
+            		PointCoordMap tmp = map;
+                    Point newPoint = Point.valueOf(map.point.getX() + diffX, map.point.getY() + diffY);
+                    
+                    if (!newPoint.equals(oldPoint)) {
+                        tmp = new PointCoordMap(newPoint);
+                        tmp.coords.add(c);
+                        iter.remove();
+                    }
 
-                Point newPoint = Point.valueOf(map.point.getX() + diffX, map.point.getY() + diffY);
-                List<Point> pointMapping = oldPointToNew.get(map.point);
-                if (pointMapping == null) {
-                    pointMapping = new ArrayList<Point>();
-                    pointMapping.add(newPoint);
-                    oldPointToNew.put(map.point, pointMapping);
-                } else {
-                    pointMapping.add(newPoint);
-                }
-                map.point = newPoint;
+                    c.pointCoordCalculator = new PointCoordCalculator(pointCoordCalculator);
+                    c.start = newPoint;
 
-                // update shape
-                points.add(map);
-                List<PointCoordMap> list = pointsToModel.get(newPoint);
-                if (list == null) {
-                    List<PointCoordMap> l = new ArrayList<PointCoordMap>();
-                    l.add(map);
-                    pointsToModel.put(newPoint, l);
-                } else {
-                    list.add(map);
-                }
+                    List<Point> pointMapping = oldPointToNew.get(oldPoint);
+                    if (pointMapping == null) {
+                        pointMapping = new ArrayList<Point>();
+                        pointMapping.add(newPoint);
+                        oldPointToNew.put(oldPoint, pointMapping);
+                    } else {
+                        pointMapping.add(newPoint);
+                    }
+                    tmp.point = newPoint;
 
-                // update Blackboard.
-                List<LazyCoord> coords = editBlackboard.coordMapping.get(newPoint);
-                if (coords == null) {
-                    List<LazyCoord> l = new ArrayList<LazyCoord>(map.coords);
-                    editBlackboard.coordMapping.put(newPoint, l);
-                } else {
-                    coords.addAll(map.coords);
-                }
+                    coordsToModel.put(c, tmp);
 
-                Set<EditGeom> mappedGeoms = editBlackboard.geomMapping.get(newPoint);
-                if (mappedGeoms == null) {
-                    Set<EditGeom> l = new HashSet<EditGeom>();
-                    l.add(getEditGeom());
-                    editBlackboard.geomMapping.put(newPoint, l);
-                } else {
-                    if (!mappedGeoms.contains(getEditGeom()))
-                        mappedGeoms.add(getEditGeom());
-                }
+                    // update shape
+                    points.add(tmp);
+                    List<PointCoordMap> list = pointsToModel.get(newPoint);
+                    if (list == null) {
+                        List<PointCoordMap> l = new ArrayList<PointCoordMap>();
+                        l.add(tmp);
+                        pointsToModel.put(newPoint, l);
+                    } else {
+                        list.add(tmp);
+                    }
 
+                    // update Blackboard.
+                    List<LazyCoord> coords = editBlackboard.coordMapping.get(newPoint);
+                    if (coords == null) {
+                        List<LazyCoord> l = new ArrayList<LazyCoord>(tmp.coords);
+                        editBlackboard.coordMapping.put(newPoint, l);
+                    } else {
+                        coords.addAll(tmp.coords);
+                    }
+
+                    Set<EditGeom> mappedGeoms = editBlackboard.geomMapping.get(newPoint);
+                    if (mappedGeoms == null) {
+                        Set<EditGeom> l = new HashSet<EditGeom>();
+                        l.add(getEditGeom());
+                        editBlackboard.geomMapping.put(newPoint, l);
+                    } else {
+                        if (!mappedGeoms.contains(getEditGeom()))
+                            mappedGeoms.add(getEditGeom());
+                    }
+                }	
             }
             return oldPointToNew;
         }
-
+        
         /**
          * Moves a single LazyCoord from the start point to the end point. Keeps the order of the
          * coordinates in the same order.
@@ -1453,5 +1458,12 @@
         return owner.getShapeType() == ShapeType.POLYGON
                 || (owner.getShapeType() == ShapeType.UNKNOWN && treatUnknownAsPolygon);
     }
-
+    
+    public List<Point> getPoints() {
+    	List<Point> result = new ArrayList<Point>();
+    	for( PointCoordMap point : points ) {
+    		result.add(point.point);
+        }
+    	return result;
+    }
 }