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

@@ -0,0 +1,85 @@
+package org.diylc.components.passive;
+
+import java.awt.Point;
+
+import org.diylc.common.Orientation;
+import org.diylc.components.AbstractTransparentComponent;
+import org.diylc.core.VisibilityPolicy;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Resistance;
+import org.diylc.core.measures.ResistanceUnit;
+
+public abstract class AbstractPotentiometer extends
+		AbstractTransparentComponent<PotentiometerValue> {
+
+	private static final long serialVersionUID = 1L;
+
+	protected Point[] controlPoints;
+
+	protected Resistance resistance = new Resistance(100d, ResistanceUnit.K);
+	protected Orientation orientation = Orientation.DEFAULT;
+	protected Taper taper = Taper.LIN;
+
+	@Override
+	public int getControlPointCount() {
+		return controlPoints.length;
+	}
+
+	@Override
+	public Point getControlPoint(int index) {
+		return controlPoints[index];
+	}
+
+	@Override
+	public void setControlPoint(Point point, int index) {
+		controlPoints[index].setLocation(point);
+	}
+
+	@Override
+	public VisibilityPolicy getControlPointVisibilityPolicy(int index) {
+		return VisibilityPolicy.NEVER;
+	}
+
+	@Override
+	public boolean isControlPointSticky(int index) {
+		return true;
+	}
+
+	@EditableProperty
+	public Resistance getResistance() {
+		return resistance;
+	}
+
+	public void setResistance(Resistance resistance) {
+		this.resistance = resistance;
+	}
+
+	@Override
+	public PotentiometerValue getValue() {
+		return new PotentiometerValue(resistance, taper);
+	}
+
+	@Override
+	public void setValue(PotentiometerValue value) {
+		this.resistance = value.getResistance();
+		this.taper = value.getTaper();
+	}
+
+	@EditableProperty
+	public Taper getTaper() {
+		return taper;
+	}
+
+	public void setTaper(Taper taper) {
+		this.taper = taper;
+	}
+
+	@EditableProperty
+	public Orientation getOrientation() {
+		return orientation;
+	}
+
+	public void setOrientation(Orientation orientation) {
+		this.orientation = orientation;
+	}
+}

src/org/diylc/components/passive/AxialElectrolyticCapacitor.java

@@ -0,0 +1,149 @@
+package org.diylc.components.passive;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.common.IPlugInPort;
+import org.diylc.common.ObjectCache;
+import org.diylc.components.AbstractLeadedComponent;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.Theme;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Capacitance;
+import org.diylc.core.measures.CapacitanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+import org.diylc.utils.Constants;
+
+import com.diyfever.gui.miscutils.ConfigurationManager;
+
+@ComponentDescriptor(name = "Electrolytic Capacitor (axial)", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "C", description = "Axial electrolytic capacitor, similar to Sprague Atom, F&T, etc", zOrder = IDIYComponent.COMPONENT)
+public class AxialElectrolyticCapacitor extends AbstractLeadedComponent<Capacitance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_WIDTH = new Size(1d / 2, SizeUnit.in);
+	public static Size DEFAULT_HEIGHT = new Size(1d / 8, SizeUnit.in);
+	public static Color BODY_COLOR = Color.decode("#EAADEA");
+	public static Color BORDER_COLOR = BODY_COLOR.darker();
+	public static Color MARKER_COLOR = Color.gray;
+	public static Color TICK_COLOR = Color.white;
+
+	private Capacitance value = new Capacitance(1d, CapacitanceUnit.uF);
+	private Voltage voltage = Voltage._63V;
+
+	private Color markerColor = MARKER_COLOR;
+	private Color tickColor = TICK_COLOR;
+	private boolean polarized = true;
+
+	public AxialElectrolyticCapacitor() {
+		super();
+		this.bodyColor = BODY_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+
+	@EditableProperty
+	public Capacitance getValue() {
+		return value;
+	}
+
+	public void setValue(Capacitance value) {
+		this.value = value;
+	}
+
+	@EditableProperty
+	public Voltage getVoltage() {
+		return voltage;
+	}
+
+	public void setVoltage(Voltage voltage) {
+		this.voltage = voltage;
+	}
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.rotate(-Math.PI / 4, width / 2, height / 2);
+		g2d.setColor(LEAD_COLOR);
+		g2d.drawLine(0, height / 2, width, height / 2);
+		g2d.setColor(BODY_COLOR);
+		g2d.fillRect(4, height / 2 - 3, width - 8, 6);
+		g2d.setColor(MARKER_COLOR);
+		g2d.fillRect(width - 9, height / 2 - 3, 5, 6);
+		g2d.setColor(TICK_COLOR);
+		g2d.drawLine(width - 6, height / 2 - 1, width - 6, height / 2 + 1);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(4, height / 2 - 3, width - 8, 6);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return DEFAULT_HEIGHT;
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		return DEFAULT_WIDTH;
+	}
+
+	@EditableProperty(name = "Marker")
+	public Color getMarkerColor() {
+		return markerColor;
+	}
+
+	public void setMarkerColor(Color coverColor) {
+		this.markerColor = coverColor;
+	}
+
+	@EditableProperty(name = "Tick")
+	public Color getTickColor() {
+		return tickColor;
+	}
+
+	public void setTickColor(Color tickColor) {
+		this.tickColor = tickColor;
+	}
+
+	@EditableProperty(name = "Polarized")
+	public boolean getPolarized() {
+		return polarized;
+	}
+
+	public void setPolarized(boolean polarized) {
+		this.polarized = polarized;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		return new Rectangle2D.Double(0f, 0f, getLength().convertToPixels(),
+				getClosestOdd(getWidth().convertToPixels()));
+	}
+
+	@Override
+	protected void decorateComponentBody(Graphics2D g2d, boolean outlineMode) {
+		if (polarized) {
+			int width = getClosestOdd(getWidth().convertToPixels());
+			int markerLength = (int) (getLength().convertToPixels() * 0.2);
+			if (!outlineMode) {
+				g2d.setColor(markerColor);
+				g2d.fillRect((int) getLength().convertToPixels() - markerLength, 0, markerLength,
+						width);
+			}
+			Color finalTickColor;
+			if (outlineMode) {
+				Theme theme = (Theme) ConfigurationManager.getInstance().readObject(
+						IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
+				finalTickColor = theme.getOutlineColor();
+			} else {
+				finalTickColor = tickColor;
+			}
+			g2d.setColor(finalTickColor);
+			g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(2));
+			g2d.drawLine((int) getLength().convertToPixels() - markerLength / 2,
+					(int) (width / 2 - width * 0.15), (int) getLength().convertToPixels()
+							- markerLength / 2, (int) (width / 2 + width * 0.15));
+		}
+	}
+}

src/org/diylc/components/passive/AxialFilmCapacitor.java

