new fonts

cleaner lead rendering
3D shading for leaded components

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

@@ -0,0 +1,86 @@
+/*
+
+    DIY Layout Creator (DIYLC).
+    Copyright (c) 2009-2018 held jointly by the individual authors.
+
+    This file is part of DIYLC.
+
+    DIYLC is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DIYLC is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with DIYLC.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+package org.diylc.awt;
+
+import java.awt.Color;
+import java.awt.Paint;
+import java.awt.PaintContext;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+
+public class ShadedPaint implements Paint {
+  
+  private ShadedPaintContext context;
+  private Point2D p1;
+  private Point2D p2;
+  private Color c1;
+  private Color c2;  
+  
+  public ShadedPaint(Point2D p1, Point2D p2, Color c, double shadeFactor) {
+    this.p1 = p1;
+    this.p2 = p2;
+    int r = c.getRed();
+    int g = c.getGreen();
+    int b = c.getBlue();
+    
+    this.c1 = new Color(
+        Math.max((int) (r * shadeFactor), 0), 
+        Math.max((int) (g * shadeFactor), 0), 
+        Math.max((int) (b * shadeFactor), 0));
+
+    
+    int i = (int)(1.0/(1.0-shadeFactor));
+    if ( r == 0 && g == 0 && b == 0) {
+       this.c2 = new Color(i, i, i);
+    } else {
+      if ( r > 0 && r < i ) r = i;
+      if ( g > 0 && g < i ) g = i;
+      if ( b > 0 && b < i ) b = i;
+  
+      this.c2 = new Color(Math.min((int)(r / shadeFactor), 255),
+                       Math.min((int)(g / shadeFactor), 255),
+                       Math.min((int)(b / shadeFactor), 255)); 
+    }
+  }
+
+  public ShadedPaint(Point2D p1, Point2D p2, Color c2) {
+    this(p1, p2, c2, 0.9f);
+  }
+
+  @Override
+  public int getTransparency() {
+    return OPAQUE;
+  }
+
+  @Override
+  public PaintContext createContext(ColorModel cm, Rectangle deviceBounds, Rectangle2D userBounds,
+      AffineTransform xform, RenderingHints hints) {
+    if (context == null || !context.getColorModel().equals(cm))
+          context = new ShadedPaintContext(cm, p1, p2, xform, c1, c2);
+    return context;
+  }
+
+}

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

@@ -0,0 +1,264 @@
+/*
+
+    DIY Layout Creator (DIYLC).
+    Copyright (c) 2009-2018 held jointly by the individual authors.
+
+    This file is part of DIYLC.
+
+    DIYLC is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DIYLC is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with DIYLC.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+package org.diylc.awt;
+
+import java.awt.Color;
+import java.awt.PaintContext;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.geom.Point2D;
+import java.awt.image.ColorModel;
+import java.awt.image.DirectColorModel;
+import java.awt.image.Raster;
+import java.lang.ref.WeakReference;
+
+import sun.awt.image.IntegerComponentRaster;
+
+public class ShadedPaintContext implements PaintContext {
+  
+    static ColorModel xrgbmodel =
+        new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff);
+    static ColorModel xbgrmodel =
+        new DirectColorModel(24, 0x000000ff, 0x0000ff00, 0x00ff0000);
+
+    static ColorModel cachedModel;
+    static WeakReference<Raster> cached;
+
+    static synchronized Raster getCachedRaster(ColorModel cm, int w, int h) {
+        if (cm == cachedModel) {
+            if (cached != null) {
+                Raster ras = (Raster) cached.get();
+                if (ras != null &&
+                    ras.getWidth() >= w &&
+                    ras.getHeight() >= h)
+                {
+                    cached = null;
+                    return ras;
+                }
+            }
+        }
+        return cm.createCompatibleWritableRaster(w, h);
+    }
+
+    static synchronized void putCachedRaster(ColorModel cm, Raster ras) {
+        if (cached != null) {
+            Raster cras = (Raster) cached.get();
+            if (cras != null) {
+                int cw = cras.getWidth();
+                int ch = cras.getHeight();
+                int iw = ras.getWidth();
+                int ih = ras.getHeight();
+                if (cw >= iw && ch >= ih) {
+                    return;
+                }
+                if (cw * ch >= iw * ih) {
+                    return;
+                }
+            }
+        }
+        cachedModel = cm;
+        cached = new WeakReference<Raster>(ras);
+    }
+
+    double x1;
+    double y1;
+    double dx;
+    double dy;
+    int interp[];
+    Raster saved;
+    ColorModel model;
+
+    public ShadedPaintContext(ColorModel cm,
+                                Point2D p1, Point2D p2, AffineTransform xform,
+                                Color c1, Color c2) {
+        // First calculate the distance moved in user space when
+        // we move a single unit along the X & Y axes in device space.
+        Point2D xvec = new Point2D.Double(1, 0);
+        Point2D yvec = new Point2D.Double(0, 1);
+        try {
+            AffineTransform inverse = xform.createInverse();
+            inverse.deltaTransform(xvec, xvec);
+            inverse.deltaTransform(yvec, yvec);
+        } catch (NoninvertibleTransformException e) {
+            xvec.setLocation(0, 0);
+            yvec.setLocation(0, 0);
+        }
+
+        // Now calculate the (square of the) user space distance
+        // between the anchor points. This value equals:
+        //     (UserVec . UserVec)
+        double udx = p2.getX() - p1.getX();
+        double udy = p2.getY() - p1.getY();
+        double ulenSq = udx * udx + udy * udy;
+
+        if (ulenSq <= Double.MIN_VALUE) {
+            dx = 0;
+            dy = 0;
+        } else {
+            // Now calculate the proportional distance moved along the
+            // vector from p1 to p2 when we move a unit along X & Y in
+            // device space.
+            //
+            // The length of the projection of the Device Axis Vector is
+            // its dot product with the Unit User Vector:
+            //     (DevAxisVec . (UserVec / Len(UserVec))
+            //
+            // The "proportional" length is that length divided again
+            // by the length of the User Vector:
+            //     (DevAxisVec . (UserVec / Len(UserVec))) / Len(UserVec)
+            // which simplifies to:
+            //     ((DevAxisVec . UserVec) / Len(UserVec)) / Len(UserVec)
+            // which simplifies to:
+            //     (DevAxisVec . UserVec) / LenSquared(UserVec)
+            dx = (xvec.getX() * udx + xvec.getY() * udy) / ulenSq;
+            dy = (yvec.getX() * udx + yvec.getY() * udy) / ulenSq;
+
+
+            // We are acyclic
+            if (dx < 0) {
+                // If we are using the acyclic form below, we need
+                // dx to be non-negative for simplicity of scanning
+                // across the scan lines for the transition points.
+                // To ensure that constraint, we negate the dx/dy
+                // values and swap the points and colors.
+                Point2D p = p1; p1 = p2; p2 = p;
+                Color c = c1; c1 = c2; c2 = c;
+                dx = -dx;
+                dy = -dy;
+            }            
+        }
+
+        Point2D dp1 = xform.transform(p1, null);
+        this.x1 = dp1.getX();
+        this.y1 = dp1.getY();
+
+        int rgb1 = c1.getRGB();
+        int rgb2 = c2.getRGB();
+        int a1 = (rgb1 >> 24) & 0xff;
+        int r1 = (rgb1 >> 16) & 0xff;
+        int g1 = (rgb1 >>  8) & 0xff;
+        int b1 = (rgb1      ) & 0xff;
+        int da = ((rgb2 >> 24) & 0xff) - a1;
+        int dr = ((rgb2 >> 16) & 0xff) - r1;
+        int dg = ((rgb2 >>  8) & 0xff) - g1;
+        int db = ((rgb2      ) & 0xff) - b1;
+        if (a1 == 0xff && da == 0) {
+            model = xrgbmodel;
+            if (cm instanceof DirectColorModel) {
+                DirectColorModel dcm = (DirectColorModel) cm;
+                int tmp = dcm.getAlphaMask();
+                if ((tmp == 0 || tmp == 0xff) &&
+                    dcm.getRedMask() == 0xff &&
+                    dcm.getGreenMask() == 0xff00 &&
+                    dcm.getBlueMask() == 0xff0000)
+                {
+                    model = xbgrmodel;
+                    tmp = r1; r1 = b1; b1 = tmp;
+                    tmp = dr; dr = db; db = tmp;
+                }
+            }
+        } else {
+            model = ColorModel.getRGBdefault();
+        }
+        interp = new int[257];
+        for (int i = 0; i <= 256; i++) {
+            float rel = i / 256.0f;
+            int rgb =
+                (((int) (a1 + da * rel)) << 24) |
+                (((int) (r1 + dr * rel)) << 16) |
+                (((int) (g1 + dg * rel)) <<  8) |
+                (((int) (b1 + db * rel))      );
+            interp[i] = rgb;
+        }
+    }
+
+    /**
+     * Release the resources allocated for the operation.
+     */
+    public void dispose() {
+        if (saved != null) {
+            putCachedRaster(model, saved);
+            saved = null;
+        }
+    }
+
+    /**
+     * Return the ColorModel of the output.
+     */
+    public ColorModel getColorModel() {
+        return model;
+    }
+
+    /**
+     * Return a Raster containing the colors generated for the graphics
+     * operation.
+     * @param x,y,w,h The area in device space for which colors are
+     * generated.
+     */
+    public Raster getRaster(int x, int y, int w, int h) {
+        double rowrel = (x - x1) * dx + (y - y1) * dy;
+
+        Raster rast = saved;
+        if (rast == null || rast.getWidth() < w || rast.getHeight() < h) {
+            rast = getCachedRaster(model, w, h);
+            saved = rast;
+        }
+        IntegerComponentRaster irast = (IntegerComponentRaster) rast;
+        int off = irast.getDataOffset(0);
+        int adjust = irast.getScanlineStride() - w;
+        int[] pixels = irast.getDataStorage();
+
+        clipFillRaster(pixels, off, adjust, w, h, rowrel, dx, dy);        
+
+//        irast.markDirty();
+
+        return rast;
+    }
+
+    void clipFillRaster(int[] pixels, int off, int adjust, int w, int h,
+                        double rowrel, double dx, double dy) {
+        while (--h >= 0) {
+            double colrel = rowrel;
+            int j = w;
+            if (colrel <= 0.0) {
+                int rgb = interp[0];
+                do {
+                    pixels[off++] = rgb;
+                    colrel += dx;
+                } while (--j > 0 && colrel <= 0.0);
+            }
+            while (colrel < 1.0 && --j >= 0) {
+                pixels[off++] = interp[(int) (colrel < 0.5 ? colrel * 2 * 256 : (2 - colrel * 2) * 256)];
+                colrel += dx;
+            }
+            if (j > 0) {
+                int rgb = interp[256];
+                do {
+                    pixels[off++] = rgb;
+                } while (--j > 0);
+            }
+
+            off += adjust;
+            rowrel += dy;
+        }
+    }
+}

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

