[Bug Fix] Should be more stable under OSX and not crash unexpectedly

config.xml

@@ -1,31 +0,0 @@
-<map>
-  <entry>
-    <string>defaults</string>
-    <map>
-      <entry>
-        <string>com.diyfever.diylc.components.MockComponentInstance:C</string>
-        <com.diyfever.diylc.model.measures.Capacitance>
-          <value>22.0</value>
-          <unit class="com.diyfever.diylc.model.measures.CapacitanceUnit">uF</unit>
-        </com.diyfever.diylc.model.measures.Capacitance>
-      </entry>
-      <entry>
-        <string>com.diyfever.diylc.components.MockComponentInstance:Color</string>
-        <awt-color>
-          <red>255</red>
-          <green>0</green>
-          <blue>0</blue>
-          <alpha>255</alpha>
-        </awt-color>
-      </entry>
-    </map>
-  </entry>
-  <entry>
-    <string>metric</string>
-    <boolean>true</boolean>
-  </entry>
-  <entry>
-    <string>lastPath</string>
-    <string>C:\Documents and Settings\Branislav Stojkovic\Desktop</string>
-  </entry>
-</map>

diylc-core/.classpath

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="test"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="lib" path="lib/log4j-1.2.15.jar"/>
+	<classpathentry kind="lib" path="lib/xstream-1.3.1.jar"/>
+	<classpathentry kind="lib" path="lib/junit-4.7.jar"/>
+	<classpathentry kind="lib" path="library/main.jar"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/app-framework"/>
+	<classpathentry kind="lib" path="lib/jettison-1.0.1.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

diylc-core/.project

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>DIYLC</name>
+	<name>diylc-core</name>
 	<comment></comment>
 	<projects>
 	</projects>

diylc-core/build.xml

@@ -0,0 +1,82 @@
+<project name="diylc-core" basedir="." default="jar">
+	<property name="src.dir" value="src" />
+
+	<property name="lib.dir" value="${basedir}/lib" />
+	<property name="build.dir" value="${basedir}/build" />
+	<property name="jar.dir" value="${build.dir}/jar" />
+	<property name="report.dir" value="${build.dir}/junitreport" />
+
+	<property name="classes.dir" value="${build.dir}/temp/${ant.project.name}/classes" />
+	<property name="test.classes.dir" value="${build.dir}/temp/${ant.project.name}/test.classes" />
+
+	<target name="clean">
+		<delete dir="${build.dir}" />
+	</target>
+
+	<!--change src dir-->
+	<target name="compile">
+		<mkdir dir="${classes.dir}" />
+		<echo>Compile with JDK ${java.runtime.version}</echo>
+		<javac encoding="8859_1" srcdir="${src.dir}" destdir="${classes.dir}" classpathref="class.path" />
+	</target>
+
+	<target name="resource.copy">
+		<copy todir="${classes.dir}">
+			<fileset dir="${src.dir}">
+				<exclude name="**/*.java" />
+			</fileset>
+		</copy>
+	</target>
+
+	<target name="lib.copy">
+		<copy todir="${jar.dir}/lib" overwrite="true">
+			<fileset dir="${basedir}/lib">
+				<exclude name="**/*dll" />
+			</fileset>
+		</copy>
+		<copy todir="${jar.dir}/library" overwrite="true">
+			<fileset dir="${basedir}/library">
+				<exclude name="**/*dll" />
+			</fileset>
+		</copy>
+		<copy todir="${jar.dir}" overwrite="true">
+			<fileset dir="${basedir}/lib/" includes="**/*.dll" />
+		</copy>
+	</target>
+
+	<path id="class.path">
+		<fileset dir="${basedir}">
+			<include name="lib/**/*.jar" />
+			<include name="library/**/*.jar" />
+		</fileset>
+	</path>
+
+	<manifestclasspath jarfile="${ant.project.name}.jar" property="manifest.class.path">
+		<classpath refid="class.path" />
+	</manifestclasspath>
+
+	<target name="jar" depends="clean, lib.copy, resource.copy, compile">
+		<jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
+			<manifest>
+				<attribute name="Built-By" value="${user.name}" />
+				<attribute name="Class-Path" value="${manifest.class.path}" />
+			</manifest>
+		</jar>
+		<copy todir="../diylc-swing/lib" overwrite="true">
+			<fileset dir="${jar.dir}" includes="${ant.project.name}.jar" />
+		</copy>
+		<copy todir="../diylc-library/lib" overwrite="true">
+			<fileset dir="${jar.dir}" includes="${ant.project.name}.jar" />
+		</copy>
+	</target>
+
+	<target name="javadoc">
+		<javadoc access="public" author="true" classpathref="class.path" destdir="doc" nodeprecated="false" nodeprecatedlist="false" noindex="false" nonavbar="false" notree="false" source="1.6" splitindex="true" use="true" version="true">
+			<fileset dir="${src.dir}">
+				<exclude name="**\.svn\**" />
+				<include name="**/*.java" />
+			</fileset>
+		</javadoc>
+	</target>
+
+</project>

diylc-core/config.properties

@@ -0,0 +1,2 @@
+#org.diylc.utils.Constants.CANVAS_COLOR=#005D96
+#org.diylc.utils.Constants.GRID_COLOR=#FFFFFF

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

@@ -0,0 +1,102 @@
+package org.diylc.common;
+
+import javax.swing.Icon;
+
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.annotations.BomPolicy;
+
+/**
+ * Entity class used to describe a component type.
+ * 
+ * @author Branislav Stojkovic
+ * 
+ * @see IDIYComponent
+ */
+public class ComponentType {
+
+	private String name;
+	private String description;
+	private CreationMethod creationMethod;
+	private String category;
+	private String namePrefix;
+	private String author;
+	private Icon icon;
+	private Class<? extends IDIYComponent<?>> instanceClass;
+	private double zOrder;
+	private boolean flexibleZOrder;
+	private boolean stretchable;
+	private BomPolicy bomPolicy;
+
+	public ComponentType(String name, String description, CreationMethod creationMethod,
+			String category, String namePrefix, String author, Icon icon,
+			Class<? extends IDIYComponent<?>> instanceClass, double zOrder, boolean flexibleZOrder,
+					boolean stretchable, BomPolicy bomPolicy) {
+		super();
+		this.name = name;
+		this.description = description;
+		this.creationMethod = creationMethod;
+		this.category = category;
+		this.namePrefix = namePrefix;
+		this.author = author;
+		this.icon = icon;
+		this.instanceClass = instanceClass;
+		this.zOrder = zOrder;
+		this.flexibleZOrder = flexibleZOrder;
+		this.stretchable = stretchable;
+		this.bomPolicy = bomPolicy;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public CreationMethod getCreationMethod() {
+		return creationMethod;
+	}
+
+	public String getCategory() {
+		return category;
+	}
+
+	public String getNamePrefix() {
+		return namePrefix;
+	}
+
+	public String getAuthor() {
+		return author;
+	}
+
+	public Icon getIcon() {
+		return icon;
+	}
+
+	public Class<? extends IDIYComponent<?>> getInstanceClass() {
+		return instanceClass;
+	}
+
+	public double getZOrder() {
+		return zOrder;
+	}
+	
+	public boolean isFlexibleZOrder() {
+		return flexibleZOrder;
+	}
+
+	public boolean isStretchable() {
+		return stretchable;
+	}
+	
+	public BomPolicy getBomPolicy() {
+		return bomPolicy;
+	}
+
+	@Override
+	public String toString() {
+		return name;
+	}
+}

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

@@ -0,0 +1,11 @@
+package org.diylc.common;
+
+public enum Display {
+
+	NAME, VALUE;
+
+	@Override
+	public String toString() {
+		return name().substring(0, 1) + name().substring(1).toLowerCase();
+	}
+}

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

@@ -5,7 +5,7 @@ import java.awt.Graphics;
 /**
  * Enumerates all options that can be used when drawing a project.
  * 
- * @see IPlugInPort#draw(java.awt.Graphics2D, java.util.EnumSet)
+ * @see IPlugInPort#draw(java.awt.Graphics2D, java.util.Set, IComponentFiler)
  * 
  * @author Branislav Stojkovic
  */
@@ -32,5 +32,9 @@ public enum DrawOption {
 	/**
 	 * Anti-aliasing is used when drawing.
 	 */
-	ANTIALIASING;
+	ANTIALIASING,
+	/**
+	 * Draw components in outline mode.
+	 */
+	OUTLINE_MODE;
 }

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

@@ -1,10 +1,9 @@
 package org.diylc.common;
 
 import java.awt.Rectangle;
+import java.awt.geom.Point2D;
 
-import org.diylc.model.IComponentType;
-import org.diylc.model.Project;
-
+import org.diylc.core.Project;
 
 /**
  * Enumerates all possible events between {@link IPlugInPort} and
@@ -27,6 +26,12 @@ public enum EventType {
 	 * or loaded with undo/redo operations.
 	 */
 	PROJECT_LOADED,
+	/**
+	 * Called when either current file name or modified flag are changed. The
+	 * first parameter is the current file name, the second one is a boolean
+	 * modified flag.
+	 */
+	FILE_STATUS_CHANGED,
 	/**
 	 * Called when selection rectangle is changed. Object of type
 	 * {@link Rectangle} is the only parameter and it contains the new selection
@@ -39,12 +44,14 @@ public enum EventType {
 	 */
 	SELECTION_CHANGED,
 	/**
-	 * Called when display needs to be repainted. No parameters are passed.
+	 * Called when selection size changes, together with a {@link Point2D}
+	 * object containing selection size (x = width, y = height). Size is
+	 * expressed in the default measure (cm for metric, inches for imperial).
 	 */
 	REPAINT,
 	/**
 	 * Called when new component slot has been changed. The only parameter is
-	 * {@link IComponentType} and may be null.
+	 * {@link ComponentType} and may be null.
 	 */
 	SLOT_CHANGED,
 	/**
@@ -52,5 +59,25 @@ public enum EventType {
 	 * {@link Project} are passed as parameters, one before and one after the
 	 * change. The third parameter is a string containing change description.
 	 */
-	PROJECT_MODIFIED, AVAILABLE_CTRL_POINTS_CHANGED, SELECTED_CTRL_POINTS_CHANGED, ;
+	PROJECT_MODIFIED,
+	/**
+	 * Called when control points under the cursor are changed. A single
+	 * parameter is passed, an instance of
+	 * <code>Map<IDIYComponent<?>, Set<Integer>></code> containing all the
+	 * components and indices of their control points that are under the cursor.
+	 */
+	AVAILABLE_CTRL_POINTS_CHANGED,
+	/**
+	 * Called when mouse cursor is moved. Point object is passed, containing the
+	 * current cursor location (not taking zoom into account).
+	 */
+	MOUSE_MOVED,
+	/**
+	 * Called when a layer status is changed. The first parameter is a set of indices of locked layers. All layers not included are considered unlocked.
+	 */
+	LAYER_STATE_CHANGED,
+	/**
+	 * Called to update the status message. New status message is passed as a first parameter.
+	 */
+	STATUS_MESSAGE_CHANGED;
 }

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