@@ -0,0 +1,86 @@
+package org.diylc.components.passive;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.components.AbstractLeadedComponent;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Capacitance;
+import org.diylc.core.measures.CapacitanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Film Capacitor (axial)", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "C", description = "Axial film capacitor, similar to Mallory 150s", zOrder = IDIYComponent.COMPONENT)
+public class AxialFilmCapacitor extends AbstractLeadedComponent<Capacitance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_WIDTH = new Size(1d / 2, SizeUnit.in);
+	public static Size DEFAULT_HEIGHT = new Size(1d / 8, SizeUnit.in);
+	public static Color BODY_COLOR = Color.decode("#FFE303");
+	public static Color BORDER_COLOR = BODY_COLOR.darker();
+
+	private Capacitance value = new Capacitance(22d, CapacitanceUnit.nF);
+	private Voltage voltage = Voltage._63V;
+
+	public AxialFilmCapacitor() {
+		super();
+		this.bodyColor = BODY_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+	
+	@Override
+	protected boolean supportsStandingMode() {
+		return true;
+	}
+
+	@EditableProperty
+	public Capacitance getValue() {
+		return value;
+	}
+
+	public void setValue(Capacitance value) {
+		this.value = value;
+	}
+	
+	@EditableProperty
+	public Voltage getVoltage() {
+		return voltage;
+	}
+
+	public void setVoltage(Voltage voltage) {
+		this.voltage = voltage;
+	}
+
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.rotate(-Math.PI / 4, width / 2, height / 2);
+		g2d.setColor(LEAD_COLOR);
+		g2d.drawLine(0, height / 2, width, height / 2);
+		g2d.setColor(BODY_COLOR);
+		g2d.fillRect(4, height / 2 - 3, width - 8, 6);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(4, height / 2 - 3, width - 8, 6);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return DEFAULT_HEIGHT;
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		return DEFAULT_WIDTH;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		return new Rectangle2D.Double(0f, 0f, getLength().convertToPixels(),
+				getClosestOdd(getWidth().convertToPixels()));
+	}
+}

src/org/diylc/components/passive/CapacitorSymbol.java

@@ -0,0 +1,101 @@
+package org.diylc.components.passive;
+
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.GeneralPath;
+
+import org.diylc.components.AbstractSchematicLeadedSymbol;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.Theme;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Capacitance;
+import org.diylc.core.measures.CapacitanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Capacitor (schematic symbol)", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "C", description = "Capacitor schematic symbol with an optional polarity sign", zOrder = IDIYComponent.COMPONENT)
+public class CapacitorSymbol extends AbstractSchematicLeadedSymbol<Capacitance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_LENGTH = new Size(0.05, SizeUnit.in);
+	public static Size DEFAULT_WIDTH = new Size(0.15, SizeUnit.in);
+
+	private Capacitance value = new Capacitance(22d, CapacitanceUnit.nF);
+	private Voltage voltage = Voltage._63V;
+	private boolean polarized = false;
+
+	@EditableProperty
+	public Capacitance getValue() {
+		return value;
+	}
+
+	public void setValue(Capacitance value) {
+		this.value = value;
+	}
+
+	@EditableProperty
+	public Voltage getVoltage() {
+		return voltage;
+	}
+
+	public void setVoltage(Voltage voltage) {
+		this.voltage = voltage;
+	}
+
+	@EditableProperty
+	public boolean getPolarized() {
+		return polarized;
+	}
+
+	public void setPolarized(boolean polarized) {
+		this.polarized = polarized;
+	}
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.rotate(-Math.PI / 4, width / 2, height / 2);
+		g2d.setColor(LEAD_COLOR);
+		g2d.drawLine(0, height / 2, 13, height / 2);
+		g2d.drawLine(width - 13, height / 2, width, height / 2);
+		g2d.setColor(COLOR);
+		g2d.drawLine(14, height / 2 - 6, 14, height / 2 + 6);
+		g2d.drawLine(width - 14, height / 2 - 6, width - 14, height / 2 + 6);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return DEFAULT_WIDTH;
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		return DEFAULT_LENGTH;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		GeneralPath polyline = new GeneralPath();
+		double length = getLength().convertToPixels();
+		double width = getWidth().convertToPixels();
+		polyline.moveTo(0, 0);
+		polyline.lineTo(0, width);
+		polyline.moveTo(length, 0);
+		polyline.lineTo(length, width);
+		return polyline;
+	}
+
+	@Override
+	protected void decorateComponentBody(Graphics2D g2d, boolean outlineMode) {
+		if (polarized) {
+			// Draw + sign.
+			g2d.setColor(getBorderColor());
+			int plusSize = getClosestOdd(getWidth().convertToPixels() / 4);
+			int x = -plusSize;
+			int y = plusSize;
+			g2d.drawLine(x - plusSize / 2, y, x + plusSize / 2, y);
+			g2d.drawLine(x, y - plusSize / 2, x, y + plusSize / 2);
+		}
+	}
+}

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