@@ -0,0 +1,525 @@
+/*
+ * 
+ * DIY Layout Creator (DIYLC). Copyright (c) 2009-2018 held jointly by the individual authors.
+ * 
+ * This file is part of DIYLC.
+ * 
+ * DIYLC is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * DIYLC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along with DIYLC. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+package org.diylc.components;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.Paint;
+import java.awt.Point;
+import java.awt.Rectangle;
+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.Line2D;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.appframework.miscutils.ConfigurationManager;
+import org.diylc.awt.ShadedPaint;
+import org.diylc.common.Display;
+import org.diylc.common.IPlugInPort;
+import org.diylc.common.LineStyle;
+import org.diylc.common.ObjectCache;
+import org.diylc.core.ComponentState;
+import org.diylc.core.IDrawingObserver;
+import org.diylc.core.Project;
+import org.diylc.core.Theme;
+import org.diylc.core.VisibilityPolicy;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.annotations.PositiveMeasureValidator;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+import org.diylc.utils.Constants;
+
+/**
+ * Base class for all leaded components such as resistors or capacitors. Has two control points and
+ * draws leads between them. Also, it positions and draws the shape of the component as specified by
+ * a child class.
+ * 
+ * @author Branislav Stojkovic
+ */
+public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComponent<T> {
+
+  private static final long serialVersionUID = 1L;
+
+  public static Color LEAD_COLOR = Color.decode("#CCCCCC");
+  public static Color LEAD_COLOR_ICON = LEAD_COLOR.darker().darker();
+  public static Size LEAD_THICKNESS = new Size(0.6d, SizeUnit.mm);
+  public static Size DEFAULT_SIZE = new Size(1d, SizeUnit.in);
+
+  protected Size length;
+  protected Size width;
+  protected Point[] points = new Point[] {new Point((int) (-DEFAULT_SIZE.convertToPixels() / 2), 0),
+      new Point((int) (DEFAULT_SIZE.convertToPixels() / 2), 0)};
+  protected Color bodyColor = Color.white;
+  protected Color borderColor = Color.black;
+  protected Color labelColor = LABEL_COLOR;
+  protected Color leadColor = LEAD_COLOR;
+  protected Display display = Display.NAME;
+  private boolean flipStanding = false;
+  private LabelOriantation labelOriantation = LabelOriantation.Directional;
+
+  protected AbstractLeadedComponent() {
+    super();
+    try {
+      this.length = getDefaultLength().clone();
+      this.width = getDefaultWidth().clone();
+    } catch (CloneNotSupportedException e) {
+      // This should never happen because Size supports cloning.
+    } catch (NullPointerException e) {
+      // This will happen if components do not have any shape.
+    }
+  }
+
+  protected boolean IsCopperArea() {
+    return false;
+  }
+
+  @Override
+  public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
+      IDrawingObserver drawingObserver) {
+    double distance = points[0].distance(points[1]);
+    Shape shape = getBodyShape();
+    // If there's no body, just draw the line connecting the ending points.
+    if (shape == null) {
+      drawLead(g2d, componentState, drawingObserver, IsCopperArea());
+    } else if (supportsStandingMode() && length.convertToPixels() > points[0].distance(points[1])) {
+      // When ending points are too close draw the component in standing
+      // mode.
+      int width = getClosestOdd(this.width.convertToPixels());
+      Shape body =
+          new Ellipse2D.Double((getFlipStanding() ? points[1] : points[0]).x - width / 2,
+              (getFlipStanding() ? points[1] : points[0]).y - width / 2, width, width);
+      Composite oldComposite = g2d.getComposite();
+      if (alpha < MAX_ALPHA) {
+        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
+      }
+      g2d.setColor(outlineMode ? Constants.TRANSPARENT_COLOR : getStandingBodyColor());
+      g2d.fill(body);
+      g2d.setComposite(oldComposite);
+      Color finalBorderColor;
+      if (outlineMode) {
+        Theme theme =
+            (Theme) ConfigurationManager.getInstance().readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
+        finalBorderColor =
+            componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
+                : theme.getOutlineColor();
+      } else {
+        finalBorderColor =
+            componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
+                : borderColor;
+      }
+
+      g2d.setColor(finalBorderColor);
+      g2d.draw(body);
+      if (!outlineMode) {
+        drawLead(g2d, componentState, drawingObserver, false);
+      }
+    } else {
+      // Normal mode with component body in the center and two lead parts.
+      Rectangle shapeRect = shape.getBounds();
+      double theta = Math.atan2(points[1].y - points[0].y, points[1].x - points[0].x);
+      // Go back to the original transformation to draw leads.
+      if (!outlineMode) {
+        AffineTransform textTransform = g2d.getTransform();
+        // if (length.convertToPixels() > points[0].distance(points[1]))
+        // {
+        // g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
+        // 0.5f));
+        // }
+        float leadThickness = getLeadThickness();
+        double leadLength = (distance - calculatePinSpacing(shapeRect)) / 2;
+
+        if (shouldShadeLeads()) {
+          Stroke leadStroke = ObjectCache.getInstance().fetchBasicStroke(leadThickness - 1);     
+          Color leadColor = getLeadColorForPainting(componentState);          
+          
+          Area leadArea = new Area();
+          
+          int endX = (int) (points[0].x + Math.cos(theta) * leadLength);
+          int endY = (int) (points[0].y + Math.sin(theta) * leadLength);
+          Line2D line = new Line2D.Double(points[0].x, points[0].y, endX, endY);
+          leadArea.add(new Area(leadStroke.createStrokedShape(line)));
+          
+          endX = (int) (points[1].x + Math.cos(theta - Math.PI) * leadLength);
+          endY = (int) (points[1].y + Math.sin(theta - Math.PI) * leadLength);
+          line = new Line2D.Double(points[1].x, points[1].y, endX, endY);
+          leadArea.add(new Area(leadStroke.createStrokedShape(line)));
+          
+          g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
+          g2d.setColor(leadColor);
+          g2d.fill(leadArea);
+          g2d.setColor(leadColor.darker());
+          g2d.draw(leadArea);          
+        } else {
+          g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(leadThickness));
+          Color leadColor = getLeadColorForPainting(componentState);
+          g2d.setColor(leadColor);
+          drawLeads(g2d, theta, leadLength);
+        }
+        g2d.setTransform(textTransform);
+      }
+      // Transform graphics to draw the body in the right place and at the
+      // right angle.
+      AffineTransform oldTransform = null;
+      double width;
+      double length;
+      if (useShapeRectAsPosition()) {
+        width = shapeRect.getHeight();
+        length = shapeRect.getWidth();
+      } else {
+        width = getWidth().convertToPixels();
+        length = getLength().convertToPixels();
+      }
+      oldTransform = g2d.getTransform();
+      g2d.translate((points[0].x + points[1].x - length) / 2, (points[0].y + points[1].y - width) / 2);
+      g2d.rotate(theta, length / 2, width / 2);
+      // Draw body.
+      Composite oldComposite = g2d.getComposite();
+      if (alpha < MAX_ALPHA) {
+        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
+      }
+      if (bodyColor != null) {
+        g2d.setColor(outlineMode ? Constants.TRANSPARENT_COLOR : bodyColor);    
+        
+        if (!outlineMode && ConfigurationManager.getInstance().readBoolean(IPlugInPort.HI_QUALITY_RENDER_KEY, false)) {
+          Point p1 = new Point((int) (length / 2), 0);
+          Point p2 = new Point((int) (length / 2), (int) width);
+          ShadedPaint paint = theta > 0 && theta < Math.PI ? new ShadedPaint(p2, p1, bodyColor) : new ShadedPaint(p1, p2, bodyColor);
+          Paint oldPaint = g2d.getPaint();
+          g2d.setPaint(paint);
+          g2d.fill(shape);
+          g2d.setPaint(oldPaint);
+        } else {        
+          g2d.fill(shape);
+        }
+      }
+      decorateComponentBody(g2d, outlineMode);
+      g2d.setComposite(oldComposite);
+      g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
+      Color finalBorderColor;
+      if (outlineMode) {
+        Theme theme =
+            (Theme) ConfigurationManager.getInstance().readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
+        finalBorderColor =
+            componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
+                : theme.getOutlineColor();
+      } else {
+        finalBorderColor =
+            componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
+                : borderColor;
+      }
+      g2d.setColor(finalBorderColor);
+      g2d.draw(shape);
+
+      // Draw label.
+      g2d.setFont(project.getFont());
+      if (useShapeRectAsPosition()) {
+        g2d.translate(shapeRect.x, shapeRect.y);
+      }
+      Color finalLabelColor;
+      if (outlineMode) {
+        Theme theme =
+            (Theme) ConfigurationManager.getInstance().readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
+        finalLabelColor =
+            componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? LABEL_COLOR_SELECTED
+                : theme.getOutlineColor();
+      } else {
+        finalLabelColor =
+            componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? LABEL_COLOR_SELECTED
+                : labelColor;
+      }
+      g2d.setColor(finalLabelColor);
+      FontMetrics fontMetrics = g2d.getFontMetrics();
+      String label = "";
+      label = display == Display.NAME ? getName() : (getValue() == null ? "" : getValue().toString());
+      if (display == Display.NONE) {
+        label = "";
+      }
+      if (display == Display.BOTH) {
+        label = getName() + " " + (getValue() == null ? "" : getValue().toString());
+      }
+      Rectangle2D textRect = fontMetrics.getStringBounds(label, g2d);
+      // Don't offset in outline mode.
+      int offset = outlineMode ? 0 : getLabelOffset((int) length, (int) textRect.getWidth());
+      // Adjust label angle if needed to make sure that it's readable.
+      if ((theta >= Math.PI / 2 && theta <= Math.PI) || (theta < -Math.PI / 2 && theta > -Math.PI)) {
+        g2d.rotate(Math.PI, length / 2, width / 2);
+        offset = -offset;
+      }
+      if (getLabelOriantation() == LabelOriantation.Horizontal) {
+        g2d.setTransform(oldTransform);
+        double x = (points[0].x + points[1].x - length) / 2.0;
+        double y = (points[0].y + points[1].y - width) / 2.0;
+        g2d.drawString(label, (int) (x + (length - textRect.getWidth()) / 2 + offset),
+            (int)(y + calculateLabelYCoordinate(shapeRect, textRect, fontMetrics)));
+      } else {
+        g2d.drawString(label, (int) (length - textRect.getWidth()) / 2 + offset,
+            calculateLabelYCoordinate(shapeRect, textRect, fontMetrics));      
+        g2d.setTransform(oldTransform); 
+      }      
+    }
+  }
+
+  private void drawLeads(Graphics2D g2d, double theta, double leadLength) {
+    int endX = (int) (points[0].x + Math.cos(theta) * leadLength);
+    int endY = (int) (points[0].y + Math.sin(theta) * leadLength);
+    g2d.drawLine(points[0].x, points[0].y, endX, endY);
+
+    endX = (int) (points[1].x + Math.cos(theta - Math.PI) * leadLength);
+    endY = (int) (points[1].y + Math.sin(theta - Math.PI) * leadLength);
+    g2d.drawLine(points[1].x, points[1].y, endX, endY);
+  }
+
+  private void drawLead(Graphics2D g2d, ComponentState componentState, IDrawingObserver observer, boolean isCopperArea) {
+    if (isCopperArea)
+      observer.startTrackingContinuityArea(true);
+
+    float thickness = getLeadThickness() - 1;
+    Stroke stroke = null;
+    switch (getStyle()) {
+      case SOLID:
+        stroke = ObjectCache.getInstance().fetchBasicStroke(thickness);
+        break;
+      case DASHED:
+        stroke =
+            ObjectCache.getInstance().fetchStroke(thickness, new float[] {thickness * 2, thickness * 4}, thickness * 4);
+        break;
+      case DOTTED:
+        stroke = ObjectCache.getInstance().fetchStroke(thickness, new float[] {thickness / 4, thickness * 4}, 0);
+        break;
+    }
+
+    Line2D line = new Line2D.Double(points[0].x, points[0].y, points[1].x, points[1].y);
+    Shape lineShape = stroke.createStrokedShape(line);
+    
+    Color leadColor =
+        shouldShadeLeads() ? getLeadColorForPainting(componentState) : getLeadColorForPainting(componentState);
+    g2d.setColor(leadColor);
+    g2d.fill(lineShape);
+
+    if (isCopperArea)
+      observer.stopTrackingContinuityArea();
+
+    if (shouldShadeLeads()) {
+      g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
+      leadColor = getLeadColorForPainting(componentState);
+      g2d.setColor(leadColor.darker());
+      g2d.draw(lineShape);
+    }
+  }
+
+  protected LineStyle getStyle() {
+    return LineStyle.SOLID;
+  }
+
+  protected void decorateComponentBody(Graphics2D g2d, boolean outlineMode) {
+    // Do nothing.
+  }
+
+  protected int calculateLabelYCoordinate(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics) {
+    return (int) (shapeRect.getHeight() - textRect.getHeight()) / 2 + fontMetrics.getAscent();
+  }
+
+  protected boolean shouldShadeLeads() {
+    return true;
+  }
+
+  protected boolean supportsStandingMode() {
+    return false;
+  }
+
+  protected int getLabelOffset(int bodyWidth, int labelWidth) {
+    return 0;
+  }
+
+  /**
+   * @return default component length.
+   */
+  protected abstract Size getDefaultLength();
+
+  /**
+   * Returns default component width.
+   * 
+   * @return
+   */
+  protected abstract Size getDefaultWidth();
+
+  /**
+   * @return shape that represents component body. Shape should not be transformed and should be
+   *         referenced to (0, 0).
+   */
+  protected abstract Shape getBodyShape();
+
+  /**
+   * Controls how component shape should be placed relative to start and end point.
+   * 
+   * @return <code>true<code> if shape rect should be used to center the component or <code>false</code>
+   *         to place the component relative to <code>length</code> and <code>width</code> values.
+   */
+  protected boolean useShapeRectAsPosition() {
+    return true;
+  }
+
+  /**
+   * @return default lead thickness. Override this method to change it.
+   */
+  protected float getLeadThickness() {
+    return getClosestOdd(LEAD_THICKNESS.convertToPixels());
+  }
+
+  /**
+   * @return default lead color. Override this method to change it.
+   */
+  protected Color getLeadColorForPainting(ComponentState componentState) {
+    return componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
+        : getLeadColor();
+  }
+
+  @EditableProperty(name = "Lead Color")
+  public Color getLeadColor() {
+    if (leadColor == null) {
+      leadColor = LEAD_COLOR_ICON;
+    }
+    return leadColor;
+  }
+
+  public void setLeadColor(Color leadColor) {
+    this.leadColor = leadColor;
+  }
+
+  protected int calculatePinSpacing(Rectangle shapeRect) {
+    return shapeRect.width;
+  }
+
+  @Override
+  public int getControlPointCount() {
+    return points.length;
+  }
+
+  @Override
+  public Point getControlPoint(int index) {
+    return (Point) points[index];
+  }
+
+  @Override
+  public boolean isControlPointSticky(int index) {
+    return true;
+  }
+
+  @Override
+  public VisibilityPolicy getControlPointVisibilityPolicy(int index) {
+    return VisibilityPolicy.ALWAYS;
+  }
+
+  @Override
+  public void setControlPoint(Point point, int index) {
+    points[index].setLocation(point);
+  }
+
+  @EditableProperty(name = "Color")
+  public Color getBodyColor() {
+    return bodyColor;
+  }
+
+  public void setBodyColor(Color bodyColor) {
+    this.bodyColor = bodyColor;
+  }
+
+  public Color getStandingBodyColor() {
+    return bodyColor;
+  }
+
+  @EditableProperty(name = "Border")
+  public Color getBorderColor() {
+    return borderColor;
+  }
+
+  public void setBorderColor(Color borderColor) {
+    this.borderColor = borderColor;
+  }
+
+  @EditableProperty(name = "Length", defaultable = true, validatorClass = PositiveMeasureValidator.class)
+  public Size getLength() {
+    return length;
+  }
+
+  public void setLength(Size length) {
+    this.length = length;
+  }
+
+  @EditableProperty(name = "Width", defaultable = true, validatorClass = PositiveMeasureValidator.class)
+  public Size getWidth() {
+    return width;
+  }
+
+  public void setWidth(Size width) {
+    this.width = width;
+  }
+
+  @EditableProperty
+  public Display getDisplay() {
+    return display;
+  }
+
+  public void setDisplay(Display display) {
+    this.display = display;
+  }
+
+  @EditableProperty(name = "Label Color")
+  public Color getLabelColor() {
+    return labelColor;
+  }
+
+  public void setLabelColor(Color labelColor) {
+    this.labelColor = labelColor;
+  }
+  
+  @EditableProperty(name = "Label Orientation")
+  public LabelOriantation getLabelOriantation() {
+    if (labelOriantation == null)
+      labelOriantation = LabelOriantation.Directional;
+    return labelOriantation;
+  }
+  
+  public void setLabelOriantation(LabelOriantation labelOriantation) {
+    this.labelOriantation = labelOriantation;
+  }
+
+  /**
+   * Override this method with @EditableProperty annotation in child classes where standing mode is
+   * supported
+   * 
+   * @return
+   */
+  public boolean getFlipStanding() {
+    return flipStanding;
+  }
+
+  public void setFlipStanding(boolean flipStanding) {
+    this.flipStanding = flipStanding;
+  }
+  
+  public enum LabelOriantation {
+    Directional, Horizontal
+  }
+}

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