@@ -0,0 +1,6 @@
+package org.diylc.common;
+
+public enum GridType {
+
+	LINES, CROSSHAIR, DOT, NONE;
+}

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

@@ -0,0 +1,5 @@
+package org.diylc.common;
+
+public enum HorizontalAlignment {
+	LEFT, CENTER, RIGHT
+}

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

@@ -0,0 +1,8 @@
+package org.diylc.common;
+
+import org.diylc.core.IDIYComponent;
+
+public interface IComponentFiler {
+
+	boolean testComponent(IDIYComponent<?> component);
+}

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

@@ -0,0 +1,22 @@
+package org.diylc.common;
+
+public interface IKeyProcessor {
+
+	public static final int VK_LEFT = 0x25;
+	public static final int VK_UP = 0x26;
+	public static final int VK_RIGHT = 0x27;
+	public static final int VK_DOWN = 0x28;
+
+	/**
+	 * Notifies the presenter that a key hes been pressed on the canvas.
+	 * 
+	 * @param key
+	 * @param ctrlDown
+	 * @param shiftDown
+	 * @param altDown
+	 * 
+	 * @return true if the event should be consumed
+	 */
+	boolean keyPressed(int key, boolean ctrlDown, boolean shiftDown,
+			boolean altDown);
+}

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

@@ -0,0 +1,69 @@
+package org.diylc.common;
+
+import java.awt.Point;
+
+public interface IMouseProcessor {
+
+	/**
+	 * Notifies the presenter that mouse is clicked.
+	 * 
+	 * Note: point coordinates are display based, i.e. scaled for zoom factor.
+	 * 
+	 * @param point
+	 * @param button
+	 * @param ctrlDown
+	 * @param shiftDown
+	 * @param altDown
+	 * @param clickCount
+	 */
+	void mouseClicked(Point point, int button, boolean ctrlDown, boolean shiftDown, boolean altDown,
+			int clickCount);
+
+	/**
+	 * Notifies the presenter that mouse is moved.
+	 * 
+	 * Note: point coordinates are display based, i.e. scaled for zoom factor.
+	 * 
+	 * @param point
+	 * @param ctrlDown
+	 * @param shiftDown
+	 * @param altDown
+	 */
+	void mouseMoved(Point point, boolean ctrlDown, boolean shiftDown, boolean altDown);
+
+	/**
+	 * Notification that drag has been started from the specified point.
+	 * 
+	 * Note: point coordinates are scaled for zoom factor.
+	 * 
+	 * @param point
+	 * @param dragAction
+	 */
+	void dragStarted(Point point, int dragAction);
+
+	/**
+	 * Checks if it's possible to drop over the specified point.
+	 * 
+	 * Note: point coordinates are scaled for zoom factor.
+	 * 
+	 * @param point
+	 * @return
+	 */
+	boolean dragOver(Point point);
+
+	/**
+	 * Changes the current drag action during the dragging.
+	 * 
+	 * @param dragAction
+	 */
+	void dragActionChanged(int dragAction);
+
+	/**
+	 * Notification that drag has been ended in the specified point.
+	 * 
+	 * Note: point coordinates are scaled for zoom factor.
+	 * 
+	 * @param point
+	 */
+	void dragEnded(Point point);
+}

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

@@ -1,6 +1,6 @@
 package org.diylc.common;
 
-import com.diyfever.gui.simplemq.IMessageListener;
+import org.diylc.appframework.simplemq.IMessageListener;
 
 /**
  * Interface for plug-ins.

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

@@ -0,0 +1,311 @@
+package org.diylc.common;
+
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.geom.Point2D;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.diylc.appframework.simplemq.IMessageListener;
+import org.diylc.appframework.simplemq.MessageDispatcher;
+import org.diylc.appframework.update.VersionNumber;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.Project;
+import org.diylc.core.Theme;
+
+/**
+ * Interface for communication between plug-ins and the application. Plug-ins
+ * may acquire information or make changes through this interface. Application
+ * events are dispatched to plug-ins through {@link MessageDispatcher}
+ * 
+ * @author Branislav Stojkovic
+ * 
+ * @see IPlugIn
+ * @see MessageDispatcher
+ * @see IMessageListener
+ * @see EventType
+ */
+public interface IPlugInPort extends ISelectionProcessor, IMouseProcessor, IKeyProcessor {
+
+	public static final String ANTI_ALIASING_KEY = "antiAliasing";
+	public static final String HI_QUALITY_RENDER_KEY = "hiQualityRender";
+	public static final String EXPORT_GRID_KEY = "exportGrid";
+	public static final String STICKY_POINTS_KEY = "stickyPoints";
+	public static final String METRIC_KEY = "metric";
+	public static final String SNAP_TO_GRID_KEY = "snapToGrid";
+	public static final String AUTO_PADS_KEY = "autoCreatePads";
+	public static final String CONTINUOUS_CREATION_KEY = "continuousCreation";
+	public static final String AUTO_EDIT_KEY = "autoEdit";
+	public static final String ABNORMAL_EXIT_KEY = "abnormalExit";
+	public static final String WHEEL_ZOOM_KEY = "wheelZoom";
+	public static final String OUTLINE_KEY = "outline";
+	public static final String THEME_KEY = "theme";
+	public static final String RECENT_COMPONENTS_KEY = "recentComponents";
+
+	public static final int DND_TOGGLE_STICKY = 0x1;
+	public static final int DND_TOGGLE_SNAP = 0x40000000;
+	
+    /**
+     * Mouse button constants.
+     */ 
+    public static final int NOBUTTON = 0;
+    public static final int BUTTON1 = 1;
+    public static final int BUTTON2 = 2;
+    public static final int BUTTON3 = 3;
+
+	/**
+	 * Returns size of the canvas that takes project dimensions into account as
+	 * well as zoom level. Each dimension is calculated as the product of the
+	 * actual size and the number of pixels per unit. If <code>useZoom</code> is
+	 * set to true, the result is scaled by zoom factor.
+	 * 
+	 * @param useZoom
+	 * 
+	 * @return canvas dimensions
+	 */
+	Dimension getCanvasDimensions(boolean useZoom);
+
+	/**
+	 * Returns an instance of {@link Cursor} that should be used at the
+	 * specified location.
+	 * 
+	 * Note: point coordinates are scaled for zoom factor.
+	 * 
+	 * @param point
+	 * @return cursor
+	 */
+	Cursor getCursorAt(Point point);
+
+	/**
+	 * Returns an instance of currently loaded project.
+	 * 
+	 * @return
+	 */
+	Project getCurrentProject();
+
+	/**
+	 * Loads specified {@link Project}.
+	 * 
+	 * @param project
+	 * @param freshStart
+	 */
+	void loadProject(Project project, boolean freshStart);
+
+	/**
+	 * Creates a new project.
+	 */
+	void createNewProject();
+
+	/**
+	 * Loads a project from the specified file.
+	 * 
+	 * @param fileName
+	 */
+	void loadProjectFromFile(String fileName);
+
+	/**
+	 * Saves the current project into the specified file.
+	 * 
+	 * @param fileName
+	 * @param isBackup
+	 */
+	void saveProjectToFile(String fileName, boolean isBackup);
+
+	/**
+	 * @return the current file name.
+	 */
+	String getCurrentFileName();
+
+	/**
+	 * @return true if the current project is modified.
+	 */
+	boolean isProjectModified();
+
+	/**
+	 * Shows a user dialog if there are changes to confirm that it's safe to
+	 * proceed.
+	 * 
+	 * @return true, if file actions (new, open, close) can be taken
+	 */
+	boolean allowFileAction();
+
+	/**
+	 * Returns all available {@link ComponentType}s classified by category.
+	 * Result is a {@link Map} between category name to a {@link List} of all
+	 * {@link ComponentType}s that share that category name.
+	 * 
+	 * @return
+	 */
+	Map<String, List<ComponentType>> getComponentTypes();
+
+	/**
+	 * Draws project on the provided {@link Graphics2D}. If the provided filter
+	 * is not null, it will be used to filter the components that are shown.
+	 * 
+	 * @param g2d
+	 * @param drawOptions
+	 *            specific drawing options
+	 * @param filter
+	 */
+	void draw(Graphics2D g2d, Set<DrawOption> drawOptions, IComponentFiler filter);
+
+	Double[] getAvailableZoomLevels();
+
+	/**
+	 * Returns current zoom level where <code>zoomLevel = 1.0d</code> means
+	 * 100%.
+	 * 
+	 * @return current zoom level
+	 */
+	double getZoomLevel();
+
+	/**
+	 * Changes current zoom level where <code>zoomLevel = 1.0d</code> means 100%
+	 * 
+	 * @param zoomLevel
+	 *            new zoom leve
+	 */
+	void setZoomLevel(double zoomLevel);
+
+	/**
+	 * Returns current version number.
+	 * 
+	 * @return
+	 */
+	VersionNumber getCurrentVersionNumber();
+
+	/**
+	 * Adds a list of components to the project.
+	 * 
+	 * @param components
+	 */
+	void pasteComponents(List<IDIYComponent<?>> components);
+
+	/**
+	 * Deletes all the selected components from the project.
+	 */
+	void deleteSelectedComponents();
+
+	/**
+	 * Sets default value for the specified property name for currently selected
+	 * component types.
+	 * 
+	 * @param propertyName
+	 *            display name for property
+	 * @param value
+	 *            new default value, must not be null
+	 */
+	void setSelectionDefaultPropertyValue(String propertyName, Object value);
+
+	/**
+	 * Sets default value for the specified property name for projects.
+	 * 
+	 * @param propertyName
+	 *            display name for property
+	 * @param value
+	 *            new default value, must not be null
+	 */
+	void setProjectDefaultPropertyValue(String propertyName, Object value);
+
+	/**
+	 * @return a list of properties that are mutual for all the selected
+	 *         components. Resulting list may be empty if selected components do
+	 *         not have mutual properties or can be null if the selection is
+	 *         empty.
+	 */
+	List<PropertyWrapper> getMutualSelectionProperties();
+
+	void editSelection();
+
+	/**
+	 * @return a list of editable properties of the current project.
+	 */
+	List<PropertyWrapper> getProjectProperties();
+
+	/**
+	 * Applies specified properties to the current project.
+	 * 
+	 * @param properties
+	 */
+	void applyPropertiesToProject(List<PropertyWrapper> properties);
+	
+	/**
+	 * Gets the current new component slot.
+	 */
+	ComponentType getNewComponentTypeSlot();
+
+	/**
+	 * Sets the new component slot. Specified component type will be used to
+	 * instantiate new component.
+	 */
+	void setNewComponentTypeSlot(ComponentType componentType);
+
+	/**
+	 * Changes default size notation, true for metric, false for imperial.
+	 * 
+	 * @param isMetric
+	 */
+	void setMetric(boolean isMetric);
+
+	/**
+	 * Groups all selected components.
+	 */
+	void groupSelectedComponents();
+
+	/**
+	 * Ungroups all selected components.
+	 */
+	void ungroupSelectedComponents();
+
+	/**
+	 * Locks or unlocks the specified layer. All components within +- 0.5 range
+	 * will be affected by the change as well.
+	 * 
+	 * @param layerZOrder
+	 * @param locked
+	 */
+	void setLayerLocked(int layerZOrder, boolean locked);
+
+	/**
+	 * @return selection size expressed in either inches or centimeters, based
+	 *         on the user preference.
+	 */
+	Point2D calculateSelectionDimension();
+
+	/**
+	 * Sends each of the selected components one step back.
+	 */
+	void sendSelectionToBack();
+
+	/**
+	 * Brings each of the selected components one step to front.
+	 */
+	void bringSelectionToFront();
+
+	/**
+	 * Causes the display to refresh.
+	 */
+	void refresh();
+
+	/**
+	 * @return currently selected theme.
+	 */
+	Theme getSelectedTheme();
+
+	/**
+	 * Changes the current theme.
+	 * 
+	 * @param theme
+	 */
+	void setSelectedTheme(Theme theme);
+
+	/**
+	 * Renumbers all the selected components.
+	 * 
+	 * @param xAxisFirst
+	 */
+	void renumberSelectedComponents(boolean xAxisFirst);
+}

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