@@ -0,0 +1,279 @@
+package org.diylc.components.passive;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.common.ObjectCache;
+import org.diylc.common.Orientation;
+import org.diylc.core.ComponentState;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.IDrawingObserver;
+import org.diylc.core.Project;
+import org.diylc.core.Theme;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Potentiometer (panel mount)", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.SINGLE_CLICK, instanceNamePrefix = "VR", description = "Panel mount potentiometer with solder lugs", zOrder = IDIYComponent.COMPONENT, stretchable = false)
+public class PotentiometerPanel extends AbstractPotentiometer {
+
+	private static final long serialVersionUID = 1L;
+
+	protected static Size BODY_DIAMETER = new Size(1d, SizeUnit.in);
+	protected static Size SPACING = new Size(0.3d, SizeUnit.in);
+	protected static Size LUG_DIAMETER = new Size(0.15d, SizeUnit.in);
+	protected static Color BODY_COLOR = Color.gray.brighter();
+	protected static Color BORDER_COLOR = Color.gray;
+
+	protected Size bodyDiameter = BODY_DIAMETER;
+	protected Size spacing = SPACING;
+	protected Size lugDiameter = LUG_DIAMETER;
+	protected Color bodyColor = BODY_COLOR;
+	protected Color borderColor = BORDER_COLOR;
+	// Array of 7 elements: 3 lug connectors, 1 pot body and 3 lugs
+	transient protected Area[] body = null;
+
+	public PotentiometerPanel() {
+		controlPoints = new Point[] { new Point(0, 0), new Point(0, 0), new Point(0, 0) };
+		updateControlPoints();
+	}
+
+	protected void updateControlPoints() {
+		int spacing = (int) this.spacing.convertToPixels();
+		switch (orientation) {
+		case DEFAULT:
+			controlPoints[1].setLocation(controlPoints[0].x + spacing, controlPoints[0].y);
+			controlPoints[2].setLocation(controlPoints[0].x + 2 * spacing, controlPoints[0].y);
+			break;
+		case _90:
+			controlPoints[1].setLocation(controlPoints[0].x, controlPoints[0].y + spacing);
+			controlPoints[2].setLocation(controlPoints[0].x, controlPoints[0].y + 2 * spacing);
+			break;
+		case _180:
+			controlPoints[1].setLocation(controlPoints[0].x - spacing, controlPoints[0].y);
+			controlPoints[2].setLocation(controlPoints[0].x - 2 * spacing, controlPoints[0].y);
+			break;
+		case _270:
+			controlPoints[1].setLocation(controlPoints[0].x, controlPoints[0].y - spacing);
+			controlPoints[2].setLocation(controlPoints[0].x, controlPoints[0].y - 2 * spacing);
+			break;
+		default:
+			break;
+		}
+	}
+
+	public Area[] getBody() {
+		int spacing = (int) this.spacing.convertToPixels();
+		int diameter = getClosestOdd(bodyDiameter.convertToPixels());
+		if (body == null) {
+			body = new Area[7];
+
+			// Add lugs.
+			int lugDiameter = getClosestOdd(this.lugDiameter.convertToPixels());
+			int holeDiameter = getClosestOdd(this.lugDiameter.convertToPixels() / 2);
+			for (int i = 0; i < 3; i++) {
+				Area area = new Area(new Ellipse2D.Double(controlPoints[i].x - lugDiameter / 2,
+						controlPoints[i].y - lugDiameter / 2, lugDiameter, lugDiameter));
+				body[4 + i] = area;
+			}
+
+			switch (orientation) {
+			case DEFAULT:
+				body[3] = new Area(new Ellipse2D.Double(
+						controlPoints[0].x + spacing - diameter / 2, controlPoints[0].y - spacing
+								/ 2 - diameter, diameter, diameter));
+				for (int i = 0; i < 3; i++) {
+					body[i] = new Area(new Rectangle2D.Double(
+							controlPoints[i].x - holeDiameter / 2, controlPoints[i].y
+									- (spacing + diameter) / 2, holeDiameter,
+							(spacing + diameter) / 2));
+				}
+				break;
+			case _90:
+				body[3] = new Area(new Ellipse2D.Double(controlPoints[0].x + spacing / 2,
+						controlPoints[0].y + spacing - diameter / 2, diameter, diameter));
+				for (int i = 0; i < 3; i++) {
+					body[i] = new Area(new Rectangle2D.Double(controlPoints[i].x,
+							controlPoints[i].y - holeDiameter / 2, (spacing + diameter) / 2,
+							holeDiameter));
+				}
+				break;
+			case _180:
+				body[3] = new Area(new Ellipse2D.Double(
+						controlPoints[0].x - spacing - diameter / 2, controlPoints[0].y + spacing
+								/ 2, diameter, diameter));
+				for (int i = 0; i < 3; i++) {
+					body[i] = new Area(new Rectangle2D.Double(
+							controlPoints[i].x - holeDiameter / 2, controlPoints[i].y,
+							holeDiameter, (spacing + diameter) / 2));
+				}
+				break;
+			case _270:
+				body[3] = new Area(new Ellipse2D.Double(
+						controlPoints[0].x - spacing / 2 - diameter, controlPoints[0].y - spacing
+								- diameter / 2, diameter, diameter));
+				for (int i = 0; i < 3; i++) {
+					body[i] = new Area(new Rectangle2D.Double(controlPoints[i].x
+							- (spacing + diameter) / 2, controlPoints[i].y - holeDiameter / 2,
+							(spacing + diameter) / 2, holeDiameter));
+				}
+				break;
+			default:
+				break;
+			}
+			for (int i = 0; i < 3; i++) {
+				for (int j = 3; j < 7; j++) {
+					body[i].subtract(body[j]);
+				}
+			}
+			// 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 - holeDiameter / 2, holeDiameter,
+						holeDiameter)));
+			}
+		}
+		return body;
+	}
+
+	@Override
+	public void setControlPoint(Point point, int index) {
+		super.setControlPoint(point, index);
+		body = null;
+	}
+
+	@Override
+	public void setOrientation(Orientation orientation) {
+		super.setOrientation(orientation);
+		updateControlPoints();
+		body = null;
+	}
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
+		for (Area shape : getBody()) {
+			if (shape != null) {
+				g2d.setColor(bodyColor);
+				Composite oldComposite = g2d.getComposite();
+				if (alpha < MAX_ALPHA) {
+					g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+							/ MAX_ALPHA));
+				}
+				g2d.fill(shape);
+				g2d.setComposite(oldComposite);
+				g2d.setColor(componentState == ComponentState.SELECTED
+						|| componentState == ComponentState.DRAGGING ? SELECTION_COLOR
+						: borderColor);
+				g2d.draw(shape);
+			}
+		}
+		// Draw caption.
+		g2d.setFont(LABEL_FONT);
+		g2d
+				.setColor(componentState == ComponentState.SELECTED ? LABEL_COLOR_SELECTED
+						: LABEL_COLOR);
+		FontMetrics fontMetrics = g2d.getFontMetrics();
+		Rectangle2D bodyRect = getBody()[3].getBounds2D();
+		Rectangle2D rect = fontMetrics.getStringBounds(getName(), g2d);
+
+		int textHeight = (int) rect.getHeight();
+		int textWidth = (int) rect.getWidth();
+		int panelHeight = (int) bodyRect.getHeight();
+		int panelWidth = (int) bodyRect.getWidth();
+
+		int x = (panelWidth - textWidth) / 2;
+		int y = panelHeight / 2 - textHeight + fontMetrics.getAscent();
+
+		g2d.drawString(getName(), (int) (bodyRect.getX() + x), (int) (bodyRect.getY() + y));
+
+		// Draw value.
+		rect = fontMetrics.getStringBounds(getValue().toString(), g2d);
+
+		textHeight = (int) rect.getHeight();
+		textWidth = (int) rect.getWidth();
+
+		x = (panelWidth - textWidth) / 2;
+		y = panelHeight / 2 + fontMetrics.getAscent();
+
+		g2d.drawString(getValue().toString(), (int) (bodyRect.getX() + x),
+				(int) (bodyRect.getY() + y));
+	}
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		int margin = 4 * width / 32;
+		int spacing = width / 3 - 1;
+		g2d.setColor(BORDER_COLOR);
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(2 * width / 32));
+		g2d.drawLine(width / 2 - spacing, height / 2, width / 2 - spacing, height - margin);
+		g2d.drawLine(width / 2 + spacing, height / 2, width / 2 + spacing, height - margin);
+		g2d.drawLine(width / 2, height / 2, width / 2, height - margin);
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(4 * width / 32));
+		g2d.drawLine(width / 2 - spacing, height - margin, width / 2 - spacing, height - margin);
+		g2d.drawLine(width / 2 + spacing, height - margin, width / 2 + spacing, height - margin);
+		g2d.drawLine(width / 2, height - margin, width / 2, height - margin);
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
+		g2d.setColor(BODY_COLOR);
+		g2d.fillOval(margin, margin / 2, width - 2 * margin, height - 2 * margin);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawOval(margin, margin / 2, width - 2 * margin, height - 2 * margin);
+	}
+
+	@EditableProperty
+	public Size getSpacing() {
+		return spacing;
+	}
+
+	public void setSpacing(Size spacing) {
+		this.spacing = spacing;
+		updateControlPoints();
+		body = null;
+	}
+
+	@EditableProperty(name = "Diameter")
+	public Size getBodyDiameter() {
+		return bodyDiameter;
+	}
+
+	public void setBodyDiameter(Size bodyDiameter) {
+		this.bodyDiameter = bodyDiameter;
+	}
+
+	@EditableProperty(name = "Lug size")
+	public Size getLugDiameter() {
+		return lugDiameter;
+	}
+
+	public void setLugDiameter(Size lugDiameter) {
+		this.lugDiameter = lugDiameter;
+	}
+
+	@EditableProperty(name = "Body")
+	public Color getBodyColor() {
+		return bodyColor;
+	}
+
+	public void setBodyColor(Color bodyColor) {
+		this.bodyColor = bodyColor;
+	}
+
+	@EditableProperty(name = "Border")
+	public Color getBorderColor() {
+		return borderColor;
+	}
+
+	public void setBorderColor(Color borderColor) {
+		this.borderColor = borderColor;
+	}
+}