@@ -0,0 +1,63 @@
+/*
+
+    DIY Layout Creator (DIYLC).
+    Copyright (c) 2009-2018 held jointly by the individual authors.
+
+    This file is part of DIYLC.
+
+    DIYLC is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DIYLC is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with DIYLC.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+package org.diylc.components;
+
+import java.awt.Rectangle;
+
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+/**
+ * Base class for radial components. The same as {@link AbstractRadialComponent} but with added pin
+ * spacing.
+ * 
+ * @author bancika
+ * 
+ * @param <T>
+ */
+public abstract class AbstractRadialComponent<T> extends AbstractLeadedComponent<T> {
+
+  private static final long serialVersionUID = 1L;
+
+  public static Size PIN_SPACING = new Size(0.1d, SizeUnit.in);
+
+  private Size pinSpacing = PIN_SPACING;
+
+  @Override
+  protected int calculatePinSpacing(Rectangle shapeRect) {
+    return getClosestOdd(getPinSpacing().convertToPixels());
+  }
+
+  @EditableProperty(name = "Pin spacing")
+  public Size getPinSpacing() {
+    if (pinSpacing == null) {
+      pinSpacing = PIN_SPACING;
+    }
+    return pinSpacing;
+  }
+
+  public void setPinSpacing(Size pinSpacing) {
+    this.pinSpacing = pinSpacing;
+  }
+
+}

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

