Big update - replace Point with Point2D in most places to increase

accuracy

diylc/diylc-core/src/org/diylc/common/DefaultTransformer.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.common;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.core.IDIYComponent;
 
@@ -43,11 +43,11 @@ public class DefaultTransformer implements IComponentTransformer {
   }
 
   @Override
-  public void rotate(IDIYComponent<?> component, Point center, int direction) {
+  public void rotate(IDIYComponent<?> component, Point2D center, int direction) {
   }
 
   @Override
-  public void mirror(IDIYComponent<?> component, Point center, int direction) {
+  public void mirror(IDIYComponent<?> component, Point2D center, int direction) {
   }
 
 }

diylc/diylc-core/src/org/diylc/common/IComponentTransformer.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.common;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.core.IDIYComponent;
 
@@ -39,7 +39,7 @@ public interface IComponentTransformer {
   
   boolean mirroringChangesCircuit();
 
-  void rotate(IDIYComponent<?> component, Point center, int direction);
+  void rotate(IDIYComponent<?> component, Point2D center, int direction);
 
-  void mirror(IDIYComponent<?> component, Point center, int direction);
+  void mirror(IDIYComponent<?> component, Point2D center, int direction);
 }

diylc/diylc-core/src/org/diylc/common/ISelectionProcessor.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.common;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.util.Collection;
 import java.util.List;
@@ -55,7 +55,7 @@ public interface ISelectionProcessor {
    * @param includeLocked
    * @return
    */
-  List<IDIYComponent<?>> findComponentsAt(Point point, boolean includeLocked);
+  List<IDIYComponent<?>> findComponentsAt(Point2D point, boolean includeLocked);
 
   /**
    * Expands the current selection to include surrounding components. Options are controlled with

diylc/diylc-core/src/org/diylc/common/SimpleComponentTransformer.java

@@ -23,6 +23,7 @@ package org.diylc.common;
 
 import java.awt.Point;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
 
 import org.diylc.core.IDIYComponent;
 
@@ -44,23 +45,23 @@ public class SimpleComponentTransformer implements IComponentTransformer {
   }
 
   @Override
-  public void rotate(IDIYComponent<?> component, Point center, int direction) {
+  public void rotate(IDIYComponent<?> component, Point2D center, int direction) {
-    AffineTransform rotate = AffineTransform.getRotateInstance(Math.PI / 2 * direction, center.x, center.y);
+    AffineTransform rotate = AffineTransform.getRotateInstance(Math.PI / 2 * direction, center.getX(), center.getY());
     for (int index = 0; index < component.getControlPointCount(); index++) {
-      Point p = new Point(component.getControlPoint(index));
+      Point2D p = new Point2D.Double();
-      rotate.transform(p, p);
+      rotate.transform(component.getControlPoint(index), p);
       component.setControlPoint(p, index);
     }
   }
 
   @Override
-  public void mirror(IDIYComponent<?> component, Point center, int direction) {
+  public void mirror(IDIYComponent<?> component, Point2D center, int direction) {
     for (int i = 0; i < component.getControlPointCount(); i++) {
-      Point p = component.getControlPoint(i);
+      Point2D p = component.getControlPoint(i);
       if (direction == IComponentTransformer.HORIZONTAL) {
-        component.setControlPoint(new Point(p.x - 2 * (p.x - center.x), p.y), i);
+        component.setControlPoint(new Point2D.Double(p.getX() - 2 * (p.getX() - center.getX()), p.getY()), i);
       } else {
-        component.setControlPoint(new Point(p.x, p.y - 2 * (p.y - center.y)), i);
+        component.setControlPoint(new Point.Double(p.getX(), p.getY() - 2 * (p.getY() - center.getY())), i);
       }
     }
   }

diylc/diylc-core/src/org/diylc/components/AbstractComponent.java

@@ -23,8 +23,8 @@ package org.diylc.components;
 
 import java.awt.Color;
 import java.awt.Font;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
@@ -117,23 +117,23 @@ public abstract class AbstractComponent<T> implements IDIYComponent<T> {
         return false;
       }
     }
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
     for (int i = 0; i < getControlPointCount(); i++) {
-      Point p = getControlPoint(i);
+      Point2D p = getControlPoint(i);
-      if (minX > p.x) {
+      if (minX > p.getX()) {
-        minX = p.x;
+        minX = p.getX();
       }
-      if (maxX < p.x) {
+      if (maxX < p.getX()) {
-        maxX = p.x;
+        maxX = p.getX();
       }
-      if (minY > p.y) {
+      if (minY > p.getY()) {
-        minY = p.y;
+        minY = p.getY();
       }
-      if (maxY < p.y) {
+      if (maxY < p.getY()) {
-        maxY = p.y;
+        maxY = p.getY();
       }
     }
     Rectangle2D rect = new Rectangle2D.Double(minX, minY, maxX - minX, maxY - minY);
@@ -160,18 +160,19 @@ public abstract class AbstractComponent<T> implements IDIYComponent<T> {
             // Deep copy point arrays.
             // TODO: something nicer
             if (value != null && value.getClass().isArray()
-                && value.getClass().getComponentType().isAssignableFrom(Point.class)) {
+                && value.getClass().getComponentType().isAssignableFrom(Point2D.class)) {
               Object newArray = Array.newInstance(value.getClass().getComponentType(), Array.getLength(value));
               for (int i = 0; i < Array.getLength(value); i++) {
-                Point p = (Point) Array.get(value, i);
+                Point2D p = (Point2D) Array.get(value, i);
-                Array.set(newArray, i, new Point(p));
+                Array.set(newArray, i, new Point2D.Double(p.getX(), p.getY()));
               }
               value = newArray;
             }
             // Deep copy points.
             // TODO: something nicer
-            if (value != null && value instanceof Point) {
+            if (value != null && value instanceof Point2D) {
-              value = new Point((Point) value);
+              Point2D p = (Point2D) value;
+              value = new Point2D.Double(p.getX(), p.getY());
             }
 
             field.set(newInstance, value);

diylc/diylc-core/src/org/diylc/components/AbstractCurvedComponent.java

@@ -21,7 +21,6 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.geom.CubicCurve2D;
 import java.awt.geom.Path2D;
 import java.awt.geom.Point2D;
@@ -53,12 +52,12 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
   public static Size DEFAULT_SIZE = new Size(1d, SizeUnit.in);
 
   // for backward compatibility
-  protected Point[] controlPoints = null;
+  protected Point2D[] controlPoints = null;
 
-  protected Point[] controlPoints2 = new Point[] {new Point(0, 0),
+  protected Point2D[] controlPoints2 = new Point2D[] {new Point2D.Double(0, 0),
-      new Point((int) (DEFAULT_SIZE.convertToPixels() / 2), 0),
+      new Point2D.Double(DEFAULT_SIZE.convertToPixels() / 2, 0),
-      new Point((int) (DEFAULT_SIZE.convertToPixels() / 2), (int) (DEFAULT_SIZE.convertToPixels())),
+      new Point2D.Double(DEFAULT_SIZE.convertToPixels() / 2, DEFAULT_SIZE.convertToPixels()),
-      new Point((int) DEFAULT_SIZE.convertToPixels(), (int) DEFAULT_SIZE.convertToPixels())};
+      new Point2D.Double(DEFAULT_SIZE.convertToPixels(), DEFAULT_SIZE.convertToPixels())};
 
   protected Color color = getDefaultColor();
   protected PointCount pointCount = PointCount.FOUR;
@@ -102,7 +101,7 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
       return;
     }
 
-    Point[] p = getControlPoints();
+    Point2D[] p = getControlPoints();
 
     // smoothen the curve if needed
     if (getSmooth() && lastUpdatePointIndex >= 0) {
@@ -127,25 +126,25 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
       g2d.setStroke(Constants.DASHED_STROKE);
       g2d.setColor(GUIDELINE_COLOR);
       for (int i = 0; i < p.length - 1; i++) {
-        g2d.drawLine(p[i].x, p[i].y, p[i + 1].x, p[i + 1].y);
+        g2d.drawLine((int)p[i].getX(), (int)p[i].getY(), (int)p[i + 1].getX(), (int)p[i + 1].getY());
       }
       drawingObserver.startTracking();
     }
 
     Path2D path = new Path2D.Double();
-    path.moveTo(p[0].x, p[0].y);
+    path.moveTo(p[0].getX(), p[0].getY());
     if (getPointCount() == PointCount.TWO) {
-      path.lineTo(p[1].x, p[1].y);
+      path.lineTo(p[1].getX(), p[1].getY());
     } else if (getPointCount() == PointCount.THREE) {
-      path.curveTo(p[1].x, p[1].y, p[1].x, p[1].y, p[2].x, p[2].y);
+      path.curveTo(p[1].getX(), p[1].getY(), p[1].getX(), p[1].getY(), p[2].getX(), p[2].getY());
     } else if (getPointCount() == PointCount.FOUR) {
-      path.curveTo(p[1].x, p[1].y, p[2].x, p[2].y, p[3].x, p[3].y);
+      path.curveTo(p[1].getX(), p[1].getY(), p[2].getX(), p[2].getY(), p[3].getX(), p[3].getY());
     } else if (getPointCount() == PointCount.FIVE) {
-      path.quadTo(p[1].x, p[1].y, p[2].x, p[2].y);
+      path.quadTo(p[1].getX(), p[1].getY(), p[2].getX(), p[2].getY());
-      path.quadTo(p[3].x, p[3].y, p[4].x, p[4].y);
+      path.quadTo(p[3].getX(), p[3].getY(), p[4].getX(), p[4].getY());
     } else if (getPointCount() == PointCount.SEVEN) {
-      path.curveTo(p[1].x, p[1].y, p[2].x, p[2].y, p[3].x, p[3].y);
+      path.curveTo(p[1].getX(), p[1].getY(), p[2].getX(), p[2].getY(), p[3].getX(), p[3].getY());
-      path.curveTo(p[4].x, p[4].y, p[5].x, p[5].y, p[6].x, p[6].y);
+      path.curveTo(p[4].getX(), p[4].getY(), p[5].getX(), p[5].getY(), p[6].getX(), p[6].getY());
     }
 
     Composite oldComposite = g2d.getComposite();
@@ -166,23 +165,23 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
     return pointCount;
   }
 
-  protected Point[] getControlPoints() {
+  protected Point2D[] getControlPoints() {
     if (this.controlPoints != null) {
       // ensure backward compatibility by copying points from the old structure to the new one
       switch (getPointCount()) {
         case TWO:
-          this.controlPoints2 = new Point[2];
+          this.controlPoints2 = new Point2D[2];
           this.controlPoints2[0] = this.controlPoints[0];
           this.controlPoints2[1] = this.controlPoints[3];
           break;
         case THREE:
-          this.controlPoints2 = new Point[3];
+          this.controlPoints2 = new Point2D[3];
           this.controlPoints2[0] = this.controlPoints[0];
           this.controlPoints2[1] = this.controlPoints[1];
           this.controlPoints2[2] = this.controlPoints[3];
           break;
         case FOUR:
-          this.controlPoints2 = new Point[4];
+          this.controlPoints2 = new Point2D[4];
           this.controlPoints2[0] = this.controlPoints[0];
           this.controlPoints2[1] = this.controlPoints[1];
           this.controlPoints2[2] = this.controlPoints[2];
@@ -198,42 +197,42 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
   }
 
   public void setPointCount(PointCount pointCount) {
-    Point[] p = getControlPoints();
+    Point2D[] p = getControlPoints();
-    Point[] newPoints = new Point[pointCount.count];
+    Point2D[] newPoints = new Point2D[pointCount.count];
     newPoints[0] = p[0];
     newPoints[pointCount.count - 1] = p[p.length - 1];
 
     if (pointCount == PointCount.THREE) {
       newPoints[1] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[0].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[0].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[0].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[0].getY()) / 2);
     } else if (pointCount == PointCount.FOUR) {
       newPoints[1] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[0].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[0].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[0].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[0].getY()) / 2);
       newPoints[2] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[0].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[0].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[0].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[0].getY()) / 2);
     } else if (pointCount == PointCount.FIVE) {
       newPoints[2] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[0].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[0].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[0].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[0].getY()) / 2);
-      newPoints[1] = new Point((newPoints[2].x + newPoints[0].x) / 2, (newPoints[2].y + newPoints[0].y) / 2);
+      newPoints[1] = new Point2D.Double((newPoints[2].getX() + newPoints[0].getX()) / 2, (newPoints[2].getY() + newPoints[0].getY()) / 2);
       newPoints[3] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[2].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[2].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[2].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[2].getY()) / 2);
     } else if (pointCount == PointCount.SEVEN) {
       newPoints[3] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[0].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[0].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[0].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[0].getY()) / 2);
-      newPoints[2] = new Point((newPoints[3].x + newPoints[0].x) / 2, (newPoints[3].y + newPoints[0].y) / 2);
+      newPoints[2] = new Point2D.Double((newPoints[3].getX() + newPoints[0].getX()) / 2, (newPoints[3].getY() + newPoints[0].getY()) / 2);
-      newPoints[1] = new Point((newPoints[3].x + newPoints[0].x) / 2, (newPoints[3].y + newPoints[0].y) / 2);
+      newPoints[1] = new Point2D.Double((newPoints[3].getX() + newPoints[0].getX()) / 2, (newPoints[3].getY() + newPoints[0].getY()) / 2);
       newPoints[4] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[3].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[3].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[3].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[3].getY()) / 2);
       newPoints[5] =
-          new Point((newPoints[pointCount.count - 1].x + newPoints[3].x) / 2,
+          new Point2D.Double((newPoints[pointCount.count - 1].getX() + newPoints[3].getX()) / 2,
-              (newPoints[pointCount.count - 1].y + newPoints[3].y) / 2);
+              (newPoints[pointCount.count - 1].getY() + newPoints[3].getY()) / 2);
     }
 
     this.controlPoints2 = newPoints;
@@ -261,13 +260,13 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return getControlPoints()[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
-    Point[] p = getControlPoints();
+    Point2D[] p = getControlPoints();
     p[index].setLocation(point);
     this.lastUpdatePointIndex = index;
     // if (getSmooth()) {
@@ -286,8 +285,8 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
     // }
   }
 
-  private Point findThirdPoint(Point p0, Point p) {
+  private Point2D findThirdPoint(Point2D p0, Point2D p) {
-    return new Point(2 * p0.x - p.x, 2 * p0.y - p.y);
+    return new Point2D.Double(2 * p0.getX() - p.getX(), 2 * p0.getY() - p.getY());
   }
 
   @EditableProperty(name = "Color")
@@ -335,7 +334,7 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
   public Size getLength() {
     double d = 0;
       try {
-      Point[] p = getControlPoints();
+      Point2D[] p = getControlPoints();
       if (getPointCount() == PointCount.TWO) {
         d = p[0].distance(p[1]);
       } else if (getPointCount() == PointCount.THREE) {
@@ -364,21 +363,21 @@ public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComp
   
   @Override
   public Rectangle2D getCachingBounds() {
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
-    int margin = 50; // hard coded, replace with something meaningful
+    double margin = 50; // hard coded, replace with something meaningful
     for (int i = 0; i < getControlPointCount(); i++) {
-      Point p = getControlPoint(i);
+      Point2D p = getControlPoint(i);
-      if (p.x < minX)
+      if (p.getX() < minX)
-        minX = p.x;
+        minX = p.getX();
-      if (p.x > maxX)
+      if (p.getX() > maxX)
-        maxX = p.x;
+        maxX = p.getX();
-      if (p.y < minY)
+      if (p.getY() < minY)
-        minY = p.y;
+        minY = p.getY();
-      if (p.y > maxY)
+      if (p.getY() > maxY)
-        maxY = p.y;
+        maxY = p.getY();
     }
     
     return new Rectangle2D.Double(minX - margin, minY - margin, maxX - minX + 2 * margin, maxY - minY + 2 * margin);

diylc/diylc-core/src/org/diylc/components/transform/DefaultTransformer.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.components.transform;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.IComponentTransformer;
 import org.diylc.core.IDIYComponent;
@@ -44,11 +44,11 @@ public class DefaultTransformer implements IComponentTransformer {
   }
 
   @Override
-  public void rotate(IDIYComponent<?> component, Point center, int direction) {
+  public void rotate(IDIYComponent<?> component, Point2D center, int direction) {
   }
 
   @Override
-  public void mirror(IDIYComponent<?> component, Point center, int direction) {
+  public void mirror(IDIYComponent<?> component, Point2D center, int direction) {
   }
 
 }

diylc/diylc-core/src/org/diylc/components/transform/LeadedComponentTransformer.java

@@ -21,8 +21,8 @@
 */
 package org.diylc.components.transform;
 
-import java.awt.Point;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.IComponentTransformer;
 import org.diylc.core.IDIYComponent;
@@ -45,23 +45,23 @@ public class LeadedComponentTransformer implements IComponentTransformer {
   }
 
   @Override
-  public void rotate(IDIYComponent<?> component, Point center, int direction) {
+  public void rotate(IDIYComponent<?> component, Point2D center, int direction) {
-    AffineTransform rotate = AffineTransform.getRotateInstance(Math.PI / 2 * direction, center.x, center.y);
+    AffineTransform rotate = AffineTransform.getRotateInstance(Math.PI / 2 * direction, center.getX(), center.getY());
     for (int index = 0; index < component.getControlPointCount(); index++) {
-      Point p = new Point(component.getControlPoint(index));
+      Point2D p = new Point2D.Double();
-      rotate.transform(p, p);
+      rotate.transform(component.getControlPoint(index), p);
       component.setControlPoint(p, index);
     }
   }
 
   @Override
-  public void mirror(IDIYComponent<?> component, Point center, int direction) {
+  public void mirror(IDIYComponent<?> component, Point2D center, int direction) {
     for (int i = 0; i < component.getControlPointCount(); i++) {
-      Point p = component.getControlPoint(i);
+      Point2D p = component.getControlPoint(i);
       if (direction == IComponentTransformer.HORIZONTAL) {
-        component.setControlPoint(new Point(p.x - 2 * (p.x - center.x), p.y), i);
+        component.setControlPoint(new Point2D.Double(p.getX() - 2 * (p.getX() - center.getX()), p.getY()), i);
       } else {
-        component.setControlPoint(new Point(p.x, p.y - 2 * (p.y - center.y)), i);
+        component.setControlPoint(new Point2D.Double(p.getX(), p.getY() - 2 * (p.getY() - center.getY())), i);
       }
     }
   }

diylc/diylc-core/src/org/diylc/core/IDIYComponent.java

@@ -22,7 +22,7 @@
 package org.diylc.core;
 
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.io.Serializable;
 
@@ -89,7 +89,7 @@ public interface IDIYComponent<T> extends Serializable, Cloneable {
    * @param index
    * @return control point at the specified index.
    */
-  Point getControlPoint(int index);
+  Point2D getControlPoint(int index);
 
   /**
    * Updates the control point at the specified index.
@@ -97,7 +97,7 @@ public interface IDIYComponent<T> extends Serializable, Cloneable {
    * @param point
    * @param index
    */
-  void setControlPoint(Point point, int index);
+  void setControlPoint(Point2D point, int index);
 
   /**
    * @param index

diylc/diylc-core/src/org/diylc/core/Template.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.core;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.util.List;
 import java.util.Map;
 
@@ -29,7 +29,7 @@ public class Template {
 
   private String name;
   private Map<String, Object> values;
-  private List<Point> points;
+  private List<Point2D> points;
   @SuppressWarnings("unused")
   @Deprecated
   private boolean defaultFlag;
@@ -37,7 +37,7 @@ public class Template {
   public Template() {    
   }
 
-  public Template(String name, Map<String, Object> values, List<Point> points) {    
+  public Template(String name, Map<String, Object> values, List<Point2D> points) {    
     this.name = name;
     this.values = values;
     this.points = points;
@@ -59,11 +59,11 @@ public class Template {
     this.values = values;
   }
 
-  public List<Point> getPoints() {
+  public List<Point2D> getPoints() {
     return points;
   }
 
-  public void setPoints(List<Point> points) {
+  public void setPoints(List<Point2D> points) {
     this.points = points;
   }
 

diylc/diylc-core/src/org/diylc/presenter/CalcUtils.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.presenter;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -37,18 +37,18 @@ public class CalcUtils {
    * @param x
    * @return
    */
-  public static int roundToGrid(double x, Size gridSpacing) {
+  public static double roundToGrid(double x, Size gridSpacing) {
     double grid = gridSpacing.convertToPixels();
-    return (int) Math.round((Math.round(1f * x / grid) * grid));
+    return (Math.round(1f * x / grid) * grid);
   }
 
-  public static void snapPointToGrid(Point point, Size gridSpacing) {
+  public static void snapPointToGrid(Point2D point, Size gridSpacing) {
-    int x = roundToGrid(point.x, gridSpacing);
+    double x = roundToGrid(point.getX(), gridSpacing);
-    int y = roundToGrid(point.y, gridSpacing);
+    double y = roundToGrid(point.getY(), gridSpacing);
     point.setLocation(x, y);
   }
   
-  public static void snapPointToObjects(Point point, Size gridSpacing, IDIYComponent<?> component, List<IDIYComponent<?>> components) {
+  public static void snapPointToObjects(Point2D point, Size gridSpacing, IDIYComponent<?> component, List<IDIYComponent<?>> components) {
     for (IDIYComponent<?> c : components) {
       if (c == component)
         continue;

diylc/diylc-core/src/org/diylc/presenter/DrawingCache.java

@@ -18,8 +18,8 @@
 package org.diylc.presenter;
 
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 import java.util.HashMap;
@@ -93,7 +93,7 @@ public class DrawingCache {
 
     if (type != null && type.getEnableCache()) {
       // if we need to apply caching
-      Point firstPoint = component.getControlPoint(0);
+      Point2D firstPoint = component.getControlPoint(0);
       
       CacheValue value = renderAndCache(component, g2d, componentState, outlineMode, project, zoom);     
       
@@ -107,8 +107,8 @@ public class DrawingCache {
         }
         try {
           // draw cached image
-          g2d.getCanvasGraphics().drawImage(value.getImage(), (int) ((firstPoint.x - value.getDx()) * zoom),
+          g2d.getCanvasGraphics().drawImage(value.getImage(), (int) ((firstPoint.getX() - value.getDx()) * zoom),
-              (int) ((firstPoint.y - value.getDy())* zoom), null);
+              (int) ((firstPoint.getY() - value.getDy())* zoom), null);
         } finally {
           if (Math.abs(1.0 - zoom) > 1e-4) {
             g2d.getCanvasGraphics().scale(zoom, zoom);
@@ -157,7 +157,7 @@ public class DrawingCache {
   private CacheValue renderAndCache(IDIYComponent<?> component, G2DWrapper g2d, ComponentState componentState,
       boolean outlineMode, Project project, double zoom) {
     // if we need to apply caching
-    Point firstPoint = component.getControlPoint(0);
+    Point2D firstPoint = component.getControlPoint(0);
 
     // cache hit!
     CacheValue value = null;
@@ -172,8 +172,8 @@ public class DrawingCache {
       int width = (int)Math.round(rect.getWidth() * zoom);
       int height = (int)Math.round(rect.getHeight() * zoom);
       // calculate the position of the first point relative to the caching bounds
-      int dx = (int) (firstPoint.x - rect.getX());
+      int dx = (int) (firstPoint.getX() - rect.getX());
-      int dy = (int) (firstPoint.y - rect.getY());
+      int dy = (int) (firstPoint.getY() - rect.getY());
       
       // create image
       BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
@@ -191,7 +191,7 @@ public class DrawingCache {
         cg2d.scale(zoom, zoom);
       }
       // translate to make the top-left corner of the component match (0, 0)
-      cg2d.translate(-firstPoint.x + dx, -firstPoint.y + dy);
+      cg2d.translate(-firstPoint.getX() + dx, -firstPoint.getY() + dy);
       
       // wrap the graphics so we can track
       G2DWrapper wrapper = new G2DWrapper(cg2d, zoom);

diylc/diylc-core/src/org/diylc/presenter/DrawingManager.java

@@ -29,6 +29,7 @@ import java.awt.RenderingHints;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -155,7 +156,7 @@ public class DrawingManager {
    */
   public List<IDIYComponent<?>> drawProject(Graphics2D g2d, Project project, Set<DrawOption> drawOptions,
       IComponentFilter filter, Rectangle selectionRect, Collection<IDIYComponent<?>> selectedComponents,
-      Set<IDIYComponent<?>> lockedComponents, Set<IDIYComponent<?>> groupedComponents, List<Point> controlPointSlot,
+      Set<IDIYComponent<?>> lockedComponents, Set<IDIYComponent<?>> groupedComponents, List<Point2D> controlPointSlot,
       List<IDIYComponent<?>> componentSlot, boolean dragInProgress, Double externalZoom, Rectangle2D visibleRect) {
     long totalStartTime = System.nanoTime();
     failedComponents.clear();
@@ -370,9 +371,9 @@ public class DrawingManager {
                 .contains(component) && !selectedComponents.contains(component) && component
                   .getControlPointVisibilityPolicy(i) == VisibilityPolicy.ALWAYS))) {
               g2dWrapper.setColor(CONTROL_POINT_COLOR);
-              Point controlPoint = component.getControlPoint(i);
+              Point2D controlPoint = component.getControlPoint(i);
               int pointSize = CONTROL_POINT_SIZE - 2;
-              g2dWrapper.fillOval(controlPoint.x - pointSize / 2, controlPoint.y - pointSize / 2, pointSize, pointSize);
+              g2dWrapper.fillOval((int)(controlPoint.getX() - pointSize / 2), (int)(controlPoint.getY() - pointSize / 2), pointSize, pointSize);
             }
           }
         }
@@ -384,14 +385,14 @@ public class DrawingManager {
               && (component.getControlPointVisibilityPolicy(i) == VisibilityPolicy.WHEN_SELECTED || component
                   .getControlPointVisibilityPolicy(i) == VisibilityPolicy.ALWAYS)) {
 
-            Point controlPoint = component.getControlPoint(i);
+            Point2D controlPoint = component.getControlPoint(i);
             int pointSize = CONTROL_POINT_SIZE;
 
             g2dWrapper.setColor(SELECTED_CONTROL_POINT_COLOR.darker());
-            g2dWrapper.fillOval(controlPoint.x - pointSize / 2, controlPoint.y - pointSize / 2, pointSize, pointSize);
+            g2dWrapper.fillOval((int)(controlPoint.getX() - pointSize / 2), (int)(controlPoint.getY() - pointSize / 2), pointSize, pointSize);
             g2dWrapper.setColor(SELECTED_CONTROL_POINT_COLOR);
-            g2dWrapper.fillOval(controlPoint.x - CONTROL_POINT_SIZE / 2 + 1, controlPoint.y - CONTROL_POINT_SIZE / 2
+            g2dWrapper.fillOval((int)(controlPoint.getX() - CONTROL_POINT_SIZE / 2 + 1), (int)(controlPoint.getY() - CONTROL_POINT_SIZE / 2
-                + 1, CONTROL_POINT_SIZE - 2, CONTROL_POINT_SIZE - 2);
+                + 1), CONTROL_POINT_SIZE - 2, CONTROL_POINT_SIZE - 2);
           }
         }
       }
@@ -417,13 +418,13 @@ public class DrawingManager {
 
     // Draw control points of the component in the slot.
     if (controlPointSlot != null) {
-      for (Point point : controlPointSlot) {
+      for (Point2D point : controlPointSlot) {
         if (point != null) {
           g2dWrapper.setColor(SELECTED_CONTROL_POINT_COLOR.darker());
-          g2dWrapper.fillOval(point.x - CONTROL_POINT_SIZE / 2, point.y - CONTROL_POINT_SIZE / 2, CONTROL_POINT_SIZE,
+          g2dWrapper.fillOval((int)(point.getX() - CONTROL_POINT_SIZE / 2), (int)(point.getY() - CONTROL_POINT_SIZE / 2), CONTROL_POINT_SIZE,
               CONTROL_POINT_SIZE);
           g2dWrapper.setColor(SELECTED_CONTROL_POINT_COLOR);
-          g2dWrapper.fillOval(point.x - CONTROL_POINT_SIZE / 2 + 1, point.y - CONTROL_POINT_SIZE / 2 + 1,
+          g2dWrapper.fillOval((int)(point.getX() - CONTROL_POINT_SIZE / 2 + 1), (int)(point.getY() - CONTROL_POINT_SIZE / 2 + 1),
               CONTROL_POINT_SIZE - 2, CONTROL_POINT_SIZE - 2);
         }
       }
@@ -539,7 +540,7 @@ public class DrawingManager {
     continuityAreaCache = null;
   }
 
-  public List<IDIYComponent<?>> findComponentsAt(Point point, Project project) {
+  public List<IDIYComponent<?>> findComponentsAt(Point2D point, Project project) {
     List<IDIYComponent<?>> components = new ArrayList<IDIYComponent<?>>();
     for (int i = 0; i < project.getComponents().size(); i++) {
       ComponentArea area = componentAreaMap.get(project.getComponents().get(i));
@@ -588,7 +589,7 @@ public class DrawingManager {
     messageDispatcher.dispatchMessage(EventType.REPAINT);
   }
   
-  public void findContinuityAreaAtPoint(Project project, Point p) {
+  public void findContinuityAreaAtPoint(Project project, Point2D p) {
     if (continuityAreaCache == null)
       continuityAreaCache = getContinuityAreas(project);
 

diylc/diylc-core/src/org/diylc/presenter/InstantiationManager.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.presenter;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -60,8 +60,8 @@ public class InstantiationManager {
   private ComponentType componentTypeSlot;
   private Template template;
   private List<IDIYComponent<?>> componentSlot;
-  private Point firstControlPoint;
+  private Point2D firstControlPoint;
-  private Point potentialControlPoint;
+  private Point2D potentialControlPoint;
 
   public static final ComponentType clipboardType = new ComponentType("Clipboard contents",
       "Components from the clipboard", CreationMethod.SINGLE_CLICK, "Multi", "", "", null, null, 0, false, null,
@@ -84,15 +84,15 @@ public class InstantiationManager {
     return componentSlot;
   }
 
-  public Point getFirstControlPoint() {
+  public Point2D getFirstControlPoint() {
     return firstControlPoint;
   }
 
-  public Point getPotentialControlPoint() {
+  public Point2D getPotentialControlPoint() {
     return potentialControlPoint;
   }
   
-  public void setPotentialControlPoint(Point potentialControlPoint) {
+  public void setPotentialControlPoint(Point2D potentialControlPoint) {
 	this.potentialControlPoint = potentialControlPoint;
 }
 
@@ -105,10 +105,10 @@ public class InstantiationManager {
     } else {
       switch (componentTypeSlot.getCreationMethod()) {
         case POINT_BY_POINT:
-          this.componentSlot = forceInstatiate ? instantiateComponent(componentTypeSlot, template, new Point(0, 0), currentProject) : null;
+          this.componentSlot = forceInstatiate ? instantiateComponent(componentTypeSlot, template, new Point2D.Double(0, 0), currentProject) : null;
           break;
         case SINGLE_CLICK:
-          this.componentSlot = instantiateComponent(componentTypeSlot, template, new Point(0, 0), currentProject);
+          this.componentSlot = instantiateComponent(componentTypeSlot, template, new Point2D.Double(0, 0), currentProject);
           break;
       }
     }
@@ -116,7 +116,7 @@ public class InstantiationManager {
     this.potentialControlPoint = null;
   }
 
-  public void instatiatePointByPoint(Point scaledPoint, Project currentProject) throws Exception {
+  public void instatiatePointByPoint(Point2D scaledPoint, Project currentProject) throws Exception {
     firstControlPoint = scaledPoint;
     componentSlot = instantiateComponent(componentTypeSlot, template, firstControlPoint, currentProject);
 
@@ -132,7 +132,7 @@ public class InstantiationManager {
    * @param scaledPoint
    * @return true, if any change is made
    */
-  public boolean updatePointByPoint(Point scaledPoint) {
+  public boolean updatePointByPoint(Point2D scaledPoint) {
     boolean changeMade = !scaledPoint.equals(potentialControlPoint);
     potentialControlPoint = scaledPoint;
     if (componentSlot != null && !componentSlot.isEmpty()) {
@@ -142,14 +142,14 @@ public class InstantiationManager {
   }
 
   @SuppressWarnings("unchecked")
-  public void pasteComponents(Collection<IDIYComponent<?>> components, Point scaledPoint, boolean snapToGrid,
+  public void pasteComponents(Collection<IDIYComponent<?>> components, Point2D scaledPoint, boolean snapToGrid,
       Size gridSpacing, boolean autoGroup, Project currentProject, boolean assignNewNames) {	  
     // Adjust location of components so they are centered under the mouse
     // cursor
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
     
     Set<String> existingNames = new HashSet<String>();
     for (IDIYComponent<?> c : currentProject.getComponents())
@@ -169,32 +169,32 @@ public class InstantiationManager {
       }
       
       for (int i = 0; i < component.getControlPointCount(); i++) {        
-        Point p = component.getControlPoint(i);
+        Point2D p = component.getControlPoint(i);
-        if (p.x > maxX) {
+        if (p.getX() > maxX) {
-          maxX = p.x;
+          maxX = p.getX();
         }
-        if (p.x < minX) {
+        if (p.getX() < minX) {
-          minX = p.x;
+          minX = p.getX();
         }
-        if (p.y > maxY) {
+        if (p.getY() > maxY) {
-          maxY = p.y;
+          maxY = p.getY();
         }
-        if (p.y < minY) {
+        if (p.getY() < minY) {
-          minY = p.y;
+          minY = p.getY();
         }
       }
     }
-    int x = minX;
+    double x = minX;
-    int y = minY;
+    double y = minY;
     if (snapToGrid) {
       x = CalcUtils.roundToGrid(x, gridSpacing);
       x = CalcUtils.roundToGrid(x, gridSpacing);
     }
     for (IDIYComponent<?> component : components) {
       for (int i = 0; i < component.getControlPointCount(); i++) {
-        Point p = component.getControlPoint(i);
+        Point2D p = component.getControlPoint(i);
-        p.translate(-x, -y);
+        Point2D newP = new Point2D.Double(p.getX() - x, p.getY() - y);        
-        component.setControlPoint(p, i);
+        component.setControlPoint(newP, i);
       }
     }
 
@@ -206,7 +206,7 @@ public class InstantiationManager {
     this.componentTypeSlot = autoGroup ? blockType : clipboardType;
 
     if (snapToGrid) {
-      scaledPoint = new Point(scaledPoint);
+      scaledPoint = new Point2D.Double(scaledPoint.getX(), scaledPoint.getY());
       CalcUtils.snapPointToGrid(scaledPoint, gridSpacing);
     }
     // Update the location according to mouse location
@@ -221,15 +221,15 @@ public class InstantiationManager {
    * @param gridSpacing
    * @return true if we need to refresh the canvas
    */
-  public boolean updateSingleClick(Point scaledPoint, boolean snapToGrid, Size gridSpacing) {
+  public boolean updateSingleClick(Point2D scaledPoint, boolean snapToGrid, Size gridSpacing) {
     if (potentialControlPoint == null) {
-      potentialControlPoint = new Point(0, 0);
+      potentialControlPoint = new Point2D.Double(0, 0);
     }
     if (scaledPoint == null) {
-      scaledPoint = new Point(0, 0);
+      scaledPoint = new Point2D.Double(0, 0);
     }
-    int dx = scaledPoint.x - potentialControlPoint.x;
+    double dx = scaledPoint.getX() - potentialControlPoint.getX();
-    int dy = scaledPoint.y - potentialControlPoint.y;
+    double dy = scaledPoint.getY() - potentialControlPoint.getY();
     if (snapToGrid) {
       dx = CalcUtils.roundToGrid(dx, gridSpacing);
       dy = CalcUtils.roundToGrid(dy, gridSpacing);
@@ -238,15 +238,15 @@ public class InstantiationManager {
     if (dx == 0 && dy == 0) {
       return false;
     }
-    potentialControlPoint.translate(dx, dy);
+    potentialControlPoint.setLocation(potentialControlPoint.getX() + dx, potentialControlPoint.getY() + dy);
     if (componentSlot == null) {
       LOG.error("Component slot should not be null!");
     } else {
-      Point p = new Point();
+      Point2D p = new Point2D.Double();
       for (IDIYComponent<?> component : componentSlot) {
         for (int i = 0; i < component.getControlPointCount(); i++) {
-          p.setLocation(component.getControlPoint(i));
+          Point2D oldP = component.getControlPoint(i);
-          p.translate(dx, dy);
+          p.setLocation(oldP.getX() + dx, oldP.getY() + dy);          
           component.setControlPoint(p, i);
         }
       }
@@ -255,7 +255,7 @@ public class InstantiationManager {
   }
 
   @SuppressWarnings("unchecked")
-  public List<IDIYComponent<?>> instantiateComponent(ComponentType componentType, Template template, Point point,
+  public List<IDIYComponent<?>> instantiateComponent(ComponentType componentType, Template template, Point2D point,
       Project currentProject) throws InstantiationException, IllegalAccessException {
     LOG.info("Instatiating component of type: " + componentType.getInstanceClass().getName());
 
@@ -267,8 +267,8 @@ public class InstantiationManager {
     // Translate them to the desired location.
     if (point != null) {
       for (int j = 0; j < component.getControlPointCount(); j++) {
-        Point controlPoint = new Point(component.getControlPoint(j));
+        Point2D p = component.getControlPoint(j);
-        controlPoint.translate(point.x, point.y);
+        Point2D controlPoint = new Point2D.Double(p.getX() + point.getX(), p.getY() + point.getY());        
         // snapPointToGrid(controlPoint);
         component.setControlPoint(controlPoint, j);
       }
@@ -388,8 +388,8 @@ public class InstantiationManager {
     if (template != null && template.getPoints() != null
         && template.getPoints().size() >= component.getControlPointCount()) {
       for (int i = 0; i < component.getControlPointCount(); i++) {
-        Point p = new Point(component.getControlPoint(0));
+        Point2D oldP = component.getControlPoint(0);
-        p.translate(template.getPoints().get(i).x, template.getPoints().get(i).y);
+        Point2D p = new Point2D.Double(oldP.getX() + template.getPoints().get(i).getX(), oldP.getY() + template.getPoints().get(i).getY());        
         component.setControlPoint(p, i);
       }
     }

diylc/diylc-core/src/org/diylc/presenter/Presenter.java

@@ -202,10 +202,10 @@ public class Presenter implements IPlugInPort {
   // D&D
   private boolean dragInProgress = false;
   // Previous mouse location, not scaled for zoom factor.
-  private Point previousDragPoint = null;
+  private Point2D previousDragPoint = null;
   private Project preDragProject = null;
   private int dragAction;
-  private Point previousScaledPoint;
+  private Point2D previousScaledPoint;
   
   private DIYTest test = null;
 
@@ -246,8 +246,8 @@ public class Presenter implements IPlugInPort {
   // IPlugInPort
 
   @Override
-  public Double[] getAvailableZoomLevels() {
+  public java.lang.Double[] getAvailableZoomLevels() {
-    return new Double[] {0.25d, 0.3333d, 0.5d, 0.6667d, 0.75d, 1d, 1.25d, 1.5d, 2d, 2.5d, 3d};
+    return new java.lang.Double[] {0.25d, 0.3333d, 0.5d, 0.6667d, 0.75d, 1d, 1.25d, 1.5d, 2d, 2.5d, 3d};
   }
 
   @Override
@@ -502,7 +502,7 @@ public class Presenter implements IPlugInPort {
   }
 
   @Override
-  public void draw(Graphics2D g2d, Set<DrawOption> drawOptions, final IComponentFilter filter, Double externalZoom, Rectangle2D visibleRect) {
+  public void draw(Graphics2D g2d, Set<DrawOption> drawOptions, final IComponentFilter filter, java.lang.Double externalZoom, Rectangle2D visibleRect) {
     if (currentProject == null) {
       return;
     }
@@ -566,7 +566,7 @@ public class Presenter implements IPlugInPort {
    * 
    * @return
    */
-  public List<IDIYComponent<?>> findComponentsAtScaled(Point point, boolean includeLocked) {
+  public List<IDIYComponent<?>> findComponentsAtScaled(Point2D point, boolean includeLocked) {
     List<IDIYComponent<?>> components = drawingManager.findComponentsAt(point, currentProject);
     Iterator<IDIYComponent<?>> iterator = components.iterator();
     while (iterator.hasNext()) {
@@ -579,8 +579,8 @@ public class Presenter implements IPlugInPort {
   }
 
   @Override
-  public List<IDIYComponent<?>> findComponentsAt(Point point, boolean includeLocked) {
+  public List<IDIYComponent<?>> findComponentsAt(Point2D point, boolean includeLocked) {
-    Point scaledPoint = scalePoint(point);
+    Point2D scaledPoint = scalePoint(point);
     List<IDIYComponent<?>> components = findComponentsAtScaled(scaledPoint, includeLocked);
     return components;
   }
@@ -601,7 +601,7 @@ public class Presenter implements IPlugInPort {
       test.addStep(DIYTest.MOUSE_CLICKED, params);
     }    
       
-    Point scaledPoint = scalePoint(point);
+    Point2D scaledPoint = scalePoint(point);
     if (clickCount >= 2) {
       editSelection();
     } else {
@@ -728,9 +728,9 @@ public class Presenter implements IPlugInPort {
     }
   }
 
-  private void addPendingComponentsToProject(Point scaledPoint, ComponentType componentTypeSlot, Template template) {
+  private void addPendingComponentsToProject(Point2D scaledPoint, ComponentType componentTypeSlot, Template template) {
     List<IDIYComponent<?>> componentSlot = instantiationManager.getComponentSlot();
-    Point firstPoint = componentSlot.get(0).getControlPoint(0);
+    Point2D firstPoint = componentSlot.get(0).getControlPoint(0);
     // don't allow to create component with the same points
     if (scaledPoint == null || scaledPoint.equals(firstPoint))
       return;
@@ -924,7 +924,7 @@ public class Presenter implements IPlugInPort {
       for (int i = currentProject.getComponents().size() - 1; i >= 0; i--) {
         IDIYComponent<?> component = currentProject.getComponents().get(i);
         for (int pointIndex = 0; pointIndex < component.getControlPointCount(); pointIndex++) {
-          Point controlPoint = component.getControlPoint(pointIndex);
+          Point2D controlPoint = component.getControlPoint(pointIndex);
           // Only consider selected components that are not grouped.
           if (selectedComponents.contains(component) && component.canPointMoveFreely(pointIndex)
               && findAllGroupedComponents(component).size() == 1) {
@@ -945,7 +945,7 @@ public class Presenter implements IPlugInPort {
     }
 
     Point2D inPoint =
-        new Point2D.Double(1.0d * previousScaledPoint.x / Constants.PIXELS_PER_INCH, 1.0d * previousScaledPoint.y
+        new Point2D.Double(1.0d * previousScaledPoint.getX() / Constants.PIXELS_PER_INCH, 1.0d * previousScaledPoint.getY()
             / Constants.PIXELS_PER_INCH);
     Point2D mmPoint =
         new Point2D.Double(inPoint.getX() * SizeUnit.in.getFactor() / SizeUnit.cm.getFactor() * 10d, inPoint.getY()
@@ -1123,7 +1123,7 @@ public class Presenter implements IPlugInPort {
     this.dragInProgress = true;
     this.dragAction = dragAction;
     this.preDragProject = currentProject.clone();
-    Point scaledPoint = scalePoint(point);
+    Point2D scaledPoint = scalePoint(point);
     this.previousDragPoint = scaledPoint;
     List<IDIYComponent<?>> components = forceSelectionRect ? null : findComponentsAtScaled(scaledPoint, false);
     if (controlPointMap != null && !this.controlPointMap.isEmpty()) {
@@ -1207,9 +1207,9 @@ public class Presenter implements IPlugInPort {
                 break;
               }
               for (Integer j : entry.getValue()) {
-                Point firstPoint = component.getControlPoint(i);
+                Point2D firstPoint = component.getControlPoint(i);
                 if (entry.getKey().isControlPointSticky(j)) {
-                  Point secondPoint = entry.getKey().getControlPoint(j);
+                  Point2D secondPoint = entry.getKey().getControlPoint(j);
                   // If they are close enough we can consider
                   // them matched.
                   if (firstPoint.distance(secondPoint) < DrawingManager.CONTROL_POINT_SIZE) {
@@ -1278,23 +1278,24 @@ public class Presenter implements IPlugInPort {
     if (point == null || configManager.readBoolean(HIGHLIGHT_CONTINUITY_AREA, false)) {
       return false;
     }
-    Point scaledPoint = scalePoint(point);
+    Point2D scaledPoint = scalePoint(point);
     if (controlPointMap != null && !controlPointMap.isEmpty()) {
       // We're dragging control point(s).
-      int dx = (scaledPoint.x - previousDragPoint.x);
+      int dx = (int) (scaledPoint.getX() - previousDragPoint.getX());
-      int dy = (scaledPoint.y - previousDragPoint.y);
+      int dy = (int) (scaledPoint.getY() - previousDragPoint.getY());
 
-      Point actualD = moveComponents(this.controlPointMap, dx, dy, isSnapToGrid(), isSnapToObjects());
+      Point2D actualD = moveComponents(this.controlPointMap, dx, dy, isSnapToGrid(), isSnapToObjects());
       if (actualD == null)
         return true;
 
-      previousDragPoint.translate(actualD.x, actualD.y);
+      previousDragPoint.setLocation(previousDragPoint.getX() + actualD.getX(), previousDragPoint.getY() + actualD.getY());
     } else if (selectedComponents.isEmpty() && instantiationManager.getComponentTypeSlot() == null
         && previousDragPoint != null) {
       // If there's no selection, the only thing to do is update the
       // selection rectangle and refresh.
       Rectangle oldSelectionRect = selectionRect == null ? null : new Rectangle(selectionRect);
-      this.selectionRect = Utils.createRectangle(scaledPoint, previousDragPoint);
+      this.selectionRect = Utils.createRectangle(new Point((int)scaledPoint.getX(), (int)scaledPoint.getY()), 
+          new Point((int)previousDragPoint.getX(), (int)previousDragPoint.getY()));
       if (selectionRect.equals(oldSelectionRect)) {
         return true;
       }
@@ -1308,11 +1309,11 @@ public class Presenter implements IPlugInPort {
     return true;
   }
 
-  private Point moveComponents(Map<IDIYComponent<?>, Set<Integer>> controlPointMap, int dx, int dy, boolean snapToGrid, boolean snapToObjects) {
+  private Point2D moveComponents(Map<IDIYComponent<?>, Set<Integer>> controlPointMap, int dx, int dy, boolean snapToGrid, boolean snapToObjects) {
     // After we make the transfer and snap to grid, calculate actual dx
     // and dy. We'll use them to translate the previous drag point.
-    int actualDx = 0;
+    double actualDx = 0;
-    int actualDy = 0;
+    double actualDy = 0;
     // For each component, do a simulation of the move to see if any of
     // them will overlap or go out of bounds.
 
@@ -1323,17 +1324,16 @@ public class Presenter implements IPlugInPort {
     if (controlPointMap.size() == 1) {
       Map.Entry<IDIYComponent<?>, Set<Integer>> entry = controlPointMap.entrySet().iterator().next();
 
-      Point firstPoint = entry.getKey().getControlPoint(entry.getValue().toArray(new Integer[] {})[0]);
+      Point2D firstPoint = entry.getKey().getControlPoint(entry.getValue().toArray(new Integer[] {})[0]);
-      Point testPoint = new Point(firstPoint);
+      Point2D testPoint = new Point2D.Double(firstPoint.getX() + dx, firstPoint.getY() + dy);      
-      testPoint.translate(dx, dy);
       if (snapToGrid) {
         CalcUtils.snapPointToGrid(testPoint, currentProject.getGridSpacing());
       } else if (snapToObjects) {
         CalcUtils.snapPointToObjects(testPoint, currentProject.getGridSpacing(), entry.getKey(), currentProject.getComponents());
       }
 
-      actualDx = testPoint.x - firstPoint.x;
+      actualDx = testPoint.getX() - firstPoint.getX();
-      actualDy = testPoint.y - firstPoint.y;
+      actualDy = testPoint.getY() - firstPoint.getY();
     } else if (snapToGrid) {
       actualDx = CalcUtils.roundToGrid(dx, currentProject.getGridSpacing());
       actualDy = CalcUtils.roundToGrid(dy, currentProject.getGridSpacing());
@@ -1350,16 +1350,16 @@ public class Presenter implements IPlugInPort {
     // Validate if moving can be done.
     for (Map.Entry<IDIYComponent<?>, Set<Integer>> entry : controlPointMap.entrySet()) {
       IDIYComponent<?> component = entry.getKey();
-      Point[] controlPoints = new Point[component.getControlPointCount()];
+      Point2D[] controlPoints = new Point2D[component.getControlPointCount()];
       for (int index = 0; index < component.getControlPointCount(); index++) {
-        controlPoints[index] = new Point(component.getControlPoint(index));
+        Point2D p = component.getControlPoint(index);
+        controlPoints[index] = new Point2D.Double(p.getX(), p.getY());
         // When the first point is moved, calculate how much it
         // actually moved after snapping.
         if (entry.getValue().contains(index)) {
-          controlPoints[index].translate(actualDx, actualDy);
+          controlPoints[index].setLocation(controlPoints[index].getX() + actualDx + extraSpace, controlPoints[index].getY() + actualDy + extraSpace);          
-          controlPoints[index].translate((int) extraSpace, (int) extraSpace);
+          if (controlPoints[index].getX() < 0 || controlPoints[index].getY() < 0 || controlPoints[index].getX() > d.width
-          if (controlPoints[index].x < 0 || controlPoints[index].y < 0 || controlPoints[index].x > d.width
+              || controlPoints[index].getY() > d.height) {
-              || controlPoints[index].y > d.height) {
             // At least one control point went out of bounds.
             return null;
           }
@@ -1386,8 +1386,8 @@ public class Presenter implements IPlugInPort {
     for (Map.Entry<IDIYComponent<?>, Set<Integer>> entry : controlPointMap.entrySet()) {
       IDIYComponent<?> c = entry.getKey();      
       for (Integer index : entry.getValue()) {
-        Point p = new Point(c.getControlPoint(index));
+        Point2D oldP = c.getControlPoint(index);
-        p.translate(actualDx, actualDy);
+        Point2D p = new Point2D.Double(oldP.getX() + actualDx, oldP.getY() + actualDy);        
         c.setControlPoint(p, index);
       }
     }
@@ -1396,7 +1396,7 @@ public class Presenter implements IPlugInPort {
     drawingManager.clearComponentAreaMap();
     drawingManager.clearContinuityArea();
     
-    return new Point(actualDx, actualDy);
+    return new Point2D.Double(actualDx, actualDy);
   }
 
   @Override
@@ -1418,7 +1418,7 @@ public class Presenter implements IPlugInPort {
    */
   @SuppressWarnings("unchecked")
   private void rotateComponents(Collection<IDIYComponent<?>> components, int direction, boolean snapToGrid) {
-    Point center = getCenterOf(components, snapToGrid);
+    Point2D center = getCenterOf(components, snapToGrid);
 
     boolean canRotate = true;
     for (IDIYComponent<?> component : selectedComponents) {
@@ -1527,7 +1527,7 @@ public class Presenter implements IPlugInPort {
 
   @SuppressWarnings("unchecked")
   private void mirrorComponents(Collection<IDIYComponent<?>> components, int direction, boolean snapToGrid) {
-    Point center = getCenterOf(components, snapToGrid);
+    Point2D center = getCenterOf(components, snapToGrid);
 
     boolean canMirror = true;
     boolean changesCircuit = false;
@@ -1567,38 +1567,38 @@ public class Presenter implements IPlugInPort {
     drawingManager.clearContinuityArea();
   }
 
-  private Point getCenterOf(Collection<IDIYComponent<?>> components, boolean snapToGrid) {
+  private Point2D getCenterOf(Collection<IDIYComponent<?>> components, boolean snapToGrid) {
     // Determine center of rotation
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
     for (IDIYComponent<?> component : components) {
       for (int i = 0; i < component.getControlPointCount(); i++) {
-        Point p = component.getControlPoint(i);
+        Point2D p = component.getControlPoint(i);
-        if (minX > p.x) {
+        if (minX > p.getX()) {
-          minX = p.x;
+          minX = p.getX();
         }
-        if (maxX < p.x) {
+        if (maxX < p.getX()) {
-          maxX = p.x;
+          maxX = p.getX();
         }
-        if (minY > p.y) {
+        if (minY > p.getY()) {
-          minY = p.y;
+          minY = p.getY();
         }
-        if (maxY < p.y) {
+        if (maxY < p.getY()) {
-          maxY = p.y;
+          maxY = p.getY();
         }
       }
     }
-    int centerX = (maxX + minX) / 2;
+    double centerX = (maxX + minX) / 2;
-    int centerY = (maxY + minY) / 2;
+    double centerY = (maxY + minY) / 2;
 
     if (snapToGrid) {
       CalcUtils.roundToGrid(centerX, this.currentProject.getGridSpacing());
       CalcUtils.roundToGrid(centerY, this.currentProject.getGridSpacing());
     }
 
-    return new Point(centerX, centerY);
+    return new Point2D.Double(centerX, centerY);
   }
 
   @Override
@@ -1613,7 +1613,7 @@ public class Presenter implements IPlugInPort {
       test.addStep(DIYTest.DRAG_END, params);
     }
 
-    Point scaledPoint = scalePoint(point);
+    Point2D scaledPoint = scalePoint(point);
 
     if (!dragInProgress && instantiationManager.getComponentSlot() == null) {
       return;
@@ -1623,7 +1623,8 @@ public class Presenter implements IPlugInPort {
       // If there's no selection finalize selectionRect and see which
       // components intersect with it.
       if (scaledPoint != null) {
-        this.selectionRect = Utils.createRectangle(scaledPoint, previousDragPoint);
+        this.selectionRect = Utils.createRectangle(new Point((int)scaledPoint.getX(), (int)scaledPoint.getY()), 
+            new Point((int)previousDragPoint.getX(), (int)previousDragPoint.getY()));;
       }
       List<IDIYComponent<?>> newSelection = new ArrayList<IDIYComponent<?>>();
       if (!configManager.readBoolean(HIGHLIGHT_CONTINUITY_AREA, false))
@@ -1691,8 +1692,8 @@ public class Presenter implements IPlugInPort {
         cloned.setName(instantiationManager.createUniqueName(componentType, currentProject.getComponents()));
         newSelection.add(cloned);
         for (int i = 0; i < component.getControlPointCount(); i++) {
-          Point p = component.getControlPoint(i);
+          Point2D p = component.getControlPoint(i);
-          Point newPoint = new Point(p.x + grid, p.y + grid);
+          Point2D newPoint = new Point2D.Double(p.getX() + grid, p.getY() + grid);
           cloned.setControlPoint(newPoint, i);
         }
         currentProject.getComponents().add(cloned);
@@ -2500,16 +2501,17 @@ public class Presenter implements IPlugInPort {
       } catch (Exception e) {
       }
     }
-    List<Point> points = new ArrayList<Point>();
+    List<Point2D> points = new ArrayList<Point2D>();
 
     for (int i = 0; i < component.getControlPointCount(); i++) {
-      Point p = new Point(component.getControlPoint(i));
+      Point2D oldP = component.getControlPoint(i);
+      Point2D p = new Point2D.Double(oldP.getX(), oldP.getY());
       points.add(p);
     }
-    int x = points.iterator().next().x;
+    double x = points.iterator().next().getX();
-    int y = points.iterator().next().y;
+    double y = points.iterator().next().getY();
-    for (Point point : points) {
+    for (Point2D point : points) {
-      point.translate(-x, -y);
+      point.setLocation(point.getX() + x, point.getY() + y);
     }
 
     Template template = new Template(variantName, values, points);
@@ -2853,14 +2855,14 @@ public class Presenter implements IPlugInPort {
    * @param point
    * @return
    */
-  private Point scalePoint(Point point) {
+  private Point2D scalePoint(Point2D point) {
-    Point p =
+    Point2D p =
-        point == null ? null : new Point((int) (point.x / drawingManager.getZoomLevel()),
+        point == null ? null : new Point2D.Double(point.getX() / drawingManager.getZoomLevel(),
-            (int) (point.y / drawingManager.getZoomLevel()));
+            point.getY() / drawingManager.getZoomLevel());
 
     if (p != null && configManager.readBoolean(EXTRA_SPACE_KEY, true)) {
       double extraSpace = drawingManager.getExtraSpace(currentProject);
-      p.translate((int) (-extraSpace), (int) (-extraSpace));
+      p.setLocation(p.getX() - extraSpace, p.getY() - extraSpace);      
     }
     return p;
   }

diylc/diylc-core/src/org/diylc/presenter/update.xml

@@ -3166,6 +3166,10 @@
 			<releaseDate>2020-09-04 00:00:00.000 CET</releaseDate>
 			<name></name>
 			<changes>
+				<org.diylc.appframework.update.Change>
+					<changeType>IMPROVEMENT</changeType>
+					<description>Improved rendering precision, especially when using metric units</description>
+				</org.diylc.appframework.update.Change>				
 				<org.diylc.appframework.update.Change>
 					<changeType>NEW_FEATURE</changeType>
 					<description>On MacOS the app registers to open .DIY files</description>

diylc/diylc-core/src/org/diylc/serialization/AreaConverter.java

@@ -21,7 +21,6 @@
 */
 package org.diylc.serialization;
 
-import java.awt.Point;
 import java.awt.geom.Area;
 import java.awt.geom.Path2D;
 import java.awt.geom.PathIterator;
@@ -35,7 +34,7 @@ import com.thoughtworks.xstream.io.HierarchicalStreamReader;
 import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
 
 /**
- * Serializes {@link Point} objects by converting coordinates from pixels to inches, thus avoiding
+ * Serializes {@link Area} objects by converting coordinates from pixels to inches, thus avoiding
  * the resolution to affect point placement.
  * 
  * @author Branislav Stojkovic

diylc/diylc-core/src/org/diylc/serialization/PointConverter.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.serialization;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.utils.Constants;
 
@@ -32,7 +32,7 @@ import com.thoughtworks.xstream.io.HierarchicalStreamReader;
 import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
 
 /**
- * Serializes {@link Point} objects by converting coordinates from pixels to inches, thus avoiding
+ * Serializes {@link Point2D} objects by converting coordinates from pixels to inches, thus avoiding
  * the resolution to affect point placement.
  * 
  * @author Branislav Stojkovic
@@ -41,21 +41,21 @@ public class PointConverter implements Converter {
 
   @Override
   public void marshal(Object object, HierarchicalStreamWriter writer, MarshallingContext context) {
-    Point point = (Point) object;
+    Point2D point = (Point2D) object;
-    writer.addAttribute("x", Double.toString(1d * point.x / Constants.PIXELS_PER_INCH));
+    writer.addAttribute("x", Double.toString(1d * point.getX() / Constants.PIXELS_PER_INCH));
-    writer.addAttribute("y", Double.toString(1d * point.y / Constants.PIXELS_PER_INCH));
+    writer.addAttribute("y", Double.toString(1d * point.getY() / Constants.PIXELS_PER_INCH));
   }
 
   @Override
   public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
     double x = Double.parseDouble(reader.getAttribute("x"));
     double y = Double.parseDouble(reader.getAttribute("y"));
-    return new Point((int) Math.round(x * Constants.PIXELS_PER_INCH), (int) Math.round(y * Constants.PIXELS_PER_INCH));
+    return new Point2D.Double(x * Constants.PIXELS_PER_INCH, y * Constants.PIXELS_PER_INCH);
   }
 
   @SuppressWarnings("rawtypes")
   @Override
   public boolean canConvert(Class clazz) {
-    return Point.class.isAssignableFrom(clazz);
+    return Point2D.class.isAssignableFrom(clazz);
   }
 }

diylc/diylc-core/src/org/diylc/serialization/ProjectFileManager.java

@@ -97,7 +97,7 @@ public class ProjectFileManager {
       }
     };
     xStream.autodetectAnnotations(true);
-    xStream.alias("point", java.awt.Point.class);
+    xStream.alias("point", java.awt.geom.Point2D.class);
     xStream.alias("font", java.awt.Font.class);
     xStream.alias("project", Project.class);
     xStream.aliasPackage("diylc", "org.diylc.components");
@@ -107,7 +107,7 @@ public class ProjectFileManager {
     xStream.registerConverter(new MeasureConverter());
     xStream.registerConverter(new AreaConverter());
     xStream.addImmutableType(Color.class);
-    xStream.addImmutableType(java.awt.Point.class);
+    xStream.addImmutableType(java.awt.geom.Point2D.class);
     xStream.addImmutableType(org.diylc.core.measures.Voltage.class);
     xStream.addImmutableType(org.diylc.core.measures.Resistance.class);
     xStream.addImmutableType(org.diylc.core.measures.Capacitance.class);

diylc/diylc-core/test/org/diylc/presenter/CalcUtilsTest.java

@@ -0,0 +1,25 @@
+package org.diylc.presenter;
+
+import static org.junit.Assert.assertTrue;
+
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+import org.junit.Test;
+
+public class CalcUtilsTest {
+
+  @Test
+  public void TestRoundToGrid() {
+    Size spacing = new Size(1d, SizeUnit.mm);
+    int value = 5;
+    double s = spacing.convertToPixels();
+    double targetPrev = (value - 1) * s;
+    double target = value * s;
+    double targetNext = (value + 1) * s;
+    for (int i = -100; i <= 100; i++) {
+      double rounded = CalcUtils.roundToGrid(target + i / 100.0 * s, spacing);
+      double expected = i < -50 ? targetPrev : (i >= 50 ? targetNext : target);
+      assertTrue("Failed at " + i + " rounded = " + rounded + "; expected = " + expected, Math.abs(rounded - expected) < 1e-10);
+    }
+  }
+}

diylc/diylc-core/test/org/diylc/testcomponents/MockDIYComponent.java

@@ -24,6 +24,7 @@ package org.diylc.testcomponents;
 import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.components.AbstractComponent;
 import org.diylc.core.ComponentState;
@@ -51,7 +52,7 @@ public class MockDIYComponent extends AbstractComponent<Capacitance> {
   private Resistance r = new Resistance(123d, ResistanceUnit.K);
   private Size s = new Size(1d, SizeUnit.cm);
   private Color color = Color.green;
-  private Point leftTopCorner = new Point(0, 0);
+  private Point2D leftTopCorner = new Point(0, 0);
   private String name = "something";
 
   public MockDIYComponent(String testField, Capacitance c, Resistance r, Size s, Color color, Point leftTopCorner) {
@@ -98,12 +99,12 @@ public class MockDIYComponent extends AbstractComponent<Capacitance> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return leftTopCorner;
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     leftTopCorner.setLocation(point);
   }
 
@@ -157,7 +158,7 @@ public class MockDIYComponent extends AbstractComponent<Capacitance> {
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {
     g2d.setColor(componentState.equals(ComponentState.SELECTED) ? color : color.darker());
-    g2d.fillRect(leftTopCorner.x, leftTopCorner.y, 200, 50);
+    g2d.fillRect((int)leftTopCorner.getX(), (int)leftTopCorner.getY(), 200, 50);
   }
 
   @Override

diylc/diylc-library/src/org/diylc/awt/StringUtils.java

@@ -195,7 +195,7 @@ public class StringUtils {
     return strings;
   }
 
-  public static void drawCenteredText(Graphics2D g2d, String text, int x, int y, HorizontalAlignment horizontalAlignment,
+  public static void drawCenteredText(Graphics2D g2d, String text, double x, double y, HorizontalAlignment horizontalAlignment,
       VerticalAlignment verticalAlignment) {
     String[] parts = text.split("\n");
     if (parts.length > 1) {
@@ -214,7 +214,7 @@ public class StringUtils {
     GlyphVector glyphVector = font.createGlyphVector(renderContext, text);
     Rectangle visualBounds = glyphVector.getVisualBounds().getBounds();
 
-    int textX = 0;
+    double textX = 0;
     switch (horizontalAlignment) {
       case CENTER:
         textX = x - stringBounds.width / 2;
@@ -227,7 +227,7 @@ public class StringUtils {
         break;
     }
 
-    int textY = 0;
+    double textY = 0;
     switch (verticalAlignment) {
       case TOP:
         textY = y;
@@ -240,6 +240,6 @@ public class StringUtils {
         break;
     }
 
-    g2d.drawString(text, textX, textY);
+    g2d.drawString(text, (int)Math.round(textX), (int)Math.round(textY));
   }
 }

diylc/diylc-library/src/org/diylc/components/Abstract3LegSymbol.java

@@ -24,10 +24,10 @@ package org.diylc.components;
 import java.awt.Color;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -57,7 +57,7 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
   public static Color COLOR = Color.black;
   
   protected String value = "";
-  protected Point[] controlPoints = new Point[] { new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0) };
+  protected Point2D[] controlPoints = new Point2D[] { new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0) };
   protected Color color = COLOR;
   protected SymbolFlipping flip = SymbolFlipping.NONE;
   protected Display display = Display.NAME;
@@ -71,17 +71,17 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
     controlPoints[3] = getDefaultLabelPosition(controlPoints);
   }
   
-  public Point[] getControlPoints() {
+  public Point2D[] getControlPoints() {
     if (controlPoints.length == 3) {
-      controlPoints = new Point[] { controlPoints[0], controlPoints[1], controlPoints[2], getDefaultLabelPosition(controlPoints) };
+      controlPoints = new Point2D[] { controlPoints[0], controlPoints[1], controlPoints[2], getDefaultLabelPosition(controlPoints) };
     }
     return controlPoints;
   }
   
-  protected Point getDefaultLabelPosition(Point[] oldControlPoints) {
+  protected Point2D getDefaultLabelPosition(Point2D[] oldControlPoints) {
     int f = flip == SymbolFlipping.X ? -1 : 1;
     int d = flip == SymbolFlipping.X ? (int) PIN_SPACING.convertToPixels() / 2 : 0;
-    return new Point(oldControlPoints[0].x + f * (int) (PIN_SPACING.convertToPixels() * 1.5 + d), oldControlPoints[0].y);
+    return new Point2D.Double(oldControlPoints[0].getX() + f * (PIN_SPACING.convertToPixels() * 1.5 + d), oldControlPoints[0].getY());
   }
 
   @Override
@@ -110,16 +110,16 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
 
     AffineTransform old = g2d.getTransform();
     
-    Point[] controlPoints = getControlPoints();
+    Point2D[] controlPoints = getControlPoints();
 
     if (this.flip == SymbolFlipping.Y) {
-      g2d.translate(0, controlPoints[0].y);
+      g2d.translate(0, controlPoints[0].getY());
       g2d.scale(1, -1);
-      g2d.translate(0, -1 * controlPoints[0].y);
+      g2d.translate(0, -1 * controlPoints[0].getY());
     } else if (this.flip == SymbolFlipping.X) {
-      g2d.translate(controlPoints[0].x, 0);
+      g2d.translate(controlPoints[0].getX(), 0);
       g2d.scale(-1, 1);
-      g2d.translate(-1 * controlPoints[0].x, 0);
+      g2d.translate(-1 * controlPoints[0].getX(), 0);
     }
 
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(2));
@@ -160,7 +160,7 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
     Rectangle shapeRect = body[0].getBounds().union(body[1].getBounds()).union(body[2].getBounds());
     
     if (getMoveLabel()) {
-      StringUtils.drawCenteredText(g2d, label, controlPoints[3].x, controlPoints[3].y, flip == SymbolFlipping.X ? HorizontalAlignment.RIGHT
+      StringUtils.drawCenteredText(g2d, label, controlPoints[3].getX(), controlPoints[3].getY(), flip == SymbolFlipping.X ? HorizontalAlignment.RIGHT
               : HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     } else {
       StringUtils.drawCenteredText(g2d, label, getLabelX(shapeRect, textRect, fontMetrics, outlineMode),
@@ -170,7 +170,7 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return getControlPoints()[index];
   }
 
@@ -179,39 +179,36 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
     return getControlPoints().length;
   }
 
-  protected int getLabelX(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics, boolean outlineMode) {
+  protected double getLabelX(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics, boolean outlineMode) {
     int f = flip == SymbolFlipping.X ? -1 : 1;
     int d = flip == SymbolFlipping.X ? (int) PIN_SPACING.convertToPixels() / 2 : 0;
-    return getControlPoints()[0].x + f * (int) (PIN_SPACING.convertToPixels() * 1.5 + d);
+    return getControlPoints()[0].getX() + f * (int) (PIN_SPACING.convertToPixels() * 1.5 + d);
   }
 
-  protected int getLabelY(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics, boolean outlineMode) {
+  protected double getLabelY(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics, boolean outlineMode) {
-    return getControlPoints()[0].y;
+    return getControlPoints()[0].getY();
   }
 
   protected void updateControlPoints() {
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
-    Point[] controlPoints = getControlPoints();
+    Point2D[] controlPoints = getControlPoints();
         
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
 
     // set default point positions
-    controlPoints[1].x = x +  pinSpacing * 2;
+    controlPoints[1].setLocation(x +  pinSpacing * 2, y - pinSpacing * 2);
-    controlPoints[1].y = y - pinSpacing * 2;
 
-    controlPoints[2].x = x + pinSpacing * 2;
+    controlPoints[2].setLocation(x + pinSpacing * 2, y + pinSpacing * 2);
-    controlPoints[2].y = y + pinSpacing * 2;
     
-    controlPoints[3].x = x + (int) (PIN_SPACING.convertToPixels() * 2);
+    controlPoints[3].setLocation(x + PIN_SPACING.convertToPixels() * 2, y);
-    controlPoints[3].y = y;
     
     // apply rotation if needed
     if (getOrientation() != Orientation.DEFAULT)
     {    
-      Point first = controlPoints[0];
+      Point2D first = controlPoints[0];
       double angle = Double.parseDouble(getOrientation().name().replace("_", ""));
-      AffineTransform rotate = AffineTransform.getRotateInstance(Math.toRadians(angle), first.x, first.y);
+      AffineTransform rotate = AffineTransform.getRotateInstance(Math.toRadians(angle), first.getX(), first.getY());
       for (int i = 1; i < controlPoints.length; i++) {
         rotate.transform(controlPoints[i], controlPoints[i]);
       }
@@ -219,14 +216,14 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
     
     // flip at the end
     if (flip == SymbolFlipping.X) {
-      controlPoints[1].x = controlPoints[0].x - (controlPoints[1].x - controlPoints[0].x);
+      controlPoints[1].setLocation(controlPoints[0].getX() - (controlPoints[1].getX() - controlPoints[0].getX()), controlPoints[1].getY());
-      controlPoints[2].x = controlPoints[0].x - (controlPoints[2].x - controlPoints[0].x);
+      controlPoints[2].setLocation(controlPoints[0].getX() - (controlPoints[2].getX() - controlPoints[0].getX()), controlPoints[2].getY());
-      controlPoints[3].x = controlPoints[0].x - (controlPoints[3].x - controlPoints[0].x);
+      controlPoints[3].setLocation(controlPoints[0].getX() - (controlPoints[3].getX() - controlPoints[0].getX()), controlPoints[3].getY());
     }
     if (flip == SymbolFlipping.Y) {
-      controlPoints[1].y = controlPoints[0].y - (controlPoints[1].y - controlPoints[0].y);
+      controlPoints[1].setLocation(controlPoints[1].getX(), controlPoints[0].getY() - (controlPoints[1].getY() - controlPoints[0].getY()));
-      controlPoints[2].y = controlPoints[0].y - (controlPoints[2].y - controlPoints[0].y);
+      controlPoints[2].setLocation(controlPoints[2].getX(), controlPoints[0].getY() - (controlPoints[2].getY() - controlPoints[0].getY()));
-      controlPoints[3].y = controlPoints[0].y - (controlPoints[3].y - controlPoints[0].y);
+      controlPoints[3].setLocation(controlPoints[3].getX(), controlPoints[0].getY() - (controlPoints[3].getY() - controlPoints[0].getY()));
     }
   }
 
@@ -252,7 +249,7 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     getControlPoints()[index].setLocation(point);
 
     // make sure we have a new drawing
@@ -329,9 +326,9 @@ public abstract class Abstract3LegSymbol extends AbstractComponent<String> {
     if (getOrientation() == Orientation.DEFAULT)
       return;
 
-    Point first = getControlPoints()[0];
+    Point2D first = getControlPoints()[0];
     double angle = Double.parseDouble(getOrientation().name().replace("_", ""));
-    AffineTransform rotate = AffineTransform.getRotateInstance(Math.toRadians(angle), first.x, first.y);
+    AffineTransform rotate = AffineTransform.getRotateInstance(Math.toRadians(angle), first.getX(), first.getY());
     
     if (body != null) {
       for (int i = 0; i < body.length; i++) {

diylc/diylc-library/src/org/diylc/components/AbstractLeadedComponent.java

@@ -32,6 +32,7 @@ import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -73,8 +74,8 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
 
   protected Size length;
   protected Size width;
-  protected Point[] points = new Point[] {new Point((int) (-DEFAULT_SIZE.convertToPixels() / 2), 0),
+  protected Point2D[] points = new Point2D[] {new Point2D.Double(-DEFAULT_SIZE.convertToPixels() / 2, 0),
-      new Point((int) (DEFAULT_SIZE.convertToPixels() / 2), 0), new Point(0, 0)};
+      new Point2D.Double(DEFAULT_SIZE.convertToPixels() / 2, 0), new Point2D.Double(0, 0)};
   protected Color bodyColor = Color.white;
   protected Color borderColor = Color.black;
   protected Color labelColor = LABEL_COLOR;
@@ -85,8 +86,8 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
   protected boolean moveLabel = false;
   
   // parameters for adjusting the label control point
-  protected transient Double gamma = null;
+  protected transient java.lang.Double gamma = null;
-  protected transient Double r = null;
+  protected transient java.lang.Double r = null;
   
   private Boolean hideShortLeads = false;
 
@@ -107,10 +108,10 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     return false;
   }
   
-  protected Point[] getPoints() {
+  protected Point2D[] getPoints() {
     // convert old points to new
     if (points.length == 2) {      
-      points = new Point[] { points[0], points[1], calculateLabelPosition(points[0], points[1]) };
+      points = new Point2D[] { points[0], points[1], calculateLabelPosition(points[0], points[1]) };
       // to make standing components backward compatible and not show a label until the user switches the display to something else
       if (isStanding())
         display = Display.NONE;
@@ -118,10 +119,10 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     return points;
   }
   
-  protected Point calculateLabelPosition(Point point1, Point point2) {
+  protected Point2D calculateLabelPosition(Point2D point1, Point2D point2) {
-    double x = (point1.x + point2.x) / 2.0;
+    double x = (point1.getX() + point2.getX()) / 2.0;
-    double y = (point1.y + point2.y) / 2.0;
+    double y = (point1.getY() + point2.getY()) / 2.0;
-    return new Point((int) x, (int) y);
+    return new Point2D.Double(x, y);
   }
 
   @Override
@@ -129,9 +130,9 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
       IDrawingObserver drawingObserver) {
     if (gamma != null) {
       // recalculate center position and theta, then adjust label point accordingly, while preserving alpha and p
-      double x = (getPoints()[1].x + getPoints()[0].x) / 2.0;
+      double x = (getPoints()[1].getX() + getPoints()[0].getX()) / 2.0;
-      double y = (getPoints()[1].y + getPoints()[0].y) / 2.0;
+      double y = (getPoints()[1].getY() + getPoints()[0].getY()) / 2.0;
-      double theta = Math.atan2(getPoints()[1].y - getPoints()[0].y, getPoints()[1].x - getPoints()[0].x);
+      double theta = Math.atan2(getPoints()[1].getY() - getPoints()[0].getY(), getPoints()[1].getX() - getPoints()[0].getX());
       double beta = gamma - (Math.PI / 2 - theta);
       getPoints()[2].setLocation(x + Math.cos(beta) * r, y + Math.sin(beta) * r);
       gamma = null;
@@ -150,15 +151,15 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     double width;
     double length;
     Rectangle shapeRect;
-    double theta = Math.atan2(getPoints()[1].y - getPoints()[0].y, getPoints()[1].x - getPoints()[0].x);
+    double theta = Math.atan2(getPoints()[1].getY() - getPoints()[0].getY(), getPoints()[1].getX() - getPoints()[0].getX());
     
     if (isStanding()) {
       // When ending points are too close draw the component in standing
       // mode.
       width = length = getClosestOdd(this.width.convertToPixels());      
       Shape body =
-          new Ellipse2D.Double((getFlipStanding() ? getPoints()[1] : getPoints()[0]).x - width / 2,
+          new Ellipse2D.Double((getFlipStanding() ? getPoints()[1] : getPoints()[0]).getX() - width / 2,
-              (getFlipStanding() ? getPoints()[1] : getPoints()[0]).y - width / 2, width, width);
+              (getFlipStanding() ? getPoints()[1] : getPoints()[0]).getY() - width / 2, width, width);
       shapeRect = body.getBounds();
       Composite oldComposite = g2d.getComposite();
       if (alpha < MAX_ALPHA) {
@@ -214,14 +215,14 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
             
             Area leadArea = new Area();
             
-            int endX = (int) (getPoints()[0].x + Math.cos(theta) * leadLength);
+            int endX = (int) (getPoints()[0].getX() + Math.cos(theta) * leadLength);
-            int endY = (int) (getPoints()[0].y + Math.sin(theta) * leadLength);
+            int endY = (int) (getPoints()[0].getY() + Math.sin(theta) * leadLength);
-            Line2D line = new Line2D.Double(getPoints()[0].x, getPoints()[0].y, endX, endY);
+            Line2D line = new Line2D.Double(getPoints()[0].getX(), getPoints()[0].getY(), endX, endY);
             leadArea.add(new Area(leadStroke.createStrokedShape(line)));
             
-            endX = (int) (getPoints()[1].x + Math.cos(theta - Math.PI) * leadLength);
+            endX = (int) (getPoints()[1].getX() + Math.cos(theta - Math.PI) * leadLength);
-            endY = (int) (getPoints()[1].y + Math.sin(theta - Math.PI) * leadLength);
+            endY = (int) (getPoints()[1].getY() + Math.sin(theta - Math.PI) * leadLength);
-            line = new Line2D.Double(getPoints()[1].x, getPoints()[1].y, endX, endY);
+            line = new Line2D.Double(getPoints()[1].getX(), getPoints()[1].getY(), endX, endY);
             leadArea.add(new Area(leadStroke.createStrokedShape(line)));
             
             g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
@@ -247,7 +248,7 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
         width = getWidth().convertToPixels();
         length = getLength().convertToPixels();
       }
-      g2d.translate((getPoints()[0].x + getPoints()[1].x - length) / 2, (getPoints()[0].y + getPoints()[1].y - width) / 2);
+      g2d.translate((getPoints()[0].getX() + getPoints()[1].getX() - length) / 2, (getPoints()[0].getY() + getPoints()[1].getY() - width) / 2);
       g2d.rotate(theta, length / 2, width / 2);
       // Draw body.
       Composite oldComposite = g2d.getComposite();
@@ -317,7 +318,7 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     // Draw label.
     g2d.setFont(project.getFont());
     if (useShapeRectAsPosition()) {
-      g2d.translate(shapeRect.x, shapeRect.y);
+      g2d.translate(shapeRect.getX(), shapeRect.getY());
     }
     Color finalLabelColor;
     if (outlineMode) {
@@ -356,7 +357,7 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     
     if (getMoveLabel()) {
       g2d.setTransform(oldTransform);
-      g2d.translate(getPoints()[2].x, getPoints()[2].y);
+      g2d.translate(getPoints()[2].getX(), getPoints()[2].getY());
       if (getLabelOriantation() != LabelOriantation.Horizontal) {
         g2d.rotate(theta);
       }
@@ -365,8 +366,8 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     } else {
       if (isStanding() || getLabelOriantation() == LabelOriantation.Horizontal) {
         g2d.setTransform(oldTransform);
-        double x = (getPoints()[0].x + getPoints()[1].x - length) / 2.0;
+        double x = (getPoints()[0].getX() + getPoints()[1].getX() - length) / 2.0;
-        double y = (getPoints()[0].y + getPoints()[1].y - width) / 2.0;
+        double y = (getPoints()[0].getY() + getPoints()[1].getY() - width) / 2.0;
         g2d.drawString(label, (int) (x + (length - textRect.getWidth()) / 2 + offset),
             (int)(y + calculateLabelYOffset(shapeRect, textRect, fontMetrics)));
       } else {
@@ -377,7 +378,7 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     }
 //      if (getLabelOriantation() == LabelOriantation.Horizontal) {        
 //
-//        drawCenteredText(g2d, label, getNewPoints()[2].x, getNewPoints()[2].x, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+//        drawCenteredText(g2d, label, getNewPoints()[2].getX(), getNewPoints()[2].getX(), HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
 //        g2d.drawString(label, (int) (x + (length - textRect.getWidth()) / 2 + offset),
 //            (int)(y + calculateLabelYCoordinate(shapeRect, textRect, fontMetrics)));
 //      } else {
@@ -392,13 +393,13 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
   }
 
   private void drawLeads(Graphics2D g2d, double theta, double leadLength) {
-    double endX = getPoints()[0].x + Math.cos(theta) * leadLength;
+    double endX = getPoints()[0].getX() + Math.cos(theta) * leadLength;
-    double endY = getPoints()[0].y + Math.sin(theta) * leadLength;
+    double endY = getPoints()[0].getY() + Math.sin(theta) * leadLength;
-    g2d.draw(new Line2D.Double(getPoints()[0].x, getPoints()[0].y, endX, endY));
+    g2d.draw(new Line2D.Double(getPoints()[0].getX(), getPoints()[0].getY(), endX, endY));
 
-    endX = getPoints()[1].x + Math.cos(theta - Math.PI) * leadLength;
+    endX = getPoints()[1].getX() + Math.cos(theta - Math.PI) * leadLength;
-    endY = getPoints()[1].y + Math.sin(theta - Math.PI) * leadLength;
+    endY = getPoints()[1].getY() + Math.sin(theta - Math.PI) * leadLength;
-    g2d.draw(new Line2D.Double(getPoints()[1].x, getPoints()[1].y, endX, endY));
+    g2d.draw(new Line2D.Double(getPoints()[1].getX(), getPoints()[1].getY(), endX, endY));
   }
 
   private void drawLead(Graphics2D g2d, ComponentState componentState, IDrawingObserver observer, boolean isCopperArea) {
@@ -407,7 +408,7 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
     
     float thickness = getLeadThickness();
     
-    Line2D line = new Line2D.Double(getPoints()[0].x, getPoints()[0].y, getPoints()[1].x, getPoints()[1].y);
+    Line2D line = new Line2D.Double(getPoints()[0].getX(), getPoints()[0].getY(), getPoints()[1].getX(), getPoints()[1].getY());
     
     if (shouldShadeLeads()) {
       // for some reason the stroked line gets approx 1px thicker when converted to shape
@@ -548,8 +549,8 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
-    return (Point) getPoints()[index];
+    return (Point2D) getPoints()[index];
   }
 
   @Override
@@ -568,14 +569,14 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {        
+  public void setControlPoint(Point2D point, int index) {        
     // when moving one of the ending points, try to retain the angle and distance from the center point to label point
     if (index < 2) {
       if (gamma == null) {
-        double x = (getPoints()[1].x + getPoints()[0].x) / 2.0;
+        double x = (getPoints()[1].getX() + getPoints()[0].getX()) / 2.0;
-        double y = (getPoints()[1].y + getPoints()[0].y) / 2.0;
+        double y = (getPoints()[1].getY() + getPoints()[0].getY()) / 2.0;
-        double theta = Math.atan2(getPoints()[1].y - getPoints()[0].y, getPoints()[1].x - getPoints()[0].x);
+        double theta = Math.atan2(getPoints()[1].getY() - getPoints()[0].getY(), getPoints()[1].getX() - getPoints()[0].getX());
-        double beta = Math.atan2(getPoints()[2].y - y, getPoints()[2].x - x);
+        double beta = Math.atan2(getPoints()[2].getY() - y, getPoints()[2].getX() - x);
         gamma = beta + (Math.PI / 2 - theta);
         r = getPoints()[2].distance(x, y);
       }
@@ -699,21 +700,21 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
   
   @Override
   public Rectangle2D getCachingBounds() {
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
-    int margin = (int) Math.max(Math.max(getWidth().convertToPixels(), getLength().convertToPixels()), getLeadThickness());
+    double margin = (int) Math.max(Math.max(getWidth().convertToPixels(), getLength().convertToPixels()), getLeadThickness());
     for (int i = 0; i < getControlPointCount(); i++) {
-      Point p = getControlPoint(i);
+      Point2D p = getControlPoint(i);
-      if (p.x < minX)
+      if (p.getX() < minX)
-        minX = p.x;
+        minX = p.getX();
-      if (p.x > maxX)
+      if (p.getX() > maxX)
-        maxX = p.x;
+        maxX = p.getX();
-      if (p.y < minY)
+      if (p.getY() < minY)
-        minY = p.y;
+        minY = p.getY();
-      if (p.y > maxY)
+      if (p.getY() > maxY)
-        maxY = p.y;
+        maxY = p.getY();
     }
     
     return new Rectangle2D.Double(minX - margin, minY - margin, maxX - minX + 2 * margin, maxY - minY + 2 * margin);

diylc/diylc-library/src/org/diylc/components/AbstractSchematicLeadedSymbol.java

@@ -24,6 +24,7 @@ package org.diylc.components;
 import java.awt.Color;
 import java.awt.FontMetrics;
 import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.common.LabelPosition;
@@ -72,10 +73,10 @@ public abstract class AbstractSchematicLeadedSymbol<T> extends AbstractLeadedCom
   }
   
   @Override
-  protected Point calculateLabelPosition(Point point1, Point point2) {
+  protected Point2D calculateLabelPosition(Point2D point1, Point2D point2) {
-    double x = (point1.x + point2.x) / 2.0;
+    double x = (point1.getX() + point2.getX()) / 2.0;
-    double y = (point1.y + point2.y) / 2.0;
+    double y = (point1.getY() + point2.getY()) / 2.0;
-    double theta = Math.atan2(point2.y - point1.y, point2.x - point2.x) - Math.PI / 2;
+    double theta = Math.atan2(point2.getY() - point1.getY(), point2.getX() - point2.getX()) - Math.PI / 2;
     double r = width.convertToPixels() / 2 + LABEL_FONT.getSize() / 2;
     return new Point((int) (x + Math.cos(theta) * r), (int) (y + Math.sin(theta) * r));
   }

diylc/diylc-library/src/org/diylc/components/RoundedPolygon.java

@@ -21,31 +21,31 @@
 */
 package org.diylc.components;
 
-import java.awt.Point;
 import java.awt.geom.Path2D;
+import java.awt.geom.Point2D;
 
 public class RoundedPolygon extends Path2D.Double {
 
   private static final long serialVersionUID = 1L;
 
-  public RoundedPolygon(Point[] points, double[] radiuses) {
+  public RoundedPolygon(Point2D[] points, double[] radiuses) {
     super();
-    moveTo(points[0].x, points[0].y);
+    moveTo(points[0].getX(), points[0].getY());
     for (int i = 0; i < points.length - 1; i++) {
-      Point first = points[i];
+      Point2D first = points[i];
-      Point second = points[i + 1 >= points.length ? i + 1 - points.length : i + 1];
+      Point2D second = points[i + 1 >= points.length ? i + 1 - points.length : i + 1];
-      Point third = points[i + 2 >= points.length ? i + 2 - points.length : i + 2];
+      Point2D third = points[i + 2 >= points.length ? i + 2 - points.length : i + 2];
       
-      Point p1 = new Point(0, 0);
+      Point2D p1 = new Point2D.Double(0, 0);
-      Point p2 = new Point(0, 0);
+      Point2D p2 = new Point2D.Double(0, 0);
       locateTwoPoints(first, second, third, radiuses.length <= i ? radiuses[radiuses.length - 1] : radiuses[i], p1, p2);
-      lineTo(p1.x, p1.y);
+      lineTo(p1.getX(), p1.getY());
-      quadTo(second.x, second.y, p2.x, p2.y);      
+      quadTo(second.getX(), second.getY(), p2.getX(), p2.getY());      
     }
     closePath();
   }
   
-  private void locateTwoPoints(Point first, Point second, Point third, double radius, Point p1, Point p2) {
+  private void locateTwoPoints(Point2D first, Point2D second, Point2D third, double radius, Point2D p1, Point2D p2) {
     double d1 = distance(first, second);
     double d2 = distance(second, third);
     double t1 = 1 - radius / d1;
@@ -54,11 +54,11 @@ public class RoundedPolygon extends Path2D.Double {
     interpolate(second, third, t2, p2);
   }
   
-  private void interpolate(Point p1, Point p2, double t, Point p) {
+  private void interpolate(Point2D p1, Point2D p2, double t, Point2D p) {
-    p.setLocation((int)Math.round(p1.x * (1-t) + p2.x * t), (int)Math.round(p1.y * (1-t) + p2.y * t));
+    p.setLocation((int)Math.round(p1.getX() * (1-t) + p2.getX() * t), (int)Math.round(p1.getY() * (1-t) + p2.getY() * t));
   }
   
-  private double distance(Point p1, Point p2) {
+  private double distance(Point2D p1, Point2D p2) {
-    return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
+    return Math.sqrt((p1.getX() - p2.getX()) * (p1.getX() - p2.getX()) + (p1.getY() - p2.getY()) * (p1.getY() - p2.getY()));
   }
 }

diylc/diylc-library/src/org/diylc/components/boards/AbstractBoard.java

@@ -26,6 +26,7 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
 import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.awt.StringUtils;
@@ -53,10 +54,10 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
   public static Size DEFAULT_HEIGHT = new Size(1.2d, SizeUnit.in);
 
   protected String value = "";
-  protected Point[] controlPoints = new Point[] {new Point(0, 0),
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0),
-      new Point((int) DEFAULT_WIDTH.convertToPixels(), (int) DEFAULT_HEIGHT.convertToPixels())};
+      new Point2D.Double(DEFAULT_WIDTH.convertToPixels(), DEFAULT_HEIGHT.convertToPixels())};
-  protected Point firstPoint = new Point();
+  protected Point2D firstPoint = new Point2D.Double();
-  protected Point secondPoint = new Point();
+  protected Point2D secondPoint = new Point.Double();
 
   protected Color boardColor = BOARD_COLOR;
   protected Color borderColor = BORDER_COLOR;
@@ -76,7 +77,7 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
       IDrawingObserver drawingObserver) {
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
     
-    Point finalSecondPoint = getFinalSecondPoint();    
+    Point2D finalSecondPoint = getFinalSecondPoint();    
 
     Composite oldComposite = g2d.getComposite();
     // render as transparent when dragging
@@ -85,7 +86,7 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
       g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
     }
     g2d.setColor(boardColor);
-    g2d.fillRect(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x, finalSecondPoint.y - firstPoint.y);
+    g2d.fillRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()), (int)(finalSecondPoint.getY() - firstPoint.getY()));
     g2d.setComposite(oldComposite);
     
     // Do not track any changes that follow because the whole board has been
@@ -93,55 +94,56 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
     drawingObserver.stopTracking();
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : borderColor);
-    g2d.drawRect(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x, finalSecondPoint.y - firstPoint.y);
+    g2d.drawRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()), (int)(finalSecondPoint.getY() - firstPoint.getY()));
   }
   
-  protected Point getFinalSecondPoint() {
+  protected Point2D getFinalSecondPoint() {
-    Point finalSecondPoint;
+    Point2D finalSecondPoint;
     if (getMode() == BoardSizingMode.TwoPoints)
       finalSecondPoint = secondPoint;
     else
-      finalSecondPoint = new Point((int)(firstPoint.x + getLength().convertToPixels()), 
+      finalSecondPoint = new Point2D.Double(firstPoint.getX() + getLength().convertToPixels(), 
-          (int)(firstPoint.y + getWidth().convertToPixels()));
+         firstPoint.getY() + getWidth().convertToPixels());
     return finalSecondPoint;
   }
 
-  protected void drawCoordinates(Graphics2D g2d, int spacing, Project project) {
+  protected void drawCoordinates(Graphics2D g2d, double spacing, Project project) {
     g2d.setColor(coordinateColor);
     g2d.setFont(project.getFont().deriveFont(COORDINATE_FONT_SIZE));
     
     // The half space is used to do rounding when calculating the range.
-    int halfSpace = spacing / 2;
+    double halfSpace = spacing / 2;
     CoordinateOrigin origin = getCoordinateOrigin();
     
-    Point finalSecondPoint = getFinalSecondPoint();
+    Point2D finalSecondPoint = getFinalSecondPoint();
     
     if (getCoordinateDisplay() != CoordinateDisplay.None) {
       int range;
-      int yOffset;
+      double yOffset;
       CoordinateType yType = getyType();
-      Point drawPoint = new Point(firstPoint);
+      double y = firstPoint.getY();
             
       if (origin == CoordinateOrigin.Top_Left || origin == CoordinateOrigin.Top_Right) {
-    	range = (int) ((finalSecondPoint.y - firstPoint.y + halfSpace) / spacing);
+    	range = (int) ((finalSecondPoint.getY() - firstPoint.getY() + halfSpace) / spacing);
     	yOffset = spacing;
       } else {
-    	range = (int) ((finalSecondPoint.y - firstPoint.y + halfSpace) / spacing);
+    	range = (int) ((finalSecondPoint.getY() - firstPoint.getY() + halfSpace) / spacing);
     	yOffset = -spacing;
-    	drawPoint.y = finalSecondPoint.y;
+    	y = finalSecondPoint.getY();
       }
       
       for (int c = 1; c < range; c++) {
     	int xOffset = (yType == CoordinateType.Numbers && c >= 10) || (yType == CoordinateType.Letters && c >= 27) ? 0 : 2;
     	String label = yType == CoordinateType.Letters ? getCoordinateLabel(c) : Integer.toString(c);
     	
-    	drawPoint.y += yOffset;
+    	y += yOffset;
+    	
     	StringUtils.drawCenteredText(g2d, label, 
-    		firstPoint.x + xOffset, drawPoint.y, 
+    		firstPoint.getX() + xOffset, y, 
     		HorizontalAlignment.LEFT, VerticalAlignment.CENTER);
     	if (getCoordinateDisplay() == CoordinateDisplay.Both_Sides) {
     	  StringUtils.drawCenteredText(g2d, label, 
-    	      finalSecondPoint.x - xOffset, drawPoint.y, 
+    	      finalSecondPoint.getX() - xOffset, y, 
     		  HorizontalAlignment.RIGHT, VerticalAlignment.CENTER);
     	}
       }
@@ -149,29 +151,30 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
 
     if (getCoordinateDisplay() != CoordinateDisplay.None) {
       int range;
-      int xOffset;
+      double xOffset;
       CoordinateType xType = getxType();
-      Point drawPoint = new Point(firstPoint);
+      double x = firstPoint.getX();   
       
       if (origin == CoordinateOrigin.Top_Left || origin == CoordinateOrigin.Bottom_Left) {
-        range = (int) ((finalSecondPoint.x - firstPoint.x + halfSpace) / spacing);
+        range = (int) ((finalSecondPoint.getX() - firstPoint.getX() + halfSpace) / spacing);
         xOffset = spacing;
       } else {
-        range = (int) ((finalSecondPoint.x - firstPoint.x + halfSpace) / spacing);
+        range = (int) ((finalSecondPoint.getX() - firstPoint.getX() + halfSpace) / spacing);
         xOffset = -spacing;
-        drawPoint.x = finalSecondPoint.x;
+        x = finalSecondPoint.getX();
       }
       
       for (int c = 1; c < range; c++) {
         String label = xType == CoordinateType.Letters ? getCoordinateLabel(c) : Integer.toString(c);
         
-        drawPoint.x += xOffset;
+        x += xOffset;
+        
         StringUtils.drawCenteredText(g2d, label, 
-            drawPoint.x, firstPoint.y + 2, 
+            x, firstPoint.getY() + 2, 
             HorizontalAlignment.CENTER, VerticalAlignment.BOTTOM);
         if (getCoordinateDisplay() == CoordinateDisplay.Both_Sides) {
           StringUtils.drawCenteredText(g2d, label, 
-              drawPoint.x, (int) (finalSecondPoint.y - COORDINATE_FONT_SIZE), 
+              x, (int) (finalSecondPoint.getY() - COORDINATE_FONT_SIZE), 
               HorizontalAlignment.CENTER, VerticalAlignment.BOTTOM);
         }
       }
@@ -271,7 +274,7 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -286,12 +289,12 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
-    firstPoint.setLocation(Math.min(controlPoints[0].x, controlPoints[1].x),
+    firstPoint.setLocation(Math.min(controlPoints[0].getX(), controlPoints[1].getX()),
-        Math.min(controlPoints[0].y, controlPoints[1].y));
+        Math.min(controlPoints[0].getY(), controlPoints[1].getY()));
-    secondPoint.setLocation(Math.max(controlPoints[0].x, controlPoints[1].x),
+    secondPoint.setLocation(Math.max(controlPoints[0].getX(), controlPoints[1].getX()),
-        Math.max(controlPoints[0].y, controlPoints[1].y));
+        Math.max(controlPoints[0].getY(), controlPoints[1].getY()));
   }
 
   @EditableProperty
@@ -336,9 +339,9 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
   
   @Override
   public Rectangle2D getCachingBounds() {
-    Point finalSecondPoint = getFinalSecondPoint();    
+    Point2D finalSecondPoint = getFinalSecondPoint();    
-    return new Rectangle2D.Double(Math.min(firstPoint.x, finalSecondPoint.x), Math.min(firstPoint.y, finalSecondPoint.y), 
+    return new Rectangle2D.Double(Math.min(firstPoint.getX(), finalSecondPoint.getX()), Math.min(firstPoint.getY(), finalSecondPoint.getY()), 
-        Math.abs(finalSecondPoint.x - firstPoint.x) + 2, Math.abs(finalSecondPoint.y - firstPoint.y) + 2);
+        Math.abs(finalSecondPoint.getX() - firstPoint.getX()) + 2, Math.abs(finalSecondPoint.getY() - firstPoint.getY()) + 2);
   }
 
   public static enum CoordinateType {

diylc/diylc-library/src/org/diylc/components/boards/BlankBoard.java

@@ -25,8 +25,8 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.ObjectCache;
 import org.diylc.common.SimpleComponentTransformer;
@@ -59,11 +59,11 @@ public class BlankBoard extends AbstractBoard {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {    
-    Point finalSecondPoint = getFinalSecondPoint();    
+    Point2D finalSecondPoint = getFinalSecondPoint();    
     
     Shape clip = g2d.getClip();
-    if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, finalSecondPoint.y)
+    if (checkPointsClipped(clip) && !clip.contains(firstPoint.getX(), finalSecondPoint.getY())
-        && !clip.contains(finalSecondPoint.x, firstPoint.y)) {
+        && !clip.contains(finalSecondPoint.getX(), firstPoint.getY())) {
       return;
     }        
 
@@ -75,9 +75,9 @@ public class BlankBoard extends AbstractBoard {
       }
       g2d.setColor(boardColor);
       if (getType() == Type.SQUARE)
-        g2d.fillRect(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x, finalSecondPoint.y - firstPoint.y);
+        g2d.fillRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()), (int)(finalSecondPoint.getY() - firstPoint.getY()));
       else
-        g2d.fillOval(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x, finalSecondPoint.y - firstPoint.y);
+        g2d.fillOval((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()), (int)(finalSecondPoint.getY() - firstPoint.getY()));
       g2d.setComposite(oldComposite);
     }
     // Do not track any changes that follow because the whole board has been
@@ -86,9 +86,9 @@ public class BlankBoard extends AbstractBoard {
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : borderColor);
     if (getType() == Type.SQUARE)
-      g2d.drawRect(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x, finalSecondPoint.y - firstPoint.y);
+      g2d.drawRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()), (int)(finalSecondPoint.getY() - firstPoint.getY()));
     else
-      g2d.drawOval(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x, finalSecondPoint.y - firstPoint.y);
+      g2d.drawOval((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()), (int)(finalSecondPoint.getY() - firstPoint.getY()));
   }
   
   @Override

diylc/diylc-library/src/org/diylc/components/boards/Breadboard.java

@@ -27,6 +27,7 @@ import java.awt.Composite;
 import java.awt.Graphics2D;
 import java.awt.Point;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.awt.StringUtils;
@@ -361,7 +362,7 @@ public class Breadboard extends AbstractComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     if (index == 0)
       this.point.setLocation(point);
   }

diylc/diylc-library/src/org/diylc/components/boards/EyeletBoard.java

@@ -24,8 +24,8 @@ package org.diylc.components.boards;
 import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.SimpleComponentTransformer;
 import org.diylc.core.ComponentState;
@@ -69,11 +69,11 @@ public class EyeletBoard extends AbstractBoard {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {
-    Point finalSecondPoint = getFinalSecondPoint(); 
+    Point2D finalSecondPoint = getFinalSecondPoint(); 
     
     Shape clip = g2d.getClip();
-    if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, finalSecondPoint.y)
+    if (checkPointsClipped(clip) && !clip.contains(firstPoint.getX(), finalSecondPoint.getY())
-        && !clip.contains(finalSecondPoint.x, firstPoint.y)) {
+        && !clip.contains(finalSecondPoint.getX(), firstPoint.getY())) {
       return;
     }
     super.draw(g2d, componentState, outlineMode, project, drawingObserver);
@@ -81,24 +81,25 @@ public class EyeletBoard extends AbstractBoard {
       if (alpha < MAX_ALPHA) {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
-      Point p = new Point(firstPoint);
+      double x = firstPoint.getX();
+      double y = finalSecondPoint.getY();
       int diameter = getClosestOdd((int) EYELET_SIZE.convertToPixels());
       int holeDiameter = getClosestOdd((int) HOLE_SIZE.convertToPixels());
       int spacing = (int) this.spacing.convertToPixels();
 
-      while (p.y < finalSecondPoint.y - spacing) {
+      while (y < finalSecondPoint.getY() - spacing) {
-        p.x = firstPoint.x;
+        x = firstPoint.getX();
-        p.y += spacing;
+        y += spacing;
-        while (p.x < finalSecondPoint.x - spacing - diameter) {
+        while (x < finalSecondPoint.getX() - spacing - diameter) {
-          p.x += spacing;
+          x += spacing;
           g2d.setColor(eyeletColor);
-          g2d.fillOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+          g2d.fillOval((int)(x - diameter / 2), (int)(y - diameter / 2), diameter, diameter);
           g2d.setColor(eyeletColor.darker());
-          g2d.drawOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+          g2d.drawOval((int)(x - diameter / 2), (int)(y - diameter / 2), diameter, diameter);
           g2d.setColor(Constants.CANVAS_COLOR);
-          g2d.fillOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter, holeDiameter);
+          g2d.fillOval((int)(x - holeDiameter / 2), (int)(y - holeDiameter / 2), holeDiameter, holeDiameter);
           g2d.setColor(eyeletColor.darker());
-          g2d.drawOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter, holeDiameter);
+          g2d.drawOval((int)(x - holeDiameter / 2), (int)(y - holeDiameter / 2), holeDiameter, holeDiameter);
         }
       }
       super.drawCoordinates(g2d, spacing, project);

diylc/diylc-library/src/org/diylc/components/boards/MarshallPerfBoard.java

@@ -24,8 +24,8 @@ package org.diylc.components.boards;
 import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.SimpleComponentTransformer;
 import org.diylc.core.ComponentState;
@@ -67,11 +67,11 @@ public class MarshallPerfBoard extends AbstractBoard {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {
-    Point finalSecondPoint = getFinalSecondPoint();
+    Point2D finalSecondPoint = getFinalSecondPoint();
     
     Shape clip = g2d.getClip();
-    if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, finalSecondPoint.y)
+    if (checkPointsClipped(clip) && !clip.contains(firstPoint.getX(), finalSecondPoint.getY())
-        && !clip.contains(finalSecondPoint.x, firstPoint.y)) {
+        && !clip.contains(finalSecondPoint.getX(), firstPoint.getY())) {
       return;
     }
     super.draw(g2d, componentState, outlineMode, project, drawingObserver);
@@ -79,19 +79,20 @@ public class MarshallPerfBoard extends AbstractBoard {
       if (alpha < MAX_ALPHA) {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
-      Point p = new Point(firstPoint);
+      double x = firstPoint.getX();
+      double y = firstPoint.getY();
       int holeDiameter = getClosestOdd((int) HOLE_SIZE.convertToPixels());
-      int spacing = (int) this.spacing.convertToPixels();
+      double spacing = this.spacing.convertToPixels();
 
-      while (p.y < finalSecondPoint.y - spacing) {
+      while (y < finalSecondPoint.getY() - spacing) {
-        p.x = firstPoint.x;
+        x = firstPoint.getX();
-        p.y += spacing;
+        y += spacing;
-        while (p.x < finalSecondPoint.x - spacing - holeDiameter) {
+        while (x < finalSecondPoint.getX() - spacing - holeDiameter) {
-          p.x += spacing;
+          x += spacing;
           g2d.setColor(Constants.CANVAS_COLOR);
-          g2d.fillOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter, holeDiameter);
+          g2d.fillOval((int)(x - holeDiameter / 2), (int)(y - holeDiameter / 2), holeDiameter, holeDiameter);
           g2d.setColor(borderColor);
-          g2d.drawOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter, holeDiameter);
+          g2d.drawOval((int)(x - holeDiameter / 2), (int)(y - holeDiameter / 2), holeDiameter, holeDiameter);
         }
       }
       super.drawCoordinates(g2d, spacing, project);

diylc/diylc-library/src/org/diylc/components/boards/PerfBoard.java

@@ -24,8 +24,8 @@ package org.diylc.components.boards;
 import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.SimpleComponentTransformer;
 import org.diylc.core.ComponentState;
@@ -62,11 +62,11 @@ public class PerfBoard extends AbstractBoard {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {
-    Point finalSecondPoint = getFinalSecondPoint();
+    Point2D finalSecondPoint = getFinalSecondPoint();
     
     Shape clip = g2d.getClip();
-    if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, finalSecondPoint.y)
+    if (checkPointsClipped(clip) && !clip.contains(firstPoint.getX(), finalSecondPoint.getY())
-        && !clip.contains(finalSecondPoint.x, firstPoint.y)) {
+        && !clip.contains(finalSecondPoint.getX(), firstPoint.getY())) {
       return;
     }
     super.draw(g2d, componentState, outlineMode, project, drawingObserver);
@@ -74,24 +74,25 @@ public class PerfBoard extends AbstractBoard {
       if (alpha < MAX_ALPHA) {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
-      Point p = new Point(firstPoint);
+      double x = firstPoint.getX();
+      double y = firstPoint.getY();
       int diameter = getClosestOdd((int) PAD_SIZE.convertToPixels());
       int holeDiameter = getClosestOdd((int) HOLE_SIZE.convertToPixels());
-      int spacing = (int) this.spacing.convertToPixels();
+      double spacing = this.spacing.convertToPixels();
 
-      while (p.y < finalSecondPoint.y - spacing) {
+      while (y < finalSecondPoint.getY() - spacing) {
-        p.x = firstPoint.x;
+        x = firstPoint.getX();
-        p.y += spacing;
+        y += spacing;
-        while (p.x < finalSecondPoint.x - spacing - diameter) {
+        while (x < finalSecondPoint.getX() - spacing - diameter) {
-          p.x += spacing;
+          x += spacing;
           g2d.setColor(padColor);
-          g2d.fillOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+          g2d.fillOval((int)(x - diameter / 2), (int)(y - diameter / 2), diameter, diameter);
           g2d.setColor(padColor.darker());
-          g2d.drawOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+          g2d.drawOval((int)(x - diameter / 2), (int)(y - diameter / 2), diameter, diameter);
           g2d.setColor(Constants.CANVAS_COLOR);
-          g2d.fillOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter, holeDiameter);
+          g2d.fillOval((int)(x - holeDiameter / 2), (int)(y - holeDiameter / 2), holeDiameter, holeDiameter);
           g2d.setColor(padColor.darker());
-          g2d.drawOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter, holeDiameter);
+          g2d.drawOval((int)(x - holeDiameter / 2), (int)(y - holeDiameter / 2), holeDiameter, holeDiameter);
         }
       }
       super.drawCoordinates(g2d, spacing, project);

diylc/diylc-library/src/org/diylc/components/boards/ProtoBoard.java

@@ -25,6 +25,7 @@ import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.Point;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.awt.StringUtils;
@@ -679,7 +680,7 @@ public class ProtoBoard extends AbstractComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     if (index == 0)
       this.point.setLocation(point);
   }

diylc/diylc-library/src/org/diylc/components/boards/TagStrip.java

@@ -28,6 +28,7 @@ import java.awt.Graphics2D;
 import java.awt.Point;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -149,7 +150,7 @@ public class TagStrip extends AbstractTransparentComponent<String> implements IC
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/boards/TerminalStrip.java

@@ -28,6 +28,7 @@ import java.awt.Graphics2D;
 import java.awt.Point;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.RoundRectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -186,7 +187,7 @@ public class TerminalStrip extends AbstractTransparentComponent<String> implemen
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/boards/TriPadBoard.java

@@ -25,8 +25,8 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.OrientationHV;
 import org.diylc.common.SimpleComponentTransformer;
@@ -65,11 +65,11 @@ public class TriPadBoard extends AbstractBoard {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {
-    Point finalSecondPoint = getFinalSecondPoint();
+    Point2D finalSecondPoint = getFinalSecondPoint();
     
     Shape clip = g2d.getClip();
-    if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, finalSecondPoint.y)
+    if (checkPointsClipped(clip) && !clip.contains(firstPoint.getX(), finalSecondPoint.getY())
-        && !clip.contains(finalSecondPoint.x, firstPoint.y)) {
+        && !clip.contains(finalSecondPoint.getX(), firstPoint.getY())) {
       return;
     }
     super.draw(g2d, componentState, outlineMode, project, drawingObserver);
@@ -78,20 +78,21 @@ public class TriPadBoard extends AbstractBoard {
       if (alpha < MAX_ALPHA) {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
-      Point p = new Point(firstPoint);
+      double x = firstPoint.getX();
+      double y = firstPoint.getY();
       int stripSize = getClosestOdd((int) STRIP_SIZE.convertToPixels());
       int holeSize = getClosestOdd((int) HOLE_SIZE.convertToPixels());
-      int spacing = (int) this.spacing.convertToPixels();
+      double spacing = this.spacing.convertToPixels();
 
       if (orientation == OrientationHV.HORIZONTAL) {
-        while (p.y < finalSecondPoint.y - spacing) {
+        while (y < finalSecondPoint.getY() - spacing) {
-          p.x = firstPoint.x;
+          x = firstPoint.getX();
-          p.y += spacing;
+          y += spacing;
 
-          while (p.x + spacing < finalSecondPoint.x) {
+          while (x + spacing < finalSecondPoint.getX()) {
 
-            int remainingSpace = finalSecondPoint.x - p.x;
+            double remainingSpace = finalSecondPoint.getX() - x;
-            int spacesToDraw = stripSpan;
+            double spacesToDraw = stripSpan;
 
             if (remainingSpace < (stripSize + (stripSpan * spacing))) {
               spacesToDraw = (remainingSpace - stripSize) / spacing;
@@ -99,37 +100,37 @@ public class TriPadBoard extends AbstractBoard {
 
             g2d.setColor(stripColor);
             drawingObserver.startTrackingContinuityArea(true);  
-            g2d.fillRect(p.x + spacing - stripSize / 2, p.y - stripSize / 2, spacing * (spacesToDraw - 1) + stripSize,
+            g2d.fillRect((int)(x + spacing - stripSize / 2), (int)(y - stripSize / 2), (int)(spacing * (spacesToDraw - 1) + stripSize),
                 stripSize);
             drawingObserver.stopTrackingContinuityArea();
             g2d.setColor(stripColor.darker());
 
-            g2d.drawRect(p.x + spacing - stripSize / 2, p.y - stripSize / 2, spacing * (spacesToDraw - 1) + stripSize,
+            g2d.drawRect((int)(x + spacing - stripSize / 2), (int)(y - stripSize / 2), (int)(spacing * (spacesToDraw - 1) + stripSize),
                 stripSize);
 
-            p.x += spacing * spacesToDraw;
+            x += spacing * spacesToDraw;
           }
 
           // draw holes
-          p.x = firstPoint.x;
+          x = firstPoint.getX();
 
-          while (p.x < finalSecondPoint.x - spacing - holeSize) {
+          while (x < finalSecondPoint.getX() - spacing - holeSize) {
-            p.x += spacing;
+            x += spacing;
             g2d.setColor(Constants.CANVAS_COLOR);
-            g2d.fillOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.fillOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
             g2d.setColor(stripColor.darker());
-            g2d.drawOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.drawOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
           }
         }
       } else {
-        while (p.x < finalSecondPoint.x - spacing) {
+        while (x < finalSecondPoint.getX() - spacing) {
-          p.x += spacing;
+          x += spacing;
-          p.y = firstPoint.y;
+          y = firstPoint.getY();
 
-          while (p.y + spacing < finalSecondPoint.y) {
+          while (y + spacing < finalSecondPoint.getY()) {
 
-            int remainingSpace = finalSecondPoint.y - p.y;
+            double remainingSpace = finalSecondPoint.getY() - y;
-            int spacesToDraw = stripSpan;
+            double spacesToDraw = stripSpan;
 
             if (remainingSpace < (stripSize + (stripSpan * spacing))) {
               spacesToDraw = (remainingSpace - stripSize) / spacing;
@@ -137,25 +138,25 @@ public class TriPadBoard extends AbstractBoard {
 
             g2d.setColor(stripColor);
             drawingObserver.startTrackingContinuityArea(true);  
-            g2d.fillRect(p.x - stripSize / 2, p.y + spacing - stripSize / 2, stripSize, spacing * (spacesToDraw - 1)
+            g2d.fillRect((int)(x - stripSize / 2), (int)(y + spacing - stripSize / 2), stripSize, (int)(spacing * (spacesToDraw - 1)
-                + stripSize);
+                + stripSize));
             drawingObserver.stopTrackingContinuityArea();
             g2d.setColor(stripColor.darker());
-            g2d.drawRect(p.x - stripSize / 2, p.y + spacing - stripSize / 2, stripSize, spacing * (spacesToDraw - 1)
+            g2d.drawRect((int)(x - stripSize / 2), (int)(y + spacing - stripSize / 2), stripSize, (int)(spacing * (spacesToDraw - 1)
-                + stripSize);
+                + stripSize));
 
-            p.y += spacing * spacesToDraw;
+            y += spacing * spacesToDraw;
           }
 
           // draw holes
-          p.y = firstPoint.y;
+          y = firstPoint.getY();
 
-          while (p.y < finalSecondPoint.y - spacing - holeSize) {
+          while (y < finalSecondPoint.getY() - spacing - holeSize) {
-            p.y += spacing;
+            y += spacing;
             g2d.setColor(Constants.CANVAS_COLOR);
-            g2d.fillOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.fillOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
             g2d.setColor(stripColor.darker());
-            g2d.drawOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.drawOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
           }
         }
       }

diylc/diylc-library/src/org/diylc/components/boards/VeroBoard.java

@@ -25,8 +25,8 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.OrientationHV;
 import org.diylc.common.SimpleComponentTransformer;
@@ -65,11 +65,11 @@ public class VeroBoard extends AbstractBoard {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {
-    Point finalSecondPoint = getFinalSecondPoint();
+    Point2D finalSecondPoint = getFinalSecondPoint();
     
     Shape clip = g2d.getClip();
-    if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, finalSecondPoint.y)
+    if (checkPointsClipped(clip) && !clip.contains(firstPoint.getX(), finalSecondPoint.getY())
-        && !clip.contains(finalSecondPoint.x, firstPoint.y)) {
+        && !clip.contains(finalSecondPoint.getX(), firstPoint.getY())) {
       return;
     }
     super.draw(g2d, componentState, outlineMode, project, drawingObserver);
@@ -78,45 +78,46 @@ public class VeroBoard extends AbstractBoard {
       if (alpha < MAX_ALPHA) {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
-      Point p = new Point(firstPoint);
+      double x = firstPoint.getX();
+      double y = finalSecondPoint.getY();
       int stripSize = getClosestOdd((int) STRIP_SIZE.convertToPixels());
       int holeSize = getClosestOdd((int) HOLE_SIZE.convertToPixels());
       int spacing = (int) this.spacing.convertToPixels();
 
       if (orientation == OrientationHV.HORIZONTAL) {
-        while (p.y < finalSecondPoint.y - spacing) {
+        while (y < finalSecondPoint.getY() - spacing) {
-          p.x = firstPoint.x;
+          x = firstPoint.getX();
-          p.y += spacing;
+          y += spacing;
           g2d.setColor(stripColor);
           drawingObserver.startTrackingContinuityArea(true);          
-          g2d.fillRect(p.x + spacing / 2, p.y - stripSize / 2, finalSecondPoint.x - spacing - p.x, stripSize);
+          g2d.fillRect((int)(x + spacing / 2), (int)(y - stripSize / 2), (int)(finalSecondPoint.getX() - spacing - x), stripSize);
           drawingObserver.stopTrackingContinuityArea();
           g2d.setColor(stripColor.darker());
-          g2d.drawRect(p.x + spacing / 2, p.y - stripSize / 2, finalSecondPoint.x - spacing - p.x, stripSize);
+          g2d.drawRect((int)(x + spacing / 2), (int)(y - stripSize / 2), (int)(finalSecondPoint.getX() - spacing - x), stripSize);
-          while (p.x < finalSecondPoint.x - spacing - holeSize) {
+          while (x < finalSecondPoint.getX() - spacing - holeSize) {
-            p.x += spacing;
+            x += spacing;
             g2d.setColor(Constants.CANVAS_COLOR);
-            g2d.fillOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.fillOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
             g2d.setColor(stripColor.darker());
-            g2d.drawOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.drawOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
           }
         }
       } else {
-        while (p.x < finalSecondPoint.x - spacing) {
+        while (x < finalSecondPoint.getX() - spacing) {
-          p.x += spacing;
+          x += spacing;
-          p.y = firstPoint.y;
+          y = firstPoint.getY();
           g2d.setColor(stripColor);
           drawingObserver.startTrackingContinuityArea(true);
-          g2d.fillRect(p.x - stripSize / 2, p.y + spacing / 2, stripSize, finalSecondPoint.y - spacing - p.y);
+          g2d.fillRect((int)(x - stripSize / 2), (int)(y + spacing / 2), stripSize, (int)(finalSecondPoint.getY() - spacing - y));
           drawingObserver.stopTrackingContinuityArea();
           g2d.setColor(stripColor.darker());
-          g2d.drawRect(p.x - stripSize / 2, p.y + spacing / 2, stripSize, finalSecondPoint.y - spacing - p.y);
+          g2d.drawRect((int)(x - stripSize / 2), (int)(y + spacing / 2), stripSize, (int)(finalSecondPoint.getY() - spacing - y));
-          while (p.y < finalSecondPoint.y - spacing - holeSize) {
+          while (y < finalSecondPoint.getY() - spacing - holeSize) {
-            p.y += spacing;
+            y += spacing;
             g2d.setColor(Constants.CANVAS_COLOR);
-            g2d.fillOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.fillOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
             g2d.setColor(stripColor.darker());
-            g2d.drawOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+            g2d.drawOval((int)(x - holeSize / 2), (int)(y - holeSize / 2), holeSize, holeSize);
           }
         }
       }

diylc/diylc-library/src/org/diylc/components/chassis/ChassisPanel.java

@@ -64,7 +64,7 @@ public class ChassisPanel extends AbstractShape {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
       g2d.setColor(color);
-      g2d.fillRoundRect(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y - firstPoint.y, radius,
+      g2d.fillRoundRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(secondPoint.getX() - firstPoint.getX()), (int)(secondPoint.getY() - firstPoint.getY()), radius,
           radius);
       g2d.setComposite(oldComposite);
     }
@@ -73,7 +73,7 @@ public class ChassisPanel extends AbstractShape {
     drawingObserver.stopTracking();
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : borderColor);
-    g2d.drawRoundRect(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y - firstPoint.y, radius,
+    g2d.drawRoundRect((int)(firstPoint.getX()), (int)(firstPoint.getY()), (int)(secondPoint.getX() - firstPoint.getX()), (int)(secondPoint.getY() - firstPoint.getY()), radius,
         radius);
   }
 

diylc/diylc-library/src/org/diylc/components/chassis/EllipticalCutout.java

@@ -53,7 +53,7 @@ public class EllipticalCutout extends AbstractShape {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
       g2d.setColor(color);
-      g2d.fillOval(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y - firstPoint.y);
+      g2d.fillOval((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(secondPoint.getX() - firstPoint.getX()), (int)(secondPoint.getY() - firstPoint.getY()));
       g2d.setComposite(oldComposite);
     }
     // Do not track any changes that follow because the whole oval has been
@@ -61,7 +61,7 @@ public class EllipticalCutout extends AbstractShape {
     drawingObserver.stopTracking();
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : borderColor);
-    g2d.drawOval(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y - firstPoint.y);
+    g2d.drawOval((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(secondPoint.getX() - firstPoint.getX()), (int)(secondPoint.getY() - firstPoint.getY()));
   }
 
   @Override

diylc/diylc-library/src/org/diylc/components/chassis/PolygonalCutout.java

@@ -22,6 +22,7 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
 import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.util.Arrays;
 
 import org.diylc.common.ObjectCache;
@@ -61,8 +62,8 @@ public class PolygonalCutout extends AbstractShape {
     int[] xPoints = new int[controlPoints.length];
     int[] yPoints = new int[controlPoints.length];
     for (int i = 0; i < controlPoints.length; i++) {
-      xPoints[i] = controlPoints[i].x;
+      xPoints[i] = (int)controlPoints[i].getX();
-      yPoints[i] = controlPoints[i].y;
+      yPoints[i] = (int)controlPoints[i].getY();
     }
 
     Composite oldComposite = g2d.getComposite();
@@ -97,8 +98,8 @@ public class PolygonalCutout extends AbstractShape {
       this.controlPoints[newPointCount - 1] = this.controlPoints[oldPointCount - 1];
       for (int i = oldPointCount - 1; i < newPointCount - 1; i++) {
         this.controlPoints[i] =
-            new Point((this.controlPoints[i - 1].x + this.controlPoints[newPointCount - 1].x) / 2,
+            new Point2D.Double((this.controlPoints[i - 1].getX() + this.controlPoints[newPointCount - 1].getX()) / 2,
-                (this.controlPoints[i - 1].y + this.controlPoints[newPointCount - 1].y) / 2);
+                (this.controlPoints[i - 1].getY() + this.controlPoints[newPointCount - 1].getY()) / 2);
       }
     }
     this.pointCount = pointCount;

diylc/diylc-library/src/org/diylc/components/chassis/RectangularCutout.java

@@ -59,7 +59,7 @@ public class RectangularCutout extends AbstractShape {
         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
       }
       g2d.setColor(color);
-      g2d.fillRoundRect(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y - firstPoint.y, radius,
+      g2d.fillRoundRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(secondPoint.getX() - firstPoint.getX()), (int)(secondPoint.getY() - firstPoint.getY()), radius,
           radius);
       g2d.setComposite(oldComposite);
     }
@@ -68,7 +68,7 @@ public class RectangularCutout extends AbstractShape {
     drawingObserver.stopTracking();
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : borderColor);
-    g2d.drawRoundRect(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y - firstPoint.y, radius,
+    g2d.drawRoundRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(secondPoint.getX() - firstPoint.getX()), (int)(secondPoint.getY() - firstPoint.getY()), radius,
         radius);
   }
 

diylc/diylc-library/src/org/diylc/components/connectivity/CutLine.java

@@ -21,7 +21,7 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.ObjectCache;
 import org.diylc.common.OrientationHV;
@@ -52,7 +52,7 @@ public class CutLine extends AbstractTransparentComponent<Void> {
   private Size width = WIDTH;
   private Size length = LENGTH;
   private Color color = COLOR;
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private OrientationHV orientation = OrientationHV.VERTICAL;
 
   @Override
@@ -70,9 +70,9 @@ public class CutLine extends AbstractTransparentComponent<Void> {
     }
 
     if (getOrientation() == OrientationHV.HORIZONTAL)
-      g2d.drawLine(point.x, point.y, point.x + l, point.y);
+      g2d.drawLine((int)point.getX(), (int)point.getY(), (int)point.getX() + l, (int)point.getY());
     else
-      g2d.drawLine(point.x, point.y, point.x, point.y + l);
+      g2d.drawLine((int)point.getX(), (int)point.getY(), (int)point.getX(), (int)point.getY() + l);
 
     g2d.setComposite(oldComposite);
   }
@@ -132,12 +132,12 @@ public class CutLine extends AbstractTransparentComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/connectivity/Dot.java

@@ -23,7 +23,7 @@ package org.diylc.components.connectivity;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.SimpleComponentTransformer;
 import org.diylc.components.AbstractComponent;
@@ -51,7 +51,7 @@ public class Dot extends AbstractComponent<Void> {
 
   private Size size = SIZE;
   private Color color = COLOR;
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
 
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
@@ -62,7 +62,7 @@ public class Dot extends AbstractComponent<Void> {
     int diameter = getClosestOdd((int) getSize().convertToPixels());
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : color);
-    g2d.fillOval(point.x - diameter / 2, point.y - diameter / 2, diameter, diameter);
+    g2d.fillOval((int)(point.getX() - diameter / 2), (int)(point.getY() - diameter / 2), diameter, diameter);
   }
 
   @Override
@@ -102,12 +102,12 @@ public class Dot extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/connectivity/Eyelet.java

@@ -23,7 +23,7 @@ package org.diylc.components.connectivity;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.common.ObjectCache;
@@ -60,7 +60,7 @@ public class Eyelet extends AbstractComponent<String> {
   private Size size = SIZE;
   private Size holeSize = HOLE_SIZE;
   private Color color = COLOR;
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private String value = "";
 
   @Override
@@ -74,16 +74,16 @@ public class Eyelet extends AbstractComponent<String> {
     g2d.setStroke(ObjectCache.getInstance().fetchZoomableStroke(1f));
     g2d.setColor(color);
     drawingObserver.startTrackingContinuityArea(true);
-    g2d.fillOval(point.x - diameter / 2, point.y - diameter / 2, diameter, diameter);
+    g2d.fillOval((int)(point.getX() - diameter / 2), (int)(point.getY() - diameter / 2), diameter, diameter);
     drawingObserver.stopTrackingContinuityArea();
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : color.darker());
-    g2d.drawOval(point.x - diameter / 2, point.y - diameter / 2, diameter, diameter);
+    g2d.drawOval((int)(point.getX() - diameter / 2), (int)(point.getY() - diameter / 2), diameter, diameter);
     g2d.setColor(Constants.CANVAS_COLOR);
-    g2d.fillOval(point.x - holeDiameter / 2, point.y - holeDiameter / 2, holeDiameter, holeDiameter);
+    g2d.fillOval((int)(point.getX() - holeDiameter / 2), (int)(point.getY() - holeDiameter / 2), holeDiameter, holeDiameter);
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : color.darker());
-    g2d.drawOval(point.x - holeDiameter / 2, point.y - holeDiameter / 2, holeDiameter, holeDiameter);
+    g2d.drawOval((int)(point.getX() - holeDiameter / 2), (int)(point.getY() - holeDiameter / 2), holeDiameter, holeDiameter);
   }
 
   @Override
@@ -139,12 +139,12 @@ public class Eyelet extends AbstractComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/connectivity/GroundFill.java

@@ -23,7 +23,7 @@ package org.diylc.components.connectivity;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.util.Arrays;
 
 import org.diylc.common.ObjectCache;
@@ -52,9 +52,9 @@ public class GroundFill extends AbstractComponent<Void> {
   public static Size DEFAULT_WIDTH = new Size(1.5d, SizeUnit.in);
   public static Size DEFAULT_HEIGHT = new Size(1.2d, SizeUnit.in);
 
-  protected Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, (int) DEFAULT_HEIGHT.convertToPixels()),
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, (int) DEFAULT_HEIGHT.convertToPixels()),
-      new Point((int) DEFAULT_WIDTH.convertToPixels(), (int) DEFAULT_HEIGHT.convertToPixels()),
+      new Point2D.Double((int) DEFAULT_WIDTH.convertToPixels(), (int) DEFAULT_HEIGHT.convertToPixels()),
-      new Point((int) DEFAULT_WIDTH.convertToPixels(), 0)};
+      new Point2D.Double((int) DEFAULT_WIDTH.convertToPixels(), 0)};
 
   protected Color color = COLOR;
   protected PointCount pointCount = PointCount._4;
@@ -71,8 +71,8 @@ public class GroundFill extends AbstractComponent<Void> {
     int[] xPoints = new int[controlPoints.length];
     int[] yPoints = new int[controlPoints.length];
     for (int i = 0; i < controlPoints.length; i++) {
-      xPoints[i] = controlPoints[i].x;
+      xPoints[i] = (int)controlPoints[i].getX();
-      yPoints[i] = controlPoints[i].y;
+      yPoints[i] = (int)controlPoints[i].getY();
     }
     drawingObserver.startTrackingContinuityArea(true);
     g2d.fillPolygon(xPoints, yPoints, controlPoints.length);
@@ -97,7 +97,7 @@ public class GroundFill extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -112,7 +112,7 @@ public class GroundFill extends AbstractComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
   }
 
@@ -131,8 +131,8 @@ public class GroundFill extends AbstractComponent<Void> {
       this.controlPoints[newPointCount - 1] = this.controlPoints[oldPointCount - 1];
       for (int i = oldPointCount - 1; i < newPointCount - 1; i++) {
         this.controlPoints[i] =
-            new Point((this.controlPoints[i - 1].x + this.controlPoints[newPointCount - 1].x) / 2,
+            new Point2D.Double((this.controlPoints[i - 1].getX() + this.controlPoints[newPointCount - 1].getX()) / 2,
-                (this.controlPoints[i - 1].y + this.controlPoints[newPointCount - 1].y) / 2);
+                (this.controlPoints[i - 1].getY() + this.controlPoints[newPointCount - 1].getY()) / 2);
       }
     }
     this.pointCount = pointCount;

diylc/diylc-library/src/org/diylc/components/connectivity/Line.java

@@ -24,11 +24,11 @@ package org.diylc.components.connectivity;
 import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Shape;
 import java.awt.Stroke;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.Display;
 import org.diylc.common.LineStyle;
@@ -91,13 +91,15 @@ public class Line extends AbstractLeadedComponent<Void> {
     g2d.setStroke(stroke);
     g2d.setColor(componentState == ComponentState.SELECTED ? SELECTION_COLOR : color);
     
-    Point startPoint = new Point(getControlPoint(0));
+    Point2D first = getControlPoint(0);
-    Point endPoint = new Point(getControlPoint(1));
+    Point2D second = getControlPoint(1);
+    Point2D startPoint = new Point2D.Double(first.getX(), first.getY());
+    Point2D endPoint = new Point2D.Double(second.getX(), second.getY());
     
     if (arrowStart) {
       arrowTx.setToIdentity();
-      double angle = Math.atan2(getControlPoint(1).y - getControlPoint(0).y, getControlPoint(1).x - getControlPoint(0).x);
+      double angle = Math.atan2(getControlPoint(1).getY() - getControlPoint(0).getY(), getControlPoint(1).getX() - getControlPoint(0).getX());
-      arrowTx.translate(getControlPoint(0).x, getControlPoint(0).y);
+      arrowTx.translate(getControlPoint(0).getX(), getControlPoint(0).getY());
       arrowTx.rotate((angle + Math.PI / 2d));
       AffineTransform oldTx = g2d.getTransform();
       g2d.transform(arrowTx);         
@@ -110,8 +112,8 @@ public class Line extends AbstractLeadedComponent<Void> {
     }
     if (arrowEnd) {
       arrowTx.setToIdentity();
-      double angle = Math.atan2(getControlPoint(1).y - getControlPoint(0).y, getControlPoint(1).x - getControlPoint(0).x);
+      double angle = Math.atan2(getControlPoint(1).getY() - getControlPoint(0).getY(), getControlPoint(1).getX() - getControlPoint(0).getX());
-      arrowTx.translate(getControlPoint(1).x, getControlPoint(1).y);
+      arrowTx.translate(getControlPoint(1).getX(), getControlPoint(1).getY());
       arrowTx.rotate((angle - Math.PI / 2d));
       AffineTransform oldTx = g2d.getTransform();
       g2d.transform(arrowTx);   
@@ -123,15 +125,15 @@ public class Line extends AbstractLeadedComponent<Void> {
       interpolate(endPoint, startPoint, getArrowSize().convertToPixels() * 0.9 / distance, endPoint);
     }
     
-    g2d.drawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y);
+    g2d.drawLine((int)startPoint.getX(), (int)startPoint.getY(), (int)endPoint.getX(), (int)endPoint.getY());
   }
   
-  private void interpolate(Point p1, Point p2, double t, Point p) {
+  private void interpolate(Point2D p1, Point2D p2, double t, Point2D p) {
-    p.setLocation((int)Math.round(p1.x * (1-t) + p2.x * t), (int)Math.round(p1.y * (1-t) + p2.y * t));
+    p.setLocation((int)Math.round(p1.getX() * (1-t) + p2.getX() * t), (int)Math.round(p1.getY() * (1-t) + p2.getY() * t));
   }
   
-  private double distance(Point p1, Point p2) {
+  private double distance(Point2D p1, Point2D p2) {
-    return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
+    return Math.sqrt((p1.getX() - p2.getX()) * (p1.getX() - p2.getX()) + (p1.getY() - p2.getY()) * (p1.getY() - p2.getY()));
   }
 
   @Override

diylc/diylc-library/src/org/diylc/components/connectivity/SolderPad.java

@@ -19,8 +19,8 @@ package org.diylc.components.connectivity;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.common.PCBLayer;
@@ -55,7 +55,7 @@ public class SolderPad extends AbstractComponent<Void> {
 
   private Size size = SIZE;
   private Color color = COLOR;
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private Type type = Type.ROUND;
   private Size holeSize = HOLE_SIZE;
   private PCBLayer layer = PCBLayer._1;
@@ -72,18 +72,18 @@ public class SolderPad extends AbstractComponent<Void> {
         : color);
     drawingObserver.startTrackingContinuityArea(true);
     if (type == Type.ROUND) {
-      g2d.fill(new Ellipse2D.Double(point.x - diameter / 2, point.y - diameter / 2, diameter, diameter));
+      g2d.fill(new Ellipse2D.Double(point.getX() - diameter / 2, point.getY() - diameter / 2, diameter, diameter));
     } else if (type == Type.OVAL_HORIZONTAL) {
-      g2d.fill(new Ellipse2D.Double(point.x - diameter / 2, point.y - diameter * 3 / 8, diameter, diameter * 3 / 4));
+      g2d.fill(new Ellipse2D.Double(point.getX() - diameter / 2, point.getY() - diameter * 3 / 8, diameter, diameter * 3 / 4));
     } else if (type == Type.OVAL_VERTICAL) {
-      g2d.fill(new Ellipse2D.Double(point.x - diameter * 3 / 8, point.y - diameter / 2, diameter * 3 / 4, diameter));
+      g2d.fill(new Ellipse2D.Double(point.getX() - diameter * 3 / 8, point.getY() - diameter / 2, diameter * 3 / 4, diameter));
     } else {
-      g2d.fill(new Rectangle2D.Double(point.x - diameter / 2, point.y - diameter / 2, diameter, diameter));
+      g2d.fill(new Rectangle2D.Double(point.getX() - diameter / 2, point.getY() - diameter / 2, diameter, diameter));
     }
     drawingObserver.stopTrackingContinuityArea();
     if (getHoleSize().getValue() > 0) {
       g2d.setColor(Constants.CANVAS_COLOR);
-      g2d.fill(new Ellipse2D.Double(point.x - holeDiameter / 2, point.y - holeDiameter / 2, holeDiameter, holeDiameter));
+      g2d.fill(new Ellipse2D.Double(point.getX() - holeDiameter / 2, point.getY() - holeDiameter / 2, holeDiameter, holeDiameter));
     }
   }
 
@@ -151,12 +151,12 @@ public class SolderPad extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/connectivity/TraceCut.java

@@ -23,7 +23,7 @@ package org.diylc.components.connectivity;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.common.ObjectCache;
@@ -70,7 +70,7 @@ public class TraceCut extends AbstractComponent<Void> {
   private OrientationHV orientation = OrientationHV.VERTICAL;
   private Size holeSpacing = VeroBoard.SPACING;
 
-  protected Point point = new Point(0, 0);
+  protected Point2D point = new Point2D.Double(0, 0);
 
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
@@ -87,22 +87,22 @@ public class TraceCut extends AbstractComponent<Void> {
           : getBoardColor());
       drawingObserver.startTrackingContinuityArea(false);
       if (getOrientation() == OrientationHV.VERTICAL)
-        g2d.fillRect(point.x - holeSpacing / 2 - cutWidth / 2, point.y - size / 2 - 1, cutWidth, size + 2);
+        g2d.fillRect((int)(point.getX() - holeSpacing / 2 - cutWidth / 2), (int)(point.getY() - size / 2 - 1), cutWidth, size + 2);
       else
-        g2d.fillRect(point.x - size / 2 - 1, point.y - holeSpacing / 2 - cutWidth / 2, size + 2, cutWidth);
+        g2d.fillRect((int)(point.getX() - size / 2 - 1), (int)(point.getY() - holeSpacing / 2 - cutWidth / 2), size + 2, cutWidth);
       drawingObserver.stopTrackingContinuityArea();
     } else {
       g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
           : getBoardColor());
       drawingObserver.startTrackingContinuityArea(false);
-      g2d.fillRoundRect(point.x - size / 2, point.y - size / 2, size, size, size, size);
+      g2d.fillRoundRect((int)(point.getX() - size / 2), (int)(point.getY() - size / 2), size, size, size, size);
       drawingObserver.stopTrackingContinuityArea();
 
       g2d.setColor(Constants.CANVAS_COLOR);
       int holeSize = getClosestOdd((int) HOLE_SIZE.convertToPixels());      
-      g2d.fillOval(point.x - holeSize / 2, point.y - holeSize / 2, holeSize, holeSize);      
+      g2d.fillOval((int)(point.getX() - holeSize / 2), (int)(point.getY() - holeSize / 2), holeSize, holeSize);      
       g2d.setColor(getBoardColor().darker());
-      g2d.drawOval(point.x - holeSize / 2, point.y - holeSize / 2, holeSize, holeSize);
+      g2d.drawOval((int)(point.getX() - holeSize / 2), (int)(point.getY() - holeSize / 2), holeSize, holeSize);
     }
   }
 
@@ -145,7 +145,7 @@ public class TraceCut extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
@@ -160,7 +160,7 @@ public class TraceCut extends AbstractComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/connectivity/Turret.java

@@ -23,7 +23,7 @@ package org.diylc.components.connectivity;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.common.ObjectCache;
@@ -58,7 +58,7 @@ public class Turret extends AbstractComponent<String> {
   private Size size = SIZE;
   private Size holeSize = HOLE_SIZE;
   private Color color = COLOR;
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private String value = "";
 
   @Override
@@ -72,16 +72,16 @@ public class Turret extends AbstractComponent<String> {
     g2d.setColor(color);
     g2d.setStroke(ObjectCache.getInstance().fetchZoomableStroke(1f));
     drawingObserver.startTrackingContinuityArea(true);
-    g2d.fillOval(point.x - diameter / 2, point.y - diameter / 2, diameter, diameter);
+    g2d.fillOval((int)(point.getX() - diameter / 2), (int)(point.getY() - diameter / 2), diameter, diameter);
     drawingObserver.stopTrackingContinuityArea();
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : color.darker());
-    g2d.drawOval(point.x - diameter / 2, point.y - diameter / 2, diameter, diameter);
+    g2d.drawOval((int)(point.getX() - diameter / 2), (int)(point.getY() - diameter / 2), diameter, diameter);
     g2d.setColor(Constants.CANVAS_COLOR);
-    g2d.fillOval(point.x - holeDiameter / 2, point.y - holeDiameter / 2, holeDiameter, holeDiameter);
+    g2d.fillOval((int)(point.getX() - holeDiameter / 2), (int)(point.getY() - holeDiameter / 2), holeDiameter, holeDiameter);
     g2d.setColor(componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
         : color.darker());
-    g2d.drawOval(point.x - holeDiameter / 2, point.y - holeDiameter / 2, holeDiameter, holeDiameter);
+    g2d.drawOval((int)(point.getX() - holeDiameter / 2), (int)(point.getY() - holeDiameter / 2), holeDiameter, holeDiameter);
   }
 
   @Override
@@ -137,12 +137,12 @@ public class Turret extends AbstractComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/connectivity/TwistedWire.java

@@ -172,7 +172,7 @@ public class TwistedWire extends AbstractCurvedComponent<Void> implements IConti
   }
   
   @Override
-  public void setControlPoint(Point point, int index) {   
+  public void setControlPoint(Point2D point, int index) {   
     super.setControlPoint(point, index);
     
     // invalidate cached areas

diylc/diylc-library/src/org/diylc/components/electromechanical/BatterySnap9V.java

@@ -31,6 +31,7 @@ import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -235,7 +236,7 @@ public class BatterySnap9V extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoint.setLocation(point);
     // Invalidate the body
     body = null;

diylc/diylc-library/src/org/diylc/components/electromechanical/CliffJack1_4.java

@@ -25,12 +25,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Rectangle;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -74,7 +73,7 @@ public class CliffJack1_4 extends AbstractMultiPartComponent<String> {
   private static Size BODY_LENGTH = new Size(0.9d, SizeUnit.in);
   private static Size TAIL_LENGTH = new Size(0.1d, SizeUnit.in);
 
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   private JackType type = JackType.MONO;
   private Orientation orientation = Orientation.DEFAULT;
   transient private Area[] body;
@@ -88,18 +87,18 @@ public class CliffJack1_4 extends AbstractMultiPartComponent<String> {
   private void updateControlPoints() {
     // invalidate body shape
     body = null;
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     int spacing = (int) SPACING.convertToPixels();
-    controlPoints = new Point[type == JackType.STEREO ? 6 : 4];
+    controlPoints = new Point2D[type == JackType.STEREO ? 6 : 4];
 
-    controlPoints[0] = new Point(x, y);
+    controlPoints[0] = new Point2D.Double(x, y);
-    controlPoints[1] = new Point(x, y + 2 * spacing);
+    controlPoints[1] = new Point2D.Double(x, y + 2 * spacing);
-    controlPoints[2] = new Point(x + 2 * spacing, y);
+    controlPoints[2] = new Point2D.Double(x + 2 * spacing, y);
-    controlPoints[3] = new Point(x + 2 * spacing, y + 2 * spacing);
+    controlPoints[3] = new Point2D.Double(x + 2 * spacing, y + 2 * spacing);
     if (type == JackType.STEREO) {
-      controlPoints[4] = new Point(x + spacing, y);
+      controlPoints[4] = new Point2D.Double(x + spacing, y);
-      controlPoints[5] = new Point(x + spacing, y + 2 * spacing);
+      controlPoints[5] = new Point2D.Double(x + spacing, y + 2 * spacing);
     }
 
     // Apply rotation if necessary
@@ -139,9 +138,9 @@ public class CliffJack1_4 extends AbstractMultiPartComponent<String> {
       // Create body.
       int bodyLength = (int) BODY_LENGTH.convertToPixels();
       int bodyWidth = (int) BODY_WIDTH.convertToPixels();
-      int centerX = (controlPoints[0].x + controlPoints[3].x) / 2;
+      double centerX = (controlPoints[0].getX() + controlPoints[3].getX()) / 2;
-      int centerY = (controlPoints[0].y + controlPoints[3].y) / 2;
+      double centerY = (controlPoints[0].getY() + controlPoints[3].getY()) / 2;
-      body[0] = new Area(new Rectangle(centerX - bodyLength / 2, centerY - bodyWidth / 2, bodyLength, bodyWidth));
+      body[0] = new Area(new Rectangle2D.Double(centerX - bodyLength / 2, centerY - bodyWidth / 2, bodyLength, bodyWidth));
 
       int tailLength = (int) TAIL_LENGTH.convertToPixels();
       body[1] = new Area(new RoundRectangle2D.Double(centerX - bodyLength / 2 - tailLength, centerY - bodyWidth / 4, tailLength * 2,
@@ -150,9 +149,9 @@ public class CliffJack1_4 extends AbstractMultiPartComponent<String> {
       tailArea.subtract(new Area(body[0]));
       body[1] = tailArea;
 
-      body[2] = new Area(new Rectangle(centerX + bodyLength / 2, centerY - bodyWidth / 4, tailLength, bodyWidth / 2));
+      body[2] = new Area(new Rectangle2D.Double(centerX + bodyLength / 2, centerY - bodyWidth / 4, tailLength, bodyWidth / 2));
 
-      body[3] = new Area(new Rectangle(centerX + bodyLength / 2 + tailLength, centerY - bodyWidth / 4, tailLength, bodyWidth / 2));
+      body[3] = new Area(new Rectangle2D.Double(centerX + bodyLength / 2 + tailLength, centerY - bodyWidth / 4, tailLength, bodyWidth / 2));
       tailArea = new Area(body[3]);
       int radius = bodyLength / 2 + tailLength * 2;
       tailArea.intersect(new Area(new Ellipse2D.Double(centerX - radius, centerY - radius, radius * 2, radius * 2)));
@@ -177,12 +176,12 @@ public class CliffJack1_4 extends AbstractMultiPartComponent<String> {
       int pinWidth = (int) PIN_WIDTH.convertToPixels();
       int pinThickness = (int) PIN_THICKNESS.convertToPixels();
       for (int i = 0; i < getControlPointCount(); i++) {
-        Point point = getControlPoint(i);
+        Point2D point = getControlPoint(i);
-        Rectangle pin;
+        Rectangle2D pin;
         if (orientation == Orientation.DEFAULT || orientation == Orientation._180) {
-          pin = new Rectangle(point.x - pinWidth / 2, point.y - pinThickness / 2, pinWidth, pinThickness);
+          pin = new Rectangle2D.Double(point.getX() - pinWidth / 2, point.getY() - pinThickness / 2, pinWidth, pinThickness);
         } else {
-          pin = new Rectangle(point.x - pinThickness / 2, point.y - pinWidth / 2, pinThickness, pinWidth);
+          pin = new Rectangle2D.Double(point.getX() - pinThickness / 2, point.getY() - pinWidth / 2, pinThickness, pinWidth);
         }
         pins.add(new Area(pin));
       }
@@ -249,8 +248,8 @@ public class CliffJack1_4 extends AbstractMultiPartComponent<String> {
     }
     g2d.setColor(finalLabelColor);
     g2d.setFont(project.getFont());
-    int centerX = (controlPoints[0].x + controlPoints[3].x) / 2;
+    double centerX = (controlPoints[0].getX() + controlPoints[3].getX()) / 2;
-    int centerY = (controlPoints[0].y + controlPoints[3].y) / 2;
+    double centerY = (controlPoints[0].getY() + controlPoints[3].getY()) / 2;
     StringUtils.drawCenteredText(g2d, name, centerX, centerY, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     
     drawSelectionOutline(g2d, componentState, outlineMode, project, drawingObserver);
@@ -293,12 +292,12 @@ public class CliffJack1_4 extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/electromechanical/ClosedJack1_4.java

@@ -25,13 +25,13 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -75,7 +75,7 @@ public class ClosedJack1_4 extends AbstractMultiPartComponent<String> {
   private static Size BODY_WIDTH = new Size(0.65d, SizeUnit.in);
   private static Size BODY_LENGTH = new Size(0.8d, SizeUnit.in);
 
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   private JackType type = JackType.MONO;
   private Orientation orientation = Orientation.DEFAULT;
   transient private Shape[] body;
@@ -89,16 +89,16 @@ public class ClosedJack1_4 extends AbstractMultiPartComponent<String> {
   private void updateControlPoints() {
     // invalidate body shape
     body = null;
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     int spacing = (int) SPACING.convertToPixels();
     int bodyLength = (int) BODY_LENGTH.convertToPixels();
-    controlPoints = new Point[type == JackType.STEREO ? 3 : 2];
+    controlPoints = new Point2D[type == JackType.STEREO ? 3 : 2];
 
-    controlPoints[0] = new Point(x, y);
+    controlPoints[0] = new Point2D.Double(x, y);
-    controlPoints[1] = new Point(x + bodyLength, y);
+    controlPoints[1] = new Point2D.Double(x + bodyLength, y);
     if (type == JackType.STEREO) {
-      controlPoints[2] = new Point(x, y + 2 * spacing);
+      controlPoints[2] = new Point2D.Double(x, y + 2 * spacing);
     }
 
     // Apply rotation if necessary
@@ -136,18 +136,18 @@ public class ClosedJack1_4 extends AbstractMultiPartComponent<String> {
       body = new Shape[5];
 
       // Create body.
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int lugWidth = (int) LUG_WIDTH.convertToPixels();
       int lugLength = (int) LUG_LENGTH.convertToPixels();
       int lugHoleSize = (int) LUG_HOLE_SIZE.convertToPixels();
       int bodyLength = (int) BODY_LENGTH.convertToPixels();
       int bodyWidth = (int) BODY_WIDTH.convertToPixels();
-      body[0] = new Area(new Rectangle(x + lugLength, y - bodyWidth / 2, bodyLength, bodyWidth));
+      body[0] = new Area(new Rectangle2D.Double(x + lugLength, y - bodyWidth / 2, bodyLength, bodyWidth));
 
       int shaftLength = (int) SHAFT_LENGTH.convertToPixels();
       int shaftWidth = (int) SHAFT_WIDTH.convertToPixels();
-      Area shaft = new Area(new Rectangle(x + lugLength + bodyLength, y - shaftWidth / 2, shaftLength, shaftWidth));
+      Area shaft = new Area(new Rectangle2D.Double(x + lugLength + bodyLength, y - shaftWidth / 2, shaftLength, shaftWidth));
       body[1] = shaft;
 
       double angle = getAngle();
@@ -158,17 +158,17 @@ public class ClosedJack1_4 extends AbstractMultiPartComponent<String> {
 
       GeneralPath path = new GeneralPath();
       int step = 4;
-      for (int i = x + lugLength + bodyLength + step; i <= x + lugLength + bodyLength + shaftLength; i += step) {
+      for (double i = x + lugLength + bodyLength + step; i <= x + lugLength + bodyLength + shaftLength; i += step) {
-        Point p = new Point(i, y - shaftWidth / 2 + 1);
+        Point2D p = new Point2D.Double(i, y - shaftWidth / 2 + 1);
         if (rotation != null) {
           rotation.transform(p, p);
         }
-        path.moveTo(p.x, p.y);
+        path.moveTo(p.getX(), p.getY());
-        p = new Point(i - step, y + shaftWidth / 2 - 1);
+        p = new Point2D.Double(i - step, y + shaftWidth / 2 - 1);
         if (rotation != null) {
           rotation.transform(p, p);
         }
-        path.lineTo(p.x, p.y);
+        path.lineTo(p.getX(), p.getY());
       }
 //      Area pathArea = new Area(path);
 //      pathArea.intersect(shaft);
@@ -178,19 +178,19 @@ public class ClosedJack1_4 extends AbstractMultiPartComponent<String> {
       Area lugs = new Area();
 
       int spacing = (int) SPACING.convertToPixels();
-      Point[] untransformedControlPoints = new Point[type == JackType.STEREO ? 3 : 2];
+      Point2D[] untransformedControlPoints = new Point2D[type == JackType.STEREO ? 3 : 2];
 
-      untransformedControlPoints[0] = new Point(x, y);
+      untransformedControlPoints[0] = new Point2D.Double(x, y);
-      untransformedControlPoints[1] = new Point(x + bodyLength, y);
+      untransformedControlPoints[1] = new Point2D.Double(x + bodyLength, y);
       if (type == JackType.STEREO) {
-        untransformedControlPoints[2] = new Point(x, y + 2 * spacing);
+        untransformedControlPoints[2] = new Point2D.Double(x, y + 2 * spacing);
       }
 
       for (int i = 0; i < untransformedControlPoints.length; i++) {
-        Point point = untransformedControlPoints[i];
+        Point2D point = untransformedControlPoints[i];
-        Area lug = new Area(new Ellipse2D.Double(point.x - lugWidth / 2, point.y - lugWidth / 2, lugWidth, lugWidth));
+        Area lug = new Area(new Ellipse2D.Double(point.getX() - lugWidth / 2, point.getY() - lugWidth / 2, lugWidth, lugWidth));
-        lug.add(new Area(new Rectangle(point.x, point.y - lugWidth / 2, lugLength, lugWidth)));
+        lug.add(new Area(new Rectangle2D.Double(point.getX(), point.getY() - lugWidth / 2, lugLength, lugWidth)));
-        lug.subtract(new Area(new Ellipse2D.Double(point.x - lugHoleSize / 2, point.y - lugHoleSize / 2, lugHoleSize,
+        lug.subtract(new Area(new Ellipse2D.Double(point.getX() - lugHoleSize / 2, point.getY() - lugHoleSize / 2, lugHoleSize,
             lugHoleSize)));
         lugs.add(lug);
       }
@@ -269,8 +269,8 @@ public class ClosedJack1_4 extends AbstractMultiPartComponent<String> {
     g2d.setColor(finalLabelColor);
     g2d.setFont(project.getFont());
     Rectangle bounds = body[0].getBounds();
-    int centerX = bounds.x + bounds.width / 2;
+    double centerX = bounds.getX() + bounds.width / 2;
-    int centerY = bounds.y + bounds.height / 2;
+    double centerY = bounds.getY() + bounds.height / 2;
     StringUtils.drawCenteredText(g2d, name, centerX, centerY, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     
     drawSelectionOutline(g2d, componentState, outlineMode, project, drawingObserver);
@@ -303,12 +303,12 @@ public class ClosedJack1_4 extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/electromechanical/DIPSwitch.java

@@ -26,10 +26,10 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -79,7 +79,7 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
   private SwitchCount switchCount = SwitchCount._8;
   private Size pinSpacing = new Size(0.1d, SizeUnit.in);
   private Size rowSpacing = new Size(0.3d, SizeUnit.in);
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   protected Display display = Display.NONE;
   private Color bodyColor = BODY_COLOR;
   private Color borderColor = BORDER_COLOR;
@@ -179,7 +179,7 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -194,14 +194,14 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
 
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
-    controlPoints = new Point[switchCount.getValue() * 2];
+    controlPoints = new Point2D[switchCount.getValue() * 2];
     controlPoints[0] = firstPoint;
     double pinSpacing = this.pinSpacing.convertToPixels();
     double rowSpacing = this.rowSpacing.convertToPixels();
@@ -239,16 +239,16 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
         default:
           throw new RuntimeException("Unexpected orientation: " + orientation);
       }
-      controlPoints[i] = new Point((int) (firstPoint.x + dx1), (int) (firstPoint.y + dy1));
+      controlPoints[i] = new Point2D.Double(firstPoint.getX() + dx1, firstPoint.getY() + dy1);
-      controlPoints[i + switchCount.getValue()] = new Point((int) (firstPoint.x + dx2), (int) (firstPoint.y + dy2));
+      controlPoints[i + switchCount.getValue()] = new Point2D.Double(firstPoint.getX() + dx2, firstPoint.getY() + dy2);
     }
   }
 
   public Area[] getBody() {
     if (body == null) {
       body = new Area[3];
-      double x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      double y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       double width;
       double height;
       double pinSpacing = this.pinSpacing.convertToPixels();
@@ -265,8 +265,8 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
           x -= (bodyWidth - rowSpacing) / 2;
           y -= pinSpacing / 2;
           for (int i = 0; i < getSwitchCount().getValue(); i++) {
-            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x + (rowSpacing - tickHoleLength) / 2, controlPoints[i].y - tickSize / 2, tickHoleLength, tickSize)));
+            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() + (rowSpacing - tickHoleLength) / 2, controlPoints[i].getY() - tickSize / 2, tickHoleLength, tickSize)));
-            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x + (rowSpacing - tickHoleLength) / 2, controlPoints[i].y - tickSize / 2, tickSize, tickSize)));
+            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() + (rowSpacing - tickHoleLength) / 2, controlPoints[i].getY() - tickSize / 2, tickSize, tickSize)));
           }
           break;
         case _90:
@@ -275,8 +275,8 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
           x -= (pinSpacing / 2) + width - pinSpacing;
           y -= (bodyWidth - rowSpacing) / 2;
           for (int i = 0; i < getSwitchCount().getValue(); i++) {
-            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x - tickSize / 2, controlPoints[i].y + (rowSpacing - tickHoleLength) / 2, tickSize, tickHoleLength)));
+            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() - tickSize / 2, controlPoints[i].getY() + (rowSpacing - tickHoleLength) / 2, tickSize, tickHoleLength)));
-            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x - tickSize / 2, controlPoints[i].y + (rowSpacing - tickHoleLength) / 2, tickSize, tickSize)));
+            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() - tickSize / 2, controlPoints[i].getY() + (rowSpacing - tickHoleLength) / 2, tickSize, tickSize)));
           }
           break;
         case _180:
@@ -285,8 +285,8 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
           x -= rowSpacing + (bodyWidth - rowSpacing) / 2;
           y -= (pinSpacing / 2) + height - pinSpacing;
           for (int i = getSwitchCount().getValue(); i < controlPoints.length; i++) {
-            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x + (rowSpacing - tickHoleLength) / 2, controlPoints[i].y - tickSize / 2, tickHoleLength, tickSize)));
+            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() + (rowSpacing - tickHoleLength) / 2, controlPoints[i].getY() - tickSize / 2, tickHoleLength, tickSize)));
-            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x + (rowSpacing + tickHoleLength) / 2 - tickSize, controlPoints[i].y - tickSize / 2, tickSize, tickSize)));
+            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() + (rowSpacing + tickHoleLength) / 2 - tickSize, controlPoints[i].getY() - tickSize / 2, tickSize, tickSize)));
           }
           break;
         case _270:
@@ -295,8 +295,8 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
           x -= pinSpacing / 2;
           y -= rowSpacing + (bodyWidth - rowSpacing) / 2;
           for (int i = getSwitchCount().getValue(); i < controlPoints.length; i++) {
-            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x - tickSize / 2, controlPoints[i].y + (rowSpacing - tickHoleLength) / 2, tickSize, tickHoleLength)));
+            tickHoleArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() - tickSize / 2, controlPoints[i].getY() + (rowSpacing - tickHoleLength) / 2, tickSize, tickHoleLength)));
-            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].x - tickSize / 2, controlPoints[i].y + (rowSpacing - tickHoleLength) / 2 + tickHoleLength - tickSize, tickSize, tickSize)));
+            tickArea.add(new Area(new Rectangle2D.Double(controlPoints[i].getX() - tickSize / 2, controlPoints[i].getY() + (rowSpacing - tickHoleLength) / 2 + tickHoleLength - tickSize, tickSize, tickSize)));
           }
           break;
         default:
@@ -319,13 +319,13 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
     Area mainArea = getBody()[0];
     if (!outlineMode) {
       int pinSize = (int) PIN_SIZE.convertToPixels() / 2 * 2;
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         g2d.setColor(PIN_COLOR);
         int pinWidth = getClosestOdd(pinSize / (getOrientation() == Orientation.DEFAULT || getOrientation() == Orientation._180 ? 2f : 1f));
         int pinHeight = getClosestOdd(pinSize / (getOrientation() == Orientation.DEFAULT || getOrientation() == Orientation._180 ? 1f : 2f));
-        g2d.fillRect(point.x - pinWidth / 2, point.y - pinHeight / 2, pinWidth, pinHeight);
+        g2d.fillRect((int)(point.getX() - pinWidth / 2), (int)(point.getY() - pinHeight / 2), pinWidth, pinHeight);
         g2d.setColor(PIN_BORDER_COLOR);
-        g2d.drawRect(point.x - pinWidth / 2, point.y - pinHeight / 2, pinWidth, pinHeight);
+        g2d.drawRect((int)(point.getX() - pinWidth / 2), (int)(point.getY() - pinHeight / 2), pinWidth, pinHeight);
       }
     }
     Composite oldComposite = g2d.getComposite();
@@ -407,14 +407,14 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
         int textWidth = (int) (rect.getWidth());
         // Center text horizontally and vertically
         Rectangle bounds = mainArea.getBounds();
-        int x = bounds.x + (bounds.width - textWidth) / 2;
+        double x = bounds.getX() + (bounds.width - textWidth) / 2;
-        int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+        double y = bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
 
         AffineTransform oldTransform = g2d.getTransform();
 
         if (getOrientation() == Orientation.DEFAULT || getOrientation() == Orientation._180) {
-          int centerX = bounds.x + bounds.width / 2;
+          double centerX = bounds.getX() + bounds.width / 2;
-          int centerY = bounds.y + bounds.height / 2;
+          double centerY = bounds.getY() + bounds.height / 2;
           g2d.rotate(-Math.PI / 2, centerX, centerY);
         }
 
@@ -425,7 +425,7 @@ public class DIPSwitch extends AbstractTransparentComponent<String> implements I
             g2d.translate(0, textHeight / 2);
         }
 
-        g2d.drawString(l, x, y);
+        g2d.drawString(l, (int)x, (int)y);
 
         g2d.setTransform(oldTransform);
       }

diylc/diylc-library/src/org/diylc/components/electromechanical/FuseHolderPanel.java

@@ -26,11 +26,11 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.Shape;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -69,7 +69,7 @@ public class FuseHolderPanel extends AbstractMultiPartComponent<String> {
   private static Color BORDER_COLOR = BODY_COLOR.darker();
   private static Color LABEL_COLOR = Color.white;
 
-  protected Point[] controlPoints = new Point[] { new Point(0, 0), new Point(0, 0) };
+  protected Point2D[] controlPoints = new Point2D[] { new Point2D.Double(0, 0), new Point2D.Double(0, 0) };
   transient protected Area[] body;
   protected String name;
   protected String value = "";
@@ -87,14 +87,14 @@ public class FuseHolderPanel extends AbstractMultiPartComponent<String> {
   }
   
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
     int spacing = (int) SPACING.convertToPixels();
    
-    controlPoints[1].setLocation(firstPoint.x + (orientation == OrientationHV.HORIZONTAL ? spacing : 0), firstPoint.y + (orientation == OrientationHV.HORIZONTAL ? 0 : spacing));    
+    controlPoints[1].setLocation(firstPoint.getX() + (orientation == OrientationHV.HORIZONTAL ? spacing : 0), firstPoint.getY() + (orientation == OrientationHV.HORIZONTAL ? 0 : spacing));    
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -114,7 +114,7 @@ public class FuseHolderPanel extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     // Reset body shape.
     body = null;
@@ -213,13 +213,13 @@ public class FuseHolderPanel extends AbstractMultiPartComponent<String> {
       lugWidth = p;
     }
     
-    for (Point p : controlPoints) {
+    for (Point2D p : controlPoints) {
       if (outlineMode) {
         g2d.setColor(theme.getOutlineColor());
-        g2d.drawRect(p.x - lugWidth / 2, p.y - lugHeight / 2, lugWidth, lugHeight);
+        g2d.drawRect((int)(p.getX() - lugWidth / 2), (int)(p.getY() - lugHeight / 2), lugWidth, lugHeight);
       } else {
         g2d.setColor(METAL_COLOR);
-        g2d.fillRect(p.x - lugWidth / 2, p.y - lugHeight / 2, lugWidth, lugHeight);
+        g2d.fillRect((int)(p.getX() - lugWidth / 2), (int)(p.getY() - lugHeight / 2), lugWidth, lugHeight);
       }
     }
     
@@ -250,9 +250,9 @@ public class FuseHolderPanel extends AbstractMultiPartComponent<String> {
     int textWidth = (int) (rect.getWidth());
     // Center text horizontally and vertically
     Rectangle bounds = body[0].getBounds();
-    int x = bounds.x + (bounds.width - textWidth) / 2;
+    double x = bounds.getX() + (bounds.width - textWidth) / 2;
-    int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+    double y = bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
-    g2d.drawString(label, x, y);
+    g2d.drawString(label, (int)x, (int)y);
     
     drawSelectionOutline(g2d, componentState, outlineMode, project, drawingObserver);
   }
@@ -260,7 +260,7 @@ public class FuseHolderPanel extends AbstractMultiPartComponent<String> {
   @Override
   public Area[] getBody() {
     if (body == null) {
-      Point firstPoint = controlPoints[0];
+      Point2D firstPoint = controlPoints[0];
       int spacing = (int) SPACING.convertToPixels();
       int outerDiameter = (int) OUTER_DIAMETER.convertToPixels();
       int innerDiameter = (int) INNER_DIAMETER.convertToPixels();
@@ -272,8 +272,8 @@ public class FuseHolderPanel extends AbstractMultiPartComponent<String> {
       else 
         dy = spacing / 2;
       body = new Area[2];
-      body[0] = new Area(new Ellipse2D.Double(firstPoint.x + dx - outerDiameter / 2, firstPoint.y + dy - outerDiameter / 2, outerDiameter, outerDiameter));      
+      body[0] = new Area(new Ellipse2D.Double(firstPoint.getX() + dx - outerDiameter / 2, firstPoint.getY() + dy - outerDiameter / 2, outerDiameter, outerDiameter));      
-      body[1] = new Area(new Ellipse2D.Double(firstPoint.x + dx - innerDiameter / 2, firstPoint.y + dy - innerDiameter / 2, innerDiameter, innerDiameter));
+      body[1] = new Area(new Ellipse2D.Double(firstPoint.getX() + dx - innerDiameter / 2, firstPoint.getY() + dy - innerDiameter / 2, innerDiameter, innerDiameter));
     }
     return body;
   }

diylc/diylc-library/src/org/diylc/components/electromechanical/IECSocket.java

@@ -29,6 +29,7 @@ import java.awt.Point;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -79,7 +80,7 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
   private static Color BODY_COLOR = Color.decode("#555555");
   private static Color BORDER_COLOR = BODY_COLOR.darker();
 
-  protected Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0)};
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   transient protected Area[] body;
   protected String name;
   protected String value;
@@ -95,12 +96,12 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
 
   @SuppressWarnings("incomplete-switch")
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
     int hSpacing = (int) HORIZONTAL_SPACING.convertToPixels();
     int vSpacing = (int) VERTICAL_SPACING.convertToPixels();
    
-    controlPoints[1].setLocation(firstPoint.x - hSpacing, firstPoint.y + vSpacing);
+    controlPoints[1].setLocation(firstPoint.getX() - hSpacing, firstPoint.getY() + vSpacing);
-    controlPoints[2].setLocation(firstPoint.x + hSpacing, firstPoint.y + vSpacing);
+    controlPoints[2].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY() + vSpacing);
     
     if (orientation != Orientation.DEFAULT) {
       double theta = 0;
@@ -115,7 +116,7 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
           theta = Math.PI * 3 / 2;
           break;
       }
-      AffineTransform rotation = AffineTransform.getRotateInstance(theta, firstPoint.x, firstPoint.y);
+      AffineTransform rotation = AffineTransform.getRotateInstance(theta, firstPoint.getX(), firstPoint.getY());
 
       for (int i = 1; i < controlPoints.length; i++) {
         rotation.transform(controlPoints[i], controlPoints[i]);
@@ -124,7 +125,7 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -144,7 +145,7 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     // Reset body shape.
     body = null;
@@ -235,13 +236,13 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
       lugWidth = p;
     }
     
-    for (Point p : controlPoints) {
+    for (Point2D p : controlPoints) {
       if (outlineMode) {
         g2d.setColor(theme.getOutlineColor());
-        g2d.drawRect(p.x - lugWidth / 2, p.y - lugHeight / 2, lugWidth, lugHeight);
+        g2d.drawRect((int)(p.getX() - lugWidth / 2), (int)(p.getY() - lugHeight / 2), lugWidth, lugHeight);
       } else {
         g2d.setColor(METAL_COLOR);
-        g2d.fillRect(p.x - lugWidth / 2, p.y - lugHeight / 2, lugWidth, lugHeight);
+        g2d.fillRect((int)(p.getX() - lugWidth / 2), (int)(p.getY() - lugHeight / 2), lugWidth, lugHeight);
       }
     }
     
@@ -251,7 +252,7 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
   @SuppressWarnings("incomplete-switch")
   public Area[] getBody() {
     if (body == null) {
-      Point firstPoint = controlPoints[0];
+      Point2D firstPoint = controlPoints[0];
       int vSpacing = (int) VERTICAL_SPACING.convertToPixels();
       
       double cutoutRadius;
@@ -278,13 +279,13 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
       outerRadius = SIMPLE_OUTER_RADIUS.convertToPixels();
       
       Point[] outerPoints = new Point[] {
-          new Point((int) Math.round(firstPoint.x), (int) Math.round(firstPoint.y + vSpacing / 2 - baseWidth / 2)),
+          new Point((int) Math.round(firstPoint.getX()), (int) Math.round(firstPoint.getY() + vSpacing / 2 - baseWidth / 2)),
-          new Point((int) Math.round(firstPoint.x + baseLength / 2), (int) Math.round(firstPoint.y + vSpacing / 2 - baseWidth / 2)),
+          new Point((int) Math.round(firstPoint.getX() + baseLength / 2), (int) Math.round(firstPoint.getY() + vSpacing / 2 - baseWidth / 2)),
-          new Point((int) Math.round(firstPoint.x + length / 2), (int) Math.round(firstPoint.y + vSpacing / 2)),
+          new Point((int) Math.round(firstPoint.getX() + length / 2), (int) Math.round(firstPoint.getY() + vSpacing / 2)),
-          new Point((int) Math.round(firstPoint.x + baseLength / 2), (int) Math.round(firstPoint.y + vSpacing / 2 + baseWidth / 2)),
+          new Point((int) Math.round(firstPoint.getX() + baseLength / 2), (int) Math.round(firstPoint.getY() + vSpacing / 2 + baseWidth / 2)),
-          new Point((int) Math.round(firstPoint.x - baseLength / 2), (int) Math.round(firstPoint.y + vSpacing / 2 + baseWidth / 2)),
+          new Point((int) Math.round(firstPoint.getX() - baseLength / 2), (int) Math.round(firstPoint.getY() + vSpacing / 2 + baseWidth / 2)),
-          new Point((int) Math.round(firstPoint.x - length / 2), (int) Math.round(firstPoint.y + vSpacing / 2)),
+          new Point((int) Math.round(firstPoint.getX() - length / 2), (int) Math.round(firstPoint.getY() + vSpacing / 2)),
-          new Point((int) Math.round(firstPoint.x - baseLength / 2), (int) Math.round(firstPoint.y + vSpacing / 2 - baseWidth / 2)),
+          new Point((int) Math.round(firstPoint.getX() - baseLength / 2), (int) Math.round(firstPoint.getY() + vSpacing / 2 - baseWidth / 2)),
       };
       
       double[] outerRadiuses = new double[] {
@@ -297,19 +298,19 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
       };
       
       body[0] = new Area(new RoundedPolygon(outerPoints, outerRadiuses));
-      body[0].subtract(new Area(new Ellipse2D.Double(firstPoint.x - holeSpacing / 2 - holeDiameter / 2, firstPoint.y + vSpacing / 2 - holeDiameter / 2, holeDiameter, holeDiameter)));
+      body[0].subtract(new Area(new Ellipse2D.Double(firstPoint.getX() - holeSpacing / 2 - holeDiameter / 2, firstPoint.getY() + vSpacing / 2 - holeDiameter / 2, holeDiameter, holeDiameter)));
-      body[0].subtract(new Area(new Ellipse2D.Double(firstPoint.x + holeSpacing / 2 - holeDiameter / 2, firstPoint.y + vSpacing / 2 - holeDiameter / 2, holeDiameter, holeDiameter)));
+      body[0].subtract(new Area(new Ellipse2D.Double(firstPoint.getX() + holeSpacing / 2 - holeDiameter / 2, firstPoint.getY() + vSpacing / 2 - holeDiameter / 2, holeDiameter, holeDiameter)));
       
-      body[1] = new Area(new RoundRectangle2D.Double(firstPoint.x - baseLength / 2, firstPoint.y + vSpacing / 2 - baseWidth / 2, baseLength, baseWidth, baseRadius, baseRadius));
+      body[1] = new Area(new RoundRectangle2D.Double(firstPoint.getX() - baseLength / 2, firstPoint.getY() + vSpacing / 2 - baseWidth / 2, baseLength, baseWidth, baseRadius, baseRadius));
       
-      Point[] cutoutPoints = new Point[] {
+      Point2D[] cutoutPoints = new Point2D[] {
-          new Point(firstPoint.x, (int) (firstPoint.y + vSpacing / 2 - cutoutWidth / 2)),
+          new Point2D.Double(firstPoint.getX(), firstPoint.getY() + vSpacing / 2 - cutoutWidth / 2),
-          new Point((int) (firstPoint.x + cutoutLength / 2 - cutoutSlant), (int) (firstPoint.y + vSpacing / 2 - cutoutWidth / 2)),
+          new Point2D.Double(firstPoint.getX() + cutoutLength / 2 - cutoutSlant, (int) (firstPoint.getY() + vSpacing / 2 - cutoutWidth / 2)),
-          new Point((int) (firstPoint.x + cutoutLength / 2), (int) (firstPoint.y + vSpacing / 2 - cutoutWidth / 2 + cutoutSlant)),
+          new Point2D.Double(firstPoint.getX() + cutoutLength / 2, firstPoint.getY() + vSpacing / 2 - cutoutWidth / 2 + cutoutSlant),
-          new Point((int) (firstPoint.x + cutoutLength / 2), (int) (firstPoint.y + vSpacing / 2 + cutoutWidth / 2)),
+          new Point2D.Double(firstPoint.getX() + cutoutLength / 2, firstPoint.getY() + vSpacing / 2 + cutoutWidth / 2),
-          new Point((int) (firstPoint.x - cutoutLength / 2), (int) (firstPoint.y + vSpacing / 2 + cutoutWidth / 2)),
+          new Point2D.Double(firstPoint.getX() - cutoutLength / 2, firstPoint.getY() + vSpacing / 2 + cutoutWidth / 2),
-          new Point((int) (firstPoint.x - cutoutLength / 2), (int) (firstPoint.y + vSpacing / 2 - cutoutWidth / 2 + cutoutSlant)),
+          new Point2D.Double(firstPoint.getX() - cutoutLength / 2, firstPoint.getY() + vSpacing / 2 - cutoutWidth / 2 + cutoutSlant),
-          new Point((int) (firstPoint.x - cutoutLength / 2 + cutoutSlant), (int) (firstPoint.y + vSpacing / 2 - cutoutWidth / 2)),
+          new Point2D.Double(firstPoint.getX() - cutoutLength / 2 + cutoutSlant, firstPoint.getY() + vSpacing / 2 - cutoutWidth / 2),
       };
       
       double[] cutoutRadiuses = new double[] {
@@ -331,7 +332,7 @@ public class IECSocket extends AbstractMultiPartComponent<String> {
             theta = Math.PI * 3 / 2;
             break;
         }
-        AffineTransform rotation = AffineTransform.getRotateInstance(theta, firstPoint.x, firstPoint.y);
+        AffineTransform rotation = AffineTransform.getRotateInstance(theta, firstPoint.getX(), firstPoint.getY());
         for (Area a : body)
           if (a != null)
             a.transform(rotation);

diylc/diylc-library/src/org/diylc/components/electromechanical/MiniRelay.java

@@ -26,9 +26,9 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -85,7 +85,7 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
   private String value = "";
   private Orientation orientation = Orientation.DEFAULT;
 
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   protected Display display = Display.NAME;
   private RelayType type = RelayType.DPDT;
   private RelaySize size = RelaySize.Miniature;
@@ -136,7 +136,7 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -151,13 +151,13 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
 
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
     int pinCount = 0;
     switch (type) {
       case DPDT:
@@ -169,7 +169,7 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
       default:
         throw new RuntimeException("Unexpected type: " + type);
     }
-    controlPoints = new Point[pinCount];
+    controlPoints = new Point2D[pinCount];
     controlPoints[0] = firstPoint;
     int pinSpacing =
         size == RelaySize.Miniature ? (int) MINI_PIN_SPACING.convertToPixels() : (int) ULTRA_PIN_SPACING
@@ -218,18 +218,18 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
         default:
           throw new RuntimeException("Unexpected orientation: " + orientation);
       }
-      controlPoints[i] = new Point(firstPoint.x + dx1, firstPoint.y + dy1);
+      controlPoints[i] = new Point2D.Double(firstPoint.getX() + dx1, firstPoint.getY() + dy1);
-      controlPoints[i + pinCount / 2] = new Point(firstPoint.x + dx2, firstPoint.y + dy2);
+      controlPoints[i + pinCount / 2] = new Point2D.Double(firstPoint.getX() + dx2, firstPoint.getY() + dy2);
     }
   }
 
   public Area[] getBody() {
     if (body == null) {
       body = new Area[2];
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
-      int centerX = (controlPoints[0].x + controlPoints[controlPoints.length - 1].x) / 2;
+      double centerX = (controlPoints[0].getX() + controlPoints[controlPoints.length - 1].getX()) / 2;
-      int centerY = (controlPoints[0].y + controlPoints[controlPoints.length - 1].y) / 2;
+      double centerY = (controlPoints[0].getY() + controlPoints[controlPoints.length - 1].getY()) / 2;
       int bodyMargin = getClosestOdd(BODY_MARGIN.convertToPixels());
       int width = 0;
       int height = 0;
@@ -308,13 +308,13 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
 
     Theme theme = (Theme) ConfigurationManager.getInstance().readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
     int pinSize = (int) PIN_SIZE.convertToPixels() / 2 * 2;
-    for (Point point : controlPoints) {
+    for (Point2D point : controlPoints) {
       if (!outlineMode) {
         g2d.setColor(PIN_COLOR);
-        g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
       g2d.setColor(outlineMode ? theme.getOutlineColor() : PIN_BORDER_COLOR);
-      g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+      g2d.drawOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
     }
 
     Color finalBorderColor;
@@ -367,9 +367,9 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
     int textWidth = (int) (rect.getWidth());
     // Center text horizontally and vertically
     Rectangle bounds = mainArea.getBounds();
-    int x = bounds.x + (bounds.width - textWidth) / 2;
+    double x = bounds.getX() + (bounds.width - textWidth) / 2;
-    int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+    double y = bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
-    g2d.drawString(label, x, y);
+    g2d.drawString(label, (int)x, (int)y);
   }
 
   @Override
@@ -434,21 +434,21 @@ public class MiniRelay extends AbstractTransparentComponent<String> {
   
   @Override
   public Rectangle2D getCachingBounds() {
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
-    int margin = 50;
+    double margin = 50;
     for (int i = 0; i < getControlPointCount(); i++) {
-      Point p = getControlPoint(i);
+      Point2D p = getControlPoint(i);
-      if (p.x < minX)
+      if (p.getX() < minX)
-        minX = p.x;
+        minX = p.getX();
-      if (p.x > maxX)
+      if (p.getX() > maxX)
-        maxX = p.x;
+        maxX = p.getX();
-      if (p.y < minY)
+      if (p.getY() < minY)
-        minY = p.y;
+        minY = p.getY();
-      if (p.y > maxY)
+      if (p.getY() > maxY)
-        maxY = p.y;
+        maxY = p.getY();
     }
     
     return new Rectangle2D.Double(minX - margin, minY - margin, maxX - minX + 2 * margin, maxY - minY + 2 * margin);

diylc/diylc-library/src/org/diylc/components/electromechanical/MiniToggleSwitch.java

@@ -25,10 +25,10 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -68,7 +68,7 @@ public class MiniToggleSwitch extends AbstractTransparentComponent<ToggleSwitchT
   private static Color BORDER_COLOR = BODY_COLOR.darker();
   private static Color CIRCLE_COLOR = Color.decode("#FFFFAA");
 
-  protected Point[] controlPoints = new Point[] {new Point(0, 0)};
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   transient protected Shape body;
   protected ToggleSwitchType switchType = ToggleSwitchType.DPDT;
   private OrientationHV orientation = OrientationHV.VERTICAL;
@@ -83,81 +83,85 @@ public class MiniToggleSwitch extends AbstractTransparentComponent<ToggleSwitchT
   }
 
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
     int spacing = (int) getSpacing().convertToPixels();
     switch (switchType) {
       case SPST:
-        controlPoints = new Point[] {firstPoint, new Point(firstPoint.x, firstPoint.y + spacing)};
+        controlPoints = new Point2D[] {firstPoint, new Point2D.Double(firstPoint.getX(), firstPoint.getY() + spacing)};
         break;
       case SPDT:
       case SPDT_off:
         controlPoints =
-            new Point[] {firstPoint, new Point(firstPoint.x, firstPoint.y + spacing),
+            new Point2D[] {firstPoint, new Point2D.Double(firstPoint.getX(), firstPoint.getY() + spacing),
-                new Point(firstPoint.x, firstPoint.y + 2 * spacing)};
+                new Point2D.Double(firstPoint.getX(), firstPoint.getY() + 2 * spacing)};
         break;
       case DPDT:
       case DPDT_off:
         controlPoints =
-            new Point[] {firstPoint, new Point(firstPoint.x, firstPoint.y + spacing),
+            new Point2D[] {firstPoint, new Point2D.Double(firstPoint.getX(), firstPoint.getY() + spacing),
-                new Point(firstPoint.x, firstPoint.y + 2 * spacing), new Point(firstPoint.x + spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX(), firstPoint.getY() + 2 * spacing), 
-                new Point(firstPoint.x + spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY()),
-                new Point(firstPoint.x + spacing, firstPoint.y + 2 * spacing)};
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + 2 * spacing)};
         break;
       case _DP3T_mustang:
         controlPoints =
-                new Point[] {firstPoint,
+                new Point2D[] {firstPoint,
-                        new Point(firstPoint.x, firstPoint.y + spacing),
+                        new Point2D.Double(firstPoint.getX(), firstPoint.getY() + spacing),
-                        new Point(firstPoint.x, firstPoint.y + 2 * spacing),
+                        new Point2D.Double(firstPoint.getX(), firstPoint.getY() + 2 * spacing),
-                        new Point(firstPoint.x, firstPoint.y + 3 * spacing),
+                        new Point2D.Double(firstPoint.getX(), firstPoint.getY() + 3 * spacing),
-                        new Point(firstPoint.x + spacing, firstPoint.y),
+                        new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY()),
-                        new Point(firstPoint.x + spacing, firstPoint.y + spacing),
+                        new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + spacing),
-                        new Point(firstPoint.x + spacing, firstPoint.y + 2 * spacing),
+                        new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + 2 * spacing),
-                        new Point(firstPoint.x + spacing, firstPoint.y + 3 * spacing)};
+                        new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + 3 * spacing)};
         break;
       case _3PDT:
       case _3PDT_off:
         controlPoints =
-            new Point[] {firstPoint, new Point(firstPoint.x, firstPoint.y + spacing),
+            new Point2D[] {firstPoint, new Point2D.Double(firstPoint.getX(), firstPoint.getY() + spacing),
-                new Point(firstPoint.x, firstPoint.y + 2 * spacing), new Point(firstPoint.x + spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX(), firstPoint.getY() + 2 * spacing), 
-                new Point(firstPoint.x + spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY()),
-                new Point(firstPoint.x + spacing, firstPoint.y + 2 * spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + spacing),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + 2 * spacing),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY()),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y + 2 * spacing)};
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY() + spacing),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY() + 2 * spacing)};
         break;
       case _4PDT:
       case _4PDT_off:
         controlPoints =
-            new Point[] {firstPoint, new Point(firstPoint.x, firstPoint.y + spacing),
+            new Point2D[] {firstPoint, new Point2D.Double(firstPoint.getX(), firstPoint.getY() + spacing),
-                new Point(firstPoint.x, firstPoint.y + 2 * spacing), new Point(firstPoint.x + spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX(), firstPoint.getY() + 2 * spacing), 
-                new Point(firstPoint.x + spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY()),
-                new Point(firstPoint.x + spacing, firstPoint.y + 2 * spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + spacing),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + 2 * spacing),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY()),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y + 2 * spacing),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY() + spacing),
-                new Point(firstPoint.x + 3 * spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY() + 2 * spacing),
-                new Point(firstPoint.x + 3 * spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + 3 * spacing, firstPoint.getY()),
-                new Point(firstPoint.x + 3 * spacing, firstPoint.y + 2 * spacing)};
+                new Point2D.Double(firstPoint.getX() + 3 * spacing, firstPoint.getY() + spacing),
+                new Point2D.Double(firstPoint.getX() + 3 * spacing, firstPoint.getY() + 2 * spacing)};
         break;
       case _5PDT:
       case _5PDT_off:
         controlPoints =
-            new Point[] {firstPoint, new Point(firstPoint.x, firstPoint.y + spacing),
+            new Point2D[] {firstPoint, new Point2D.Double(firstPoint.getX(), firstPoint.getY() + spacing),
-                new Point(firstPoint.x, firstPoint.y + 2 * spacing), new Point(firstPoint.x + spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX(), firstPoint.getY() + 2 * spacing), 
-                new Point(firstPoint.x + spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY()),
-                new Point(firstPoint.x + spacing, firstPoint.y + 2 * spacing),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + spacing),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX() + spacing, firstPoint.getY() + 2 * spacing),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY()),
-                new Point(firstPoint.x + 2 * spacing, firstPoint.y + 2 * spacing),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY() + spacing),
-                new Point(firstPoint.x + 3 * spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX() + 2 * spacing, firstPoint.getY() + 2 * spacing),
-                new Point(firstPoint.x + 3 * spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + 3 * spacing, firstPoint.getY()),
-                new Point(firstPoint.x + 3 * spacing, firstPoint.y + 2 * spacing),
+                new Point2D.Double(firstPoint.getX() + 3 * spacing, firstPoint.getY() + spacing),
-                new Point(firstPoint.x + 4 * spacing, firstPoint.y),
+                new Point2D.Double(firstPoint.getX() + 3 * spacing, firstPoint.getY() + 2 * spacing),
-                new Point(firstPoint.x + 4 * spacing, firstPoint.y + spacing),
+                new Point2D.Double(firstPoint.getX() + 4 * spacing, firstPoint.getY()),
-                new Point(firstPoint.x + 4 * spacing, firstPoint.y + 2 * spacing)};
+                new Point2D.Double(firstPoint.getX() + 4 * spacing, firstPoint.getY() + spacing),
+                new Point2D.Double(firstPoint.getX() + 4 * spacing, firstPoint.getY() + 2 * spacing)};
         break;
     }
-    AffineTransform xform = AffineTransform.getRotateInstance(-Math.PI / 2, firstPoint.x, firstPoint.y);
+    AffineTransform xform = AffineTransform.getRotateInstance(-Math.PI / 2, firstPoint.getX(), firstPoint.getY());
     if (getOrientation() == OrientationHV.HORIZONTAL) {
       for (int i = 1; i < controlPoints.length; i++) {
         xform.transform(controlPoints[i], controlPoints[i]);
@@ -166,7 +170,7 @@ public class MiniToggleSwitch extends AbstractTransparentComponent<ToggleSwitchT
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -186,7 +190,7 @@ public class MiniToggleSwitch extends AbstractTransparentComponent<ToggleSwitchT
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     // Reset body shape.
     body = null;
@@ -285,68 +289,68 @@ public class MiniToggleSwitch extends AbstractTransparentComponent<ToggleSwitchT
     int circleDiameter = getClosestOdd((int) CIRCLE_SIZE.convertToPixels());
     int lugWidth = getClosestOdd((int) LUG_WIDTH.convertToPixels());
     int lugHeight = getClosestOdd((int) LUG_THICKNESS.convertToPixels());
-    for (Point p : controlPoints) {
+    for (Point2D p : controlPoints) {
       if (outlineMode) {
         g2d.setColor(theme.getOutlineColor());
-        g2d.drawRect(p.x - lugWidth / 2, p.y - lugHeight / 2, lugWidth, lugHeight);
+        g2d.drawRect((int)(p.getX() - lugWidth / 2), (int)(p.getY() - lugHeight / 2), lugWidth, lugHeight);
       } else {
         g2d.setColor(CIRCLE_COLOR);
-        g2d.fillOval(p.x - circleDiameter / 2, p.y - circleDiameter / 2, circleDiameter, circleDiameter);
+        g2d.fillOval((int)(p.getX() - circleDiameter / 2), (int)(p.getY() - circleDiameter / 2), circleDiameter, circleDiameter);
         g2d.setColor(METAL_COLOR);
-        g2d.fillRect(p.x - lugWidth / 2, p.y - lugHeight / 2, lugWidth, lugHeight);
+        g2d.fillRect((int)(p.getX() - lugWidth / 2), (int)(p.getY() - lugHeight / 2), lugWidth, lugHeight);
       }
     }
   }
 
   public Shape getBody() {
     if (body == null) {
-      Point firstPoint = controlPoints[0];
+      Point2D firstPoint = controlPoints[0];
       int margin = (int) MARGIN.convertToPixels();
       int spacing = (int) getSpacing().convertToPixels();
       switch (switchType) {
         case SPST:
           body =
-              new RoundRectangle2D.Double(firstPoint.x - margin, firstPoint.y - margin, 2 * margin, 2 * margin
+              new RoundRectangle2D.Double(firstPoint.getX() - margin, firstPoint.getY() - margin, 2 * margin, 2 * margin
                   + spacing, margin, margin);
           break;
         case SPDT:
         case SPDT_off:
           body =
-              new RoundRectangle2D.Double(firstPoint.x - margin, firstPoint.y - margin, 2 * margin, 2 * margin + 2
+              new RoundRectangle2D.Double(firstPoint.getX() - margin, firstPoint.getY() - margin, 2 * margin, 2 * margin + 2
                   * spacing, margin, margin);
           break;
         case DPDT:
         case DPDT_off:
           body =
-              new RoundRectangle2D.Double(firstPoint.x - margin, firstPoint.y - margin, 2 * margin + spacing, 2
+              new RoundRectangle2D.Double(firstPoint.getX() - margin, firstPoint.getY() - margin, 2 * margin + spacing, 2
                   * margin + 2 * spacing, margin, margin);
           break;
         case _DP3T_mustang:
           body =
-                  new RoundRectangle2D.Double(firstPoint.x - margin, firstPoint.y - margin, 2 * margin + spacing, 2
+                  new RoundRectangle2D.Double(firstPoint.getX() - margin, firstPoint.getY() - margin, 2 * margin + spacing, 2
                           * margin + 3 * spacing, margin, margin);
           break;
         case _3PDT:
         case _3PDT_off:
           body =
-              new RoundRectangle2D.Double(firstPoint.x - margin, firstPoint.y - margin, 2 * margin + 2 * spacing, 2
+              new RoundRectangle2D.Double(firstPoint.getX() - margin, firstPoint.getY() - margin, 2 * margin + 2 * spacing, 2
                   * margin + 2 * spacing, margin, margin);
           break;
         case _4PDT:
         case _4PDT_off:
           body =
-              new RoundRectangle2D.Double(firstPoint.x - margin, firstPoint.y - margin, 2 * margin + 3 * spacing, 2
+              new RoundRectangle2D.Double(firstPoint.getX() - margin, firstPoint.getY() - margin, 2 * margin + 3 * spacing, 2
                   * margin + 2 * spacing, margin, margin);
           break;
         case _5PDT:
         case _5PDT_off:
           body =
-              new RoundRectangle2D.Double(firstPoint.x - margin, firstPoint.y - margin, 2 * margin + 4 * spacing, 2
+              new RoundRectangle2D.Double(firstPoint.getX() - margin, firstPoint.getY() - margin, 2 * margin + 4 * spacing, 2
                   * margin + 2 * spacing, margin, margin);
           break;
       }
       if (getOrientation() == OrientationHV.HORIZONTAL) {
-        AffineTransform xform = AffineTransform.getRotateInstance(-Math.PI / 2, firstPoint.x, firstPoint.y);
+        AffineTransform xform = AffineTransform.getRotateInstance(-Math.PI / 2, firstPoint.getX(), firstPoint.getY());
         body = new Area(body);
         ((Area) body).transform(xform);
       }

diylc/diylc-library/src/org/diylc/components/electromechanical/OpenJack1_4.java

@@ -30,6 +30,7 @@ import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -77,7 +78,7 @@ public class OpenJack1_4 extends AbstractMultiPartComponent<String> {
   private static Size HOLE_TO_EDGE = new Size(0.063d, SizeUnit.in);
 
   private String value = "";
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   transient Area[] body;
   @Deprecated
   private Orientation orientation = Orientation.DEFAULT;
@@ -161,27 +162,27 @@ public class OpenJack1_4 extends AbstractMultiPartComponent<String> {
       g2d.setFont(project.getFont().deriveFont(project.getFont().getSize2D() * 0.8f));
       int springLength = (int) SPRING_LENGTH.convertToPixels();
       int holeToEdge = (int) HOLE_TO_EDGE.convertToPixels();
-      int centerY = controlPoints[0].y + springLength - holeToEdge;
+      double centerY = controlPoints[0].getY() + springLength - holeToEdge;
-      Point tipLabel = new Point(controlPoints[0].x, (int) (controlPoints[0].y + holeToEdge * 1.25));
+      Point2D tipLabel = new Point2D.Double(controlPoints[0].getX(), (int) (controlPoints[0].getY() + holeToEdge * 1.25));
-      AffineTransform ringTransform = AffineTransform.getRotateInstance(getType() == OpenJackType.SWITCHED ? SWITCH_THETA : RING_THETA, controlPoints[0].x, centerY);
+      AffineTransform ringTransform = AffineTransform.getRotateInstance(getType() == OpenJackType.SWITCHED ? SWITCH_THETA : RING_THETA, controlPoints[0].getX(), centerY);
-      AffineTransform sleeveTransform = AffineTransform.getRotateInstance(getType() == OpenJackType.SWITCHED ? SLEEVE_SWITCHED_THETA : SLEEVE_THETA, controlPoints[0].x, centerY);
+      AffineTransform sleeveTransform = AffineTransform.getRotateInstance(getType() == OpenJackType.SWITCHED ? SLEEVE_SWITCHED_THETA : SLEEVE_THETA, controlPoints[0].getX(), centerY);
       Point ringOrSwitchLabel = new Point(0, 0);
       Point sleeveLabel = new Point(0, 0);
       ringTransform.transform(tipLabel, ringOrSwitchLabel);
       sleeveTransform.transform(tipLabel, sleeveLabel);
 
       if (getTheta() != 0) {
-        AffineTransform rotation = AffineTransform.getRotateInstance(getTheta(), controlPoints[0].x, controlPoints[0].y);
+        AffineTransform rotation = AffineTransform.getRotateInstance(getTheta(), controlPoints[0].getX(), controlPoints[0].getY());
         rotation.transform(tipLabel, tipLabel);
         rotation.transform(ringOrSwitchLabel, ringOrSwitchLabel);
         rotation.transform(sleeveLabel, sleeveLabel);
       }
-      StringUtils.drawCenteredText(g2d, "T", tipLabel.x, tipLabel.y, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+      StringUtils.drawCenteredText(g2d, "T", tipLabel.getX(), tipLabel.getY(), HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
-      StringUtils.drawCenteredText(g2d, "S", sleeveLabel.x, sleeveLabel.y, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+      StringUtils.drawCenteredText(g2d, "S", sleeveLabel.getX(), sleeveLabel.getY(), HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
       if (getType() == OpenJackType.STEREO)
-        StringUtils.drawCenteredText(g2d, "R", ringOrSwitchLabel.x, ringOrSwitchLabel.y, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+        StringUtils.drawCenteredText(g2d, "R", ringOrSwitchLabel.getX(), ringOrSwitchLabel.getY(), HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
       if (getType() == OpenJackType.SWITCHED)
-        StringUtils.drawCenteredText(g2d, "Sw", ringOrSwitchLabel.x, ringOrSwitchLabel.y, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+        StringUtils.drawCenteredText(g2d, "Sw", ringOrSwitchLabel.getX(), ringOrSwitchLabel.getY(), HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     }
     
     drawSelectionOutline(g2d, componentState, outlineMode, project, drawingObserver);
@@ -191,8 +192,8 @@ public class OpenJack1_4 extends AbstractMultiPartComponent<String> {
     if (body == null) {
       body = new Area[4];
 
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int outerDiameter = getClosestOdd(OUTER_DIAMETER.convertToPixels());
       int innerDiameter = getClosestOdd(INNER_DIAMETER.convertToPixels());
       int ringDiameter = getClosestOdd(RING_DIAMETER.convertToPixels());
@@ -201,7 +202,7 @@ public class OpenJack1_4 extends AbstractMultiPartComponent<String> {
       int holeDiameter = getClosestOdd(HOLE_DIAMETER.convertToPixels());
       int holeToEdge = (int) HOLE_TO_EDGE.convertToPixels();
 
-      int centerY = y + springLength - holeToEdge;
+      double centerY = y + springLength - holeToEdge;
 
       Area wafer =
           new Area(new Ellipse2D.Double(x - outerDiameter / 2, centerY - outerDiameter / 2, outerDiameter,
@@ -264,13 +265,13 @@ public class OpenJack1_4 extends AbstractMultiPartComponent<String> {
   }
 
   private void updateControlPoints() {
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
 
     int springLength = (int) SPRING_LENGTH.convertToPixels();
     int holeToEdge = (int) HOLE_TO_EDGE.convertToPixels();
 
-    int centerY = y + springLength - holeToEdge;
+    double centerY = y + springLength - holeToEdge;
 
     AffineTransform.getRotateInstance(getType() == OpenJackType.SWITCHED ? SLEEVE_SWITCHED_THETA : SLEEVE_THETA, x, centerY).transform(controlPoints[0], controlPoints[1]);
     AffineTransform.getRotateInstance(getType() == OpenJackType.SWITCHED ? SWITCH_THETA : RING_THETA, x, centerY).transform(controlPoints[0], controlPoints[2]);
@@ -278,7 +279,7 @@ public class OpenJack1_4 extends AbstractMultiPartComponent<String> {
     // Rotate if needed
     if (getTheta() != 0) {
       AffineTransform rotation = AffineTransform.getRotateInstance(getTheta(), x, y);
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         rotation.transform(point, point);
       }
     }
@@ -328,12 +329,12 @@ public class OpenJack1_4 extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
     // Invalidate the body
     body = null;

diylc/diylc-library/src/org/diylc/components/electromechanical/PilotLampHolder.java

@@ -25,12 +25,12 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -76,7 +76,7 @@ public class PilotLampHolder extends AbstractMultiPartComponent<String> {
   private static Size HOLE_SPACING = new Size(0.1d, SizeUnit.in);
 
   private String value = "";
-  private Point[] controlPoints = new Point[] { new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0) };
+  private Point2D[] controlPoints = new Point2D[] { new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0) };
   transient Area[] body;
   @Deprecated
   private Orientation orientation = Orientation.DEFAULT;
@@ -162,8 +162,8 @@ public class PilotLampHolder extends AbstractMultiPartComponent<String> {
     if (body == null) {
       body = new Area[6];
 
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int threadOuterDiameter = getClosestOdd(THREAD_OUTER_DIAMETER.convertToPixels());
       int threadThickness = getClosestOdd(THREAD_THICKNESS.convertToPixels());
       int nutDiameter = getClosestOdd(NUT_DIAMETER.convertToPixels());
@@ -175,7 +175,7 @@ public class PilotLampHolder extends AbstractMultiPartComponent<String> {
       int holeDiameter = getClosestOdd(HOLE_DIAMETER.convertToPixels());
       int holeToEdge = (int) HOLE_TO_EDGE.convertToPixels();
 
-      int centerY = y + springLength - holeToEdge;
+      double centerY = y + springLength - holeToEdge;
 
       Area wafer =
           new Area(new Ellipse2D.Double(x - waferDiameter / 2, centerY - waferDiameter / 2, waferDiameter,
@@ -244,34 +244,34 @@ public class PilotLampHolder extends AbstractMultiPartComponent<String> {
       }
       
       for (int i = 1; i <= 2; i++)
-        for (Point p : controlPoints)
+        for (Point2D p : controlPoints)
-          body[i].subtract(new Area(new Ellipse2D.Double(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter, holeDiameter)));
+          body[i].subtract(new Area(new Ellipse2D.Double(p.getX() - holeDiameter / 2, p.getY() - holeDiameter / 2, holeDiameter, holeDiameter)));
     }
 
     return body;
   }
 
   private void updateControlPoints() {
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
 
     int springLength = (int) SPRING_LENGTH.convertToPixels();
     int holeToEdge = (int) HOLE_TO_EDGE.convertToPixels();
     int holeSpacing = (int) HOLE_SPACING.convertToPixels();
 
-    int centerY = y + springLength - holeToEdge;
+    double centerY = y + springLength - holeToEdge;
     
     AffineTransform rotation = AffineTransform.getRotateInstance(Math.PI * 0.295, x, centerY);
 
     rotation.transform(controlPoints[0], controlPoints[1]);
     
-    controlPoints[2].setLocation(controlPoints[0].x, controlPoints[0].y + holeSpacing);
+    controlPoints[2].setLocation(controlPoints[0].getX(), controlPoints[0].getY() + holeSpacing);
     rotation.transform(controlPoints[2], controlPoints[3]);
 
     // Rotate if needed
     if (getTheta() != 0) {
       rotation = AffineTransform.getRotateInstance(getTheta(), x, y);
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         rotation.transform(point, point);
       }
     }
@@ -365,12 +365,12 @@ public class PilotLampHolder extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
     // Invalidate the body
     body = null;

diylc/diylc-library/src/org/diylc/components/electromechanical/PinHeader.java

@@ -29,6 +29,7 @@ import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -65,7 +66,7 @@ public class PinHeader extends AbstractTransparentComponent<Void> {
 
   private Orientation orientation = Orientation.DEFAULT;
 
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   private int rowCount = 2;
   private int columnCount = 5;
   private Size spacing = PIN_SPACING;
@@ -99,7 +100,7 @@ public class PinHeader extends AbstractTransparentComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -114,26 +115,26 @@ public class PinHeader extends AbstractTransparentComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
 
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
     int pinCount = rowCount * columnCount;
-    controlPoints = new Point[pinCount];
+    controlPoints = new Point2D[pinCount];
     controlPoints[0] = firstPoint;
     double pinSpacing = spacing.convertToPixels();   
     
     for (int i = 0; i < columnCount; i++)
       for (int j = 0; j < rowCount; j++) 
-        controlPoints[i + j * columnCount] = new Point((int)Math.round(firstPoint.x + j * pinSpacing), (int)Math.round(firstPoint.y + i * pinSpacing));
+        controlPoints[i + j * columnCount] = new Point((int)Math.round(firstPoint.getX() + j * pinSpacing), (int)Math.round(firstPoint.getY() + i * pinSpacing));
     
     // Apply rotation if necessary
     double angle = getAngle();
     if (angle != 0) {
-      AffineTransform rotation = AffineTransform.getRotateInstance(angle, controlPoints[0].x, controlPoints[0].y);
+      AffineTransform rotation = AffineTransform.getRotateInstance(angle, controlPoints[0].getX(), controlPoints[0].getY());
       for (int i = 1; i < controlPoints.length; i++) {
         rotation.transform(controlPoints[i], controlPoints[i]);
       }
@@ -163,11 +164,11 @@ public class PinHeader extends AbstractTransparentComponent<Void> {
   public Area[] getBody() {
     if (body == null) {
       body = new Area[2];
-      int centerX = (controlPoints[0].x + controlPoints[controlPoints.length - 1].x) / 2;
+      double centerX = (controlPoints[0].getX() + controlPoints[controlPoints.length - 1].getX()) / 2;
-      int centerY = (controlPoints[0].y + controlPoints[controlPoints.length - 1].y) / 2;
+      double centerY = (controlPoints[0].getY() + controlPoints[controlPoints.length - 1].getY()) / 2;
       double pinSpacing = spacing.convertToPixels();
-      double width = Math.abs((controlPoints[0].x - controlPoints[controlPoints.length - 1].x)) + pinSpacing;
+      double width = Math.abs((controlPoints[0].getX() - controlPoints[controlPoints.length - 1].getX())) + pinSpacing;
-      double height = Math.abs((controlPoints[0].y - controlPoints[controlPoints.length - 1].y)) + pinSpacing;
+      double height = Math.abs((controlPoints[0].getY() - controlPoints[controlPoints.length - 1].getY())) + pinSpacing;
       if (shrouded) {
         if (orientation == Orientation.DEFAULT || orientation == Orientation._180) {
           height += 2 * pinSpacing;
@@ -236,13 +237,13 @@ public class PinHeader extends AbstractTransparentComponent<Void> {
 
     Theme theme = (Theme) ConfigurationManager.getInstance().readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
     int pinSize = (int) PIN_SIZE.convertToPixels() / 2 * 2;
-    for (Point point : controlPoints) {
+    for (Point2D point : controlPoints) {
       if (!outlineMode) {
         g2d.setColor(PIN_COLOR);
-        g2d.fillRect(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillRect((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
       g2d.setColor(outlineMode ? theme.getOutlineColor() : PIN_BORDER_COLOR);
-      g2d.drawRect(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+      g2d.drawRect((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
     }
 
     Color finalBorderColor;
@@ -358,21 +359,21 @@ public class PinHeader extends AbstractTransparentComponent<Void> {
   
   @Override
   public Rectangle2D getCachingBounds() {
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
     int margin = 50;
     for (int i = 0; i < getControlPointCount(); i++) {
-      Point p = getControlPoint(i);
+      Point2D p = getControlPoint(i);
-      if (p.x < minX)
+      if (p.getX() < minX)
-        minX = p.x;
+        minX = p.getX();
-      if (p.x > maxX)
+      if (p.getX() > maxX)
-        maxX = p.x;
+        maxX = p.getX();
-      if (p.y < minY)
+      if (p.getY() < minY)
-        minY = p.y;
+        minY = p.getY();
-      if (p.y > maxY)
+      if (p.getY() > maxY)
-        maxY = p.y;
+        maxY = p.getY();
     }
     
     return new Rectangle2D.Double(minX - margin, minY - margin, maxX - minX + 2 * margin, maxY - minY + 2 * margin);

diylc/diylc-library/src/org/diylc/components/electromechanical/PlasticDCJack.java

@@ -25,11 +25,10 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Rectangle;
 import java.awt.Shape;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -67,7 +66,7 @@ public class PlasticDCJack extends AbstractMultiPartComponent<String> {
   private static Color BORDER_COLOR = Color.black;
   private static Color MARKING_COLOR = Color.lightGray;
 
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   private String value = "";
   private DCPolarity polarity = DCPolarity.CENTER_NEGATIVE;
   transient private Area[] body;
@@ -80,12 +79,12 @@ public class PlasticDCJack extends AbstractMultiPartComponent<String> {
     // invalidate body shape
     body = null;
 
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
 
     int spacing = (int) SPACING.convertToPixels();
-    controlPoints[1] = new Point(x + spacing, y + spacing);
+    controlPoints[1] = new Point2D.Double(x + spacing, y + spacing);
-    controlPoints[2] = new Point(x - spacing, y + spacing * 2);
+    controlPoints[2] = new Point2D.Double(x - spacing, y + spacing * 2);
   }
 
   @Override
@@ -93,36 +92,36 @@ public class PlasticDCJack extends AbstractMultiPartComponent<String> {
     if (body == null) {
       body = new Area[4];
 
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int spacing = (int) SPACING.convertToPixels();
       int diameter = getClosestOdd(DIAMETER.convertToPixels());
       body[0] = new Area(new Ellipse2D.Double(x - diameter / 2, y + spacing - diameter / 2, diameter, diameter));
 
       int rectWidth = (int) (diameter / Math.sqrt(2)) - 2;
-      body[1] = new Area(new Rectangle(x - rectWidth / 2, y + spacing - rectWidth / 2, rectWidth, rectWidth));
+      body[1] = new Area(new Rectangle2D.Double(x - rectWidth / 2, y + spacing - rectWidth / 2, rectWidth, rectWidth));
 
       int lugWidth = getClosestOdd(LUG_WIDTH.convertToPixels());
       int lugThickness = getClosestOdd(LUG_THICKNESS.convertToPixels());
 
-      Point groundPoint = controlPoints[controlPoints.length - 1];
+      Point2D groundPoint = controlPoints[controlPoints.length - 1];
       Area groundLug =
-          new Area(new Ellipse2D.Double(groundPoint.x + spacing - lugWidth / 2, groundPoint.y - lugWidth / 2, lugWidth,
+          new Area(new Ellipse2D.Double(groundPoint.getX() + spacing - lugWidth / 2, groundPoint.getY() - lugWidth / 2, lugWidth,
               lugWidth));
-      groundLug.add(new Area(new Rectangle(groundPoint.x, groundPoint.y - lugWidth / 2, spacing, lugWidth)));
+      groundLug.add(new Area(new Rectangle2D.Double(groundPoint.getX(), groundPoint.getY() - lugWidth / 2, spacing, lugWidth)));
-      groundLug.subtract(new Area(new Ellipse2D.Double(groundPoint.x + spacing - lugWidth / 6, groundPoint.y - lugWidth
+      groundLug.subtract(new Area(new Ellipse2D.Double(groundPoint.getX() + spacing - lugWidth / 6, groundPoint.getY() - lugWidth
           / 6, lugWidth / 3, lugWidth / 3)));
       body[2] = groundLug;
 
       Area lugArea = new Area();
       for (int i = 0; i < controlPoints.length; i++) {
-        Point point = controlPoints[i];
+        Point2D point = controlPoints[i];
         if (i == getControlPointCount() - 1) {
           lugArea.add(new Area(
-              new Rectangle(point.x - lugThickness / 2, point.y - lugWidth / 2, lugThickness, lugWidth)));
+              new Rectangle2D.Double(point.getX() - lugThickness / 2, point.getY() - lugWidth / 2, lugThickness, lugWidth)));
         } else {
           lugArea.add(new Area(
-              new Rectangle(point.x - lugWidth / 2, point.y - lugThickness / 2, lugWidth, lugThickness)));
+              new Rectangle2D.Double(point.getX() - lugWidth / 2, point.getY() - lugThickness / 2, lugWidth, lugThickness)));
         }
       }
       body[3] = lugArea;
@@ -184,10 +183,10 @@ public class PlasticDCJack extends AbstractMultiPartComponent<String> {
       int spacing = (int) SPACING.convertToPixels();
       g2d.setColor(MARKING_COLOR);
       g2d.setFont(project.getFont().deriveFont(12f));
-      StringUtils.drawCenteredText(g2d, getPolarity() == DCPolarity.CENTER_NEGATIVE ? "+" : "-", controlPoints[0].x,
+      StringUtils.drawCenteredText(g2d, getPolarity() == DCPolarity.CENTER_NEGATIVE ? "+" : "-", controlPoints[0].getX(),
-          controlPoints[0].y - spacing * 7 / 16, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+          controlPoints[0].getY() - spacing * 7 / 16, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
-      StringUtils.drawCenteredText(g2d, getPolarity() == DCPolarity.CENTER_NEGATIVE ? "_" : "+", controlPoints[2].x,
+      StringUtils.drawCenteredText(g2d, getPolarity() == DCPolarity.CENTER_NEGATIVE ? "_" : "+", controlPoints[2].getX(),
-          controlPoints[2].y - spacing * 3 / 4, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+          controlPoints[2].getY() - spacing * 3 / 4, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     }
     
     drawSelectionOutline(g2d, componentState, outlineMode, project, drawingObserver);
@@ -222,12 +221,12 @@ public class PlasticDCJack extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     this.body = null;
   }

diylc/diylc-library/src/org/diylc/components/electromechanical/RCAJack.java

@@ -25,7 +25,6 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
@@ -71,7 +70,7 @@ public class RCAJack extends AbstractMultiPartComponent<String> {
   private static Size HOLE_TO_EDGE = new Size(0.063d, SizeUnit.in);
 
   private String value = "";
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0) };
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0) };
   transient Area[] body;
   private Orientation orientation = Orientation.DEFAULT;
 
@@ -147,10 +146,10 @@ public class RCAJack extends AbstractMultiPartComponent<String> {
     if (body == null) {
       body = new Area[4];
 
-      int x0 = controlPoints[0].x;
+      double x0 = controlPoints[0].getX();
-      int y0 = controlPoints[0].y;
+      double y0 = controlPoints[0].getY();
-      int x1 = controlPoints[1].x;
+      double x1 = controlPoints[1].getX();
-      int y1 = controlPoints[1].y;      
+      double y1 = controlPoints[1].getY();      
       int bodyDiameter = getClosestOdd(BODY_DIAMETER.convertToPixels());
       int waferDiameter = getClosestOdd(WAFER_DIAMETER.convertToPixels());      
       int springWidth = (int) SPRING_WIDTH.convertToPixels();
@@ -202,13 +201,13 @@ public class RCAJack extends AbstractMultiPartComponent<String> {
 
   @SuppressWarnings("incomplete-switch")
   private void updateControlPoints() {
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
 
     int springLength = (int) SPRING_LENGTH.convertToPixels();
     int holeToEdge = (int) HOLE_TO_EDGE.convertToPixels();
 
-    int centerY = y + springLength - holeToEdge;
+    double centerY = y + springLength - holeToEdge;
 
     controlPoints[1].setLocation(x,  centerY);    
 
@@ -284,12 +283,12 @@ public class RCAJack extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
     // Invalidate the body
     body = null;

diylc/diylc-library/src/org/diylc/components/electromechanical/RotarySelectorSwitch.java

@@ -22,11 +22,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -73,8 +73,8 @@ public class RotarySelectorSwitch extends AbstractMultiPartComponent<String> {
   private static Size HOLE_DIAMETER = new Size(2.5d, SizeUnit.mm);
 
   private String value = "";
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0),
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0),
-      new Point(0, 0), new Point(0, 0)};
+      new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   transient Area[] body;
   private Orientation orientation = Orientation.DEFAULT;
   private boolean showLabels = true;
@@ -154,8 +154,8 @@ public class RotarySelectorSwitch extends AbstractMultiPartComponent<String> {
       g2d.setFont(project.getFont().deriveFont(project.getFont().getSize2D() * 0.8f));
       for (int i = 2; i < body.length; i++) {
         Rectangle2D bounds = body[i].getBounds2D();
-        int x = (int) ((bounds.getCenterX() + controlPoints[i - 2].x) / 2);
+        double x = (int) ((bounds.getCenterX() + controlPoints[i - 2].getX()) / 2);
-        int y = (int) ((bounds.getCenterY() + controlPoints[i - 2].y) / 2);
+        double y = (int) ((bounds.getCenterY() + controlPoints[i - 2].getY()) / 2);
         StringUtils.drawCenteredText(g2d, i == 2 ? "C" : String.valueOf(i - 2), x, y,
             HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
       }
@@ -168,8 +168,8 @@ public class RotarySelectorSwitch extends AbstractMultiPartComponent<String> {
     if (body == null) {
       body = new Area[3 + getPositionCount().getCount()];
 
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int outerDiameter = getClosestOdd(OUTER_DIAMETER.convertToPixels());
       int innerDiameter = getClosestOdd(INNER_DIAMETER.convertToPixels());
       int springLength = (int) TERMINAL_LENGTH.convertToPixels();
@@ -177,7 +177,7 @@ public class RotarySelectorSwitch extends AbstractMultiPartComponent<String> {
       int holeDiameter = getClosestOdd(HOLE_DIAMETER.convertToPixels());
       int holeDistance = (int) HOLE_DISTANCE.convertToPixels();
 
-      int centerY = y - holeDistance;
+      double centerY = y - holeDistance;
 
       Area main = new Area(new Ellipse2D.Double(x - outerDiameter / 2, centerY - outerDiameter / 2,
           outerDiameter, outerDiameter));
@@ -218,12 +218,12 @@ public class RotarySelectorSwitch extends AbstractMultiPartComponent<String> {
   }
 
   private void updateControlPoints() {
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
 
     int holeDistance = (int) HOLE_DISTANCE.convertToPixels();
 
-    int centerY = y - holeDistance;
+    double centerY = y - holeDistance;
 
     for (int i = 1; i < controlPoints.length; i++) {
       double theta = -i * Math.PI / 4;
@@ -236,7 +236,7 @@ public class RotarySelectorSwitch extends AbstractMultiPartComponent<String> {
     // Rotate if needed
     if (theta != 0) {
       AffineTransform rotation = AffineTransform.getRotateInstance(theta, x, y);
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         rotation.transform(point, point);
       }
     }
@@ -292,12 +292,12 @@ public class RotarySelectorSwitch extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
     // Invalidate the body
     body = null;

diylc/diylc-library/src/org/diylc/components/guitar/AbstractGuitarPickup.java

@@ -20,11 +20,11 @@ package org.diylc.components.guitar;
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -56,8 +56,8 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
   protected Orientation orientation = Orientation.DEFAULT;
   protected transient Shape[] body;  
   
-  protected Point controlPoint = new Point(0, 0);
+  protected Point2D controlPoint = new Point2D.Double(0, 0);
-  protected Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0)};
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   
   protected Polarity polarity = Polarity.North;  
   
@@ -68,7 +68,7 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
   }
   
   protected void drawlTerminalLabels(Graphics2D g2d, Color color, Project project) {
-    Point[] points = getControlPoints();    
+    Point2D[] points = getControlPoints();    
     g2d.setColor(color);
       
     g2d.setFont(project.getFont().deriveFont(TERMINAL_FONT_SIZE * 1f));
@@ -93,8 +93,8 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
         break;     
     }   
 
-    StringUtils.drawCenteredText(g2d, "N", (points[0].x + points[1].x) / 2 + dx, (points[0].y + points[1].y) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+    StringUtils.drawCenteredText(g2d, "N", (points[0].getX() + points[1].getX()) / 2 + dx, (points[0].getY() + points[1].getY()) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
-    StringUtils.drawCenteredText(g2d, "S", (points[2].x + points[3].x) / 2 + dx, (points[2].y + points[3].y) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);   
+    StringUtils.drawCenteredText(g2d, "S", (points[2].getX() + points[3].getX()) / 2 + dx, (points[2].getY() + points[3].getY()) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);   
   }
   
   protected void drawMainLabel(Graphics2D g2d, Project project, boolean outlineMode, ComponentState componentState) {
@@ -115,7 +115,7 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
     Rectangle bounds = getBody()[0].getBounds();
     
     AffineTransform originalTx = g2d.getTransform();
-    g2d.translate(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);
+    g2d.translate(bounds.getX() + bounds.width / 2, bounds.getY() + bounds.height / 2);
     if (orientation == Orientation._90)
       g2d.rotate(Math.PI / 2);
     else if (orientation == Orientation._270){
@@ -159,11 +159,11 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
     updateControlPoints();
   }
   
-  protected Point[] getControlPoints() {
+  protected Point2D[] getControlPoints() {
     if (controlPoints == null) {
       controlPoints =
-          new Point[] {controlPoint, new Point(controlPoint.x, controlPoint.y),
+          new Point2D[] {controlPoint, new Point2D.Double(controlPoint.getX(), controlPoint.getY()),
-              new Point(controlPoint.x, controlPoint.y), new Point(controlPoint.x, controlPoint.y)};
+              new Point2D.Double(controlPoint.getX(), controlPoint.getY()), new Point2D.Double(controlPoint.getX(), controlPoint.getY())};
       updateControlPoints();
     }
     return controlPoints;
@@ -181,12 +181,12 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
 
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return getControlPoints()[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     getControlPoints()[index].setLocation(point);
     // Invalidate the body
     body = null;
@@ -225,7 +225,7 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
 
   @SuppressWarnings("incomplete-switch")
   protected void updateControlPoints() {
-    Point[] points = getControlPoints();
+    Point2D[] points = getControlPoints();
     int pointSpacing = (int) POINT_SPACING.convertToPixels();
     int dx = getControlPointDirection() == OrientationHV.HORIZONTAL ? 1 : 0;
     int dy = getControlPointDirection() == OrientationHV.HORIZONTAL ? 0 : 1;
@@ -245,11 +245,11 @@ public abstract class AbstractGuitarPickup extends AbstractTransparentComponent<
           break;
       }
     }
-    points[1].setLocation(points[0].x + dx * pointSpacing, points[0].y + dy * pointSpacing);
+    points[1].setLocation(points[0].getX() + dx * pointSpacing, points[0].getY() + dy * pointSpacing);
     points[2]
-        .setLocation(points[0].x + 2 * dx * pointSpacing, points[0].y + 2 * dy * pointSpacing);
+        .setLocation(points[0].getX() + 2 * dx * pointSpacing, points[0].getY() + 2 * dy * pointSpacing);
     points[3]
-        .setLocation(points[0].x + 3 * dx * pointSpacing, points[0].y + 3 * dy * pointSpacing);
+        .setLocation(points[0].getX() + 3 * dx * pointSpacing, points[0].getY() + 3 * dy * pointSpacing);
   }
   
   @Override

diylc/diylc-library/src/org/diylc/components/guitar/AbstractSingleOrHumbuckerPickup.java

@@ -19,7 +19,7 @@ package org.diylc.components.guitar;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.awt.StringUtils;
 import org.diylc.common.HorizontalAlignment;
@@ -35,7 +35,7 @@ public abstract class AbstractSingleOrHumbuckerPickup extends AbstractGuitarPick
     
   @Override
   protected void drawlTerminalLabels(Graphics2D g2d, Color color, Project project) {
-    Point[] points = getControlPoints();
+    Point2D[] points = getControlPoints();
     g2d.setColor(color);
 
     g2d.setFont(project.getFont().deriveFont(TERMINAL_FONT_SIZE * 1f));
@@ -61,11 +61,11 @@ public abstract class AbstractSingleOrHumbuckerPickup extends AbstractGuitarPick
     }
     
     if (getPolarity() == Polarity.North || getPolarity() == Polarity.South) {
-      StringUtils.drawCenteredText(g2d, getPolarity().name().substring(0, 1), (points[1].x + points[2].x) / 2 + dx, (points[1].y + points[2].y) / 2 + dy, HorizontalAlignment.CENTER,
+      StringUtils.drawCenteredText(g2d, getPolarity().name().substring(0, 1), (points[1].getX() + points[2].getX()) / 2 + dx, (points[1].getY() + points[2].getY()) / 2 + dy, HorizontalAlignment.CENTER,
           VerticalAlignment.CENTER);
     } else {
-      StringUtils.drawCenteredText(g2d, "N", (points[0].x + points[1].x) / 2 + dx, (points[0].y + points[1].y) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+      StringUtils.drawCenteredText(g2d, "N", (points[0].getX() + points[1].getX()) / 2 + dx, (points[0].getY() + points[1].getY()) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
-      StringUtils.drawCenteredText(g2d, "S", (points[2].x + points[3].x) / 2 + dx, (points[2].y + points[3].y) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+      StringUtils.drawCenteredText(g2d, "S", (points[2].getX() + points[3].getX()) / 2 + dx, (points[2].getY() + points[3].getY()) / 2 + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     }
   }
   

diylc/diylc-library/src/org/diylc/components/guitar/HumbuckerPickup.java

@@ -21,13 +21,13 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.Stroke;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -187,9 +187,9 @@ public class HumbuckerPickup extends AbstractGuitarPickup {
     if (body == null) {
       body = new Shape[7];
 
-      Point[] points = getControlPoints();
+      Point2D[] points = getControlPoints();
-      int x = points[0].x;
+      double x = points[0].getX();
-      int y = points[0].y;
+      double y = points[0].getY();
       int width = (int) getType().getWidth().convertToPixels();
       int length = (int) getType().getLength().convertToPixels();
       int lipWidth = (int) LIP_WIDTH.convertToPixels();

diylc/diylc-library/src/org/diylc/components/guitar/JazzBassPickup.java

@@ -25,11 +25,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.RoundRectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -144,9 +144,9 @@ public class JazzBassPickup extends AbstractSingleOrHumbuckerPickup {
     if (body == null) {
       body = new Shape[4];
 
-      Point[] points = getControlPoints();
+      Point2D[] points = getControlPoints();
-      int x = points[0].x;
+      double x = points[0].getX();
-      int y = points[0].y;
+      double y = points[0].getY();
       int width = (int) WIDTH.convertToPixels();
       int length = (int) LENGTH.convertToPixels();
       int edgeRadius = (int) EDGE_RADIUS.convertToPixels();

diylc/diylc-library/src/org/diylc/components/guitar/LPSwitch.java

@@ -25,11 +25,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -66,7 +66,7 @@ public class LPSwitch extends AbstractTransparentComponent<String> implements IS
   private static Size TERMINAL_SPACING = new Size(0.2d, SizeUnit.in);
 
   private String value = "";
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   transient Shape[] body;
   private Orientation orientation = Orientation.DEFAULT;
 
@@ -135,8 +135,8 @@ public class LPSwitch extends AbstractTransparentComponent<String> implements IS
     if (body == null) {
       body = new Shape[3];
 
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int baseLength = (int) BASE_LENGTH.convertToPixels();
       int length = (int) LENGTH.convertToPixels();
       int waferThickness = getClosestOdd(WAFER_THICKNESS.convertToPixels());
@@ -145,7 +145,7 @@ public class LPSwitch extends AbstractTransparentComponent<String> implements IS
           new Rectangle2D.Double(x - waferThickness / 2, y, waferThickness - 1, baseLength + (length - baseLength) / 2);
       body[0] = new Area(ground);
 
-      int bodyY = y + (length - baseLength) / 2;
+      double bodyY = y + (length - baseLength) / 2;
 
       Area waferArea = new Area();//new Area(new Rectangle2D.Double(x - waferThickness * 3 / 2, bodyY, waferThickness, baseLength));
       waferArea.add(new Area(new Rectangle2D.Double(x + waferThickness / 2, bodyY, waferThickness  *3, baseLength)));
@@ -215,8 +215,8 @@ public class LPSwitch extends AbstractTransparentComponent<String> implements IS
 
   @SuppressWarnings("incomplete-switch")
   private void updateControlPoints() {
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     int terminalSpacing = (int) TERMINAL_SPACING.convertToPixels();
     int length = (int) LENGTH.convertToPixels();
 
@@ -239,7 +239,7 @@ public class LPSwitch extends AbstractTransparentComponent<String> implements IS
           break;
       }
       AffineTransform rotation = AffineTransform.getRotateInstance(theta, x, y);
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         rotation.transform(point, point);
       }
     }
@@ -290,12 +290,12 @@ public class LPSwitch extends AbstractTransparentComponent<String> implements IS
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
     // Invalidate the body
     body = null;

diylc/diylc-library/src/org/diylc/components/guitar/LeverSwitch.java

@@ -25,11 +25,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -77,7 +77,7 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
   private static Size TERMINAL_SPACING = new Size(0.1d, SizeUnit.in);
 
   private String value = "";
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   transient Shape[] body;
   private Orientation orientation = Orientation.DEFAULT;
   private LeverSwitchType type = LeverSwitchType.DP3T;
@@ -147,7 +147,7 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
     
 //    g2d.setColor(Color.black);
 //    for(int i = 0; i < getControlPointCount(); i++) {
-//      g2d.drawString(i + "", controlPoints[i].x, controlPoints[i].y);
+//      g2d.drawString(i + "", controlPoints[i].getX(), controlPoints[i].getY());
 //    }
   }
 
@@ -156,8 +156,8 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
     if (body == null) {
       body = new Shape[4];
 
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int baseWidth = (int) BASE_WIDTH.convertToPixels();
       int baseLength = (int) BASE_LENGTH.convertToPixels();
       int holeSize = getClosestOdd(HOLE_SIZE.convertToPixels());
@@ -177,8 +177,8 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
         yOffset = 12;
       }      
 
-      int baseX = x - terminalLength / 2 - waferSpacing;
+      double baseX = x - terminalLength / 2 - waferSpacing;
-      int baseY = y - (baseLength - terminalSpacing * yOffset) / 2;
+      double baseY = y - (baseLength - terminalSpacing * yOffset) / 2;
       Area baseArea = new Area(new Rectangle2D.Double(baseX, baseY, baseWidth, baseLength));
       baseArea.subtract(new Area(new Ellipse2D.Double(baseX + baseWidth / 2 - holeSize / 2, baseY
           + (baseLength - holeSpacing) / 2 - holeSize / 2, holeSize, holeSize)));
@@ -217,15 +217,15 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
       Area terminalArea = new Area();
       Area commonTerminalArea = new Area();
       for (int i = 0; i < controlPoints.length; i++) {
-        Point point = controlPoints[i];
+        Point2D point = controlPoints[i];
         Area terminal =
-            new Area(new RoundRectangle2D.Double(point.x - terminalLength / 2, point.y - terminalWidth / 2,
+            new Area(new RoundRectangle2D.Double(point.getX() - terminalLength / 2, point.getY() - terminalWidth / 2,
                 terminalLength, terminalWidth, terminalWidth / 2, terminalWidth / 2));
-        terminal.subtract(new Area(new RoundRectangle2D.Double(point.x - terminalLength / 4, point.y - terminalWidth
+        terminal.subtract(new Area(new RoundRectangle2D.Double(point.getX() - terminalLength / 4, point.getY() - terminalWidth
             / 4, terminalLength / 2, terminalWidth / 2, terminalWidth / 2, terminalWidth / 2)));
         // Rotate the terminal if needed
         if (theta != 0) {
-          AffineTransform rotation = AffineTransform.getRotateInstance(theta, point.x, point.y);
+          AffineTransform rotation = AffineTransform.getRotateInstance(theta, point.getX(), point.getY());
           terminal.transform(rotation);
         }
         terminalArea.add(terminal);
@@ -242,7 +242,7 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
 
       // Rotate if needed
       if (theta != 0) {
-        AffineTransform rotation = AffineTransform.getRotateInstance(theta, controlPoints[0].x, controlPoints[0].y);
+        AffineTransform rotation = AffineTransform.getRotateInstance(theta, controlPoints[0].getX(), controlPoints[0].getY());
         // Skip the last two because terminals are already rotated
         for (int i = 0; i < body.length - 2; i++) {
           Shape shape = body[i];
@@ -256,8 +256,8 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
 
   @SuppressWarnings("incomplete-switch")
   private void updateControlPoints() {
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     int waferSpacing = (int) WAFER_SPACING.convertToPixels();
     int terminalSpacing = (int) TERMINAL_SPACING.convertToPixels();
     int terminalLength = (int) TERMINAL_LENGTH.convertToPixels();
@@ -265,28 +265,28 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
     switch (type) {
       case DP3T:
       case DP3T_5pos:
-        controlPoints = new Point[8];
+        controlPoints = new Point2D[8];
         for (int i = 0; i < 8; i++) {
-          controlPoints[i] = new Point(x + (i % 2 == 1 ? terminalLength : 0), y + i * terminalSpacing);
+          controlPoints[i] = new Point2D.Double(x + (i % 2 == 1 ? terminalLength : 0), y + i * terminalSpacing);
         }
         break;
       case DP4T:
-        controlPoints = new Point[10];
+        controlPoints = new Point2D[10];
         for (int i = 0; i < 10; i++) {
-          controlPoints[i] = new Point(x + (i % 2 == 1 ? terminalLength : 0), y + i * terminalSpacing);
+          controlPoints[i] = new Point2D.Double(x + (i % 2 == 1 ? terminalLength : 0), y + i * terminalSpacing);
         }
         break;
       case DP5T:
-        controlPoints = new Point[12];
+        controlPoints = new Point2D[12];
         for (int i = 0; i < 12; i++) {
-          controlPoints[i] = new Point(x, y + i * terminalSpacing + (i >= 6 ? terminalSpacing : 0));
+          controlPoints[i] = new Point2D.Double(x, y + i * terminalSpacing + (i >= 6 ? terminalSpacing : 0));
         }
         break;
       case _4P5T:
-        controlPoints = new Point[24];
+        controlPoints = new Point2D[24];
         for (int i = 0; i < 12; i++) {
-          controlPoints[i] = new Point(x, y + i * terminalSpacing + (i >= 6 ? terminalSpacing : 0));
+          controlPoints[i] = new Point2D.Double(x, y + i * terminalSpacing + (i >= 6 ? terminalSpacing : 0));
-          controlPoints[i + 12] = new Point(x + waferSpacing, y + i * terminalSpacing + (i >= 6 ? terminalSpacing : 0));
+          controlPoints[i + 12] = new Point2D.Double(x + waferSpacing, y + i * terminalSpacing + (i >= 6 ? terminalSpacing : 0));
         }
         break;
     }
@@ -306,7 +306,7 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
           break;
       }
       AffineTransform rotation = AffineTransform.getRotateInstance(theta, x, y);
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         rotation.transform(point, point);
       }
     }        
@@ -360,12 +360,12 @@ public class LeverSwitch extends AbstractTransparentComponent<String> implements
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
     // Invalidate the body
     body = null;

diylc/diylc-library/src/org/diylc/components/guitar/P90Pickup.java

@@ -25,13 +25,13 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Rectangle;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.RoundRectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -195,9 +195,9 @@ public class P90Pickup extends AbstractSingleOrHumbuckerPickup {
     if (body == null) {
       body = new Shape[4];
 
-      Point[] points = getControlPoints();
+      Point2D[] points = getControlPoints();
-      int x = points[0].x;
+      double x = points[0].getX();
-      int y = points[0].y;
+      double y = points[0].getY();
       int width = (int) getType().getWidth().convertToPixels();
       int length = (int) getType().getLength().convertToPixels();
       int edgeRadius = (int) getType().getEdgeRadius().convertToPixels();

diylc/diylc-library/src/org/diylc/components/guitar/PBassPickup.java

@@ -25,11 +25,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.RoundRectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -142,9 +142,9 @@ public class PBassPickup extends AbstractSingleOrHumbuckerPickup {
     if (body == null) {
       body = new Shape[4];
 
-      Point[] points = getControlPoints();
+      Point2D[] points = getControlPoints();
-      int x = points[0].x;
+      double x = points[0].getX();
-      int y = points[0].y;
+      double y = points[0].getY();
       int width = (int) WIDTH.convertToPixels();
       int length = (int) LENGTH.convertToPixels();
       int edgeRadius = (int) EDGE_RADIUS.convertToPixels();

diylc/diylc-library/src/org/diylc/components/guitar/SingleCoilPickup.java

@@ -25,11 +25,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -186,9 +186,9 @@ public class SingleCoilPickup extends AbstractSingleOrHumbuckerPickup {
     if (body == null) {
       body = new Shape[5];
 
-      Point[] points = getControlPoints();
+      Point2D[] points = getControlPoints();
-      int x = (points[0].x + points[3].x) / 2;
+      double x = (points[0].getX() + points[3].getX()) / 2;
-      int y = (points[0].y + points[3].y) / 2;;
+      double y = (points[0].getY() + points[3].getY()) / 2;;
       int width = (int) WIDTH.convertToPixels();
       int length = (int) LENGTH.convertToPixels();
       int stratInnerLength = (int) STRAT_INNER_LENGTH.convertToPixels();
@@ -327,9 +327,9 @@ public class SingleCoilPickup extends AbstractSingleOrHumbuckerPickup {
       body[1] = new Area();
       double lugHole = getClosestOdd(lugDiameter * 0.4);
       for (int i = getPolarity() == Polarity.Humbucking ? 0 : 1; i < (getPolarity() == Polarity.Humbucking ? 4 : 3); i++) {
-        Point p = points[i];
+        Point2D p = points[i];
-        ((Area)body[1]).add(new Area(new Ellipse2D.Double(p.x - lugDiameter / 2, p.y - lugDiameter / 2, lugDiameter, lugDiameter)));
+        ((Area)body[1]).add(new Area(new Ellipse2D.Double(p.getX() - lugDiameter / 2, p.getY() - lugDiameter / 2, lugDiameter, lugDiameter)));
-        ((Area)body[1]).subtract(new Area(new Ellipse2D.Double(p.x - lugHole / 2, p.y - lugHole / 2, lugHole, lugHole)));
+        ((Area)body[1]).subtract(new Area(new Ellipse2D.Double(p.getX() - lugHole / 2, p.getY() - lugHole / 2, lugHole, lugHole)));
       } 
     }
     return body;

diylc/diylc-library/src/org/diylc/components/misc/BOM.java

@@ -25,7 +25,7 @@ import java.awt.Color;
 import java.awt.Font;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.util.Iterator;
 import java.util.List;
@@ -57,7 +57,7 @@ public class BOM extends AbstractComponent<Void> {
   private static final long serialVersionUID = 1L;
   private Size size = DEFAULT_SIZE;
 
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private Color color = COLOR;
   
   @Override
@@ -116,7 +116,7 @@ public class BOM extends AbstractComponent<Void> {
     int columnWidth = (int) size.convertToPixels() / columnCount;
     int entriesPerColumn = (int) Math.ceil(1.d * bom.size() / columnCount);
     if (entriesPerColumn == 0) {
-      g2d.drawString(DEFAULT_TEXT, point.x, point.y);
+      g2d.drawString(DEFAULT_TEXT, (int)point.getX(), (int)point.getY());
       return;
     }
     for (int i = 0; i < bom.size(); i++) {
@@ -129,8 +129,8 @@ public class BOM extends AbstractComponent<Void> {
       }
       int columnIndex = i / entriesPerColumn;
       int rowIndex = i % entriesPerColumn;
-      int x = point.x + columnIndex * columnWidth;
+      int x = (int)(point.getX() + columnIndex * columnWidth);
-      int y = point.y + rowIndex * maxHeight;
+      int y = (int)(point.getY() + rowIndex * maxHeight);
       g2d.drawString(entry.getName(), x, y);
       x += maxNameWidth + SPACING.convertToPixels();
       g2d.drawString(valueStr, x, y);
@@ -176,7 +176,7 @@ public class BOM extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
@@ -191,7 +191,7 @@ public class BOM extends AbstractComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/misc/GroundSymbol.java

@@ -23,8 +23,8 @@ package org.diylc.components.misc;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.ObjectCache;
 import org.diylc.common.Orientation;
@@ -50,7 +50,7 @@ public class GroundSymbol extends AbstractComponent<Void> {
   public static Color COLOR = Color.black;
   public static Size SIZE = new Size(0.15d, SizeUnit.in);
 
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private Color color = COLOR;
   private Size size = SIZE;
   private GroundSymbolType type = GroundSymbolType.DEFAULT;
@@ -60,35 +60,35 @@ public class GroundSymbol extends AbstractComponent<Void> {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
       IDrawingObserver drawingObserver) {
-    int sizePx = (int) size.convertToPixels();
+    double sizePx = size.convertToPixels();
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
     g2d.setColor(color);
-    int x = point.x;
+    double x = point.getX();
-    int y = point.y;
+    double y = point.getY();
 
     switch (getOrientation()) {
       case _90:
-        g2d.rotate(Math.PI / 2, point.x, point.y);
+        g2d.rotate(Math.PI / 2, point.getX(), point.getY());
         break;
       case _180:
-        g2d.rotate(Math.PI, point.x, point.y);
+        g2d.rotate(Math.PI, point.getX(), point.getY());
         break;
       case _270:
-        g2d.rotate(Math.PI * 3 / 2, point.x, point.y);
+        g2d.rotate(Math.PI * 3 / 2, point.getX(), point.getY());
         break;
     }
 
-    g2d.drawLine(x, y, x, y + sizePx / 6);
+    g2d.drawLine((int)x, (int)y, (int)x, (int)(y + sizePx / 6));
     if (type == GroundSymbolType.DEFAULT) {
-      int delta = sizePx / 7;
+      double delta = sizePx / 7;
       for (int i = 0; i < 5; i++) {
-        g2d.drawLine(x - sizePx / 2 + delta * i, y + sizePx / 6 * (i + 1), x + sizePx / 2 - delta * i, y + sizePx / 6
+        g2d.drawLine((int)(x - sizePx / 2 + delta * i), (int)(y + sizePx / 6 * (i + 1)), (int)(x + sizePx / 2 - delta * i), (int)(y + sizePx / 6
-            * (i + 1));
+            * (i + 1)));
       }
     } else {
       Polygon poly =
-          new Polygon(new int[] {x - sizePx / 2, x + sizePx / 2, x}, new int[] {y + sizePx / 6, y + sizePx / 6,
+          new Polygon(new int[] {(int)(x - sizePx / 2), (int)(x + sizePx / 2), (int)x}, new int[] {(int)(y + sizePx / 6), (int)(y + sizePx / 6),
-              y + sizePx}, 3);
+              (int)(y + sizePx)}, 3);
       g2d.draw(poly);
     }
   }
@@ -126,7 +126,7 @@ public class GroundSymbol extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
@@ -159,7 +159,7 @@ public class GroundSymbol extends AbstractComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 //  

diylc/diylc-library/src/org/diylc/components/misc/Image.java

@@ -20,8 +20,8 @@ package org.diylc.components.misc;
 import java.awt.AlphaComposite;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayOutputStream;
@@ -47,7 +47,6 @@ import org.diylc.core.annotations.PercentEditor;
 
 import com.thoughtworks.xstream.annotations.XStreamConverter;
 
-
 @ComponentDescriptor(name = "Image", author = "Branislav Stojkovic", category = "Misc",
     description = "User defined image", instanceNamePrefix = "Img", zOrder = IDIYComponent.COMPONENT,
     flexibleZOrder = true, bomPolicy = BomPolicy.NEVER_SHOW)
@@ -58,6 +57,9 @@ public class Image extends AbstractTransparentComponent<Void> {
   private static ImageIcon ICON;
   private static byte DEFAULT_SCALE = 25;
   
+  private Point2D point = new Point2D.Double(0, 0);
+  private Point2D secondPoint = null;
+
   static {
     String name = "image.png";
     java.net.URL imgURL = Image.class.getResource(name);
@@ -71,9 +73,6 @@ public class Image extends AbstractTransparentComponent<Void> {
     return null;
   }  
 
-  private Point point = new Point(0, 0);
-  private Point secondPoint = null;
-
   @XStreamConverter(IconImageConverter.class)
   @Deprecated
   private ImageIcon image;
@@ -99,9 +98,9 @@ public class Image extends AbstractTransparentComponent<Void> {
     if (getSizingMode() == ImageSizingMode.Scale) {
       scaleX = scaleY = 1d * getScale() / DEFAULT_SCALE;
     } else {
-      Point secondPoint = getControlPoint(1);
+      Point2D secondPoint = getControlPoint(1);
-      scaleX = 1d * Math.abs(point.x - secondPoint.x) / imageIcon.getIconWidth();
+      scaleX = 1d * Math.abs(point.getX() - secondPoint.getX()) / imageIcon.getIconWidth();
-      scaleY = 1d * Math.abs(point.y - secondPoint.y) / imageIcon.getIconHeight();
+      scaleY = 1d * Math.abs(point.getY() - secondPoint.getY()) / imageIcon.getIconHeight();
     }
     
     Shape clip = g2d.getClip().getBounds();
@@ -114,16 +113,16 @@ public class Image extends AbstractTransparentComponent<Void> {
       g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
     }
     
-    int x;
+    double x;
-    int y;
+    double y;
     if (getSizingMode() == ImageSizingMode.Scale)
     {
-      x = point.x;
+      x = point.getX();
-      y = point.y;
+      y = point.getY();
     } else {
-      Point secondPoint = getControlPoint(1);
+      Point2D secondPoint = getControlPoint(1);
-      x = Math.min(point.x, secondPoint.x);
+      x = Math.min(point.getX(), secondPoint.getX());
-      y = Math.min(point.y, secondPoint.y);
+      y = Math.min(point.getY(), secondPoint.getY());
     }
 
     g2d.scale(scaleX, scaleY);
@@ -133,13 +132,13 @@ public class Image extends AbstractTransparentComponent<Void> {
       g2d.scale(1 / scaleX, 1 / scaleY);
       g2d.setColor(SELECTION_COLOR);
       g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
-      g2d.drawRect(x, y, (int) (imageIcon.getIconWidth() * scaleX), (int) (imageIcon.getIconHeight() * scaleY));
+      g2d.drawRect((int)x, (int)y, (int) (imageIcon.getIconWidth() * scaleX), (int) (imageIcon.getIconHeight() * scaleY));
     }
   }
 
   @Override
   public void drawIcon(Graphics2D g2d, int width, int height) {
-    g2d.drawImage(ICON.getImage(), point.x, point.y, null);
+    g2d.drawImage(ICON.getImage(), (int)point.getX(), (int)point.getY(), null);
   }
 
   @Override
@@ -148,12 +147,12 @@ public class Image extends AbstractTransparentComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     if (index == 0)
       return point;
     if (secondPoint == null) {
       ImageIcon imageIcon = getImage();
-      secondPoint = new Point(point.x + imageIcon.getIconWidth(), point.y + imageIcon.getIconHeight());
+      secondPoint = new Point2D.Double(point.getX() + imageIcon.getIconWidth(), point.getY() + imageIcon.getIconHeight());
     }
     return secondPoint;
   }
@@ -169,14 +168,14 @@ public class Image extends AbstractTransparentComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     if (index == 0) {
-      this.point.setLocation(point);
+      this.point.setLocation(point.getX(), point.getY());
     } else {
       if (secondPoint == null)
-        secondPoint = new Point(point);
+        secondPoint = new Point2D.Double(point.getX(), point.getY());
       else
-        secondPoint.setLocation(point);
+        secondPoint.setLocation(point.getX(), point.getY());
     }
   }
 
@@ -208,7 +207,7 @@ public class Image extends AbstractTransparentComponent<Void> {
     this.image = null;
     if (getSizingMode() == ImageSizingMode.TwoPoints) {
       ImageIcon imageIcon = getImage();
-      setControlPoint(new Point(point.x + imageIcon.getIconWidth(), point.y + imageIcon.getIconHeight()), 1);
+      setControlPoint(new Point2D.Double(point.getX() + imageIcon.getIconWidth(), point.getY() + imageIcon.getIconHeight()), 1);
     }
   }
 

diylc/diylc-library/src/org/diylc/components/misc/Label.java

@@ -25,7 +25,7 @@ import java.awt.Color;
 import java.awt.Font;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.common.HorizontalAlignment;
@@ -51,7 +51,7 @@ public class Label extends AbstractComponent<String> {
 
   private static final long serialVersionUID = 1L;
 
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private String text = DEFAULT_TEXT;
   private Font font = LABEL_FONT;
   private Color color = LABEL_COLOR;
@@ -74,30 +74,30 @@ public class Label extends AbstractComponent<String> {
     int textHeight = (int) rect.getHeight();
     int textWidth = (int) rect.getWidth();
 
-    int x = point.x;
+    double x = point.getX();
-    int y = point.y;
+    double y = point.getY();
     switch (getVerticalAlignment()) {
       case CENTER:
-        y = point.y - textHeight / 2 + fontMetrics.getAscent();
+        y = point.getY() - textHeight / 2 + fontMetrics.getAscent();
         break;
       case TOP:
-        y = point.y - textHeight + fontMetrics.getAscent();
+        y = point.getY() - textHeight + fontMetrics.getAscent();
         break;
       case BOTTOM:
-        y = point.y + fontMetrics.getAscent();
+        y = point.getY() + fontMetrics.getAscent();
         break;
       default:
         throw new RuntimeException("Unexpected alignment: " + getVerticalAlignment());
     }
     switch (getHorizontalAlignment()) {
       case CENTER:
-        x = point.x - textWidth / 2;
+        x = point.getX() - textWidth / 2;
         break;
       case LEFT:
-        x = point.x;
+        x = point.getX();
         break;
       case RIGHT:
-        x = point.x - textWidth;
+        x = point.getX() - textWidth;
         break;
       default:
         throw new RuntimeException("Unexpected alignment: " + getHorizontalAlignment());
@@ -105,16 +105,16 @@ public class Label extends AbstractComponent<String> {
 
     switch (getOrientation()) {
       case _90:
-        g2d.rotate(Math.PI / 2, point.x, point.y);
+        g2d.rotate(Math.PI / 2, point.getX(), point.getY());
         break;
       case _180:
-        g2d.rotate(Math.PI, point.x, point.y);
+        g2d.rotate(Math.PI, point.getX(), point.getY());
         break;
       case _270:
-        g2d.rotate(Math.PI * 3 / 2, point.x, point.y);
+        g2d.rotate(Math.PI * 3 / 2, point.getX(), point.getY());
         break;
     }
-    g2d.drawString(text, x, y);
+    g2d.drawString(text, (int)x, (int)y);
   }
 
   @Override
@@ -216,7 +216,7 @@ public class Label extends AbstractComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
@@ -231,7 +231,7 @@ public class Label extends AbstractComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }  
 

diylc/diylc-library/src/org/diylc/components/misc/Loadline.java

@@ -22,18 +22,14 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.ObjectCache;
-import org.diylc.common.SimpleComponentTransformer;
 import org.diylc.components.boards.AbstractBoard;
 import org.diylc.core.ComponentState;
-import org.diylc.core.IDIYComponent;
 import org.diylc.core.IDrawingObserver;
 import org.diylc.core.Project;
-import org.diylc.core.annotations.BomPolicy;
-import org.diylc.core.annotations.ComponentDescriptor;
 import org.diylc.core.annotations.EditableProperty;
 
 //@ComponentDescriptor(name = "Loadline", category = "Misc", author = "Branislav Stojkovic",
@@ -66,11 +62,11 @@ public class Loadline extends AbstractBoard {
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
       Project project, IDrawingObserver drawingObserver) {
-    Point finalSecondPoint = getFinalSecondPoint();
+    Point2D finalSecondPoint = getFinalSecondPoint();
 
     Shape clip = g2d.getClip();
-    if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, finalSecondPoint.y)
+    if (checkPointsClipped(clip) && !clip.contains(firstPoint.getX(), finalSecondPoint.getY())
-        && !clip.contains(finalSecondPoint.x, firstPoint.y)) {
+        && !clip.contains(finalSecondPoint.getX(), firstPoint.getY())) {
       return;
     }
 
@@ -83,8 +79,8 @@ public class Loadline extends AbstractBoard {
       }
       g2d.setColor(boardColor);
 
-      g2d.fillRect(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x,
+      g2d.fillRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()),
-          finalSecondPoint.y - firstPoint.y);
+          (int)(finalSecondPoint.getY() - firstPoint.getY()));
 
       g2d.setComposite(oldComposite);
     }
@@ -96,8 +92,8 @@ public class Loadline extends AbstractBoard {
             ? SELECTION_COLOR
             : borderColor);
 
-    g2d.drawRect(firstPoint.x, firstPoint.y, finalSecondPoint.x - firstPoint.x,
+    g2d.drawRect((int)firstPoint.getX(), (int)firstPoint.getY(), (int)(finalSecondPoint.getX() - firstPoint.getX()),
-        finalSecondPoint.y - firstPoint.y);
+        (int)(finalSecondPoint.getY() - firstPoint.getY()));
 
   }
 

diylc/diylc-library/src/org/diylc/components/misc/LoadlineCurve.java

@@ -3,7 +3,7 @@ package org.diylc.components.misc;
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.awt.StringUtils;
 import org.diylc.common.HorizontalAlignment;
@@ -34,10 +34,10 @@ public class LoadlineCurve extends CurvedTrace {
     g2d.setColor(Color.black);
     Font oldFont = g2d.getFont();
     g2d.setFont(project.getFont().deriveFont(12f).deriveFont(Font.BOLD));
-    Point lastPoint = getControlPoint(getControlPointCount() - 1);
+    Point2D lastPoint = getControlPoint(getControlPointCount() - 1);
     int spacing = (int) LABEL_SPACING.convertToPixels();
-    int x = lastPoint.x + spacing;
+    double x = lastPoint.getX() + spacing;
-    int y = lastPoint.y - spacing;
+    double y = lastPoint.getY() - spacing;
     StringUtils.drawCenteredText(g2d, getVoltage().toString(), x, y, HorizontalAlignment.LEFT, VerticalAlignment.TOP);
     g2d.setFont(oldFont);
   }

diylc/diylc-library/src/org/diylc/components/misc/PCBText.java

@@ -25,8 +25,8 @@ import java.awt.Color;
 import java.awt.Font;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.common.HorizontalAlignment;
@@ -55,7 +55,7 @@ public class PCBText extends AbstractComponent<Void> {
 
   private static final long serialVersionUID = 1L;
 
-  private Point point = new Point(0, 0);
+  private Point2D point = new Point2D.Double(0, 0);
   private String text = DEFAULT_TEXT;
   private Font font = DEFAULT_FONT;
   private Color color = LABEL_COLOR;
@@ -77,30 +77,30 @@ public class PCBText extends AbstractComponent<Void> {
     int textHeight = (int) rect.getHeight();
     int textWidth = (int) rect.getWidth();
 
-    int x = point.x;
+    double x = point.getX();
-    int y = point.y;
+    double y = point.getY();
     switch (getVerticalAlignment()) {
       case CENTER:
-        y = point.y - textHeight / 2 + fontMetrics.getAscent();
+        y = point.getY() - textHeight / 2 + fontMetrics.getAscent();
         break;
       case TOP:
-        y = point.y - textHeight + fontMetrics.getAscent();
+        y = point.getY() - textHeight + fontMetrics.getAscent();
         break;
       case BOTTOM:
-        y = point.y + fontMetrics.getAscent();
+        y = point.getY() + fontMetrics.getAscent();
         break;
       default:
         throw new RuntimeException("Unexpected alignment: " + getVerticalAlignment());
     }
     switch (getHorizontalAlignment()) {
       case CENTER:
-        x = point.x - textWidth / 2;
+        x = point.getX() - textWidth / 2;
         break;
       case LEFT:
-        x = point.x;
+        x = point.getX();
         break;
       case RIGHT:
-        x = point.x - textWidth;
+        x = point.getX() - textWidth;
         break;
       default:
         throw new RuntimeException("Unexpected alignment: " + getHorizontalAlignment());
@@ -108,13 +108,13 @@ public class PCBText extends AbstractComponent<Void> {
 
     switch (getOrientation()) {
       case _90:
-        g2d.rotate(Math.PI / 2, point.x, point.y);
+        g2d.rotate(Math.PI / 2, point.getX(), point.getY());
         break;
       case _180:
-        g2d.rotate(Math.PI, point.x, point.y);
+        g2d.rotate(Math.PI, point.getX(), point.getY());
         break;
       case _270:
-        g2d.rotate(Math.PI * 3 / 2, point.x, point.y);
+        g2d.rotate(Math.PI * 3 / 2, point.getX(), point.getY());
         break;
     }
     
@@ -125,7 +125,7 @@ public class PCBText extends AbstractComponent<Void> {
     tx.translate(-2 * x - textWidth, 0);
     g2d.transform(tx);
 
-    g2d.drawString(text, x, y);
+    g2d.drawString(text, (int)x, (int)y);
     
     g2d.setTransform(oldTx);
   }
@@ -231,7 +231,7 @@ public class PCBText extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return point;
   }
 
@@ -246,7 +246,7 @@ public class PCBText extends AbstractComponent<Void> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.point.setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/misc/WrapLabel.java

@@ -25,7 +25,7 @@ import java.awt.Color;
 import java.awt.Font;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.awt.StringUtils;
@@ -54,10 +54,10 @@ public class WrapLabel extends AbstractComponent<String> {
   public static Size DEFAULT_WIDTH = new Size(1.5d, SizeUnit.in);
   public static Size DEFAULT_HEIGHT = new Size(0.5d, SizeUnit.in);
   
-  protected Point[] controlPoints = new Point[] {new Point(0, 0),
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0),
-      new Point((int) DEFAULT_WIDTH.convertToPixels(), (int) DEFAULT_HEIGHT.convertToPixels())};
+      new Point2D.Double((int) DEFAULT_WIDTH.convertToPixels(), (int) DEFAULT_HEIGHT.convertToPixels())};
-  protected Point firstPoint = new Point();
+  protected Point2D firstPoint = new Point2D.Double();
-  protected Point secondPoint = new Point();
+  protected Point2D secondPoint = new Point2D.Double();
   
   private Font font = LABEL_FONT;
   private Color color = LABEL_COLOR;
@@ -86,17 +86,17 @@ public class WrapLabel extends AbstractComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
-    firstPoint.setLocation(Math.min(controlPoints[0].x, controlPoints[1].x),
+    firstPoint.setLocation(Math.min(controlPoints[0].getX(), controlPoints[1].getX()),
-        Math.min(controlPoints[0].y, controlPoints[1].y));
+        Math.min(controlPoints[0].getY(), controlPoints[1].getY()));
-    secondPoint.setLocation(Math.max(controlPoints[0].x, controlPoints[1].x),
+    secondPoint.setLocation(Math.max(controlPoints[0].getX(), controlPoints[1].getX()),
-        Math.max(controlPoints[0].y, controlPoints[1].y));
+        Math.max(controlPoints[0].getY(), controlPoints[1].getY()));
   }
 
   @Override
@@ -178,11 +178,11 @@ public class WrapLabel extends AbstractComponent<String> {
     g2d.setColor(componentState == ComponentState.SELECTED ? LABEL_COLOR_SELECTED : color);
     g2d.setFont(font);
 
-    int x = firstPoint.x;
+    double x = firstPoint.getX();
-    int y = firstPoint.y;
+    double y = firstPoint.getY();
-    int maxWidth = secondPoint.x - firstPoint.x;
+    double maxWidth = secondPoint.getX() - firstPoint.getX();
     
-    StringUtils.drawWrappedText(value, g2d, x, y, maxWidth, horizontalAlignment);
+    StringUtils.drawWrappedText(value, g2d, (int)x, (int)y, (int)maxWidth, horizontalAlignment);
   }
 
   @Override

diylc/diylc-library/src/org/diylc/components/passive/AbstractPotentiometer.java

@@ -21,7 +21,7 @@
 */
 package org.diylc.components.passive;
 
-import java.awt.Point;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.Orientation;
 import org.diylc.components.AbstractTransparentComponent;
@@ -34,7 +34,7 @@ public abstract class AbstractPotentiometer extends AbstractTransparentComponent
 
   private static final long serialVersionUID = 1L;
 
-  protected Point[] controlPoints;
+  protected Point2D[] controlPoints;
 
   protected Resistance resistance = null;
   protected Orientation orientation = Orientation.DEFAULT;
@@ -46,12 +46,12 @@ public abstract class AbstractPotentiometer extends AbstractTransparentComponent
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D    point, int index) {
     controlPoints[index].setLocation(point);
   }
 

diylc/diylc-library/src/org/diylc/components/passive/AudioTransformer.java

@@ -26,10 +26,10 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -82,7 +82,7 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
   private Size coreWidth = new Size(0.6, SizeUnit.in);
   private Size coilWidth = new Size(0.5, SizeUnit.in);
   private Size coilLength = new Size(0.6, SizeUnit.in);
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   protected Display display = Display.BOTH;
   private Color coreColor = CORE_COLOR;
   private Color coreBorderColor = CORE_BORDER_COLOR;
@@ -163,7 +163,7 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -178,24 +178,24 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
 
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
     int pinCount = 4 + (primaryCT ? 1 : 0) + (secondaryCT ? 1 : 0);
-    controlPoints = new Point[pinCount];
+    controlPoints = new Point2D[pinCount];
     controlPoints[0] = firstPoint;
     double leadSpacing = this.leadSpacing.convertToPixels();
     double windingSpacing = this.windingSpacing.convertToPixels();
     
     // Update control points.
     for (int i = 1; i < 2 + (primaryCT ? 1 : 0); i++)
-      controlPoints[i] = new Point(firstPoint.x, (int) (firstPoint.y + i * leadSpacing * (primaryCT ? 1 : 2)));    
+      controlPoints[i] = new Point2D.Double(firstPoint.getX(), firstPoint.getY() + i * leadSpacing * (primaryCT ? 1 : 2));    
     for (int i = 0; i < 2 + (secondaryCT ? 1 : 0); i++)
-      controlPoints[2 + (primaryCT ? 1 : 0) + i] = new Point((int) (firstPoint.x + windingSpacing), (int) (firstPoint.y + i * leadSpacing * (secondaryCT ? 1 : 2)));    
+      controlPoints[2 + (primaryCT ? 1 : 0) + i] = new Point2D.Double(firstPoint.getX() + windingSpacing, firstPoint.getY() + i * leadSpacing * (secondaryCT ? 1 : 2));    
         
     AffineTransform tx = getTx();
 
@@ -212,8 +212,8 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
       body = new Area[2];
       double leadSpacing = this.leadSpacing.convertToPixels();
       double windingSpacing = this.windingSpacing.convertToPixels();
-      int centerX = (int) (controlPoints[0].x + windingSpacing / 2);
+      double centerX = (int) (controlPoints[0].getX() + windingSpacing / 2);
-      int centerY = (int) (controlPoints[0].y + leadSpacing);
+      double centerY = (int) (controlPoints[0].getY() + leadSpacing);
       int coreWidth = getClosestOdd(this.coreWidth.convertToPixels());
       int coreThickness = getClosestOdd(this.coreThickness.convertToPixels());
       int coilWidth = getClosestOdd(this.coilWidth.convertToPixels());
@@ -235,8 +235,8 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
   
   @SuppressWarnings("incomplete-switch")
   private AffineTransform getTx() {
-    double x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    double y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     if (orientation == Orientation.DEFAULT)
       return null;
     
@@ -269,11 +269,11 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
         
     if (!outlineMode) {
       int pinSize = (int) PIN_SIZE.convertToPixels() / 2 * 2;
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         g2d.setColor(PIN_COLOR);
-        g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
         g2d.setColor(PIN_BORDER_COLOR);
-        g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.drawOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
     }
     Composite oldComposite = g2d.getComposite();
@@ -312,15 +312,15 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
     g2d.setFont(project.getFont());
     
     // Draw winding designations
-    Point wPoint = new Point((int) (controlPoints[0].x + project.getFontSize()), (int) (controlPoints[0].y + leadSpacing.convertToPixels()));
+    Point2D wPoint = new Point2D.Double((int) (controlPoints[0].getX() + project.getFontSize()), (int) (controlPoints[0].getY() + leadSpacing.convertToPixels()));
     AffineTransform tx = getTx();
     if (tx != null)
       tx.transform(wPoint, wPoint);
-    StringUtils.drawCenteredText(g2d, "P", wPoint.x, wPoint.y, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+    StringUtils.drawCenteredText(g2d, "P", wPoint.getX(), wPoint.getY(), HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
-    wPoint = new Point((int) (controlPoints[0].x + windingSpacing.convertToPixels() - project.getFontSize()), (int) (controlPoints[0].y + leadSpacing.convertToPixels()));
+    wPoint = new Point2D.Double((int) (controlPoints[0].getX() + windingSpacing.convertToPixels() - project.getFontSize()), (int) (controlPoints[0].getY() + leadSpacing.convertToPixels()));
     if (tx != null)
       tx.transform(wPoint, wPoint);
-    StringUtils.drawCenteredText(g2d, "S", wPoint.x, wPoint.y, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+    StringUtils.drawCenteredText(g2d, "S", wPoint.getX(), wPoint.getY(), HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
 
     // Draw label.
     Color finalLabelColor;
@@ -356,14 +356,14 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
         int textWidth = (int) (rect.getWidth());
         // Center text horizontally and vertically
         Rectangle bounds = coreArea.getBounds();
-        int x = bounds.x + (bounds.width - textWidth) / 2;
+        double x = bounds.getX() + (bounds.width - textWidth) / 2;
-        int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+        double y = bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
 
         AffineTransform oldTransform = g2d.getTransform();
 
         if (getOrientation() == Orientation.DEFAULT || getOrientation() == Orientation._180) {
-          int centerX = bounds.x + bounds.width / 2;
+          double centerX = bounds.getX() + bounds.width / 2;
-          int centerY = bounds.y + bounds.height / 2;
+          double centerY = bounds.getY() + bounds.height / 2;
           g2d.rotate(-Math.PI / 2, centerX, centerY);
         }
 
@@ -374,7 +374,7 @@ public class AudioTransformer extends AbstractMultiPartComponent<String> {
             g2d.translate(0, textHeight / 2);
         }
 
-        g2d.drawString(l, x, y);
+        g2d.drawString(l, (int)x, (int)y);
 
         g2d.setTransform(oldTransform);
       }

diylc/diylc-library/src/org/diylc/components/passive/MultiSectionCapacitor.java

@@ -25,10 +25,10 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.text.DecimalFormat;
 import java.text.Format;
@@ -79,7 +79,7 @@ public class MultiSectionCapacitor extends AbstractTransparentComponent<Capacita
   private org.diylc.core.measures.Voltage voltage = null;
 
   private Orientation orientation = Orientation.DEFAULT;
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   transient private Area[] body;
   private Color bodyColor = BODY_COLOR;
   private Color baseColor = BASE_COLOR;
@@ -169,7 +169,7 @@ public class MultiSectionCapacitor extends AbstractTransparentComponent<Capacita
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -184,7 +184,7 @@ public class MultiSectionCapacitor extends AbstractTransparentComponent<Capacita
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
@@ -195,17 +195,17 @@ public class MultiSectionCapacitor extends AbstractTransparentComponent<Capacita
     int newCount = value.length + 1;
     if (newCount != controlPoints.length) {
       // need new control points
-      Point[] newPoints = new Point[newCount];
+      Point2D[] newPoints = new Point2D[newCount];
       newPoints[0] = controlPoints[0];
       for (int i = 1; i < newCount; i++) {
-        newPoints[i] = new Point(0, 0);
+        newPoints[i] = new Point2D.Double(0, 0);
       }
       controlPoints = newPoints;
     }
     
     // Update control points.
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     
     if (newCount == 2) {      
       switch (orientation) {
@@ -286,8 +286,8 @@ public class MultiSectionCapacitor extends AbstractTransparentComponent<Capacita
     if (body == null) {
       double centerX;
       double centerY;
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int pinSpacing = (int) (getDiameter().convertToPixels() * RELATIVE_DIAMETERS[value == null || value.length == 1 ? 0 : 1]);
       if (controlPoints.length == 2 || controlPoints.length == 3) {       
         switch (orientation) {
@@ -380,13 +380,13 @@ public class MultiSectionCapacitor extends AbstractTransparentComponent<Capacita
       g2d.draw(area[1]);
     }
 
-    for (Point point : controlPoints) {
+    for (Point2D point : controlPoints) {
       if (!outlineMode) {
         g2d.setColor(pinColor);
-        g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
       g2d.setColor(outlineMode ? theme.getOutlineColor() : pinColor.darker());
-      g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+      g2d.drawOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
     }
 
     // Draw label.
@@ -416,18 +416,18 @@ public class MultiSectionCapacitor extends AbstractTransparentComponent<Capacita
     
     Rectangle bounds = area[0].getBounds();
 
-    StringUtils.drawCenteredText(g2d, label, bounds.x + bounds.width / 2, bounds.y + bounds.height / 2, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+    StringUtils.drawCenteredText(g2d, label, bounds.getX() + bounds.width / 2, bounds.getY() + bounds.height / 2, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     
     // draw polarity markers
     g2d.setColor(pinColor.darker());
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(2f));
     double markerSize = pinSize * 0.7;
     for (int i = 0; i < controlPoints.length; i++) {
-      int x = controlPoints[i].x;
+      double x = controlPoints[i].getX();
-      int y = controlPoints[i].y;
+      double y = controlPoints[i].getY();
-      g2d.drawLine((int)(x - markerSize / 2), y, (int)(x + markerSize / 2), y);
+      g2d.drawLine((int)(x - markerSize / 2), (int)y, (int)(x + markerSize / 2), (int)y);
       if (i > 0)
-        g2d.drawLine(x, (int)(y - markerSize / 2), x, (int)(y + markerSize / 2));
+        g2d.drawLine((int)x, (int)(y - markerSize / 2), (int)x, (int)(y + markerSize / 2));
     }
   }
 

diylc/diylc-library/src/org/diylc/components/passive/PotentiometerPanel.java

@@ -30,6 +30,7 @@ import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -93,20 +94,20 @@ public class PotentiometerPanel extends AbstractPotentiometer {
     int spacing = (int) this.spacing.convertToPixels();
     switch (orientation) {
       case DEFAULT:
-        controlPoints[1].setLocation(controlPoints[0].x + spacing, controlPoints[0].y);
+        controlPoints[1].setLocation(controlPoints[0].getX() + spacing, controlPoints[0].getY());
-        controlPoints[2].setLocation(controlPoints[0].x + 2 * spacing, controlPoints[0].y);
+        controlPoints[2].setLocation(controlPoints[0].getX() + 2 * spacing, controlPoints[0].getY());
         break;
       case _90:
-        controlPoints[1].setLocation(controlPoints[0].x, controlPoints[0].y + spacing);
+        controlPoints[1].setLocation(controlPoints[0].getX(), controlPoints[0].getY() + spacing);
-        controlPoints[2].setLocation(controlPoints[0].x, controlPoints[0].y + 2 * spacing);
+        controlPoints[2].setLocation(controlPoints[0].getX(), controlPoints[0].getY() + 2 * spacing);
         break;
       case _180:
-        controlPoints[1].setLocation(controlPoints[0].x - spacing, controlPoints[0].y);
+        controlPoints[1].setLocation(controlPoints[0].getX() - spacing, controlPoints[0].getY());
-        controlPoints[2].setLocation(controlPoints[0].x - 2 * spacing, controlPoints[0].y);
+        controlPoints[2].setLocation(controlPoints[0].getX() - 2 * spacing, controlPoints[0].getY());
         break;
       case _270:
-        controlPoints[1].setLocation(controlPoints[0].x, controlPoints[0].y - spacing);
+        controlPoints[1].setLocation(controlPoints[0].getX(), controlPoints[0].getY() - spacing);
-        controlPoints[2].setLocation(controlPoints[0].x, controlPoints[0].y - 2 * spacing);
+        controlPoints[2].setLocation(controlPoints[0].getX(), controlPoints[0].getY() - 2 * spacing);
         break;
       default:
         break;
@@ -124,66 +125,66 @@ public class PotentiometerPanel extends AbstractPotentiometer {
       // Add lugs.
       int pinWidth = (int) PIN_SIZE.convertToPixels();
 
-      int centerX = 0;
+      double centerX = 0;
-      int centerY = 0;
+      double centerY = 0;
 
       double waferWidth = 2.5 * spacing;
       double waferHeight = spacing;
 
       switch (orientation) {
         case DEFAULT:
-          centerX = controlPoints[0].x + spacing;
+          centerX = controlPoints[0].getX() + spacing;
-          centerY = controlPoints[0].y - spacing / 2 - diameter / 2;
+          centerY = controlPoints[0].getY() - spacing / 2 - diameter / 2;
 
           body[9] =
-              new Area(new RoundRectangle2D.Double(centerX - waferWidth / 2, controlPoints[0].y - waferHeight - spacing
+              new Area(new RoundRectangle2D.Double(centerX - waferWidth / 2, controlPoints[0].getY() - waferHeight - spacing
                   / 2, waferWidth, waferHeight, spacing / 4, spacing / 4));
 
           for (int i = 0; i < 3; i++) {
             body[i] =
-                new Area(new Rectangle2D.Double(controlPoints[i].x - pinWidth / 2, controlPoints[i].y
+                new Area(new Rectangle2D.Double(controlPoints[i].getX() - pinWidth / 2, controlPoints[i].getY()
                     - (spacing + diameter) / 2, pinWidth, (spacing + diameter) / 2));
           }
           break;
         case _90:
-          centerX = controlPoints[0].x + spacing / 2 + diameter / 2;
+          centerX = controlPoints[0].getX() + spacing / 2 + diameter / 2;
-          centerY = controlPoints[0].y + spacing;
+          centerY = controlPoints[0].getY() + spacing;
 
           body[9] =
-              new Area(new RoundRectangle2D.Double(controlPoints[0].x + spacing / 2, centerY - waferWidth / 2,
+              new Area(new RoundRectangle2D.Double(controlPoints[0].getX() + spacing / 2, centerY - waferWidth / 2,
                   waferHeight, waferWidth, spacing / 4, spacing / 4));
 
           for (int i = 0; i < 3; i++) {
             body[i] =
-                new Area(new Rectangle2D.Double(controlPoints[i].x, controlPoints[i].y - pinWidth / 2,
+                new Area(new Rectangle2D.Double(controlPoints[i].getX(), controlPoints[i].getY() - pinWidth / 2,
                     (spacing + diameter) / 2, pinWidth));
           }
           break;
         case _180:
-          centerX = controlPoints[0].x - spacing;
+          centerX = controlPoints[0].getX() - spacing;
-          centerY = controlPoints[0].y + spacing / 2 + diameter / 2;
+          centerY = controlPoints[0].getY() + spacing / 2 + diameter / 2;
 
           body[9] =
-              new Area(new RoundRectangle2D.Double(centerX - waferWidth / 2, controlPoints[0].y + spacing / 2,
+              new Area(new RoundRectangle2D.Double(centerX - waferWidth / 2, controlPoints[0].getY() + spacing / 2,
                   waferWidth, waferHeight, spacing / 4, spacing / 4));
 
           for (int i = 0; i < 3; i++) {
             body[i] =
-                new Area(new Rectangle2D.Double(controlPoints[i].x - pinWidth / 2, controlPoints[i].y, pinWidth,
+                new Area(new Rectangle2D.Double(controlPoints[i].getX() - pinWidth / 2, controlPoints[i].getY(), pinWidth,
                     (spacing + diameter) / 2));
           }
           break;
         case _270:
-          centerX = controlPoints[0].x - spacing / 2 - diameter / 2;
+          centerX = controlPoints[0].getX() - spacing / 2 - diameter / 2;
-          centerY = controlPoints[0].y - spacing;
+          centerY = controlPoints[0].getY() - spacing;
 
           body[9] =
-              new Area(new RoundRectangle2D.Double(controlPoints[0].x - waferHeight - spacing / 2, centerY - waferWidth
+              new Area(new RoundRectangle2D.Double(controlPoints[0].getX() - waferHeight - spacing / 2, centerY - waferWidth
                   / 2, waferHeight, waferWidth, spacing / 4, spacing / 4));
 
           for (int i = 0; i < 3; i++) {
             body[i] =
-                new Area(new Rectangle2D.Double(controlPoints[i].x - (spacing + diameter) / 2, controlPoints[i].y
+                new Area(new Rectangle2D.Double(controlPoints[i].getX() - (spacing + diameter) / 2, controlPoints[i].getY()
                     - pinWidth / 2, (spacing + diameter) / 2, pinWidth));
           }
           break;
@@ -205,7 +206,7 @@ public class PotentiometerPanel extends AbstractPotentiometer {
 
         for (int i = 0; i < 3; i++) {
           Area area =
-              new Area(new Ellipse2D.Double(controlPoints[i].x - lugDiameter / 2, controlPoints[i].y - lugDiameter / 2,
+              new Area(new Ellipse2D.Double(controlPoints[i].getX() - lugDiameter / 2, controlPoints[i].getY() - lugDiameter / 2,
                   lugDiameter, lugDiameter));
           body[4 + i] = area;
         }
@@ -217,7 +218,7 @@ public class PotentiometerPanel extends AbstractPotentiometer {
         }
         // Make holes in the lugs.
         for (int i = 0; i < 3; i++) {
-          body[4 + i].subtract(new Area(new Ellipse2D.Double(controlPoints[i].x - holeDiameter / 2, controlPoints[i].y
+          body[4 + i].subtract(new Area(new Ellipse2D.Double(controlPoints[i].getX() - holeDiameter / 2, controlPoints[i].getY()
               - holeDiameter / 2, holeDiameter, holeDiameter)));
         }
       }
@@ -241,7 +242,7 @@ public class PotentiometerPanel extends AbstractPotentiometer {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     super.setControlPoint(point, index);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/passive/PotentiometerSymbol.java

@@ -24,10 +24,10 @@ package org.diylc.components.passive;
 import java.awt.Color;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Shape;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.components.Abstract3LegSymbol;
@@ -51,9 +51,9 @@ public class PotentiometerSymbol extends Abstract3LegSymbol {
 
   public Shape[] getBody() {
     Shape[] body = new Shape[3];
-    Point[] controlPoints = getControlPoints();
+    Point2D[] controlPoints = getControlPoints();
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
 
     GeneralPath polyline = new GeneralPath();
@@ -92,8 +92,8 @@ public class PotentiometerSymbol extends Abstract3LegSymbol {
   }
 
   @Override
-  protected int getLabelX(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics, boolean outlineMode) {
+  protected double getLabelX(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics, boolean outlineMode) {
-    int x = super.getLabelX(shapeRect, textRect, fontMetrics, outlineMode);
+    double x = super.getLabelX(shapeRect, textRect, fontMetrics, outlineMode);
     if (getFlip() == SymbolFlipping.X)
       return x - (int) (PIN_SPACING.convertToPixels() / 2);
     return x + (int) PIN_SPACING.convertToPixels();

diylc/diylc-library/src/org/diylc/components/passive/TransformerCoil.java

@@ -23,9 +23,9 @@ package org.diylc.components.passive;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Shape;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
 import org.diylc.common.IPlugInPort;
@@ -60,7 +60,7 @@ public class TransformerCoil extends AbstractComponent<org.diylc.core.measures.V
   public static Color COLOR = Color.blue;
   public static Color LEAD_COLOR = Color.black;
 
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   private Orientation orientation = Orientation.DEFAULT;
   private org.diylc.core.measures.Voltage voltage = null;
   private Color color = COLOR;
@@ -96,9 +96,9 @@ public class TransformerCoil extends AbstractComponent<org.diylc.core.measures.V
         break;
     }
 
-    Point refPoint = this.controlPoints[0];
+    Point2D refPoint = this.controlPoints[0];
     for (int i = 1; i < controlPoints.length; i++) {
-      this.controlPoints[i].setLocation(refPoint.x + i * fx * spacing, refPoint.y + i * fy * spacing);
+      this.controlPoints[i].setLocation(refPoint.getX() + i * fx * spacing, refPoint.getY() + i * fy * spacing);
     }
   }
 
@@ -130,12 +130,12 @@ public class TransformerCoil extends AbstractComponent<org.diylc.core.measures.V
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return this.controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
     this.body = null;
   }
@@ -248,11 +248,11 @@ public class TransformerCoil extends AbstractComponent<org.diylc.core.measures.V
       double offset = OFFSET.convertToPixels();
 
       int i = 0;
-      leads.moveTo(this.controlPoints[i].x, this.controlPoints[i].y);
+      leads.moveTo(this.controlPoints[i].getX(), this.controlPoints[i].getY());
       leads
-          .lineTo(this.controlPoints[i].x + fx * (spacing + offset), this.controlPoints[i].y + fy * (spacing + offset));
+          .lineTo(this.controlPoints[i].getX() + fx * (spacing + offset), this.controlPoints[i].getY() + fy * (spacing + offset));
-      leads.moveTo(this.controlPoints[i + 1].x, this.controlPoints[i + 1].y);
+      leads.moveTo(this.controlPoints[i + 1].getX(), this.controlPoints[i + 1].getY());
-      leads.lineTo(this.controlPoints[i + 1].x + fx * (spacing + offset), this.controlPoints[i + 1].y + fy
+      leads.lineTo(this.controlPoints[i + 1].getX() + fx * (spacing + offset), this.controlPoints[i + 1].getY() + fy
           * (spacing + offset));
 
       double dx = this.controlPoints[i + 1].getX() - this.controlPoints[i].getX();
@@ -262,7 +262,7 @@ public class TransformerCoil extends AbstractComponent<org.diylc.core.measures.V
       double x1 = this.controlPoints[i].getX() + fx * (spacing + d + offset);
       double y1 = this.controlPoints[i].getY() + fy * (spacing + d + offset);
       double x2 = this.controlPoints[i + 1].getX() + fx * (spacing + d + offset);
-      double y2 = this.controlPoints[i + 1].y + fy * (spacing + d + offset);
+      double y2 = this.controlPoints[i + 1].getY() + fy * (spacing + d + offset);
       double dxa = x2 - x1;
       double dya = y2 - y1;
 

diylc/diylc-library/src/org/diylc/components/passive/TransformerCore.java

@@ -23,8 +23,8 @@ package org.diylc.components.passive;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
 import org.diylc.common.IPlugInPort;
@@ -54,7 +54,7 @@ public class TransformerCore extends AbstractComponent<Void> {
   public static Size SPACING = new Size(0.025d, SizeUnit.in);
   public static Color COLOR = Color.blue;
 
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
 
   protected Color color = COLOR;
 
@@ -68,12 +68,12 @@ public class TransformerCore extends AbstractComponent<Void> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return this.controlPoints[index];
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     this.controlPoints[index].setLocation(point);
   }
 
@@ -115,7 +115,7 @@ public class TransformerCore extends AbstractComponent<Void> {
     }
 
     double theta =
-        Math.atan2(this.controlPoints[1].y - this.controlPoints[0].y, this.controlPoints[1].x - this.controlPoints[0].x)
+        Math.atan2(this.controlPoints[1].getY() - this.controlPoints[0].getY(), this.controlPoints[1].getX() - this.controlPoints[0].getX())
             + Math.PI / 2;
     double spacing = SPACING.convertToPixels();
     // System.out.println(theta);
@@ -124,9 +124,9 @@ public class TransformerCore extends AbstractComponent<Void> {
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
 
     g2d.translate(spacing * Math.cos(theta) / 2, spacing * Math.sin(theta) / 2);
-    g2d.drawLine(this.controlPoints[0].x, this.controlPoints[0].y, this.controlPoints[1].x, this.controlPoints[1].y);
+    g2d.drawLine((int)this.controlPoints[0].getX(), (int)this.controlPoints[0].getY(), (int)this.controlPoints[1].getX(), (int)this.controlPoints[1].getY());
     g2d.translate(-spacing * Math.cos(theta), -spacing * Math.sin(theta));
-    g2d.drawLine(this.controlPoints[0].x, this.controlPoints[0].y, this.controlPoints[1].x, this.controlPoints[1].y);
+    g2d.drawLine((int)this.controlPoints[0].getX(), (int)this.controlPoints[0].getY(), (int)this.controlPoints[1].getX(), (int)this.controlPoints[1].getY());
   }
 
   @Override

diylc/diylc-library/src/org/diylc/components/passive/TrimmerPotentiometer.java

@@ -27,6 +27,7 @@ import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -283,8 +284,8 @@ public class TrimmerPotentiometer extends AbstractPotentiometer {
       default:
         break;
     }
-    controlPoints[1].setLocation(controlPoints[0].x + dx1, controlPoints[0].y + dy1);
+    controlPoints[1].setLocation(controlPoints[0].getX() + dx1, controlPoints[0].getY() + dy1);
-    controlPoints[2].setLocation(controlPoints[0].x + dx2, controlPoints[0].y + dy2);
+    controlPoints[2].setLocation(controlPoints[0].getX() + dx2, controlPoints[0].getY() + dy2);
   }
 
   public Shape[] getBody() {
@@ -293,12 +294,12 @@ public class TrimmerPotentiometer extends AbstractPotentiometer {
 
       // Calculate the center point as center of the minimum bounding
       // rectangle.
-      int centerX =
+      double centerX =
-          (Math.max(Math.max(controlPoints[0].x, controlPoints[1].x), controlPoints[2].x) + Math.min(
+          (Math.max(Math.max(controlPoints[0].getX(), controlPoints[1].getX()), controlPoints[2].getX()) + Math.min(
-              Math.min(controlPoints[0].x, controlPoints[1].x), controlPoints[2].x)) / 2;
+              Math.min(controlPoints[0].getX(), controlPoints[1].getX()), controlPoints[2].getX())) / 2;
-      int centerY =
+      double centerY =
-          (Math.max(Math.max(controlPoints[0].y, controlPoints[1].y), controlPoints[2].y) + Math.min(
+          (Math.max(Math.max(controlPoints[0].getY(), controlPoints[1].getY()), controlPoints[2].getY()) + Math.min(
-              Math.min(controlPoints[0].y, controlPoints[1].y), controlPoints[2].y)) / 2;
+              Math.min(controlPoints[0].getY(), controlPoints[1].getY()), controlPoints[2].getY())) / 2;
 
       // Calculate body dimensions based on the selected type.
       int length = 0;
@@ -350,7 +351,7 @@ public class TrimmerPotentiometer extends AbstractPotentiometer {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     super.setControlPoint(point, index);
     body = null;
   }
@@ -404,13 +405,13 @@ public class TrimmerPotentiometer extends AbstractPotentiometer {
 
     // Draw pins.
     int pinSize = getClosestOdd(PIN_SIZE.convertToPixels());
-    for (Point point : controlPoints) {
+    for (Point2D point : controlPoints) {
       if (!outlineMode) {
         g2d.setColor(PIN_COLOR);
-        g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
       g2d.setColor(outlineMode ? theme.getOutlineColor() : PIN_BORDER_COLOR);
-      g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+      g2d.drawOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
     }
 
     // Draw label.

diylc/diylc-library/src/org/diylc/components/semiconductors/AbstractTransistorPackage.java

@@ -26,6 +26,7 @@ import java.awt.Font;
 import java.awt.Graphics2D;
 import java.awt.Point;
 import java.awt.geom.Area;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.awt.StringUtils;
@@ -157,7 +158,7 @@ public abstract class AbstractTransistorPackage extends AbstractTransparentCompo
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/semiconductors/BJTSymbol.java

@@ -22,12 +22,12 @@
 package org.diylc.components.semiconductors;
 
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.ObjectCache;
 import org.diylc.components.Abstract3LegSymbol;
@@ -48,9 +48,9 @@ public class BJTSymbol extends Abstract3LegSymbol {
 
   public Shape[] getBody() {
     Shape[] body = new Shape[3];
-    Point[] controlPoints = getControlPoints();
+    Point2D[] controlPoints = getControlPoints();
-    int x = controlPoints[0].x;
+    int x = (int) controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    int y = (int) controlPoints[0].getY();
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
 
     GeneralPath polyline = new GeneralPath();

diylc/diylc-library/src/org/diylc/components/semiconductors/BridgeRectifier.java

@@ -26,11 +26,11 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -103,7 +103,7 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
 
   private String value = "";
   private Orientation orientation = Orientation.DEFAULT;
-  private Point[] controlPoints = new Point[] { new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0) };
+  private Point2D[] controlPoints = new Point2D[] { new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0) };
   private String[] pointLabels = new String[] { "+", "~", "~", "-" };
   protected Display display = Display.BOTH;
   private Color bodyColor = BODY_COLOR;
@@ -160,7 +160,7 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -175,14 +175,14 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
 
   @SuppressWarnings("incomplete-switch")
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
     
     int hSpacing;
     int vSpacing;
@@ -191,40 +191,40 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
       case MiniDIP1:
         hSpacing = (int) MINI_HORIZONTAL_SPACING.convertToPixels();
         vSpacing = (int) MINI_VERTICAL_SPACING.convertToPixels();
-        controlPoints[1].setLocation(firstPoint.x + hSpacing, firstPoint.y);
+        controlPoints[1].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY());
-        controlPoints[2].setLocation(firstPoint.x + hSpacing, firstPoint.y + vSpacing);        
+        controlPoints[2].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY() + vSpacing);        
-        controlPoints[3].setLocation(firstPoint.x, firstPoint.y + vSpacing);
+        controlPoints[3].setLocation(firstPoint.getX(), firstPoint.getY() + vSpacing);
         break;
       case MiniDIP2:
         hSpacing = (int) MINI_HORIZONTAL_SPACING.convertToPixels();
         vSpacing = (int) MINI_VERTICAL_SPACING.convertToPixels();
-        controlPoints[1].setLocation(firstPoint.x + hSpacing, firstPoint.y);
+        controlPoints[1].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY());
-        controlPoints[2].setLocation(firstPoint.x, firstPoint.y + vSpacing);
+        controlPoints[2].setLocation(firstPoint.getX(), firstPoint.getY() + vSpacing);
-        controlPoints[3].setLocation(firstPoint.x + hSpacing, firstPoint.y + vSpacing);                
+        controlPoints[3].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY() + vSpacing);                
         break;
       case MiniRound1:
         hSpacing = vSpacing = (int) MINI_ROUND_SPACING.convertToPixels();
-        controlPoints[1].setLocation(firstPoint.x + hSpacing, firstPoint.y);
+        controlPoints[1].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY());
-        controlPoints[2].setLocation(firstPoint.x + hSpacing, firstPoint.y + vSpacing);        
+        controlPoints[2].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY() + vSpacing);        
-        controlPoints[3].setLocation(firstPoint.x, firstPoint.y + vSpacing);
+        controlPoints[3].setLocation(firstPoint.getX(), firstPoint.getY() + vSpacing);
         break;
       case MiniRound2:
         hSpacing = vSpacing = (int) MINI_ROUND_SPACING.convertToPixels();
-        controlPoints[1].setLocation(firstPoint.x + hSpacing, firstPoint.y);
+        controlPoints[1].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY());
-        controlPoints[2].setLocation(firstPoint.x, firstPoint.y + vSpacing);
+        controlPoints[2].setLocation(firstPoint.getX(), firstPoint.getY() + vSpacing);
-        controlPoints[3].setLocation(firstPoint.x + hSpacing, firstPoint.y + vSpacing); 
+        controlPoints[3].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY() + vSpacing); 
         break;
       case InLine:
         vSpacing = (int) INLINE_SPACING.convertToPixels();
-        controlPoints[1].setLocation(firstPoint.x, firstPoint.y + vSpacing);
+        controlPoints[1].setLocation(firstPoint.getX(), firstPoint.getY() + vSpacing);
-        controlPoints[2].setLocation(firstPoint.x, firstPoint.y + 2 * vSpacing);
+        controlPoints[2].setLocation(firstPoint.getX(), firstPoint.getY() + 2 * vSpacing);
-        controlPoints[3].setLocation(firstPoint.x, firstPoint.y + 3 * vSpacing);
+        controlPoints[3].setLocation(firstPoint.getX(), firstPoint.getY() + 3 * vSpacing);
         break;
       case SquareBR3:
         hSpacing = vSpacing = (int) BR3_SPACING.convertToPixels();        
-        controlPoints[1].setLocation(firstPoint.x + hSpacing, firstPoint.y);
+        controlPoints[1].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY());
-        controlPoints[2].setLocation(firstPoint.x, firstPoint.y + vSpacing);
+        controlPoints[2].setLocation(firstPoint.getX(), firstPoint.getY() + vSpacing);
-        controlPoints[3].setLocation(firstPoint.x + hSpacing, firstPoint.y + vSpacing);
+        controlPoints[3].setLocation(firstPoint.getX() + hSpacing, firstPoint.getY() + vSpacing);
         break;
     }
 
@@ -241,7 +241,7 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
           theta = Math.PI * 3 / 2;
           break;
       }
-      AffineTransform rotation = AffineTransform.getRotateInstance(theta, firstPoint.x, firstPoint.y);
+      AffineTransform rotation = AffineTransform.getRotateInstance(theta, firstPoint.getX(), firstPoint.getY());
 
       for (int i = 1; i < controlPoints.length; i++) {
         rotation.transform(controlPoints[i], controlPoints[i]);
@@ -254,8 +254,8 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
     if (body == null) {
       body = new Area[2];
       
-      int centerX = (controlPoints[0].x + controlPoints[1].x + controlPoints[2].x + controlPoints[3].x) / 4;
+      double centerX = (controlPoints[0].getX() + controlPoints[1].getX() + controlPoints[2].getX() + controlPoints[3].getX()) / 4;
-      int centerY = (controlPoints[0].y + controlPoints[1].y + controlPoints[2].y + controlPoints[3].y) / 4;
+      double centerY = (controlPoints[0].getY() + controlPoints[1].getY() + controlPoints[2].getY() + controlPoints[3].getY()) / 4;
       
       int width = 0;
       int length = 0;
@@ -307,13 +307,13 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
 //          path.lineTo(centerX - width / 2, centerY - width / 2 + margin);
 //          path.closePath();
           
-          RoundedPolygon poly = new RoundedPolygon(new Point[] {
+          RoundedPolygon poly = new RoundedPolygon(new Point2D[] {
-              new Point(centerX, centerY - width / 2),
+              new Point2D.Double(centerX, centerY - width / 2),
-              new Point(centerX + width / 2, centerY - width / 2),
+              new Point2D.Double(centerX + width / 2, centerY - width / 2),
-              new Point(centerX + width / 2, centerY + width / 2),
+              new Point2D.Double(centerX + width / 2, centerY + width / 2),
-              new Point(centerX - width / 2, centerY + width / 2),
+              new Point2D.Double(centerX - width / 2, centerY + width / 2),
-              new Point(centerX - width / 2, (int) (centerY - width / 2 + margin)),
+              new Point2D.Double(centerX - width / 2, (int) (centerY - width / 2 + margin)),
-              new Point((int) (centerX - width / 2 + margin), centerY - width / 2),
+              new Point2D.Double((int) (centerX - width / 2 + margin), centerY - width / 2),
               
           }, new double[] { EDGE_RADIUS, EDGE_RADIUS, EDGE_RADIUS, EDGE_RADIUS / 2 , EDGE_RADIUS / 2});
           
@@ -358,17 +358,17 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
     
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
     if (!outlineMode) {      
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         g2d.setColor(PIN_COLOR);
         if (pinShape == PinShape.Round)
-          g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+          g2d.fillOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
         else
-          g2d.fillRect(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+          g2d.fillRect((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
         g2d.setColor(PIN_BORDER_COLOR);
         if (pinShape == PinShape.Round)
-          g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+          g2d.drawOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
         else 
-          g2d.drawRect(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+          g2d.drawRect((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
     }
     
@@ -443,14 +443,14 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
         int textWidth = (int) (rect.getWidth());
         // Center text horizontally and vertically
         Rectangle bounds = mainArea.getBounds();
-        int x = bounds.x + (bounds.width - textWidth) / 2;
+        double x = bounds.getX() + (bounds.width - textWidth) / 2;
-        int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+        double y = bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
 
         AffineTransform oldTransform = g2d.getTransform();
 
         if (getLabelOriantation() == LabelOriantation.Directional && (getOrientation() == Orientation.DEFAULT || getOrientation() == Orientation._180)) {
-          int centerX = bounds.x + bounds.width / 2;
+          double centerX = bounds.getX() + bounds.width / 2;
-          int centerY = bounds.y + bounds.height / 2;
+          double centerY = bounds.getY() + bounds.height / 2;
           g2d.rotate(-Math.PI / 2, centerX, centerY);
         }
 
@@ -464,7 +464,7 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
         if (rectifierType == RectifierType.SquareBR3)
           y -= BR3_HOLE_SIZE.convertToPixels();
 
-        g2d.drawString(l, x, y);
+        g2d.drawString(l, (int)x, (int)y);
 
         g2d.setTransform(oldTransform);
       }
@@ -474,7 +474,7 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
     g2d.setFont(project.getFont().deriveFont((float) (project.getFont().getSize2D() * 0.8)));
     g2d.setColor(finalLabelColor);
     for (int i = 0; i <controlPoints.length; i++) {
-      Point point = controlPoints[i];            
+      Point2D point = controlPoints[i];            
       
       int dx = 0;
       int dy = 0;
@@ -563,7 +563,7 @@ public class BridgeRectifier extends AbstractTransparentComponent<String> {
           break;
       }         
       
-      StringUtils.drawCenteredText(g2d, pointLabels[i], point.x + dx, point.y + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+      StringUtils.drawCenteredText(g2d, pointLabels[i], point.getX() + dx, point.getY() + dy, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
     }
   }
 

diylc/diylc-library/src/org/diylc/components/semiconductors/DIL_IC.java

@@ -26,11 +26,11 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -79,7 +79,7 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
   private PinCount pinCount = PinCount._8;
   private Size pinSpacing = new Size(0.1d, SizeUnit.in);
   private Size rowSpacing = new Size(0.3d, SizeUnit.in);
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   protected Display display = Display.BOTH;
   private Color bodyColor = BODY_COLOR;
   private Color borderColor = BORDER_COLOR;
@@ -178,7 +178,7 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -193,14 +193,14 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
 
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
-    controlPoints = new Point[pinCount.getValue()];
+    controlPoints = new Point2D[pinCount.getValue()];
     controlPoints[0] = firstPoint;
     double pinSpacing = this.pinSpacing.convertToPixels();
     double rowSpacing = this.rowSpacing.convertToPixels();
@@ -238,16 +238,16 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
         default:
           throw new RuntimeException("Unexpected orientation: " + orientation);
       }
-      controlPoints[i] = new Point((int) (firstPoint.x + dx1), (int) (firstPoint.y + dy1));
+      controlPoints[i] = new Point2D.Double((int) (firstPoint.getX() + dx1), (int) (firstPoint.getY() + dy1));
-      controlPoints[i + pinCount.getValue() / 2] = new Point((int) (firstPoint.x + dx2), (int) (firstPoint.y + dy2));
+      controlPoints[i + pinCount.getValue() / 2] = new Point2D.Double((int) (firstPoint.getX() + dx2), (int) (firstPoint.getY() + dy2));
     }
   }
 
   public Area[] getBody() {
     if (body == null) {
       body = new Area[2];
-      double x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      double y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       double width;
       double height;
       double pinSize = PIN_SIZE.convertToPixels();
@@ -314,11 +314,11 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
     if (!outlineMode) {
       int pinSize = (int) PIN_SIZE.convertToPixels() / 2 * 2;
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         g2d.setColor(PIN_COLOR);
-        g2d.fillRect(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillRect((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
         g2d.setColor(PIN_BORDER_COLOR);        
-        g2d.drawRect(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.drawRect((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
     }
     Composite oldComposite = g2d.getComposite();
@@ -392,14 +392,14 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
         int textWidth = (int) (rect.getWidth());
         // Center text horizontally and vertically
         Rectangle bounds = mainArea.getBounds();
-        int x = bounds.x + (bounds.width - textWidth) / 2;
+        double x = bounds.getX() + (bounds.width - textWidth) / 2;
-        int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+        double y = bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
 
         AffineTransform oldTransform = g2d.getTransform();
 
         if (getOrientation() == Orientation.DEFAULT || getOrientation() == Orientation._180) {
-          int centerX = bounds.x + bounds.width / 2;
+          double centerX = bounds.getX() + bounds.width / 2;
-          int centerY = bounds.y + bounds.height / 2;
+          double centerY = bounds.getY() + bounds.height / 2;
           g2d.rotate(-Math.PI / 2, centerX, centerY);
         }
 
@@ -410,7 +410,7 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
             g2d.translate(0, textHeight / 2);
         }
 
-        g2d.drawString(l, x, y);
+        g2d.drawString(l, (int)x, (int)y);
 
         g2d.setTransform(oldTransform);
       }
@@ -421,14 +421,14 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
     int j = 0;
     int k = 0;
     int pinSize = (int) PIN_SIZE.convertToPixels();
-    for (Point point : controlPoints) {
+    for (Point2D point : controlPoints) {
       pinNo++;
 
       // determine points relative to rotation
-      int textX1 = point.x - 2 * pinSize;
+      int textX1 = (int) (point.getX() - 2 * pinSize);
-      int textY1 = point.y + pinSize / 2;
+      int textY1 = (int) (point.getY() + pinSize / 2);
-      int textX2 = point.x + pinSize;
+      int textX2 = (int) (point.getX() + pinSize);
-      int textY2 = point.y + pinSize / 2;
+      int textY2 = (int) (point.getY() + pinSize / 2);
       if (orientation == Orientation._90) {
         textX2 = textX2 - pinSize - pinSize / 2;
         textY2 = textY2 + pinSize;
@@ -560,21 +560,21 @@ public class DIL_IC extends AbstractTransparentComponent<String> {
   
   @Override
   public Rectangle2D getCachingBounds() {
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
     int margin = 50;
     for (int i = 0; i < getControlPointCount(); i++) {
-      Point p = getControlPoint(i);
+      Point2D p = getControlPoint(i);
-      if (p.x < minX)
+      if (p.getX() < minX)
-        minX = p.x;
+        minX = p.getX();
-      if (p.x > maxX)
+      if (p.getX() > maxX)
-        maxX = p.x;
+        maxX = p.getX();
-      if (p.y < minY)
+      if (p.getY() < minY)
-        minY = p.y;
+        minY = p.getY();
-      if (p.y > maxY)
+      if (p.getY() > maxY)
-        maxY = p.y;
+        maxY = p.getY();
     }
     
     return new Rectangle2D.Double(minX - margin, minY - margin, maxX - minX + 2 * margin, maxY - minY + 2 * margin);

diylc/diylc-library/src/org/diylc/components/semiconductors/ICSymbol.java

@@ -25,11 +25,11 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Shape;
 import java.awt.geom.Area;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -66,8 +66,8 @@ public class ICSymbol extends AbstractTransparentComponent<String> {
 
   protected ICPointCount icPointCount = ICPointCount._5;
   protected String value = "";
-  protected Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0),
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0),
-      new Point(0, 0)};
+      new Point2D.Double(0, 0)};
   protected Color bodyColor = BODY_COLOR;
   protected Color borderColor = BORDER_COLOR;
   protected Display display = Display.NAME;
@@ -126,7 +126,7 @@ public class ICSymbol extends AbstractTransparentComponent<String> {
               : LABEL_COLOR;
     }
     g2d.setColor(finalLabelColor);
-    int x = (controlPoints[0].x + controlPoints[2].x) / 2;
+    double x = (controlPoints[0].getX() + controlPoints[2].getX()) / 2;
     String label = "";
     label = display == Display.VALUE ? getValue() : getName();
     if (display == Display.NONE) {
@@ -135,12 +135,12 @@ public class ICSymbol extends AbstractTransparentComponent<String> {
     if (display == Display.BOTH) {
       label = getName() + "  " + (getValue() == null ? "" : getValue().toString());
     }
-    StringUtils.drawCenteredText(g2d, label, x, controlPoints[0].y + pinSpacing, HorizontalAlignment.CENTER,
+    StringUtils.drawCenteredText(g2d, label, x, controlPoints[0].getY() + pinSpacing, HorizontalAlignment.CENTER,
         VerticalAlignment.CENTER);
     // Draw +/- markers    
-    StringUtils.drawCenteredText(g2d, getFlip() ? "+" : "-", controlPoints[0].x + pinSpacing, controlPoints[0].y, HorizontalAlignment.CENTER,
+    StringUtils.drawCenteredText(g2d, getFlip() ? "+" : "-", controlPoints[0].getX() + pinSpacing, controlPoints[0].getY(), HorizontalAlignment.CENTER,
         VerticalAlignment.CENTER);
-    StringUtils.drawCenteredText(g2d, getFlip() ? "-" : "+", controlPoints[1].x + pinSpacing, controlPoints[1].y, HorizontalAlignment.CENTER,
+    StringUtils.drawCenteredText(g2d, getFlip() ? "-" : "+", controlPoints[1].getX() + pinSpacing, controlPoints[1].getY(), HorizontalAlignment.CENTER,
         VerticalAlignment.CENTER);
   }
 
@@ -165,7 +165,7 @@ public class ICSymbol extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -177,45 +177,38 @@ public class ICSymbol extends AbstractTransparentComponent<String> {
   private void updateControlPoints() {
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
     // Update control points.
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
 
-    controlPoints[1].x = x;
+    controlPoints[1].setLocation(x, y + pinSpacing * 2);
-    controlPoints[1].y = y + pinSpacing * 2;
+    controlPoints[2].setLocation(x + pinSpacing * 6, y + pinSpacing);
-
+    controlPoints[3].setLocation(x + pinSpacing * 3, y - pinSpacing);
-    controlPoints[2].x = x + pinSpacing * 6;
+    controlPoints[4].setLocation(x + pinSpacing * 3, y + pinSpacing * 3);
-    controlPoints[2].y = y + pinSpacing;
-
-    controlPoints[3].x = x + pinSpacing * 3;
-    controlPoints[3].y = y - pinSpacing;
-
-    controlPoints[4].x = x + pinSpacing * 3;
-    controlPoints[4].y = y + pinSpacing * 3;
   }
 
   public Shape[] getBody() {
     if (body == null) {
       body = new Shape[2];
       int pinSpacing = (int) PIN_SPACING.convertToPixels();
-      int x = controlPoints[0].x;
+      int x = (int) controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      int y = (int) controlPoints[0].getY();
       Shape triangle =
           new Polygon(new int[] {x + pinSpacing / 2, x + pinSpacing * 11 / 2, x + pinSpacing / 2}, new int[] {
               y - pinSpacing * 3 / 2, y + pinSpacing, y + pinSpacing * 7 / 2}, 3);
       body[0] = triangle;
 
       GeneralPath polyline = new GeneralPath();
-      polyline.moveTo(controlPoints[0].x, controlPoints[0].y);
+      polyline.moveTo(controlPoints[0].getX(), controlPoints[0].getY());
-      polyline.lineTo(controlPoints[0].x + pinSpacing / 2, controlPoints[0].y);
+      polyline.lineTo(controlPoints[0].getX() + pinSpacing / 2, controlPoints[0].getY());
-      polyline.moveTo(controlPoints[1].x, controlPoints[1].y);
+      polyline.moveTo(controlPoints[1].getX(), controlPoints[1].getY());
-      polyline.lineTo(controlPoints[1].x + pinSpacing / 2, controlPoints[1].y);
+      polyline.lineTo(controlPoints[1].getX() + pinSpacing / 2, controlPoints[1].getY());
-      polyline.moveTo(controlPoints[2].x, controlPoints[2].y);
+      polyline.moveTo(controlPoints[2].getX(), controlPoints[2].getY());
-      polyline.lineTo(controlPoints[2].x - pinSpacing / 2, controlPoints[2].y);
+      polyline.lineTo(controlPoints[2].getX() - pinSpacing / 2, controlPoints[2].getY());
       if (icPointCount == ICPointCount._5) {
-        polyline.moveTo(controlPoints[3].x, controlPoints[3].y);
+        polyline.moveTo(controlPoints[3].getX(), controlPoints[3].getY());
-        polyline.lineTo(controlPoints[3].x, controlPoints[3].y + pinSpacing * 3 / 4);
+        polyline.lineTo(controlPoints[3].getX(), controlPoints[3].getY() + pinSpacing * 3 / 4);
-        polyline.moveTo(controlPoints[4].x, controlPoints[4].y);
+        polyline.moveTo(controlPoints[4].getX(), controlPoints[4].getY());
-        polyline.lineTo(controlPoints[4].x, controlPoints[4].y - pinSpacing * 3 / 4);
+        polyline.lineTo(controlPoints[4].getX(), controlPoints[4].getY() - pinSpacing * 3 / 4);
       }
       body[1] = polyline;
     }
@@ -244,7 +237,7 @@ public class ICSymbol extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/semiconductors/JFETSymbol.java

@@ -22,10 +22,10 @@
 package org.diylc.components.semiconductors;
 
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Shape;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.ObjectCache;
 import org.diylc.components.Abstract3LegSymbol;
@@ -46,9 +46,9 @@ public class JFETSymbol extends Abstract3LegSymbol {
 
   public Shape[] getBody() {    
     Shape[] body = new Shape[3];
-    Point[] controlPoints = getControlPoints();
+    Point2D[] controlPoints = getControlPoints();
-    int x = controlPoints[0].x;
+    int x = (int) controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    int y = (int) controlPoints[0].getY();
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
 
     GeneralPath polyline = new GeneralPath();

diylc/diylc-library/src/org/diylc/components/semiconductors/LogicGateSymbol.java

@@ -21,13 +21,13 @@ import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Composite;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Shape;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.GeneralPath;
 import java.awt.geom.Path2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 
 import org.diylc.appframework.miscutils.ConfigurationManager;
@@ -64,7 +64,7 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
 
   protected GateType gateType = GateType.Not;
   protected String value = "";
-  protected Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0), new Point(0, 0)};
+  protected Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   protected Color bodyColor = BODY_COLOR;
   protected Color borderColor = BORDER_COLOR;
   protected Display display = Display.NONE;
@@ -124,7 +124,7 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
               : LABEL_COLOR;
     }
     g2d.setColor(finalLabelColor);
-    int x = (controlPoints[0].x + controlPoints[getControlPointCount() == 2 ? 1 : 2].x) / 2;
+    int x = (int) ((controlPoints[0].getX() + controlPoints[getControlPointCount() == 2 ? 1 : 2].getX()) / 2);
     String label = "";
     label = display == Display.VALUE ? getValue() : getName();
     if (display == Display.NONE) {
@@ -133,7 +133,7 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
     if (display == Display.BOTH) {
       label = getName() + "  " + (getValue() == null ? "" : getValue().toString());
     }
-    StringUtils.drawCenteredText(g2d, label, x, controlPoints[0].y + (getControlPointCount() == 2 ? 0 : pinSpacing), HorizontalAlignment.CENTER,
+    StringUtils.drawCenteredText(g2d, label, x, controlPoints[0].getY() + (getControlPointCount() == 2 ? 0 : pinSpacing), HorizontalAlignment.CENTER,
         VerticalAlignment.CENTER);   
   }
 
@@ -155,7 +155,7 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -167,18 +167,14 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
   private void updateControlPoints() {
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
     // Update control points.
-    int x = controlPoints[0].x;
+    int x = (int) controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    int y = (int) controlPoints[0].getY();
 
     if (getControlPointCount() == 2) {
-      controlPoints[1].x = x + pinSpacing * 6;
+      controlPoints[1].setLocation(x + pinSpacing * 6, y);
-      controlPoints[1].y = y;
     } else {
-      controlPoints[1].x = x;
+      controlPoints[1].setLocation(x, y + pinSpacing * 2);
-      controlPoints[1].y = y + pinSpacing * 2;
+      controlPoints[2].setLocation(x + pinSpacing * 6, y + pinSpacing);
-
-      controlPoints[2].x = x + pinSpacing * 6;
-      controlPoints[2].y = y + pinSpacing;
     }   
   }
 
@@ -186,8 +182,8 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
     if (body == null) {
       body = new Shape[3];
       int pinSpacing = (int) PIN_SPACING.convertToPixels();
-      int x = controlPoints[0].x;
+      int x = (int) controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      int y = (int) controlPoints[0].getY();
 
       Area main = null;
 
@@ -224,23 +220,23 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
 
       GeneralPath connections = new GeneralPath();
       if (getControlPointCount() == 2) {
-        connections.moveTo(controlPoints[0].x, controlPoints[0].y);
+        connections.moveTo(controlPoints[0].getX(), controlPoints[0].getY());
-        connections.lineTo(controlPoints[0].x + pinSpacing * 3 / 2, controlPoints[0].y);
+        connections.lineTo(controlPoints[0].getX() + pinSpacing * 3 / 2, controlPoints[0].getY());
-        connections.moveTo(controlPoints[1].x, controlPoints[1].y);
+        connections.moveTo(controlPoints[1].getX(), controlPoints[1].getY());
         if (getGateType().getNeedsCircle())
-          connections.lineTo(controlPoints[1].x - pinSpacing, controlPoints[1].y);
+          connections.lineTo(controlPoints[1].getX() - pinSpacing, controlPoints[1].getY());
         else
-          connections.lineTo(controlPoints[1].x - pinSpacing * 3 / 2, controlPoints[1].y);
+          connections.lineTo(controlPoints[1].getX() - pinSpacing * 3 / 2, controlPoints[1].getY());
       } else {
-        connections.moveTo(controlPoints[0].x, controlPoints[0].y);
+        connections.moveTo(controlPoints[0].getX(), controlPoints[0].getY());
-        connections.lineTo(controlPoints[0].x + pinSpacing * 3 / 2, controlPoints[0].y);
+        connections.lineTo(controlPoints[0].getX() + pinSpacing * 3 / 2, controlPoints[0].getY());
-        connections.moveTo(controlPoints[1].x, controlPoints[1].y);
+        connections.moveTo(controlPoints[1].getX(), controlPoints[1].getY());
-        connections.lineTo(controlPoints[1].x + pinSpacing * 3 / 2, controlPoints[1].y);
+        connections.lineTo(controlPoints[1].getX() + pinSpacing * 3 / 2, controlPoints[1].getY());
-        connections.moveTo(controlPoints[2].x, controlPoints[2].y);
+        connections.moveTo(controlPoints[2].getX(), controlPoints[2].getY());
         if (getGateType().getNeedsCircle())
-          connections.lineTo(controlPoints[2].x - pinSpacing, controlPoints[2].y);
+          connections.lineTo(controlPoints[2].getX() - pinSpacing, controlPoints[2].getY());
         else
-          connections.lineTo(controlPoints[2].x - pinSpacing * 3 / 2, controlPoints[2].y);
+          connections.lineTo(controlPoints[2].getX() - pinSpacing * 3 / 2, controlPoints[2].getY());
       }
       body[1] = connections;
       
@@ -276,7 +272,7 @@ public class LogicGateSymbol extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }

diylc/diylc-library/src/org/diylc/components/semiconductors/MOSFETSymbol.java

@@ -22,10 +22,10 @@
 package org.diylc.components.semiconductors;
 
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Polygon;
 import java.awt.Shape;
 import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
 
 import org.diylc.common.ObjectCache;
 import org.diylc.components.Abstract3LegSymbol;
@@ -46,9 +46,9 @@ public class MOSFETSymbol extends Abstract3LegSymbol {
 
   public Shape[] getBody() {    
     Shape[] body = new Shape[3];
-    Point[] controlPoints = getControlPoints();
+    Point2D[] controlPoints = getControlPoints();
-    int x = controlPoints[0].x;
+    int x = (int) controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    int y = (int) controlPoints[0].getY();
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
 
     GeneralPath polyline = new GeneralPath();

diylc/diylc-library/src/org/diylc/components/semiconductors/SIL_IC.java

@@ -26,10 +26,10 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.geom.Area;
 import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
 
@@ -77,7 +77,7 @@ public class SIL_IC extends AbstractTransparentComponent<String> {
   private Orientation orientation = Orientation.DEFAULT;
   private PinCount pinCount = PinCount._8;
   private Size pinSpacing = new Size(0.1d, SizeUnit.in);
-  private Point[] controlPoints = new Point[] {new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0)};
   protected Display display = Display.NAME;
   private Color bodyColor = BODY_COLOR;
   private Color borderColor = BORDER_COLOR;
@@ -169,7 +169,7 @@ public class SIL_IC extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -184,14 +184,14 @@ public class SIL_IC extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
 
   private void updateControlPoints() {
-    Point firstPoint = controlPoints[0];
+    Point2D firstPoint = controlPoints[0];
-    controlPoints = new Point[pinCount.getValue()];
+    controlPoints = new Point2D.Double[pinCount.getValue()];
     controlPoints[0] = firstPoint;
     double pinSpacing = this.pinSpacing.convertToPixels();
     // Update control points.
@@ -218,15 +218,15 @@ public class SIL_IC extends AbstractTransparentComponent<String> {
         default:
           throw new RuntimeException("Unexpected orientation: " + orientation);
       }
-      controlPoints[i] = new Point((int) (firstPoint.x + dx1), (int) (firstPoint.y + dy1));
+      controlPoints[i] = new Point2D.Double((int) (firstPoint.getX() + dx1), (int) (firstPoint.getY() + dy1));
     }
   }
 
   public Area[] getBody() {
     if (body == null) {
       body = new Area[2];
-      int x = controlPoints[0].x;
+      double x = controlPoints[0].getX();
-      int y = controlPoints[0].y;
+      double y = controlPoints[0].getY();
       int thickness = getClosestOdd(THICKNESS.convertToPixels());
       double width;
       double height;
@@ -293,11 +293,11 @@ public class SIL_IC extends AbstractTransparentComponent<String> {
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
     if (!outlineMode) {
       int pinSize = (int) PIN_SIZE.convertToPixels() / 2 * 2;
-      for (Point point : controlPoints) {
+      for (Point2D point : controlPoints) {
         g2d.setColor(PIN_COLOR);
-        g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
         g2d.setColor(PIN_BORDER_COLOR);        
-        g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.drawOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
     }
     
@@ -363,8 +363,8 @@ public class SIL_IC extends AbstractTransparentComponent<String> {
     int textWidth = (int) (rect.getWidth());
     // Center text horizontally and vertically
     Rectangle bounds = mainArea.getBounds();
-    int x = bounds.x + (bounds.width - textWidth) / 2;
+    int x = (int) (bounds.getX() + (bounds.width - textWidth) / 2);
-    int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+    int y = (int) (bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent());
     g2d.drawString(label, x, y);
   }
 
@@ -434,21 +434,21 @@ public class SIL_IC extends AbstractTransparentComponent<String> {
   
   @Override
   public Rectangle2D getCachingBounds() {
-    int minX = Integer.MAX_VALUE;
+    double minX = Integer.MAX_VALUE;
-    int maxX = Integer.MIN_VALUE;
+    double maxX = Integer.MIN_VALUE;
-    int minY = Integer.MAX_VALUE;
+    double minY = Integer.MAX_VALUE;
-    int maxY = Integer.MIN_VALUE;
+    double maxY = Integer.MIN_VALUE;
     int margin = 50;
     for (int i = 0; i < getControlPointCount(); i++) {
-      Point p = getControlPoint(i);
+      Point2D p = getControlPoint(i);
-      if (p.x < minX)
+      if (p.getX() < minX)
-        minX = p.x;
+        minX = p.getX();
-      if (p.x > maxX)
+      if (p.getX() > maxX)
-        maxX = p.x;
+        maxX = p.getX();
-      if (p.y < minY)
+      if (p.getY() < minY)
-        minY = p.y;
+        minY = p.getY();
-      if (p.y > maxY)
+      if (p.getY() > maxY)
-        maxY = p.y;
+        maxY = p.getY();
     }
     
     return new Rectangle2D.Double(minX - margin, minY - margin, maxX - minX + 2 * margin, maxY - minY + 2 * margin);

diylc/diylc-library/src/org/diylc/components/semiconductors/TransistorTO3.java

@@ -26,7 +26,6 @@ import java.awt.Color;
 import java.awt.Composite;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
-import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.RenderingHints;
 import java.awt.geom.AffineTransform;
@@ -79,7 +78,7 @@ public class TransistorTO3 extends AbstractTransparentComponent<String> {
 
   private String value = "";
   private Orientation orientation = Orientation.DEFAULT;
-  private Point[] controlPoints = new Point[] {new Point(0, 0), new Point(0, 0)};
+  private Point2D[] controlPoints = new Point2D[] {new Point2D.Double(0, 0), new Point2D.Double(0, 0)};
   transient private Area[] body;
   private Color bodyColor = BODY_COLOR;
   private Color borderColor = BORDER_COLOR;
@@ -119,7 +118,7 @@ public class TransistorTO3 extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public Point getControlPoint(int index) {
+  public Point2D getControlPoint(int index) {
     return controlPoints[index];
   }
 
@@ -134,7 +133,7 @@ public class TransistorTO3 extends AbstractTransparentComponent<String> {
   }
 
   @Override
-  public void setControlPoint(Point point, int index) {
+  public void setControlPoint(Point2D point, int index) {
     controlPoints[index].setLocation(point);
     body = null;
   }
@@ -142,8 +141,8 @@ public class TransistorTO3 extends AbstractTransparentComponent<String> {
   private void updateControlPoints() {
     int pinSpacing = (int) PIN_SPACING.convertToPixels();
     // Update control points.
-    int x = controlPoints[0].x;
+    double x = controlPoints[0].getX();
-    int y = controlPoints[0].y;
+    double y = controlPoints[0].getY();
     switch (orientation) {
       case DEFAULT:
         controlPoints[1].setLocation(x, y + pinSpacing);
@@ -166,8 +165,8 @@ public class TransistorTO3 extends AbstractTransparentComponent<String> {
     if (body == null) {
       body = new Area[2];
       int pinOffset = (int) PIN_OFFSET.convertToPixels();
-      int x = (controlPoints[0].x + controlPoints[1].x) / 2;
+      double x = (controlPoints[0].getX() + controlPoints[1].getX()) / 2;
-      int y = (controlPoints[0].y + controlPoints[1].y) / 2;
+      double y = (controlPoints[0].getY() + controlPoints[1].getY()) / 2;
 
       switch (orientation) {
         case DEFAULT:
@@ -235,13 +234,13 @@ public class TransistorTO3 extends AbstractTransparentComponent<String> {
     Theme theme = (Theme) ConfigurationManager.getInstance().readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
     g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
     
-    for (Point point : controlPoints) {
+    for (Point2D point : controlPoints) {
       if (!outlineMode) {
         g2d.setColor(PIN_COLOR);
-        g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+        g2d.fillOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
       }
       g2d.setColor(outlineMode ? theme.getOutlineColor() : PIN_BORDER_COLOR);      
-      g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+      g2d.drawOval((int)(point.getX() - pinSize / 2), (int)(point.getY() - pinSize / 2), pinSize, pinSize);
     }
     
     Area mainArea = getBody()[0];
@@ -296,8 +295,8 @@ public class TransistorTO3 extends AbstractTransparentComponent<String> {
     int textWidth = (int) (rect.getWidth());
     // Center text horizontally and vertically
     Rectangle bounds = mainArea.getBounds();
-    int x = bounds.x + (bounds.width - textWidth) / 2;
+    int x = (int) (bounds.getX() + (bounds.width - textWidth) / 2);
-    int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
+    int y = (int) (bounds.getY() + (bounds.height - textHeight) / 2 + fontMetrics.getAscent());
     g2d.drawString(label, x, y);
   }