@@ -0,0 +1,48 @@
+package org.diylc.common;
+
+import java.awt.Point;
+import java.util.List;
+
+import org.diylc.core.ExpansionMode;
+import org.diylc.core.IDIYComponent;
+
+public interface ISelectionProcessor {
+
+	/**
+	 * Returns the current {@link ComponentTransferable}.
+	 * 
+	 * @return
+	 */
+	List<IDIYComponent<?>> getSelectedComponents();
+
+	/**
+	 * Updates the selection with the specified list of component. Also, updates
+	 * control point map with all components that are stuck to the newly
+	 * selected components.
+	 * 
+	 * @param newSelection
+	 */
+	void updateSelection(List<IDIYComponent<?>> newSelection);
+
+	/**
+	 * Finds all components at the specified location, sorted by z-index from
+	 * top to bottom.
+	 * 
+	 * @param point
+	 * @return
+	 */
+	List<IDIYComponent<?>> findComponentsAt(Point point);
+
+	/**
+	 * Expands the current selection to include surrounding components.
+	 * Options are controlled with <code>expansionMode</code> flag.
+	 * 
+	 * @param expansionMode
+	 */
+	void expandSelection(ExpansionMode expansionMode);
+
+	/**
+	 * Selects all components in the project.
+	 */
+	void selectAll();
+}

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

@@ -0,0 +1,34 @@
+package org.diylc.common;
+
+/**
+ * Abstract layer between the app and platform worker thread implementation.
+ * 
+ * @author Branislav Stojkovic
+ * 
+ * @param <T>
+ */
+public interface ITask<T> {
+
+	/**
+	 * Runs in background thread.
+	 * 
+	 * @return
+	 * @throws Exception
+	 */
+	T doInBackground() throws Exception;
+
+	/**
+	 * Called if background thread fails.
+	 * 
+	 * @param e
+	 */
+	void failed(Exception e);
+
+	/**
+	 * Called if background thread is executed correctly, the result is passed
+	 * as a parameter.
+	 * 
+	 * @param result
+	 */
+	void complete(T result);
+}

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

@@ -0,0 +1,11 @@
+package org.diylc.common;
+
+public enum LabelPosition {
+
+	ABOVE, BELOW;
+	
+	@Override
+	public String toString() {
+		return name().substring(0, 1) + name().substring(1).toLowerCase();
+	}
+}

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