src/org/diylc/components/passive/PotentiometerValue.java

@@ -0,0 +1,28 @@
+package org.diylc.components.passive;
+
+import org.diylc.core.measures.Resistance;
+
+public class PotentiometerValue {
+
+	private Resistance resistance;
+	private Taper taper;
+
+	public PotentiometerValue(Resistance resistance, Taper taper) {
+		super();
+		this.resistance = resistance;
+		this.taper = taper;
+	}
+
+	public Resistance getResistance() {
+		return resistance;
+	}
+
+	public Taper getTaper() {
+		return taper;
+	}
+
+	@Override
+	public String toString() {
+		return resistance.toString() + " " + taper.toString();
+	}
+}

src/org/diylc/components/passive/Power.java

@@ -0,0 +1,18 @@
+package org.diylc.components.passive;
+
+public enum Power {
+
+	EIGHT("1/8W"), QUARTER("1/4W"), HALF("1/2W"), ONE("1W"), TWO("2W"), FIVE("5W"), TEN("10W"), FIFTY(
+			"50W"), HUNDRED("100W");
+
+	String label;
+
+	Power(String label) {
+		this.label = label;
+	}
+
+	@Override
+	public String toString() {
+		return label;
+	}
+}

src/org/diylc/components/passive/RadialCeramicDiskCapacitor.java

@@ -0,0 +1,80 @@
+package org.diylc.components.passive;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.Ellipse2D;
+
+import org.diylc.components.AbstractLeadedComponent;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Capacitance;
+import org.diylc.core.measures.CapacitanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Ceramic Capacitor (radial)", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "C", description = "Standard radial ceramic capacitor", zOrder = IDIYComponent.COMPONENT)
+public class RadialCeramicDiskCapacitor extends AbstractLeadedComponent<Capacitance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_WIDTH = new Size(1d / 2, SizeUnit.in);
+	public static Size DEFAULT_HEIGHT = new Size(1d / 8, SizeUnit.in);
+	public static Color BODY_COLOR = Color.decode("#F0E68C");
+	public static Color BORDER_COLOR = BODY_COLOR.darker();
+
+	private Capacitance value = new Capacitance(470d, CapacitanceUnit.pF);
+	private Voltage voltage = Voltage._63V;
+
+	public RadialCeramicDiskCapacitor() {
+		super();
+		this.bodyColor = BODY_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+
+	@EditableProperty
+	public Capacitance getValue() {
+		return value;
+	}
+
+	public void setValue(Capacitance value) {
+		this.value = value;
+	}
+	
+	@EditableProperty
+	public Voltage getVoltage() {
+		return voltage;
+	}
+	
+	public void setVoltage(Voltage voltage) {
+		this.voltage = voltage;
+	}
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.rotate(-Math.PI / 4, width / 2, height / 2);
+		g2d.setColor(LEAD_COLOR);
+		g2d.drawLine(0, height / 2, width, height / 2);
+		g2d.setColor(BODY_COLOR);
+		g2d.fillOval(4, height / 2 - 3, width - 8, 6);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawOval(4, height / 2 - 3, width - 8, 6);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return DEFAULT_HEIGHT;
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		return DEFAULT_WIDTH;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		return new Ellipse2D.Double(0f, 0f, getLength().convertToPixels(), getClosestOdd(getWidth()
+				.convertToPixels()));
+	}
+}

src/org/diylc/components/passive/RadialElectrolytic.java