@@ -0,0 +1,93 @@
+/*
+
+    DIY Layout Creator (DIYLC).
+    Copyright (c) 2009-2018 held jointly by the individual authors.
+
+    This file is part of DIYLC.
+
+    DIYLC is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DIYLC is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with DIYLC.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+package org.diylc.components;
+
+import java.awt.Color;
+import java.awt.FontMetrics;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.common.LabelPosition;
+import org.diylc.core.ComponentState;
+import org.diylc.core.annotations.EditableProperty;
+
+public abstract class AbstractSchematicLeadedSymbol<T> extends AbstractLeadedComponent<T> {
+
+  private static final long serialVersionUID = 1L;
+
+  public static Color COLOR = Color.blue;
+  public static Color LEAD_COLOR = Color.black;
+
+  protected LabelPosition labelPosition = LabelPosition.ABOVE;
+
+  public AbstractSchematicLeadedSymbol() {
+    super();
+    // We don't want to fill the body, so use null.
+    this.bodyColor = null;
+    this.leadColor = LEAD_COLOR;
+    this.borderColor = COLOR;
+  }
+
+  @Override
+  public Color getBodyColor() {
+    return super.getBodyColor();
+  }
+
+  @Override
+  protected boolean shouldShadeLeads() {
+    return false;
+  }
+
+  @Override
+  protected float getLeadThickness() {
+    return 1;
+  }
+
+  @Override
+  protected int calculateLabelYCoordinate(Rectangle2D shapeRect, Rectangle2D textRect, FontMetrics fontMetrics) {
+    if (labelPosition == LabelPosition.ABOVE) {
+      return -5;
+    } else {
+      return (int) (shapeRect.getHeight() + textRect.getHeight());
+    }
+  }
+
+  @EditableProperty(name = "Label Position")
+  public LabelPosition getLabelPosition() {
+    return labelPosition;
+  }
+
+  @Override
+  @EditableProperty(name = "Color")
+  public Color getBorderColor() {
+    return super.getBorderColor();
+  }
+
+  public void setLabelPosition(LabelPosition labelPosition) {
+    this.labelPosition = labelPosition;
+  }
+
+  @Override
+  protected Color getLeadColorForPainting(ComponentState componentState) {
+    return componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
+        : getLeadColor();
+  }
+}

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

@@ -19,6 +19,7 @@ package org.diylc.components.connectivity;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
+import java.awt.Shape;
 import java.awt.Stroke;
 import java.awt.geom.Path2D;
 
@@ -54,10 +55,10 @@ public class HookupWire extends AbstractCurvedComponent<Void> {
   @Override
   protected void drawCurve(Path2D curve, Graphics2D g2d, ComponentState componentState, IDrawingObserver drawingObserver) {
     int thickness =
-        (int) (Math.pow(Math.E, -1.12436 - 0.11594 * gauge.getValue()) * Constants.PIXELS_PER_INCH * (1 + 2 * INSULATION_THICKNESS_PCT));
+        (int) (Math.pow(Math.E, -1.12436 - 0.11594 * gauge.getValue()) * Constants.PIXELS_PER_INCH * (1 + 2 * INSULATION_THICKNESS_PCT)) - 1;
     Color curveColor =
         componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING ? SELECTION_COLOR
-            : color.darker();
+            : color;
     g2d.setColor(curveColor);
     Stroke stroke = null;
     switch (getStyle()) {
@@ -72,24 +73,25 @@ public class HookupWire extends AbstractCurvedComponent<Void> {
         stroke = ObjectCache.getInstance().fetchStroke(thickness, new float[] {thickness / 4, thickness * 3}, 0);
         break;
     }
-    g2d.setStroke(stroke);
-    g2d.draw(curve);
+    Shape s = stroke.createStrokedShape(curve);    
+    g2d.fill(s);
     if (componentState == ComponentState.NORMAL) {
-      g2d.setColor(color);
-      switch (getStyle()) {
-        case SOLID:
-          stroke = ObjectCache.getInstance().fetchBasicStroke(thickness - 2);
-          break;
-        case DASHED:
-          stroke =
-              ObjectCache.getInstance().fetchStroke(thickness - 2, new float[] {thickness * 2, thickness * 3},
-                  thickness * 4);
-          break;
-        case DOTTED:
-          stroke = ObjectCache.getInstance().fetchStroke(thickness - 2, new float[] {thickness / 4, thickness * 3}, 0);
-      }
-      g2d.setStroke(stroke);
-      g2d.draw(curve);
+      g2d.setColor(color.darker());
+      g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
+//      switch (getStyle()) {
+//        case SOLID:
+//          stroke = ObjectCache.getInstance().fetchBasicStroke(thickness - 2);
+//          break;
+//        case DASHED:
+//          stroke =
+//              ObjectCache.getInstance().fetchStroke(thickness - 2, new float[] {thickness * 2, thickness * 3},
+//                  thickness * 4);
+//          break;
+//        case DOTTED:
+//          stroke = ObjectCache.getInstance().fetchStroke(thickness - 2, new float[] {thickness / 4, thickness * 3}, 0);
+//      }
+//      g2d.setStroke(stroke);
+      g2d.draw(s);
     }
   }