@@ -0,0 +1,39 @@
+package org.diylc.common;
+
+import java.awt.AlphaComposite;
+import java.awt.BasicStroke;
+import java.awt.Stroke;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Repository for object that may be reused, such as {@link Stroke} or
+ * {@link AlphaComposite}.
+ * 
+ * @author Branislav Stojkovic
+ */
+public class ObjectCache {
+
+	private static ObjectCache instance;
+
+	public static ObjectCache getInstance() {
+		if (instance == null) {
+			instance = new ObjectCache();
+		}
+		return instance;
+	}
+
+	private ObjectCache() {
+	}
+
+	private Map<Integer, Stroke> basicStrokeMap = new HashMap<Integer, Stroke>();
+
+	public Stroke fetchBasicStroke(int width) {
+		if (basicStrokeMap.containsKey(width)) {
+			return basicStrokeMap.get(width);
+		}
+		Stroke stroke = new BasicStroke(width, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
+		basicStrokeMap.put(width, stroke);
+		return stroke;
+	}
+}

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

@@ -0,0 +1,15 @@
+package org.diylc.common;
+
+public enum Orientation {
+
+	DEFAULT, _90, _180, _270;
+
+	@Override
+	public String toString() {
+		if (this == DEFAULT) {
+			return "Default";
+		} else {
+			return name().replace("_", "") + " degrees clockwise";
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+package org.diylc.common;
+
+public enum OrientationHV {
+
+	VERTICAL, HORIZONTAL;
+
+	@Override
+	public String toString() {
+		return name().substring(0, 1) + name().substring(1).toLowerCase();
+	}
+}

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

@@ -1,10 +1,8 @@
 package org.diylc.common;
 
 import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import org.diylc.model.IComponentInstance;
 
+import org.diylc.core.IPropertyValidator;
 
 /**
  * Entity class for editable properties extracted from component objects.
@@ -17,26 +15,31 @@ public class PropertyWrapper implements Cloneable {
 	private String name;
 	private Class<?> type;
 	private Object value;
-	private Method setter;
-	private Method getter;
+	private String setter;
+	private String getter;
 	private boolean defaultable;
+	private IPropertyValidator validator;
+	private boolean unique = true;
+	private boolean changed = false;
 
-	public PropertyWrapper(String name, Class<?> type, Method getter, Method setter,
-			boolean defaultable) {
+	public PropertyWrapper(String name, Class<?> type, String getter,
+			String setter, boolean defaultable, IPropertyValidator validator) {
 		super();
 		this.name = name;
 		this.type = type;
 		this.getter = getter;
 		this.setter = setter;
 		this.defaultable = defaultable;
+		this.validator = validator;
 	}
 
-	public void readFrom(IComponentInstance component) throws IllegalArgumentException,
-			IllegalAccessException, InvocationTargetException {
-		this.value = getter.invoke(component);
+	public void readFrom(Object object) throws IllegalArgumentException,
+			IllegalAccessException, InvocationTargetException,
+			SecurityException, NoSuchMethodException {
+		this.value = object.getClass().getMethod(getter).invoke(object);
 	}
 
-	// public void readUniqueFrom(IComponentInstance component)
+	// public void readUniqueFrom(IDIYComponent component)
 	// throws IllegalArgumentException, IllegalAccessException,
 	// InvocationTargetException {
 	// Object newValue = getter.invoke(component);
@@ -45,9 +48,10 @@ public class PropertyWrapper implements Cloneable {
 	// }
 	// }
 
-	public void writeTo(IComponentInstance component) throws IllegalArgumentException,
-			IllegalAccessException, InvocationTargetException {
-		setter.invoke(component, value);
+	public void writeTo(Object object) throws IllegalArgumentException,
+			IllegalAccessException, InvocationTargetException,
+			SecurityException, NoSuchMethodException {
+		object.getClass().getMethod(setter, type).invoke(object, this.value);
 	}
 
 	public String getName() {
@@ -70,8 +74,24 @@ public class PropertyWrapper implements Cloneable {
 		return defaultable;
 	}
 
-	public void setDefaultable(boolean defaultable) {
-		this.defaultable = defaultable;
+	public IPropertyValidator getValidator() {
+		return validator;
+	}
+
+	public boolean isUnique() {
+		return unique;
+	}
+
+	public void setUnique(boolean unique) {
+		this.unique = unique;
+	}
+
+	public boolean isChanged() {
+		return changed;
+	}
+
+	public void setChanged(boolean changed) {
+		this.changed = changed;
 	}
 
 	// @Override
@@ -84,6 +104,15 @@ public class PropertyWrapper implements Cloneable {
 	// }
 	// return new Property(name, type, value);
 	// }
+	@Override
+	public Object clone() throws CloneNotSupportedException {
+		PropertyWrapper clone = new PropertyWrapper(this.name, this.type, this.getter,
+				this.setter, this.defaultable, this.validator);
+		clone.value = this.value;
+		clone.changed = this.changed;
+		clone.unique = this.unique;
+		return clone;
+	}
 
 	@Override
 	public int hashCode() {
@@ -94,7 +123,6 @@ public class PropertyWrapper implements Cloneable {
 		result = prime * result + ((name == null) ? 0 : name.hashCode());
 		result = prime * result + ((setter == null) ? 0 : setter.hashCode());
 		result = prime * result + ((type == null) ? 0 : type.hashCode());
-		result = prime * result + ((value == null) ? 0 : value.hashCode());
 		return result;
 	}
 
@@ -129,11 +157,6 @@ public class PropertyWrapper implements Cloneable {
 				return false;
 		} else if (!type.equals(other.type))
 			return false;
-		if (value == null) {
-			if (other.value != null)
-				return false;
-		} else if (!value.equals(other.value))
-			return false;
 		return true;
 	}
 

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

@@ -0,0 +1,14 @@
+package org.diylc.common;
+
+public enum ResistorColorCode {
+
+	NONE, _4_BAND, _5_BAND;
+
+	@Override
+	public String toString() {
+		if (name().startsWith("_")) {
+			return name().substring(1).replace("_", " ").toLowerCase();
+		}
+		return name().substring(0, 1).toUpperCase() + name().substring(1).toLowerCase();
+	}
+}

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

@@ -0,0 +1,5 @@
+package org.diylc.common;
+
+public enum VerticalAlignment {
+	TOP, CENTER, BOTTOM
+}

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

@@ -0,0 +1,181 @@
+package org.diylc.components;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+import org.diylc.common.HorizontalAlignment;
+import org.diylc.common.VerticalAlignment;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.annotations.EditableProperty;
+
+/**
+ * Abstract implementation of {@link IDIYComponent} that contains component name
+ * and toString.
+ * 
+ * IMPORTANT: to improve performance, all fields except for <code>Point</code>
+ * and <code>Point</code> arrays should be immutable. Failing to comply with
+ * this can result in annoying and hard to trace bugs.
+ * 
+ * @author Branislav Stojkovic
+ * 
+ * @param <T>
+ */
+public abstract class AbstractComponent<T> implements IDIYComponent<T> {
+
+	private static final long serialVersionUID = 1L;
+
+	protected String name = "";
+
+	public static Color SELECTION_COLOR = Color.red;
+	public static Color LABEL_COLOR = Color.black;
+	public static Color LABEL_COLOR_SELECTED = Color.red;
+	public static Font LABEL_FONT = new Font("Tahoma", Font.PLAIN, 14);
+	public static Color METAL_COLOR = Color.decode("#236B8E");
+
+	@EditableProperty(defaultable = false)
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	@Override
+	public boolean canControlPointOverlap(int index) {
+		return false;
+	}
+
+	@Override
+	public String toString() {
+		return name;
+	}
+
+	/**
+	 * Returns the closest odd number, i.e. x when x is odd, or x + 1 when x is
+	 * even.
+	 * 
+	 * @param x
+	 * @return
+	 */
+	protected int getClosestOdd(double x) {
+		return ((int) x / 2) * 2 + 1;
+	}
+
+	/**
+	 * @param clip
+	 * @return true if none of the control points lie in the clip rectangle.
+	 */
+	protected boolean checkPointsClipped(Shape clip) {
+		for (int i = 0; i < getControlPointCount(); i++) {
+			if (clip.contains(getControlPoint(i))) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	protected void drawCenteredText(Graphics2D g2d, String text, int x, int y,
+			HorizontalAlignment horizontalAlignment,
+			VerticalAlignment verticalAlignment) {
+		FontMetrics fontMetrics = g2d.getFontMetrics();
+		Rectangle stringBounds = fontMetrics.getStringBounds(text, g2d)
+				.getBounds();
+
+		Font font = g2d.getFont();
+		FontRenderContext renderContext = g2d.getFontRenderContext();
+		GlyphVector glyphVector = font.createGlyphVector(renderContext, text);
+		Rectangle visualBounds = glyphVector.getVisualBounds().getBounds();
+
+		int textX = 0;
+		switch (horizontalAlignment) {
+		case CENTER:
+			textX = x - stringBounds.width / 2;
+			break;
+		case LEFT:
+			textX = x;
+			break;
+		case RIGHT:
+			textX = x - stringBounds.width;
+			break;
+		}
+
+		int textY = 0;
+		switch (verticalAlignment) {
+		case TOP:
+			textY = y + stringBounds.height;
+			break;
+		case CENTER:
+			textY = y - visualBounds.height / 2 - visualBounds.y;
+			break;
+		case BOTTOM:
+			textY = y - visualBounds.y;
+			break;
+		}
+
+		g2d.drawString(text, textX, textY);
+	}
+
+	@SuppressWarnings("unchecked")
+	public IDIYComponent<T> clone() throws CloneNotSupportedException {
+		try {
+			// Instantiate object of the same type
+			AbstractComponent<T> newInstance = (AbstractComponent<T>) this
+					.getClass().getConstructors()[0].newInstance();
+			Class<?> clazz = this.getClass();
+			while (AbstractComponent.class.isAssignableFrom(clazz)) {
+				Field[] fields = clazz.getDeclaredFields();
+				clazz = clazz.getSuperclass();
+				// fields = this.getClass().getDeclaredFields();
+				// Copy over all non-static, non-final fields that are declared
+				// in
+				// AbstractComponent or one of it's child classes
+				for (Field field : fields) {
+					if (!Modifier.isStatic(field.getModifiers())
+							&& !Modifier.isFinal(field.getModifiers())) {
+						field.setAccessible(true);
+						Object value = field.get(this);
+
+						// Deep copy point arrays.
+						// TODO: something nicer
+						if (value != null
+								&& value.getClass().isArray()
+								&& value.getClass().getComponentType()
+										.isAssignableFrom(Point.class)) {
+							Object newArray = Array.newInstance(value
+									.getClass().getComponentType(), Array
+									.getLength(value));
+							for (int i = 0; i < Array.getLength(value); i++) {
+								Point p = (Point) Array.get(value, i);
+								Array.set(newArray, i, new Point(p));
+							}
+							value = newArray;
+						}
+						// Deep copy points.
+						// TODO: something nicer
+						if (value != null && value instanceof Point) {
+							value = new Point((Point) value);
+						}
+
+						field.set(newInstance, value);
+					}
+				}
+			}
+			return newInstance;
+		} catch (Exception e) {
+			throw new CloneNotSupportedException("Could not clone the component. Reason: " + e.getMessage());
+		}
+	}
+}

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

@@ -0,0 +1,249 @@
+package org.diylc.components;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.geom.CubicCurve2D;
+
+import org.diylc.common.ObjectCache;
+import org.diylc.core.ComponentState;
+import org.diylc.core.IDrawingObserver;
+import org.diylc.core.Project;
+import org.diylc.core.VisibilityPolicy;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+import org.diylc.utils.Constants;
+
+public abstract class AbstractCurvedComponent<T> extends AbstractTransparentComponent<T> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Color GUIDELINE_COLOR = Color.blue;
+	public static Size DEFAULT_SIZE = new Size(1d, SizeUnit.in);
+
+	protected Point[] controlPoints = new Point[] {
+			new Point(0, 0),
+			new Point((int) (DEFAULT_SIZE.convertToPixels() / 2), 0),
+			new Point((int) (DEFAULT_SIZE.convertToPixels() / 2), (int) (DEFAULT_SIZE
+					.convertToPixels())),
+			new Point((int) DEFAULT_SIZE.convertToPixels(), (int) DEFAULT_SIZE.convertToPixels()) };
+
+	protected Color color = getDefaultColor();
+	protected PointCount pointCount = PointCount.FOUR;
+
+	/**
+	 * Draws the specified curve onto graphics.
+	 * 
+	 * @param curve
+	 * @param g2d
+	 * @param componentState
+	 * @param theme
+	 */
+	protected abstract void drawCurve(CubicCurve2D curve, Graphics2D g2d,
+			ComponentState componentState);
+
+	/**
+	 * @return default color.
+	 */
+	protected abstract Color getDefaultColor();
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.setColor(getDefaultColor().darker());
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(3));
+		CubicCurve2D curve = new CubicCurve2D.Double(1, height - 1, width / 4, height / 3,
+				3 * width / 4, 2 * height / 3, width - 1, 1);
+		g2d.draw(curve);
+		g2d.setColor(getDefaultColor());
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
+		g2d.draw(curve);
+	}
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		if (checkPointsClipped(g2d.getClip())) {
+			return;
+		}
+		if (componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING) {
+			// Do not track guidelines.
+			drawingObserver.stopTracking();
+			g2d.setStroke(Constants.DASHED_STROKE);
+			g2d.setColor(GUIDELINE_COLOR);
+			g2d.drawLine(controlPoints[0].x, controlPoints[0].y, controlPoints[1].x,
+					controlPoints[1].y);
+			g2d.drawLine(controlPoints[1].x, controlPoints[1].y, controlPoints[2].x,
+					controlPoints[2].y);
+			g2d.drawLine(controlPoints[2].x, controlPoints[2].y, controlPoints[3].x,
+					controlPoints[3].y);
+			drawingObserver.startTracking();
+		}
+		CubicCurve2D curve = new CubicCurve2D.Double(controlPoints[0].x, controlPoints[0].y,
+				controlPoints[1].x, controlPoints[1].y, controlPoints[2].x, controlPoints[2].y,
+				controlPoints[3].x, controlPoints[3].y);
+
+		Composite oldComposite = g2d.getComposite();
+		if (alpha < MAX_ALPHA) {
+			g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+					/ MAX_ALPHA));
+		}
+		// g2d.setColor(color.darker());
+		// g2d.setStroke(new BasicStroke(thickness));
+		// g2d.draw(path);
+		// g2d.setColor(color);
+		// g2d.setStroke(new BasicStroke(thickness - 2));
+		// g2d.draw(path);
+		drawCurve(curve, g2d, componentState);
+		g2d.setComposite(oldComposite);
+	}
+
+	@EditableProperty(name = "Point Count")
+	public PointCount getPointCount() {
+		if (pointCount == null) {
+			pointCount = PointCount.FOUR;
+		}
+		return pointCount;
+	}
+
+	public void setPointCount(PointCount pointCount) {
+		this.pointCount = pointCount;
+		// Reset control points.
+		for (int i = 0; i < getControlPointCount(); i++) {
+			setControlPoint(getControlPoint(i), i);
+		}
+	}
+
+	@Override
+	public int getControlPointCount() {
+		switch (getPointCount()) {
+		case TWO:
+			return 2;
+		case THREE:
+			return 3;
+		case FOUR:
+			return 4;
+		}
+		return 0;
+	}
+
+	@Override
+	public boolean isControlPointSticky(int index) {
+		return index == 0 || index == getControlPointCount() - 1;
+	}
+
+	@Override
+	public VisibilityPolicy getControlPointVisibilityPolicy(int index) {
+		return VisibilityPolicy.WHEN_SELECTED;
+	}
+
+	@Override
+	public boolean canControlPointOverlap(int index) {
+		// Only shape control points may overlap.
+		switch (getPointCount()) {
+		case TWO:
+			return false;
+		case THREE:
+			return index == 1;
+		case FOUR:
+			return index == 1 || index == 2;
+		}
+		return false;
+	}
+
+	@Override
+	public Point getControlPoint(int index) {
+		if (index == 0) {
+			return controlPoints[0];
+		}
+		switch (getPointCount()) {
+		case TWO:
+			switch (index) {
+			case 1:
+				return controlPoints[3];
+			}
+		case THREE:
+			switch (index) {
+			case 1:
+				return controlPoints[1];
+			case 2:
+				return controlPoints[3];
+			}
+		case FOUR:
+			switch (index) {
+			case 1:
+				return controlPoints[1];
+			case 2:
+				return controlPoints[2];
+			case 3:
+				return controlPoints[3];
+			}
+		}
+		return controlPoints[index];
+	}
+
+	@Override
+	public void setControlPoint(Point point, int index) {
+		if (index == 0) {
+			controlPoints[0].setLocation(point);
+		} else {
+			switch (getPointCount()) {
+			case TWO:
+				switch (index) {
+				case 1:
+					Point center = new Point((point.x + controlPoints[0].x) / 2,
+							(point.y + controlPoints[0].y) / 2);
+					controlPoints[1].setLocation(center);
+					controlPoints[2].setLocation(center);
+					controlPoints[3].setLocation(point);
+					break;
+				}
+				break;
+			case THREE:
+				switch (index) {
+				case 1:
+					controlPoints[1].setLocation(point);
+					controlPoints[2].setLocation(point);
+					break;
+				case 2:
+					controlPoints[3].setLocation(point);
+					break;
+				}
+				break;
+			case FOUR:
+				switch (index) {
+				case 1:
+					controlPoints[1].setLocation(point);
+					break;
+				case 2:
+					controlPoints[2].setLocation(point);
+					break;
+				case 3:
+					controlPoints[3].setLocation(point);
+					break;
+				}
+				break;
+			}
+		}
+	}
+
+	@EditableProperty
+	public Color getColor() {
+		return color;
+	}
+
+	public void setColor(Color color) {
+		this.color = color;
+	}
+
+	enum PointCount {
+		TWO, THREE, FOUR;
+
+		@Override
+		public String toString() {
+			return name().substring(0, 1) + name().substring(1).toLowerCase();
+		}
+	}
+}

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