@@ -0,0 +1,184 @@
+package org.diylc.components.passive;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.common.IPlugInPort;
+import org.diylc.common.ObjectCache;
+import org.diylc.components.AbstractLeadedComponent;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.Theme;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Capacitance;
+import org.diylc.core.measures.CapacitanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+import org.diylc.utils.Constants;
+
+import com.diyfever.gui.miscutils.ConfigurationManager;
+
+@ComponentDescriptor(name = "Electrolytic Capacitor", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "C", description = "Vertical mounted electrolytic capacitor, polarized or bipolar", zOrder = IDIYComponent.COMPONENT)
+public class RadialElectrolytic extends AbstractLeadedComponent<Capacitance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_SIZE = new Size(1d / 2, SizeUnit.in);
+	public static Color BODY_COLOR = Color.decode("#EAADEA");
+	public static Color BORDER_COLOR = BODY_COLOR.darker();
+	public static Color MARKER_COLOR = Color.gray;
+	public static Color TICK_COLOR = Color.white;
+
+	private Capacitance value = new Capacitance(1d, CapacitanceUnit.uF);
+	private Voltage voltage = Voltage._63V;
+
+	private Color markerColor = MARKER_COLOR;
+	private Color tickColor = TICK_COLOR;
+	private boolean polarized = true;
+
+	public RadialElectrolytic() {
+		super();
+		this.bodyColor = BODY_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+
+	@EditableProperty
+	public Capacitance getValue() {
+		return value;
+	}
+
+	public void setValue(Capacitance value) {
+		this.value = value;
+	}
+
+	@EditableProperty
+	public Voltage getVoltage() {
+		return voltage;
+	}
+
+	public void setVoltage(Voltage voltage) {
+		this.voltage = voltage;
+	}
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.setColor(BODY_COLOR);
+		int margin = 3;
+		Ellipse2D body = new Ellipse2D.Double(margin, margin, getClosestOdd(width - 2 * margin),
+				getClosestOdd(width - 2 * margin));
+		g2d.fill(body);
+		Area marker = new Area(body);
+		marker.subtract(new Area(new Rectangle2D.Double(margin, margin, width - 4 * margin,
+				getClosestOdd(width - 2 * margin))));
+		g2d.setColor(MARKER_COLOR);
+		g2d.fill(marker);
+		g2d.setColor(TICK_COLOR);
+		g2d.drawLine(width - 2 * margin, height / 2 - 2, width - 2 * margin, height / 2 + 2);
+		g2d.setColor(BORDER_COLOR);
+		g2d.draw(body);
+		// g2d.setColor(COVER_COLOR.darker());
+		// g2d.drawLine(innerMargin + 2, innerMargin + 2, width - innerMargin -
+		// 2, width - innerMargin
+		// - 2);
+		// g2d.drawLine(innerMargin + 2, width - innerMargin - 2, width -
+		// innerMargin - 2,
+		// innerMargin + 2);
+	}
+
+	@Override
+	protected void decorateComponentBody(Graphics2D g2d, boolean outlineMode) {
+		if (polarized) {
+			int totalDiameter = getClosestOdd(getLength().convertToPixels());
+			if (!outlineMode) {
+				Area area = new Area(getBodyShape());
+				area.subtract(new Area(new Rectangle2D.Double(0, 0, totalDiameter * 0.8,
+						totalDiameter)));
+				g2d.setColor(markerColor);
+				g2d.fill(area);
+			}
+			Color finalTickColor;
+			if (outlineMode) {
+				Theme theme = (Theme) ConfigurationManager.getInstance().readObject(
+						IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
+				finalTickColor = theme.getOutlineColor();
+			} else {
+				finalTickColor = tickColor;
+			}
+			g2d.setColor(finalTickColor);
+			g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(2));
+			g2d.drawLine((int) (totalDiameter * 0.9), totalDiameter / 2
+					- (int) (totalDiameter * 0.05), (int) (totalDiameter * 0.9), totalDiameter / 2
+					+ (int) (totalDiameter * 0.05));
+		}
+		// int coverDiameter = getClosestOdd(totalDiameter * 3 / 4);
+		// g2d.setColor(coverColor);
+		// int position = (totalDiameter - coverDiameter) / 2;
+		// g2d.fillOval(position, position, coverDiameter, coverDiameter);
+		// g2d.setColor(coverColor.darker());
+		// g2d.drawLine(position + coverDiameter / 5, position + coverDiameter /
+		// 5, position + 4
+		// * coverDiameter / 5, position + 4 * coverDiameter / 5);
+		// g2d.drawLine(position + coverDiameter / 5, position + 4 *
+		// coverDiameter / 5, position + 4
+		// * coverDiameter / 5, position + coverDiameter / 5);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return null;
+	}
+
+	@Override
+	public Size getWidth() {
+		return super.getWidth();
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		// We'll reuse width property to set the diameter.
+		return DEFAULT_SIZE;
+	}
+
+	@EditableProperty(name = "Diameter")
+	@Override
+	public Size getLength() {
+		return super.getLength();
+	}
+
+	@EditableProperty(name = "Marker")
+	public Color getMarkerColor() {
+		return markerColor;
+	}
+
+	public void setMarkerColor(Color coverColor) {
+		this.markerColor = coverColor;
+	}
+
+	@EditableProperty(name = "Tick")
+	public Color getTickColor() {
+		return tickColor;
+	}
+
+	public void setTickColor(Color tickColor) {
+		this.tickColor = tickColor;
+	}
+
+	@EditableProperty(name = "Polarized")
+	public boolean getPolarized() {
+		return polarized;
+	}
+
+	public void setPolarized(boolean polarized) {
+		this.polarized = polarized;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		return new Ellipse2D.Double(0f, 0f, getClosestOdd(getLength().convertToPixels()),
+				getClosestOdd(getLength().convertToPixels()));
+	}
+}

src/org/diylc/components/passive/RadialFilmCapacitor.java

@@ -0,0 +1,82 @@
+package org.diylc.components.passive;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.RoundRectangle2D;
+
+import org.diylc.components.AbstractLeadedComponent;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Capacitance;
+import org.diylc.core.measures.CapacitanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Film Capacitor (radial)", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "C", description = "Radial film capacitor, similar to Sprague Orange Drop", zOrder = IDIYComponent.COMPONENT)
+public class RadialFilmCapacitor extends AbstractLeadedComponent<Capacitance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_WIDTH = new Size(1d, SizeUnit.in);
+	public static Size DEFAULT_HEIGHT = new Size(1d / 4, SizeUnit.in);
+	public static Color BODY_COLOR = Color.decode("#FF8000");
+	public static Color BORDER_COLOR = BODY_COLOR.darker();
+
+	private Capacitance value = new Capacitance(123d, CapacitanceUnit.nF);
+	private Voltage voltage = Voltage._63V;
+
+	public RadialFilmCapacitor() {
+		super();
+		this.bodyColor = BODY_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+
+	@EditableProperty
+	public Capacitance getValue() {
+		return value;
+	}
+
+	public void setValue(Capacitance value) {
+		this.value = value;
+	}
+	
+	@EditableProperty
+	public Voltage getVoltage() {
+		return voltage;
+	}
+
+	public void setVoltage(Voltage voltage) {
+		this.voltage = voltage;
+	}
+
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.rotate(-Math.PI / 4, width / 2, height / 2);
+		g2d.setColor(LEAD_COLOR);
+		g2d.drawLine(0, height / 2, width, height / 2);
+		g2d.setColor(BODY_COLOR);
+		g2d.fillRoundRect(4, height / 2 - 3, width - 8, 6, 5, 5);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRoundRect(4, height / 2 - 3, width - 8, 6, 5, 5);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return DEFAULT_HEIGHT;
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		return DEFAULT_WIDTH;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		double radius = getWidth().convertToPixels() * 0.7;
+		return new RoundRectangle2D.Double(0f, 0f, getLength().convertToPixels(),
+				getClosestOdd(getWidth().convertToPixels()), radius, radius);
+	}
+}

src/org/diylc/components/passive/Resistor.java

@@ -0,0 +1,122 @@
+package org.diylc.components.passive;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.common.ObjectCache;
+import org.diylc.common.ResistorColorCode;
+import org.diylc.components.AbstractLeadedComponent;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.Theme;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.annotations.PositiveMeasureValidator;
+import org.diylc.core.measures.Resistance;
+import org.diylc.core.measures.ResistanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Resistor", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "R", description = "test", zOrder = IDIYComponent.COMPONENT)
+public class Resistor extends AbstractLeadedComponent<Resistance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_WIDTH = new Size(1d / 2, SizeUnit.in);
+	public static Size DEFAULT_HEIGHT = new Size(1d / 8, SizeUnit.in);
+	public static Color BODY_COLOR = Color.decode("#82CFFD");
+	public static Color BORDER_COLOR = BODY_COLOR.darker();
+
+	private Resistance value = new Resistance(123d, ResistanceUnit.K);
+	private Power power = Power.HALF;
+	private ResistorColorCode colorCode = ResistorColorCode._5_BAND;
+
+	public Resistor() {
+		super();
+		this.bodyColor = BODY_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+	
+	@Override
+	protected boolean supportsStandingMode() {
+		return true;
+	}
+
+	@EditableProperty(validatorClass = PositiveMeasureValidator.class)
+	public Resistance getValue() {
+		return value;
+	}
+
+	public void setValue(Resistance value) {
+		this.value = value;
+	}
+
+	@EditableProperty
+	public Power getPower() {
+		return power;
+	}
+
+	public void setPower(Power power) {
+		this.power = power;
+	}
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.rotate(-Math.PI / 4, width / 2, height / 2);
+		g2d.setColor(LEAD_COLOR);
+		g2d.drawLine(0, height / 2, width, height / 2);
+		g2d.setColor(BODY_COLOR);
+		g2d.fillRect(4, height / 2 - 3, width - 8, 6);
+		g2d.setColor(Color.red);
+		g2d.drawLine(7, height / 2 - 3, 7, height / 2 + 3);
+		g2d.setColor(Color.orange);
+		g2d.drawLine(11, height / 2 - 3, 11, height / 2 + 3);
+		g2d.setColor(Color.black);
+		g2d.drawLine(15, height / 2 - 3, 15, height / 2 + 3);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(4, height / 2 - 3, width - 8, 6);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return DEFAULT_HEIGHT;
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		return DEFAULT_WIDTH;
+	}
+
+	@EditableProperty(name = "Color code")
+	public ResistorColorCode getColorCode() {
+		return colorCode;
+	}
+
+	public void setColorCode(ResistorColorCode colorCode) {
+		this.colorCode = colorCode;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		return new Rectangle2D.Double(0f, 0f, getLength().convertToPixels(),
+				getClosestOdd(getWidth().convertToPixels()));
+	}
+
+	@Override
+	protected void decorateComponentBody(Graphics2D g2d, boolean outlineMode) {
+		// int width = getWidth().convertToPixels();
+		if (colorCode == ResistorColorCode.NONE || outlineMode) {
+			return;
+		}
+		int height = getClosestOdd(getWidth().convertToPixels());
+		Color[] bands = value.getColorCode(colorCode);
+		int x = 4;
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(2));
+		for (int i = 0; i < bands.length; i++) {
+			g2d.setColor(bands[i]);
+			g2d.drawLine(x, 1, x, height - 1);
+			x += 5;
+		}
+	}
+}

src/org/diylc/components/passive/ResistorSymbol.java

@@ -0,0 +1,84 @@
+package org.diylc.components.passive;
+
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.GeneralPath;
+
+import org.diylc.components.AbstractSchematicLeadedSymbol;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Resistance;
+import org.diylc.core.measures.ResistanceUnit;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Resistor (schematic symbol)", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "R", description = "", zOrder = IDIYComponent.COMPONENT)
+public class ResistorSymbol extends AbstractSchematicLeadedSymbol<Resistance> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Size DEFAULT_LENGTH = new Size(0.3, SizeUnit.in);
+	public static Size DEFAULT_WIDTH = new Size(0.08, SizeUnit.in);
+
+	private Resistance value = new Resistance(100d, ResistanceUnit.K);
+	private Power power = Power.HALF;
+
+	@EditableProperty
+	public Resistance getValue() {
+		return value;
+	}
+
+	public void setValue(Resistance value) {
+		this.value = value;
+	}
+	
+	@EditableProperty
+	public Power getPower() {
+		return power;
+	}
+	
+	public void setPower(Power power) {
+		this.power = power;
+	}
+
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.rotate(-Math.PI / 4, width / 2, height / 2);
+		g2d.setColor(LEAD_COLOR);
+		g2d.drawLine(0, height / 2, 4, height / 2);
+		g2d.drawLine(width - 4, height / 2, width, height / 2);
+		g2d.setColor(COLOR);
+		g2d.drawPolyline(new int[] { 4, 6, 10, 14, 18, 22, 26, 28 }, new int[] { height / 2,
+				height / 2 + 2, height / 2 - 2, height / 2 + 2, height / 2 - 2, height / 2 + 2,
+				height / 2 - 2, height / 2 }, 8);
+	}
+
+	@Override
+	protected Size getDefaultWidth() {
+		return DEFAULT_WIDTH;
+	}
+
+	@Override
+	protected Size getDefaultLength() {
+		return DEFAULT_LENGTH;
+	}
+
+	@Override
+	protected Shape getBodyShape() {
+		GeneralPath polyline = new GeneralPath();
+		double length = getLength().convertToPixels();
+		double width = getWidth().convertToPixels();
+		polyline.moveTo(0, width / 2);
+		polyline.lineTo(length / 16, width);
+		polyline.lineTo(3 * length / 16, 0);
+		polyline.lineTo(5 * length / 16, width);
+		polyline.lineTo(7 * length / 16, 0);
+		polyline.lineTo(9 * length / 16, width);
+		polyline.lineTo(11 * length / 16, 0);
+		polyline.lineTo(13 * length / 16, width);
+		polyline.lineTo(15 * length / 16, 0);
+		polyline.lineTo(length, width / 2);
+		return polyline;
+	}
+}

src/org/diylc/components/passive/ResistorValue.java

@@ -0,0 +1,28 @@
+package org.diylc.components.passive;
+
+import org.diylc.core.measures.Resistance;
+
+public class ResistorValue {
+
+	private Resistance resistance;
+	private Power power;
+
+	public ResistorValue(Resistance resistance, Power power) {
+		super();
+		this.resistance = resistance;
+		this.power = power;
+	}
+
+	public Resistance getResistance() {
+		return resistance;
+	}
+
+	public Power getPower() {
+		return power;
+	}
+	
+	@Override
+	public String toString() {
+		return resistance.toString() + power.toString();
+	}
+}

src/org/diylc/components/passive/Taper.java

@@ -0,0 +1,12 @@
+package org.diylc.components.passive;
+
+public enum Taper {
+
+	LIN, LOG, REV_LOG, W, S;
+
+	@Override
+	public String toString() {
+		return name().substring(0, 1).toUpperCase()
+				+ name().substring(1).toLowerCase().replace("_", " ");
+	}
+}

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