@@ -0,0 +1,350 @@
+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.Point;
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Rectangle2D;
+
+import org.diylc.appframework.miscutils.ConfigurationManager;
+import org.diylc.common.Display;
+import org.diylc.common.IPlugInPort;
+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.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("#236B8E");
+	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 Display display = Display.VALUE;
+
+	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.
+		}
+	}
+
+	@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);
+		} 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(points[0].x - width / 2, 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 : bodyColor);
+			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);
+			}
+		} 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);
+			// Transform graphics to draw the body in the right place and at the
+			// right angle.
+			AffineTransform oldTransform = g2d.getTransform();
+			g2d.translate((points[0].x + points[1].x - shapeRect.width) / 2, (points[0].y
+					+ points[1].y - shapeRect.height) / 2);
+			g2d.rotate(theta, shapeRect.width / 2, shapeRect.height / 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) {
+				if (bodyColor != null) {
+					g2d.setColor(outlineMode ? Constants.TRANSPARENT_COLOR : bodyColor);
+					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);
+			
+			// Go back to the original transformation to draw leads.
+			if (!outlineMode) {
+				AffineTransform textTransform = g2d.getTransform();
+				g2d.setTransform(oldTransform);
+				if (length.convertToPixels() > points[0].distance(points[1])) {
+					g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
+				}
+				int leadThickness = getClosestOdd(getLeadThickness());
+				double leadLength = (distance - shapeRect.width) / 2 - leadThickness / 2;
+				g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(leadThickness));
+				Color leadColor = shouldShadeLeads() ? getLeadColor(componentState).darker()
+						: getLeadColor(componentState);
+				g2d.setColor(leadColor);
+				int endX = (int) (points[0].x + Math.cos(theta) * leadLength);
+				int endY = (int) Math.round(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) Math.round(points[1].y + Math.sin(theta - Math.PI) * leadLength);
+				g2d.drawLine(points[1].x, points[1].y, endX, endY);
+				if (shouldShadeLeads()) {
+					g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(leadThickness - 2));
+					leadColor = getLeadColor(componentState);
+					g2d.setColor(leadColor);
+					g2d.drawLine(points[0].x, points[0].y, (int) (points[0].x + Math.cos(theta)
+							* leadLength), (int) (points[0].y + Math.sin(theta) * leadLength));
+					g2d.drawLine(points[1].x, points[1].y, (int) (points[1].x + Math.cos(theta
+							- Math.PI)
+							* leadLength), (int) (points[1].y + Math.sin(theta - Math.PI)
+							* leadLength));
+				}
+				g2d.setComposite(oldComposite);
+				g2d.setTransform(textTransform);
+			}
+			
+			// Draw label.
+			g2d.setFont(LABEL_FONT);
+			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 = display == Display.NAME ? getName() : getValue().toString();
+			Rectangle2D textRect = fontMetrics.getStringBounds(label, g2d);
+			// Don't offset in outline mode.
+			int offset = outlineMode ? 0 : getLabelOffset((int) shapeRect.getWidth(), (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, shapeRect.width / 2, shapeRect.height / 2);
+				offset = -offset;
+			}			
+			g2d.drawString(label, (int) (shapeRect.width - textRect.getWidth()) / 2 + offset,
+					calculateLabelYCoordinate(shapeRect, textRect, fontMetrics));
+			g2d.setTransform(oldTransform);
+		}
+	}
+
+	private void drawLead(Graphics2D g2d, ComponentState componentState) {
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(getLeadThickness()));
+		Color leadColor = shouldShadeLeads() ? getLeadColor(componentState).darker()
+				: getLeadColor(componentState);
+		g2d.setColor(leadColor);
+		g2d.drawLine(points[0].x, points[0].y, points[1].x, points[1].y);
+		if (shouldShadeLeads()) {
+			g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(getLeadThickness() - 2));
+			leadColor = getLeadColor(componentState);
+			g2d.setColor(leadColor);
+			g2d.drawLine(points[0].x, points[0].y, points[1].x, points[1].y);
+		}
+	}
+
+	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();
+
+	/**
+	 * @return default lead thickness. Override this method to change it.
+	 */
+	protected int getLeadThickness() {
+		return (int) LEAD_THICKNESS.convertToPixels();
+	}
+
+	/**
+	 * @return default lead color. Override this method to change it.
+	 */
+	protected Color getLeadColor(ComponentState componentState) {
+		return componentState == ComponentState.SELECTED
+				|| componentState == ComponentState.DRAGGING ? SELECTION_COLOR : LEAD_COLOR;
+	}
+
+	@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;
+	}
+
+	@EditableProperty(name = "Border")
+	public Color getBorderColor() {
+		return borderColor;
+	}
+
+	public void setBorderColor(Color borderColor) {
+		this.borderColor = borderColor;
+	}
+
+	@EditableProperty(name = "Length", defaultable = true)
+	public Size getLength() {
+		return length;
+	}
+
+	public void setLength(Size length) {
+		this.length = length;
+	}
+
+	@EditableProperty(name = "Width", defaultable = true)
+	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;
+	}
+}

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

@@ -0,0 +1,72 @@
+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.borderColor = COLOR;
+	}
+
+	@Override
+	public Color getBodyColor() {
+		return super.getBodyColor();
+	}
+
+	@Override
+	protected boolean shouldShadeLeads() {
+		return false;
+	}
+
+	@Override
+	protected int getLeadThickness() {
+		return 1;
+	}
+
+	@Override
+	protected int calculateLabelYCoordinate(Rectangle2D shapeRect, Rectangle2D textRect,
+			FontMetrics fontMetrics) {
+		if (labelPosition == LabelPosition.ABOVE) {
+			return -1;
+		} else {
+			return (int) (shapeRect.getHeight() + textRect.getHeight() - 1);
+		}
+	}
+
+	@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 getLeadColor(ComponentState componentState) {
+		return componentState == ComponentState.SELECTED
+				|| componentState == ComponentState.DRAGGING ? SELECTION_COLOR : LEAD_COLOR;
+	}
+}

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

@@ -0,0 +1,21 @@
+package org.diylc.components;
+
+import org.diylc.core.annotations.EditableProperty;
+
+public abstract class AbstractTransparentComponent<T> extends AbstractComponent<T> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static byte MAX_ALPHA = 127;
+
+	protected byte alpha = MAX_ALPHA;
+
+	@EditableProperty
+	public Byte getAlpha() {
+		return alpha;
+	}
+
+	public void setAlpha(Byte alpha) {
+		this.alpha = alpha;
+	}
+}

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

@@ -0,0 +1,13 @@
+package org.diylc.core;
+
+/**
+ * Validator that allows all values.
+ * 
+ * @author Branislav Stojkovic
+ */
+public class AllowAllValidator implements IPropertyValidator {
+
+	@Override
+	public void validate(Object value) throws ValidationException {
+	}
+}

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

@@ -1,4 +1,4 @@
-package org.diylc.model;
+package org.diylc.core;
 
 /**
  * Enumerates all possible states that a component can be in.

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

@@ -0,0 +1,6 @@
+package org.diylc.core;
+
+public enum CreationMethod {
+
+	SINGLE_CLICK, POINT_BY_POINT;
+}

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

@@ -0,0 +1,8 @@
+package org.diylc.core;
+
+public enum ExpansionMode {
+
+	ALL,
+	SAME_TYPE,
+	IMMEDIATE,
+}

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

@@ -0,0 +1,130 @@
+package org.diylc.core;
+
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.io.Serializable;
+
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+
+/**
+ * Interface for component instance. Implementation classes of this interface
+ * will be instantiated by the application when component is added to the
+ * canvas. <br>
+ * <br>
+ * <b>Implementing classes should meet the following: </b>
+ * <ul>
+ * <li>Must have an empty constructor.</li>
+ * <li>Class should be annotated with {@link ComponentDescriptor}.</li>
+ * <li>Getters for properties editable by users should be annotated with
+ * {@link EditableProperty}.</li>
+ * <li>Component configuration should be stored int <code>public static</code>
+ * fields so they can be set through config file.</li>
+ * </ul>
+ * 
+ * @author Branislav Stojkovic
+ * 
+ * @param <T>
+ *            type of component values, e.g. Resistance for resistors or String
+ *            for transistors.
+ */
+public interface IDIYComponent<T> extends Serializable {
+
+	public static final int CHASSIS = 1;
+	public static final int BOARD = 2;
+	public static final int TRACE = 3;
+	public static final int COMPONENT = 4;
+	public static final int TEXT = 5;
+
+	/**
+	 * @return component instance name.
+	 */
+	String getName();
+
+	/**
+	 * Updates component instance name.
+	 * 
+	 * @param name
+	 */
+	void setName(String name);
+
+	/**
+	 * @return component value.
+	 */
+	T getValue();
+
+	/**
+	 * Updates component value.
+	 * 
+	 * @param value
+	 */
+	void setValue(T value);
+
+	/**
+	 * @return number of control points for this component instance. May vary
+	 *         between two instances of the same type, e.g. DIL IC with 8 and 16
+	 *         pins will have 8 or 16 pins although they are of the same type.
+	 */
+	int getControlPointCount();
+
+	/**
+	 * @param index
+	 * @return control point at the specified index.
+	 */
+	Point getControlPoint(int index);
+
+	/**
+	 * Updates the control point at the specified index.
+	 * 
+	 * @param point
+	 * @param index
+	 */
+	void setControlPoint(Point point, int index);
+
+	/**
+	 * @param index
+	 * @return true, if the specified control point may stick to control points
+	 *         of other components.
+	 */
+	boolean isControlPointSticky(int index);
+
+	/**
+	 * @param index
+	 * @return true, if the specified control point may overlap with other
+	 *         control points <b>of the same component</b>. The other control
+	 *         point must be able to overlap too.
+	 */
+	boolean canControlPointOverlap(int index);
+
+	VisibilityPolicy getControlPointVisibilityPolicy(int index);
+
+	/**
+	 * Draws the component onto the {@link Graphics2D}.
+	 * 
+	 * @param g2d
+	 * @param componentState
+	 * @param outlineMode
+	 * @param project
+	 * @param drawingObserver
+	 */
+	void draw(Graphics2D g2d, ComponentState componentState,
+			boolean outlineMode, Project project,
+			IDrawingObserver drawingObserver);
+
+	/**
+	 * Draws icon representation of the component. This should not depend on
+	 * component state, i.e. it should be treated as a static method.
+	 * 
+	 * @param g2d
+	 * @param width
+	 * @param height
+	 */
+	void drawIcon(Graphics2D g2d, int width, int height);
+
+	/**
+	 * Clones the component.
+	 * 
+	 * @return
+	 */
+	IDIYComponent<T> clone() throws CloneNotSupportedException;
+}

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