@@ -0,0 +1,375 @@
+package org.diylc.components.passive;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.FontMetrics;
+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.Rectangle2D;
+
+import org.diylc.common.ObjectCache;
+import org.diylc.common.Orientation;
+import org.diylc.core.ComponentState;
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.IDrawingObserver;
+import org.diylc.core.Project;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+@ComponentDescriptor(name = "Trimmer Potentiometer", author = "Branislav Stojkovic", category = "Passive", creationMethod = CreationMethod.SINGLE_CLICK, instanceNamePrefix = "VR", description = "Various types of board mounted trimmer potentiometers", zOrder = IDIYComponent.COMPONENT, stretchable = false)
+public class TrimmerPotentiometer extends AbstractPotentiometer {
+
+	private static final long serialVersionUID = 1L;
+
+	protected static Size FLAT_BODY_SIZE = new Size(9.5d, SizeUnit.mm);
+	protected static Size FLAT_SHAFT_SIZE = new Size(4d, SizeUnit.mm);
+	protected static Size VERTICAL_BODY_LENGTH = new Size(9.5d, SizeUnit.mm);
+	protected static Size VERTICAL_BODY_WIDTH = new Size(4.5d, SizeUnit.mm);
+	protected static Size SPACING = new Size(0.1d, SizeUnit.in);
+	private static Color BODY_COLOR = Color.decode("#FFFFE0");
+	private static Color BORDER_COLOR = Color.decode("#8E8E38");
+	private static Color SHAFT_COLOR = Color.decode("#FFFFE0");
+	private static Color SHAFT_BORDER_COLOR = Color.decode("#8E8E38");
+	public static Color PIN_COLOR = Color.decode("#00B2EE");
+	public static Color PIN_BORDER_COLOR = PIN_COLOR.darker();
+	public static Size PIN_SIZE = new Size(0.03d, SizeUnit.in);
+
+	protected Color bodyColor = BODY_COLOR;
+	protected Color borderColor = BORDER_COLOR;
+	// Array of 7 elements: 3 lug connectors, 1 pot body and 3 lugs
+	transient protected Shape[] body = null;
+
+	protected TrimmerType type = TrimmerType.FLAT_SMALL;
+
+	public TrimmerPotentiometer() {
+		controlPoints = new Point[] { new Point(0, 0), new Point(0, 0), new Point(0, 0) };
+		updateControlPoints();
+	}
+
+	protected void updateControlPoints() {
+		int spacing = (int) SPACING.convertToPixels();
+		int dx1 = 0;
+		int dy1 = 0;
+		int dx2 = 0;
+		int dy2 = 0;
+		switch (orientation) {
+		case DEFAULT:
+			switch (type) {
+			case FLAT_SMALL:
+				dx1 = 2 * spacing;
+				dy1 = spacing;
+				dx2 = 0;
+				dy2 = 2 * spacing;
+				break;
+			case FLAT_LARGE:
+				dx1 = 4 * spacing;
+				dy1 = spacing;
+				dx2 = 0;
+				dy2 = 2 * spacing;
+				break;
+			case VERTICAL_INLINE:
+				dx1 = 0;
+				dy1 = spacing;
+				dx2 = 0;
+				dy2 = 2 * spacing;
+				break;
+			case VERTICAL_OFFSET:
+				dx1 = spacing;
+				dy1 = spacing;
+				dx2 = 0;
+				dy2 = 2 * spacing;
+				break;
+			}
+			break;
+		case _90:
+			switch (type) {
+			case FLAT_SMALL:
+				dx1 = -spacing;
+				dy1 = 2 * spacing;
+				dx2 = -2 * spacing;
+				dy2 = 0;
+				break;
+			case FLAT_LARGE:
+				dx1 = -spacing;
+				dy1 = 4 * spacing;
+				dx2 = -2 * spacing;
+				dy2 = 0;
+				break;
+			case VERTICAL_INLINE:
+				dx1 = -spacing;
+				dy1 = 0;
+				dx2 = -2 * spacing;
+				dy2 = 0;
+				break;
+			case VERTICAL_OFFSET:
+				dx1 = -spacing;
+				dy1 = spacing;
+				dx2 = -2 * spacing;
+				dy2 = 0;
+				break;
+			}
+			break;
+		case _180:
+			switch (type) {
+			case FLAT_SMALL:
+				dx1 = -2 * spacing;
+				dy1 = -spacing;
+				dx2 = 0;
+				dy2 = -2 * spacing;
+				break;
+			case FLAT_LARGE:
+				dx1 = -4 * spacing;
+				dy1 = -spacing;
+				dx2 = 0;
+				dy2 = -2 * spacing;
+				break;
+			case VERTICAL_INLINE:
+				dx1 = 0;
+				dy1 = -spacing;
+				dx2 = 0;
+				dy2 = -2 * spacing;
+				break;
+			case VERTICAL_OFFSET:
+				dx1 = -spacing;
+				dy1 = -spacing;
+				dx2 = 0;
+				dy2 = -2 * spacing;
+				break;
+			}
+			break;
+		case _270:
+			switch (type) {
+			case FLAT_SMALL:
+				dx1 = spacing;
+				dy1 = -2 * spacing;
+				dx2 = 2 * spacing;
+				dy2 = 0;
+				break;
+			case FLAT_LARGE:
+				dx1 = spacing;
+				dy1 = -4 * spacing;
+				dx2 = 2 * spacing;
+				dy2 = 0;
+				break;
+			case VERTICAL_INLINE:
+				dx1 = spacing;
+				dy1 = 0;
+				dx2 = 2 * spacing;
+				dy2 = 0;
+				break;
+			case VERTICAL_OFFSET:
+				dx1 = spacing;
+				dy1 = -spacing;
+				dx2 = 2 * spacing;
+				dy2 = 0;
+				break;
+			}
+			break;
+		default:
+			break;
+		}
+		controlPoints[1].setLocation(controlPoints[0].x + dx1, controlPoints[0].y + dy1);
+		controlPoints[2].setLocation(controlPoints[0].x + dx2, controlPoints[0].y + dy2);
+	}
+
+	public Shape[] getBody() {
+		if (body == null) {
+			body = new Shape[2];
+
+			// Calculate the center point as center of the minimum bounding
+			// rectangle.
+			int centerX = (Math.max(Math.max(controlPoints[0].x, controlPoints[1].x),
+					controlPoints[2].x) + Math.min(
+					Math.min(controlPoints[0].x, controlPoints[1].x), controlPoints[2].x)) / 2;
+			int centerY = (Math.max(Math.max(controlPoints[0].y, controlPoints[1].y),
+					controlPoints[2].y) + Math.min(
+					Math.min(controlPoints[0].y, controlPoints[1].y), controlPoints[2].y)) / 2;
+
+			// Calculate body dimensions based on the selected type.
+			int length = 0;
+			int width = 0;
+			switch (type) {
+			case FLAT_LARGE:
+			case FLAT_SMALL:
+				length = getClosestOdd(FLAT_BODY_SIZE.convertToPixels());
+				width = length;
+				int shaftSize = getClosestOdd(FLAT_SHAFT_SIZE.convertToPixels());
+				Area shaft = new Area(new Ellipse2D.Double(centerX - shaftSize / 2, centerY
+						- shaftSize / 2, shaftSize, shaftSize));
+				Area slot = new Area(new Rectangle2D.Double(centerX - shaftSize / 2, centerY
+						- shaftSize / 8, shaftSize, shaftSize / 4));
+				slot.transform(AffineTransform.getRotateInstance(Math.PI / 4, centerX, centerY));
+				shaft.subtract(slot);
+				body[1] = shaft;
+				break;
+			case VERTICAL_INLINE:
+			case VERTICAL_OFFSET:
+				length = getClosestOdd(VERTICAL_BODY_LENGTH.convertToPixels());
+				width = getClosestOdd(VERTICAL_BODY_WIDTH.convertToPixels());
+				break;
+			}
+			if (orientation == Orientation.DEFAULT || orientation == Orientation._180) {
+				int p = length;
+				length = width;
+				width = p;
+			}
+			body[0] = new Rectangle2D.Double(centerX - length / 2, centerY - width / 2, length,
+					width);
+		}
+		return body;
+	}
+
+	@Override
+	public void setControlPoint(Point point, int index) {
+		super.setControlPoint(point, index);
+		body = null;
+	}
+
+	@Override
+	public void setOrientation(Orientation orientation) {
+		super.setOrientation(orientation);
+		updateControlPoints();
+		body = null;
+	}
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		if (checkPointsClipped(g2d.getClip())) {
+			return;
+		}
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
+		Shape mainShape = getBody()[0];
+		Shape shaftShape = getBody()[1];
+		if (mainShape != null) {
+			g2d.setColor(bodyColor);
+			Composite oldComposite = g2d.getComposite();
+			if (alpha < MAX_ALPHA) {
+				g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+						/ MAX_ALPHA));
+			}
+			g2d.fill(mainShape);
+			if (shaftShape != null) {
+				g2d.setColor(SHAFT_COLOR);
+				g2d.fill(shaftShape);
+				g2d.setColor(SHAFT_BORDER_COLOR);
+				g2d.draw(shaftShape);
+			}
+			g2d.setComposite(oldComposite);
+			g2d.setColor(componentState == ComponentState.SELECTED
+					|| componentState == ComponentState.DRAGGING ? SELECTION_COLOR : borderColor);
+			g2d.draw(mainShape);
+		}
+
+		// Draw pins.
+		int pinSize = getClosestOdd(PIN_SIZE.convertToPixels());
+		for (Point point : controlPoints) {
+			g2d.setColor(PIN_COLOR);
+			g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+			g2d.setColor(PIN_BORDER_COLOR);
+			g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
+		}
+
+		// Draw label.
+		g2d.setFont(LABEL_FONT);
+		g2d
+				.setColor(componentState == ComponentState.SELECTED ? LABEL_COLOR_SELECTED
+						: LABEL_COLOR);
+		FontMetrics fontMetrics = g2d.getFontMetrics();
+		Rectangle2D bodyRect = getBody()[0].getBounds2D();
+		Rectangle2D rect = fontMetrics.getStringBounds(getName(), g2d);
+
+		int textHeight = (int) rect.getHeight();
+		int textWidth = (int) rect.getWidth();
+		int panelHeight = (int) bodyRect.getHeight();
+		int panelWidth = (int) bodyRect.getWidth();
+
+		int x = (panelWidth - textWidth) / 2;
+		int y = (panelHeight - textHeight) / 2 + fontMetrics.getAscent();
+
+		g2d.drawString(getName(), (int) (bodyRect.getX() + x), (int) (bodyRect.getY() + y));
+	}
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		int margin = 4;
+		g2d.setColor(BODY_COLOR);
+		g2d.fillRect(margin, margin, width - 2 * margin, width - 2 * margin);
+		g2d.setColor(BORDER_COLOR);
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
+		g2d.drawRect(margin, margin, width - 2 * margin, width - 2 * margin);
+		int shaftSize = 11;
+		int slotSize = 2;
+		Area area = new Area(new Ellipse2D.Double(width / 2 - shaftSize / 2, width / 2 - shaftSize
+				/ 2, shaftSize, shaftSize));
+		Area slot = new Area(new Rectangle2D.Double(0, width / 2 - slotSize / 2, width, slotSize));
+		slot.transform(AffineTransform.getRotateInstance(Math.PI / 4, width / 2, width / 2));
+		area.subtract(slot);
+		g2d.setColor(SHAFT_COLOR);
+		g2d.fill(area);
+		g2d.setColor(SHAFT_BORDER_COLOR);
+		g2d.draw(area);
+
+		int pinSize = 3;
+		g2d.setColor(PIN_COLOR);
+		g2d.fillOval(margin - pinSize / 2, 10 - pinSize / 2, pinSize, pinSize);
+		g2d.setColor(PIN_BORDER_COLOR);
+		g2d.drawOval(margin - pinSize / 2, 10 - pinSize / 2, pinSize, pinSize);
+
+		g2d.setColor(PIN_COLOR);
+		g2d.fillOval(margin - pinSize / 2, 21 - pinSize / 2, pinSize, pinSize);
+		g2d.setColor(PIN_BORDER_COLOR);
+		g2d.drawOval(margin - pinSize / 2, 21 - pinSize / 2, pinSize, pinSize);
+
+		g2d.setColor(PIN_COLOR);
+		g2d.fillOval(width - margin - pinSize / 2, width / 2 - pinSize / 2, pinSize, pinSize);
+		g2d.setColor(PIN_BORDER_COLOR);
+		g2d.drawOval(width - margin - pinSize / 2, width / 2 - pinSize / 2, pinSize, pinSize);
+	}
+
+	@EditableProperty(name = "Body")
+	public Color getBodyColor() {
+		return bodyColor;
+	}
+
+	public void setBodyColor(Color bodyColor) {
+		this.bodyColor = bodyColor;
+	}
+
+	@EditableProperty(name = "Border")
+	public Color getBorderColor() {
+		return borderColor;
+	}
+
+	public void setBorderColor(Color borderColor) {
+		this.borderColor = borderColor;
+	}
+
+	@EditableProperty
+	public TrimmerType getType() {
+		return type;
+	}
+
+	public void setType(TrimmerType type) {
+		this.type = type;
+		updateControlPoints();
+		body = null;
+	}
+
+	public static enum TrimmerType {
+		FLAT_LARGE, FLAT_SMALL, VERTICAL_INLINE, VERTICAL_OFFSET;
+
+		@Override
+		public String toString() {
+			return name().substring(0, 1) + name().substring(1).toLowerCase().replace("_", " ");
+		}
+	}
+}

src/org/diylc/components/passive/Voltage.java

@@ -0,0 +1,11 @@
+package org.diylc.components.passive;
+
+public enum Voltage {
+
+	_16V, _25V, _63V, _100V, _160V, _250V, _300V, _350V, _400V, _500V, _630V, _1KV;
+	
+	@Override
+	public String toString() {
+		return name().replace("_", "");
+	}
+}