@@ -0,0 +1,15 @@
+package org.diylc.core;
+
+/**
+ * Interface for tracking component drawing process. Components may use it to
+ * stop or restart tracking. Anything drawn while tracking is stopped will not
+ * be added to the mouse hot-spot area.
+ * 
+ * @author Branislav Stojkovic
+ */
+public interface IDrawingObserver {
+
+	void stopTracking();
+
+	void startTracking();
+}

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

@@ -0,0 +1,16 @@
+package org.diylc.core;
+
+/**
+ * Interface for validating property value changes.
+ * 
+ * @author Branislav Stojkovic
+ */
+public interface IPropertyValidator {
+
+	/**
+	 * @param value
+	 * @throws ValidationException
+	 *             if validation fails. Message will contain the reason.
+	 */
+	void validate(Object value) throws ValidationException;
+}

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

@@ -0,0 +1,41 @@
+package org.diylc.core;
+
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+
+import org.diylc.common.PropertyWrapper;
+
+
+/**
+ * Base interface for the main GUI component.
+ * 
+ * @author Branislav Stojkovic
+ */
+public interface IView {
+
+	public static final int ERROR_MESSAGE = 0;
+	public static final int INFORMATION_MESSAGE = 1;
+	public static final int WARNING_MESSAGE = 2;
+	public static final int QUESTION_MESSAGE = 3;
+	public static final int PLAIN_MESSAGE = -1;
+	public static final int DEFAULT_OPTION = -1;
+	public static final int YES_NO_OPTION = 0;
+	public static final int YES_NO_CANCEL_OPTION = 1;
+	public static final int OK_CANCEL_OPTION = 2;
+	public static final int YES_OPTION = 0;
+	public static final int NO_OPTION = 1;
+	public static final int CANCEL_OPTION = 2;
+	public static final int OK_OPTION = 0;
+	
+	public static final String CHECK_BOX_MENU_ITEM = "org.diylc.checkBoxMenuItem";
+	public static final String RADIO_BUTTON_GROUP_KEY = "org.diylc.radioButtonGroup";
+
+	void showMessage(String message, String title, int messageType);
+
+	int showConfirmDialog(String message, String title, int optionType, int messageType);
+	
+	boolean editProperties(List<PropertyWrapper> properties, Set<PropertyWrapper> defaultedProperties);
+	
+	File promptFileSave();
+}

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

@@ -0,0 +1,248 @@
+package org.diylc.core;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.diylc.appframework.update.VersionNumber;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.annotations.PositiveMeasureValidator;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+
+/**
+ * Entity class that defines a project. Contains project properties and a
+ * collection of components.This class is serialized to file. Some filed getters
+ * are tagged with {@link EditableProperty} to enable for user to edit them.
+ * 
+ * @author Branislav Stojkovic
+ */
+public class Project implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	public static String DEFAULT_TITLE = "New Project";
+	public static Size DEFAULT_WIDTH = new Size(29d, SizeUnit.cm);
+	public static Size DEFAULT_HEIGHT = new Size(21d, SizeUnit.cm);
+	public static Size DEFAULT_GRID_SPACING = new Size(0.1d, SizeUnit.in);
+
+	private VersionNumber fileVersion;
+	
+	private String title;
+	private String author;
+	private String description;
+	private Size width;
+	private Size height;
+	private Size gridSpacing;
+	private List<IDIYComponent<?>> components;
+	private Set<Set<IDIYComponent<?>>> groups;
+	private Set<Integer> lockedLayers;
+
+	public Project() {
+		components = new ArrayList<IDIYComponent<?>>();
+		groups = new HashSet<Set<IDIYComponent<?>>>();
+		lockedLayers = new HashSet<Integer>();
+		title = DEFAULT_TITLE;
+		author = System.getProperty("user.name");
+		width = DEFAULT_WIDTH;
+		height = DEFAULT_HEIGHT;
+		gridSpacing = DEFAULT_GRID_SPACING;
+	}
+
+	@EditableProperty(defaultable = false)
+	public String getTitle() {
+		return title;
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	@EditableProperty
+	public String getAuthor() {
+		return author;
+	}
+
+	public void setAuthor(String author) {
+		this.author = author;
+	}
+
+	@EditableProperty(defaultable = false)
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+	@EditableProperty
+	public Size getWidth() {
+		return width;
+	}
+
+	public void setWidth(Size width) {
+		this.width = width;
+	}
+
+	@EditableProperty
+	public Size getHeight() {
+		return height;
+	}
+
+	public void setHeight(Size height) {
+		this.height = height;
+	}
+
+	@EditableProperty(name = "Grid spacing", validatorClass = SpacingValidator.class)
+	public Size getGridSpacing() {
+		return gridSpacing;
+	}
+
+	public void setGridSpacing(Size gridSpacing) {
+		this.gridSpacing = gridSpacing;
+	}
+
+	/**
+	 * List of components sorted by z-order ascending.
+	 * 
+	 * @return
+	 */
+	public List<IDIYComponent<?>> getComponents() {
+		return components;
+	}
+
+	/**
+	 * Set of grouped components.
+	 * 
+	 * @return
+	 */
+	public Set<Set<IDIYComponent<?>>> getGroups() {
+		return groups;
+	}
+
+	public Set<Integer> getLockedLayers() {
+		return lockedLayers;
+	}
+	
+	public VersionNumber getFileVersion() {
+		return fileVersion;
+	}
+	
+	public void setFileVersion(VersionNumber fileVersion) {
+		this.fileVersion = fileVersion;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((author == null) ? 0 : author.hashCode());
+		result = prime * result + ((components == null) ? 0 : components.hashCode());
+		result = prime * result + ((description == null) ? 0 : description.hashCode());
+		result = prime * result + ((height == null) ? 0 : height.hashCode());
+		result = prime * result + ((title == null) ? 0 : title.hashCode());
+		result = prime * result + ((width == null) ? 0 : width.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Project other = (Project) obj;
+		if (author == null) {
+			if (other.author != null)
+				return false;
+		} else if (!author.equals(other.author))
+			return false;
+		if (components == null) {
+			if (other.components != null)
+				return false;
+		} else if (!components.equals(other.components))
+			return false;
+		if (description == null) {
+			if (other.description != null)
+				return false;
+		} else if (!description.equals(other.description))
+			return false;
+		if (height == null) {
+			if (other.height != null)
+				return false;
+		} else if (!height.equals(other.height))
+			return false;
+		if (title == null) {
+			if (other.title != null)
+				return false;
+		} else if (!title.equals(other.title))
+			return false;
+		if (width == null) {
+			if (other.width != null)
+				return false;
+		} else if (!width.equals(other.width))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return title;
+	}
+
+	public static class SpacingValidator extends PositiveMeasureValidator {
+
+		@Override
+		public void validate(Object value) throws ValidationException {
+			super.validate(value);
+			Size size = (Size) value;
+			if (size.compareTo(new Size(0.5d, SizeUnit.mm)) < 0) {
+				throw new ValidationException("must be at least 0.5mm");
+			}
+			if (size.compareTo(new Size(1d, SizeUnit.in)) > 0) {
+				throw new ValidationException("must be less than 1in");
+			}
+		}
+	}
+
+	@Override
+	public Project clone()  {
+		Project project = new Project();
+		project.setTitle(this.getTitle());
+		project.setAuthor(this.getAuthor());
+		project.setDescription(this.getDescription());
+		project.setFileVersion(this.getFileVersion());
+		project.setGridSpacing(this.getGridSpacing());
+		project.setHeight(this.getHeight());
+		project.setWidth(this.getWidth());
+		project.getLockedLayers().addAll(this.getLockedLayers());		
+		
+		Map<IDIYComponent<?>, IDIYComponent<?>> cloneMap = new HashMap<IDIYComponent<?>, IDIYComponent<?>>();
+		
+		for (IDIYComponent<?> component : this.components) {
+			try {
+				IDIYComponent<?> clone = component.clone();
+				project.getComponents().add(clone);
+				cloneMap.put(component, clone);
+			} catch (CloneNotSupportedException e) {
+				throw new RuntimeException(e);
+			}
+		}
+		
+		for (Set<IDIYComponent<?>> group : this.groups) {
+			Set<IDIYComponent<?>> cloneGroup = new HashSet<IDIYComponent<?>>();
+			for (IDIYComponent<?> component : group) {
+				cloneGroup.add(cloneMap.get(component));
+			}
+			project.groups.add(cloneGroup);
+		}
+		return project;
+	}
+}

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

@@ -0,0 +1,86 @@
+package org.diylc.core;
+
+import java.awt.Color;
+import java.io.Serializable;
+
+public class Theme implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	private String name;
+	private Color bgColor;
+	private Color gridColor;
+	private Color outlineColor;
+
+	public Theme(String name, Color bgColor, Color gridColor, Color outlineColor) {
+		super();
+		this.name = name;
+		this.bgColor = bgColor;
+		this.gridColor = gridColor;
+		this.outlineColor = outlineColor;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public Color getBgColor() {
+		return bgColor;
+	}
+
+	public Color getGridColor() {
+		return gridColor;
+	}
+
+	public Color getOutlineColor() {
+		return outlineColor;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((bgColor == null) ? 0 : bgColor.hashCode());
+		result = prime * result + ((gridColor == null) ? 0 : gridColor.hashCode());
+		result = prime * result + ((outlineColor == null) ? 0 : outlineColor.hashCode());
+		result = prime * result + ((name == null) ? 0 : name.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Theme other = (Theme) obj;
+		if (bgColor == null) {
+			if (other.bgColor != null)
+				return false;
+		} else if (!bgColor.equals(other.bgColor))
+			return false;
+		if (gridColor == null) {
+			if (other.gridColor != null)
+				return false;
+		} else if (!gridColor.equals(other.gridColor))
+			return false;
+		if (outlineColor == null) {
+			if (other.outlineColor != null)
+				return false;
+		} else if (!outlineColor.equals(other.outlineColor))
+			return false;
+		if (name == null) {
+			if (other.name != null)
+				return false;
+		} else if (!name.equals(other.name))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return name;
+	}
+}

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

@@ -0,0 +1,11 @@
+
+package org.diylc.core;
+
+public class ValidationException extends Exception {
+
+	private static final long serialVersionUID = 1L;
+
+	public ValidationException(String message) {
+		super(message);
+	}
+}

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

@@ -1,4 +1,4 @@
-package org.diylc.model;
+package org.diylc.core;
 
 /**
  * Enumerates control point visibility policies.

diylc-core/src/org/diylc/core/annotations/BomPolicy.java

@@ -0,0 +1,7 @@
+package org.diylc.core.annotations;
+
+public enum BomPolicy {
+	SHOW_ALL_NAMES,
+	SHOW_ONLY_TYPE_NAME,
+	NEVER_SHOW,
+}

diylc-core/src/org/diylc/core/annotations/ComponentDescriptor.java

@@ -0,0 +1,74 @@
+package org.diylc.core.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import org.diylc.core.CreationMethod;
+import org.diylc.core.IDIYComponent;
+
+/**
+ * Annotation for {@link IDIYComponent} implementation. Describes component
+ * properties.
+ * 
+ * @author Branislav Stojkovic
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ComponentDescriptor {
+
+	/**
+	 * @return component type name.
+	 */
+	String name();
+
+	/**
+	 * @return component type description.
+	 */
+	String description();
+
+	/**
+	 * @return method that should be used to create a component. If
+	 *         <code>CreationMethod.POINT_BY_POINT</code> is used, user will
+	 *         have to select ending points before the component is created.
+	 */
+	CreationMethod creationMethod() default CreationMethod.SINGLE_CLICK;
+
+	/**
+	 * @return component category, e.g. "Passive", "Semiconductors", etc.
+	 */
+	String category();
+
+	/**
+	 * @return component author name.
+	 */
+	String author();
+
+	/**
+	 * @return prefix that will be used to generate component instance names,
+	 *         e.g. "R" for resistors or "Q" for transistors.
+	 */
+	String instanceNamePrefix();
+
+	/**
+	 * @return Z-order of the component.
+	 */
+	double zOrder();
+
+	/**
+	 * @return true if the component may go beyond it's predefined layer. In
+	 *         that case, <code>zOrder</code> is used as initial z order of the
+	 *         component.
+	 */
+	boolean flexibleZOrder() default false;
+
+	/**
+	 * @return when false, moving one control point will cause all the others to
+	 *         move together with it.
+	 */
+	boolean stretchable() default true;
+
+	/**
+	 * @return controls what should be shown the BOM
+	 */
+	BomPolicy bomPolicy() default BomPolicy.SHOW_ALL_NAMES;
+
+}

diylc-core/src/org/diylc/core/annotations/EditableProperty.java

@@ -1,8 +1,11 @@
-package org.diylc.model.annotations;
+package org.diylc.core.annotations;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
+import org.diylc.core.AllowAllValidator;
+import org.diylc.core.IPropertyValidator;
+
 /**
  * Used to annotate editable component property. Editable property XYZ must have
  * both getter and setter named <code>getXYZ</code> and <code>setXYZ</code>
@@ -16,16 +19,24 @@ public @interface EditableProperty {
 	/**
 	 * Returns property name. If left blank property name will be extracted from
 	 * the getter name, e.g. getter <code>getXYZ</code> will induce property
-	 * name <code>XYZ</code>.
+	 * name <code>XYZ</code>. <br>
+	 * Default value is blank.
 	 * 
 	 * @return
 	 */
 	String name() default "";
 
 	/**
-	 * If true, application may set default value for this property.
+	 * If true, application may set default value for this property. <br>
+	 * Default value is true.
 	 * 
 	 * @return
 	 */
-	boolean defaultable() default false;
+	boolean defaultable() default true;
+	
+	/**
+	 * Class of validator to use to 
+	 * @return
+	 */
+	Class<? extends IPropertyValidator> validatorClass() default AllowAllValidator.class;
 }

diylc-core/src/org/diylc/core/annotations/PositiveMeasureValidator.java

@@ -0,0 +1,20 @@
+package org.diylc.core.annotations;
+
+import org.diylc.core.IPropertyValidator;
+import org.diylc.core.ValidationException;
+import org.diylc.core.measures.AbstractMeasure;
+
+public class PositiveMeasureValidator implements IPropertyValidator {
+
+	@Override
+	public void validate(Object value) throws ValidationException {
+		if (value instanceof AbstractMeasure) {
+			AbstractMeasure measure = (AbstractMeasure) value;
+			if (measure.getValue() < 0) {
+				throw new ValidationException("must be greater than zero.");
+			}
+		} else {
+			throw new ValidationException("wrong data type, measure expected.");
+		}
+	}
+}

diylc-core/src/org/diylc/core/measures/AbstractMeasure.java

@@ -1,20 +1,27 @@
-package org.diylc.model.measures;
+package org.diylc.core.measures;
 
 import java.io.Serializable;
 import java.text.DecimalFormat;
 import java.text.Format;
 
+/***
+ * Immutable measure class.
+ * 
+ * @author bancika
+ *
+ * @param <T>
+ */
 public class AbstractMeasure<T extends Enum<? extends Unit>> implements Serializable, Cloneable {
 
 	private static final long serialVersionUID = 1L;
 
-	protected static final Format format = new DecimalFormat("#.00##");
+	protected static final Format format = new DecimalFormat("0.####");
 
 	protected Double value;
 	protected T unit;
 
-	public AbstractMeasure() {
-	}
+//	public AbstractMeasure() {
+//	}
 
 	public AbstractMeasure(Double value, T unit) {
 		super();
@@ -26,17 +33,22 @@ public class AbstractMeasure<T extends Enum<? extends Unit>> implements Serializ
 		return value;
 	}
 
-	public void setValue(Double value) {
-		this.value = value;
-	}
+//	public void setValue(Double value) {
+//		this.value = value;
+//	}
 
 	public T getUnit() {
 		return unit;
 	}
 
-	public void setUnit(T multiplier) {
-		this.unit = multiplier;
-	}
+//	public void setUnit(T multiplier) {
+//		this.unit = multiplier;
+//	}
+	
+//	@Override
+//	public Object clone() throws CloneNotSupportedException {
+//		return super.clone();
+//	}
 
 	@Override
 	public int hashCode() {
@@ -71,6 +83,6 @@ public class AbstractMeasure<T extends Enum<? extends Unit>> implements Serializ
 
 	@Override
 	public String toString() {
-		return format.format(value) + " " + unit;
+		return format.format(value) + unit;
 	}
 }

diylc-core/src/org/diylc/core/measures/Capacitance.java

@@ -0,0 +1,31 @@
+package org.diylc.core.measures;
+
+public class Capacitance extends AbstractMeasure<CapacitanceUnit> {
+
+	private static final long serialVersionUID = 1L;
+
+//	public Capacitance() {
+//		super();
+//		// TODO Auto-generated constructor stub
+//	}
+
+	public Capacitance(Double value, CapacitanceUnit unit) {
+		super(value, unit);
+		// TODO Auto-generated constructor stub
+	}
+
+	@Override
+	public Capacitance clone() throws CloneNotSupportedException {
+		return new Capacitance(value, unit);
+	}
+	
+	public static Capacitance parseCapacitance(String value) {
+		for (CapacitanceUnit unit : CapacitanceUnit.values()) {
+			if (value.toLowerCase().endsWith(unit.toString().toLowerCase())) {
+				value = value.substring(0, value.length() - unit.toString().length() - 1).trim();
+				return new Capacitance(Double.parseDouble(value), unit);
+			}
+		}
+		throw new IllegalArgumentException("Could not parse capacitance: " + value);
+	}
+}

diylc-core/src/org/diylc/core/measures/CapacitanceUnit.java

@@ -1,8 +1,8 @@
-package org.diylc.model.measures;
+package org.diylc.core.measures;
 
 public enum CapacitanceUnit implements Unit {
 
-	pF(1, "pF"), nF(1e3, "nF"), uF(1e6, "\u03bcF"), mF(1e9, "mF"), F(1e12, "F");
+	pF(1, "pF"), nF(1e3, "nF"), uF(1e6, "uF"), mF(1e9, "mF"), F(1e12, "F");
 
 	double factor;
 	String display;

diylc-core/src/org/diylc/core/measures/Inductance.java

@@ -0,0 +1,31 @@
+package org.diylc.core.measures;
+
+public class Inductance extends AbstractMeasure<InductanceUnit> {
+
+	private static final long serialVersionUID = 1L;
+
+//	public Inductance() {
+//		super();
+//		// TODO Auto-generated constructor stub
+//	}
+
+	public Inductance(Double value, InductanceUnit unit) {
+		super(value, unit);
+		// TODO Auto-generated constructor stub
+	}
+
+	@Override
+	public Inductance clone() throws CloneNotSupportedException {
+		return new Inductance(value, unit);
+	}
+
+	public static Inductance parseCapacitance(String value) {
+		for (InductanceUnit unit : InductanceUnit.values()) {
+			if (value.toLowerCase().endsWith(unit.toString().toLowerCase())) {
+				value = value.substring(0, value.length() - unit.toString().length() - 1).trim();
+				return new Inductance(Double.parseDouble(value), unit);
+			}
+		}
+		throw new IllegalArgumentException("Could not parse inductance: " + value);
+	}
+}

diylc-core/src/org/diylc/core/measures/InductanceUnit.java

@@ -1,4 +1,4 @@
-package org.diylc.model.measures;
+package org.diylc.core.measures;
 
 public enum InductanceUnit implements Unit {
 

diylc-core/src/org/diylc/core/measures/Power.java

@@ -0,0 +1,31 @@
+package org.diylc.core.measures;
+
+public class Power extends AbstractMeasure<PowerUnit> {
+
+	private static final long serialVersionUID = 1L;
+
+//	public Power() {
+//		super();
+//		// TODO Auto-generated constructor stub
+//	}
+
+	public Power(Double value, PowerUnit unit) {
+		super(value, unit);
+		// TODO Auto-generated constructor stub
+	}
+
+	@Override
+	public Power clone() throws CloneNotSupportedException {
+		return new Power(value, unit);
+	}
+
+	public static Power parseCapacitance(String value) {
+		for (PowerUnit unit : PowerUnit.values()) {
+			if (value.toLowerCase().endsWith(unit.toString().toLowerCase())) {
+				value = value.substring(0, value.length() - unit.toString().length() - 1).trim();
+				return new Power(Double.parseDouble(value), unit);
+			}
+		}
+		throw new IllegalArgumentException("Could not parse power: " + value);
+	}
+}

diylc-core/src/org/diylc/core/measures/PowerUnit.java

@@ -0,0 +1,24 @@
+package org.diylc.core.measures;
+
+public enum PowerUnit implements Unit {
+
+	MW(1e-1, "mW"), W(1, "W"), KW(1e3, "KW");
+
+	double factor;
+	String display;
+
+	private PowerUnit(double factor, String display) {
+		this.factor = factor;
+		this.display = display;
+	}
+
+	@Override
+	public double getFactor() {
+		return factor;
+	}
+
+	@Override
+	public String toString() {
+		return display;
+	}
+}

diylc-core/src/org/diylc/core/measures/Resistance.java

@@ -0,0 +1,98 @@
+package org.diylc.core.measures;
+
+import java.awt.Color;
+
+import org.diylc.common.ResistorColorCode;
+
+public class Resistance extends AbstractMeasure<ResistanceUnit> {
+
+	private static final long serialVersionUID = 1L;
+
+	private static final Color[] COLOR_DIGITS = new Color[] { Color.black, Color.decode("#8B4513"),
+			Color.red, Color.orange, Color.yellow, Color.decode("#76EE00"), Color.blue,
+			Color.decode("#91219E"), Color.lightGray, Color.white };
+	private static final Color[] COLOR_MULTIPLIER = new Color[] { Color.lightGray.brighter(),
+			Color.decode("#FFB90F"), Color.black, Color.decode("#8B4513"), Color.red, Color.orange,
+			Color.yellow, Color.decode("#76EE00"), Color.blue };
+
+//	public Resistance() {
+//		super();
+//		// TODO Auto-generated constructor stub
+//	}
+
+	public Resistance(Double value, ResistanceUnit multiplier) {
+		super(value, multiplier);
+		// TODO Auto-generated constructor stub
+	}
+
+	@Override
+	public Resistance clone() throws CloneNotSupportedException {
+		return new Resistance(value, unit);
+	}
+
+	public Color[] getColorCode(ResistorColorCode resistorColorCode) {
+		Color[] bands;
+		if (getValue() == 0) {
+			switch (resistorColorCode) {
+			case _4_BAND:
+				bands = new Color[3];
+				bands[0] = COLOR_DIGITS[0];
+				bands[1] = COLOR_DIGITS[0];
+				bands[2] = COLOR_MULTIPLIER[2];
+				break;
+			case _5_BAND:
+				bands = new Color[4];
+				bands[0] = COLOR_DIGITS[0];
+				bands[1] = COLOR_DIGITS[0];
+				bands[2] = COLOR_DIGITS[0];
+				bands[3] = COLOR_MULTIPLIER[2];
+				break;
+			default:
+				bands = new Color[] {};
+			}
+		} else {
+			double base = getValue() * getUnit().getFactor();
+			int multiplier = 0;
+			while (base > (resistorColorCode == ResistorColorCode._4_BAND ? 99 : 999)) {
+				multiplier += 1;
+				base /= 10;
+			}
+			while (base < (resistorColorCode == ResistorColorCode._4_BAND ? 10 : 100)) {
+				multiplier -= 1;
+				base *= 10;
+			}
+			if (multiplier > 6 || multiplier < -2) {
+				// Out of range.
+				return new Color[] {};
+			}
+			switch (resistorColorCode) {
+			case _4_BAND:
+				bands = new Color[3];
+				bands[0] = COLOR_DIGITS[(int) (base / 10)];
+				bands[1] = COLOR_DIGITS[(int) (base % 10)];
+				bands[2] = COLOR_MULTIPLIER[multiplier + 2];
+				break;
+			case _5_BAND:
+				bands = new Color[4];
+				bands[0] = COLOR_DIGITS[(int) (base / 100)];
+				bands[1] = COLOR_DIGITS[(int) (base / 10 % 10)];
+				bands[2] = COLOR_DIGITS[(int) (base % 10)];
+				bands[3] = COLOR_MULTIPLIER[multiplier + 2];
+				break;
+			default:
+				bands = new Color[] {};
+			}
+		}
+		return bands;
+	}
+
+	public static Resistance parseResistance(String value) {
+		for (ResistanceUnit unit : ResistanceUnit.values()) {
+			if (value.toLowerCase().endsWith(unit.toString().toLowerCase())) {
+				value = value.substring(0, value.length() - unit.toString().length()).trim();
+				return new Resistance(Double.parseDouble(value), unit);
+			}
+		}
+		throw new IllegalArgumentException("Could not parse resistance: " + value);
+	}
+}

diylc-core/src/org/diylc/core/measures/ResistanceUnit.java

@@ -1,8 +1,8 @@
-package org.diylc.model.measures;
+package org.diylc.core.measures;
 
 public enum ResistanceUnit implements Unit {
 
-	R(1, "\u03a9"), K(1e3, "K"), M(1e6, "M");
+	R(1, "\u2126"), K(1e3, "K"), M(1e6, "M");
 
 	double factor;
 	String display;

diylc-core/src/org/diylc/core/measures/Size.java

@@ -0,0 +1,47 @@
+package org.diylc.core.measures;
+
+import org.diylc.utils.Constants;
+
+public class Size extends AbstractMeasure<SizeUnit> implements Comparable<Size> {
+
+	private static final long serialVersionUID = 1L;
+
+//	public Size() {
+//		super();
+//		// TODO Auto-generated constructor stub
+//	}
+
+	public Size(Double value, SizeUnit unit) {
+		super(value, unit);
+		// TODO Auto-generated constructor stub
+	}
+
+	public double convertToPixels() {
+//		double factor = getUnit().getFactor() / SizeUnit.in.getFactor();
+//		int grids = (int) (factor * getValue() * Constants.GRIDS_PER_INCH);
+//		double remainder = (factor * getValue() * Constants.GRIDS_PER_INCH) - grids;
+//		return (int) Math.round(Constants.PIXELS_PER_INCH / Constants.GRIDS_PER_INCH
+//				* (grids + remainder));
+		return getValue() * getUnit().getFactor() / SizeUnit.in.getFactor() * Constants.PIXELS_PER_INCH;
+	}
+
+	@Override
+	public Size clone() throws CloneNotSupportedException {
+		return new Size(value, unit);
+	}
+	
+	public static Size parseSize(String value) {
+		for (SizeUnit unit : SizeUnit.values()) {
+			if (value.toLowerCase().endsWith(unit.toString().toLowerCase())) {
+				value = value.substring(0, value.length() - unit.toString().length() - 1).trim();
+				return new Size(Double.parseDouble(value), unit);
+			}
+		}
+		throw new IllegalArgumentException("Could not parse size: " + value);
+	}
+
+	@Override
+	public int compareTo(Size o) {
+		return new Double(value * unit.getFactor()).compareTo(o.getValue() * o.getUnit().getFactor());
+	}
+}

diylc-core/src/org/diylc/core/measures/SizeUnit.java

@@ -1,4 +1,4 @@
-package org.diylc.model.measures;
+package org.diylc.core.measures;
 
 public enum SizeUnit implements Unit {
 

diylc-core/src/org/diylc/core/measures/Unit.java

@@ -1,4 +1,4 @@
-package org.diylc.model.measures;
+package org.diylc.core.measures;
 
 public interface Unit {
 

diylc-core/src/org/diylc/core/measures/Voltage.java

@@ -0,0 +1,31 @@
+package org.diylc.core.measures;
+
+public class Voltage extends AbstractMeasure<VoltageUnit> {
+
+	private static final long serialVersionUID = 1L;
+
+//	public Voltage() {
+//		super();
+//		// TODO Auto-generated constructor stub
+//	}
+
+	public Voltage(Double value, VoltageUnit unit) {
+		super(value, unit);
+		// TODO Auto-generated constructor stub
+	}
+
+	@Override
+	public Voltage clone() throws CloneNotSupportedException {
+		return new Voltage(value, unit);
+	}
+
+	public static Voltage parseCapacitance(String value) {
+		for (VoltageUnit unit : VoltageUnit.values()) {
+			if (value.toLowerCase().endsWith(unit.toString().toLowerCase())) {
+				value = value.substring(0, value.length() - unit.toString().length() - 1).trim();
+				return new Voltage(Double.parseDouble(value), unit);
+			}
+		}
+		throw new IllegalArgumentException("Could not parse voltage: " + value);
+	}
+}

diylc-core/src/org/diylc/core/measures/VoltageUnit.java

@@ -0,0 +1,24 @@
+package org.diylc.core.measures;
+
+public enum VoltageUnit implements Unit {
+
+	MV(1e-1, "mV"), V(1, "V"), KV(1e3, "KV");
+
+	double factor;
+	String display;
+
+	private VoltageUnit(double factor, String display) {
+		this.factor = factor;
+		this.display = display;
+	}
+
+	@Override
+	public double getFactor() {
+		return factor;
+	}
+
+	@Override
+	public String toString() {
+		return display;
+	}
+}

diylc-core/src/org/diylc/images/IconLoader.java

@@ -1,5 +1,10 @@
 package org.diylc.images;
 
+import java.awt.Image;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
 import javax.swing.Icon;
 import javax.swing.ImageIcon;
 
@@ -14,14 +19,19 @@ public enum IconLoader {
 			"disk_blue.png"), SaveAs("save_as.png"), Exit("exit.png"), DocumentPlainYellow(
 			"document_plain_yellow.png"), PhotoScenery("photo_scenery.png"), LightBulbOn(
 			"lightbulb_on.png"), LightBulbOff("lightbulb_off.png"), NotebookAdd("notebook_add.png"), FormGreen(
-			"form_green.png"), Gears("gears.png"), About("about.png"), Donate("donate.gif"), WindowColors(
+			"form_green.png"), Gears("gears.png"), About("about.png"), WindowColors(
 			"window_colors.png"), WindowGear("window_gear.png"), NavigateCheck("navigate_check.png"), Undo(
 			"undo.png"), Error("error.png"), Warning("warning.png"), ZoomSmall("zoom_small.png"), MoveSmall(
 			"move_small.png"), Print("print.png"), PDF("pdf.png"), Excel("excel.png"), CSV(
 			"csv.png"), HTML("html.png"), Image("image.png"), Cut("cut.png"), Copy("copy.png"), Paste(
 			"paste.png"), Selection("selection.png"), BOM("bom.png"), BlackBoard("blackboard.png"), IdCard(
 			"id_card.png"), IdCardAdd("id_card_add.png"), Chest("chest.png"), Upload("upload.png"), Wrench(
-			"wrench.png"), ;
+			"wrench.png"), Group("group.png"), Ungroup("ungroup.png"), TraceMask("trace_mask.png"), Faq(
+			"faq.png"), Component("component.png"), Plugin("plugin.png"), Manual("manual.png"), Donate(
+			"donate.png"), Bug("bug.png"), IconLarge("icon_large.png"), IconMedium(
+			"icon_medium.png"), IconSmall("icon_small.png"), DocumentEdit("document_edit.png"), EditComponent(
+			"edit_component.png"), Size("size.png"), Front("front.png"), Back("back.png"), Pens(
+			"pens.png"), Sort("sort.png"), ElementsSelection("elements_selection.png");
 
 	protected String name;
 
@@ -38,4 +48,14 @@ public enum IconLoader {
 			return null;
 		}
 	}
+
+	public Image getImage() {
+		BufferedImage img = null;
+		try {
+			img = ImageIO.read(getClass().getResourceAsStream(name));
+		} catch (IOException e) {
+			System.err.println("Couldn't find file: " + name);
+		}
+		return img;
+	}
 }