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

@@ -0,0 +1,183 @@
+package org.diylc.components.boards;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.Graphics2D;
+import java.awt.Point;
+
+import org.diylc.common.HorizontalAlignment;
+import org.diylc.common.ObjectCache;
+import org.diylc.common.VerticalAlignment;
+import org.diylc.components.AbstractTransparentComponent;
+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;
+
+public abstract class AbstractBoard extends AbstractTransparentComponent<String> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Color BOARD_COLOR = Color.decode("#F8EBB3");
+	public static Color BORDER_COLOR = BOARD_COLOR.darker();
+	public static Color COORDINATE_COLOR = Color.gray.brighter();
+	public static float COORDINATE_FONT_SIZE = 9f;
+	public static Size DEFAULT_WIDTH = new Size(1.5d, SizeUnit.in);
+	public static Size DEFAULT_HEIGHT = new Size(1.2d, SizeUnit.in);
+
+	protected String value = "";
+	protected Point[] controlPoints = new Point[] {
+			new Point(0, 0),
+			new Point((int) DEFAULT_WIDTH.convertToPixels(), (int) DEFAULT_HEIGHT.convertToPixels()) };
+	protected Point firstPoint = new Point();
+	protected Point secondPoint = new Point();
+
+	protected Color boardColor = BOARD_COLOR;
+	protected Color borderColor = BORDER_COLOR;
+	protected Color coordinateColor = COORDINATE_COLOR;
+	protected Boolean drawCoordinates = true;
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
+		if (componentState != ComponentState.DRAGGING) {
+			Composite oldComposite = g2d.getComposite();
+			if (alpha < MAX_ALPHA) {
+				g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+						/ MAX_ALPHA));
+			}
+			g2d.setColor(boardColor);
+			g2d.fillRect(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y
+					- firstPoint.y);
+			g2d.setComposite(oldComposite);
+		}
+		g2d.setColor(componentState == ComponentState.SELECTED
+				|| componentState == ComponentState.DRAGGING ? SELECTION_COLOR : borderColor);
+		g2d.drawRect(firstPoint.x, firstPoint.y, secondPoint.x - firstPoint.x, secondPoint.y
+				- firstPoint.y);
+		// Do not track any changes that follow because the whole board has been
+		// tracked so far.
+		drawingObserver.stopTracking();
+	}
+
+	protected void drawCoordinates(Graphics2D g2d, int spacing) {
+		if (!getDrawCoordinates())
+			return;
+		Point p = new Point(firstPoint);
+		g2d.setColor(coordinateColor);
+		g2d.setFont(LABEL_FONT.deriveFont(COORDINATE_FONT_SIZE));
+
+		int t = 1;
+		while (p.y < secondPoint.y - spacing) {
+			p.y += spacing;
+			super.drawCenteredText(g2d, getCoordinateLabel(t++), p.x + 2, p.y,
+					HorizontalAlignment.LEFT, VerticalAlignment.CENTER);
+		}
+
+		p = new Point(firstPoint);
+		t = 1;
+		while (p.x < secondPoint.x - spacing) {
+			p.x += spacing;
+			super.drawCenteredText(g2d, getCoordinateLabel(t++), p.x, p.y - 2,
+					HorizontalAlignment.CENTER, VerticalAlignment.TOP);
+		}
+	}
+
+	private String getCoordinateLabel(int coordinate) {
+		String result = "";
+		while (coordinate > 0) {
+			int digit = coordinate % 26;
+			coordinate /= 26;
+			if (digit == 0) {
+				result = 'Z' + result;
+				coordinate--;
+			} else {
+				result = (char) ((int) 'A' + digit - 1) + result;
+			}
+		}
+		return result;
+	}
+
+	@EditableProperty(name = "Color")
+	public Color getBoardColor() {
+		return boardColor;
+	}
+
+	public void setBoardColor(Color boardColor) {
+		this.boardColor = boardColor;
+	}
+
+	@EditableProperty(name = "Coordinate Color")
+	public Color getCoordinateColor() {
+		// Null protection for older files
+		return coordinateColor == null ? COORDINATE_COLOR : coordinateColor;
+	}
+
+	public void setCoordinateColor(Color coordinateColor) {
+		this.coordinateColor = coordinateColor;
+	}
+
+	@EditableProperty(name = "Border")
+	public Color getBorderColor() {
+		return borderColor;
+	}
+
+	public void setBorderColor(Color borderColor) {
+		this.borderColor = borderColor;
+	}
+
+	@EditableProperty(name = "Draw Coordinates")
+	public boolean getDrawCoordinates() {
+		// Null protection for older files
+		return drawCoordinates == null || drawCoordinates;
+	}
+
+	public void setDrawCoordinates(boolean drawCoordinates) {
+		this.drawCoordinates = drawCoordinates;
+	}
+
+	@Override
+	public int getControlPointCount() {
+		return controlPoints.length;
+	}
+
+	@Override
+	public Point getControlPoint(int index) {
+		return controlPoints[index];
+	}
+
+	@Override
+	public boolean isControlPointSticky(int index) {
+		return false;
+	}
+
+	@Override
+	public VisibilityPolicy getControlPointVisibilityPolicy(int index) {
+		return VisibilityPolicy.WHEN_SELECTED;
+	}
+
+	@Override
+	public void setControlPoint(Point point, int index) {
+		controlPoints[index].setLocation(point);
+		firstPoint.setLocation(Math.min(controlPoints[0].x, controlPoints[1].x), Math.min(
+				controlPoints[0].y, controlPoints[1].y));
+		secondPoint.setLocation(Math.max(controlPoints[0].x, controlPoints[1].x), Math.max(
+				controlPoints[0].y, controlPoints[1].y));
+	}
+
+	@EditableProperty
+	@Override
+	public String getValue() {
+		return value;
+	}
+
+	@Override
+	public void setValue(String value) {
+		this.value = value;
+	}
+}

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

@@ -0,0 +1,26 @@
+package org.diylc.components.boards;
+
+import java.awt.Graphics2D;
+
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.annotations.ComponentDescriptor;
+
+@ComponentDescriptor(name = "Blank Board", category = "Boards", author = "Branislav Stojkovic", zOrder = IDIYComponent.BOARD, instanceNamePrefix = "Board", description = "Blank circuit board")
+public class BlankBoard extends AbstractBoard {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.setColor(BOARD_COLOR);
+		g2d.fillRect(2, 2, width - 4, height - 4);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(2, 2, width - 4, height - 4);
+	}
+	
+	@Override
+	public boolean getDrawCoordinates() {
+		// Override to prevent editing.
+		return super.getDrawCoordinates();
+	}
+}

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

@@ -0,0 +1,115 @@
+package org.diylc.components.boards;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.Shape;
+
+import org.diylc.core.ComponentState;
+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;
+import org.diylc.utils.Constants;
+
+@ComponentDescriptor(name = "Eyelet Board", category = "Boards", author = "Branislav Stojkovic", zOrder = IDIYComponent.BOARD, instanceNamePrefix = "Board", description = "Perforated board with eyelets")
+public class EyeletBoard extends AbstractBoard {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Color BOARD_COLOR = Color.decode("#CCFFCC");
+	public static Color BORDER_COLOR = BOARD_COLOR.darker();
+	public static Color EYELET_COLOR = Color.decode("#C3E4ED");
+
+	public static Size SPACING = new Size(0.5d, SizeUnit.in);
+	public static Size EYELET_SIZE = new Size(0.2d, SizeUnit.in);
+	public static Size HOLE_SIZE = new Size(0.1d, SizeUnit.in);
+
+	// private Area copperArea;
+	protected Size spacing = SPACING;
+	protected Color eyeletColor = EYELET_COLOR;
+
+	public EyeletBoard() {
+		super();
+		this.boardColor = BOARD_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		Shape clip = g2d.getClip();
+		if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, secondPoint.y)
+				&& !clip.contains(secondPoint.x, firstPoint.y)) {
+			return;
+		}
+		super.draw(g2d, componentState, outlineMode, project, drawingObserver);
+		if (componentState != ComponentState.DRAGGING) {
+			if (alpha < MAX_ALPHA) {
+				g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+						/ MAX_ALPHA));
+			}
+			Point p = new Point(firstPoint);
+			int diameter = getClosestOdd((int) EYELET_SIZE.convertToPixels());
+			int holeDiameter = getClosestOdd((int) HOLE_SIZE.convertToPixels());
+			int spacing = (int) this.spacing.convertToPixels();
+
+			while (p.y < secondPoint.y - spacing) {
+				p.x = firstPoint.x;
+				p.y += spacing;
+				while (p.x < secondPoint.x - spacing - diameter) {
+					p.x += spacing;
+					g2d.setColor(eyeletColor);
+					g2d.fillOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+					g2d.setColor(eyeletColor.darker());
+					g2d.drawOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+					g2d.setColor(Constants.CANVAS_COLOR);
+					g2d.fillOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter,
+							holeDiameter);
+					g2d.setColor(eyeletColor.darker());
+					g2d.drawOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter,
+							holeDiameter);
+				}
+			}
+			super.drawCoordinates(g2d, spacing);
+		}
+	}
+
+	@EditableProperty(name = "Eyelet color")
+	public Color getEyeletColor() {
+		return eyeletColor;
+	}
+
+	public void setEyeletColor(Color padColor) {
+		this.eyeletColor = padColor;
+	}
+
+	@EditableProperty
+	public Size getSpacing() {
+		return spacing;
+	}
+
+	public void setSpacing(Size spacing) {
+		this.spacing = spacing;
+	}
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.setColor(BOARD_COLOR);
+		g2d.fillRect(2, 2, width - 4, height - 4);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(2, 2, width - 4, height - 4);
+		g2d.setColor(EYELET_COLOR);
+		g2d.fillOval(width / 4, width / 4, width / 2, width / 2);
+		g2d.setColor(EYELET_COLOR.darker());
+		g2d.drawOval(width / 4, width / 4, width / 2, width / 2);
+		g2d.setColor(Constants.CANVAS_COLOR);
+		g2d.fillOval(width / 2 - 2, width / 2 - 2, 5, 5);
+		g2d.setColor(EYELET_COLOR.darker());
+		g2d.drawOval(width / 2 - 2, width / 2 - 2, 5, 5);
+	}
+}

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

@@ -0,0 +1,109 @@
+package org.diylc.components.boards;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.Shape;
+
+import org.diylc.core.ComponentState;
+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;
+import org.diylc.utils.Constants;
+
+@ComponentDescriptor(name = "Marshall Style Perf Board", category = "Boards", author = "Branislav Stojkovic", zOrder = IDIYComponent.BOARD, instanceNamePrefix = "Board", description = "Perforated board as found on some Marshall and Trainwreck amps")
+public class MarshallPerfBoard extends AbstractBoard {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Color BOARD_COLOR = Color.decode("#CD8500");
+	public static Color BORDER_COLOR = BOARD_COLOR.darker();
+	public static Size SPACING = new Size(3 / 8d, SizeUnit.in);
+	public static Size HOLE_SIZE = new Size(1 / 8d, SizeUnit.in);
+
+	// private Area copperArea;
+	protected Size spacing = SPACING;
+
+	public MarshallPerfBoard() {
+		super();
+		this.boardColor = BOARD_COLOR;
+		this.borderColor = BORDER_COLOR;
+	}
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		Shape clip = g2d.getClip();
+		if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, secondPoint.y)
+				&& !clip.contains(secondPoint.x, firstPoint.y)) {
+			return;
+		}
+		super.draw(g2d, componentState, outlineMode, project, drawingObserver);
+		if (componentState != ComponentState.DRAGGING) {
+			if (alpha < MAX_ALPHA) {
+				g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+						/ MAX_ALPHA));
+			}
+			Point p = new Point(firstPoint);
+			int holeDiameter = getClosestOdd((int) HOLE_SIZE.convertToPixels());
+			int spacing = (int) this.spacing.convertToPixels();
+
+			while (p.y < secondPoint.y - spacing) {
+				p.x = firstPoint.x;
+				p.y += spacing;
+				while (p.x < secondPoint.x - spacing - holeDiameter) {
+					p.x += spacing;
+					g2d.setColor(Constants.CANVAS_COLOR);
+					g2d.fillOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter,
+							holeDiameter);
+					g2d.setColor(borderColor);
+					g2d.drawOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter,
+							holeDiameter);
+				}
+			}
+			super.drawCoordinates(g2d, spacing);
+		}
+	}
+
+	@EditableProperty
+	public Size getSpacing() {
+		return spacing;
+	}
+
+	public void setSpacing(Size spacing) {
+		this.spacing = spacing;
+	}
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.setColor(BOARD_COLOR);
+		g2d.fillRect(2, 2, width - 4, height - 4);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(2, 2, width - 4, height - 4);
+
+		g2d.setColor(Constants.CANVAS_COLOR);
+		g2d.fillOval(width / 3 - 2, width / 3 - 2, 5, 5);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawOval(width / 3 - 2, width / 3 - 2, 5, 5);
+
+		g2d.setColor(Constants.CANVAS_COLOR);
+		g2d.fillOval(2 * width / 3 - 2, width / 3 - 2, 5, 5);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawOval(2 * width / 3 - 2, width / 3 - 2, 5, 5);
+
+		g2d.setColor(Constants.CANVAS_COLOR);
+		g2d.fillOval(width / 3 - 2, 2 * width / 3 - 2, 5, 5);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawOval(width / 3 - 2, 2 * width / 3 - 2, 5, 5);
+
+		g2d.setColor(Constants.CANVAS_COLOR);
+		g2d.fillOval(2 * width / 3 - 2, 2 * width / 3 - 2, 5, 5);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawOval(2 * width / 3 - 2, 2 * width / 3 - 2, 5, 5);
+	}
+}

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

@@ -0,0 +1,107 @@
+package org.diylc.components.boards;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.Shape;
+
+import org.diylc.core.ComponentState;
+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;
+import org.diylc.utils.Constants;
+
+@ComponentDescriptor(name = "Perf Board w/ Pads", category = "Boards", author = "Branislav Stojkovic", zOrder = IDIYComponent.BOARD, instanceNamePrefix = "Board", description = "Perforated board with solder pads")
+public class PerfBoard extends AbstractBoard {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Color COPPER_COLOR = Color.decode("#DA8A67");
+
+	public static Size SPACING = new Size(0.1d, SizeUnit.in);
+	public static Size PAD_SIZE = new Size(0.08d, SizeUnit.in);
+	public static Size HOLE_SIZE = new Size(0.7d, SizeUnit.mm);
+
+	// private Area copperArea;
+	protected Size spacing = SPACING;
+	protected Color padColor = COPPER_COLOR;
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		Shape clip = g2d.getClip();
+		if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, secondPoint.y)
+				&& !clip.contains(secondPoint.x, firstPoint.y)) {
+			return;
+		}
+		super.draw(g2d, componentState, outlineMode, project, drawingObserver);
+		if (componentState != ComponentState.DRAGGING) {
+			if (alpha < MAX_ALPHA) {
+				g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+						/ MAX_ALPHA));
+			}
+			Point p = new Point(firstPoint);
+			int diameter = getClosestOdd((int) PAD_SIZE.convertToPixels());
+			int holeDiameter = getClosestOdd((int) HOLE_SIZE.convertToPixels());
+			int spacing = (int) this.spacing.convertToPixels();
+
+			while (p.y < secondPoint.y - spacing) {
+				p.x = firstPoint.x;
+				p.y += spacing;
+				while (p.x < secondPoint.x - spacing - diameter) {
+					p.x += spacing;
+					g2d.setColor(padColor);
+					g2d.fillOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+					g2d.setColor(padColor.darker());
+					g2d.drawOval(p.x - diameter / 2, p.y - diameter / 2, diameter, diameter);
+					g2d.setColor(Constants.CANVAS_COLOR);
+					g2d.fillOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter,
+							holeDiameter);
+					g2d.setColor(padColor.darker());
+					g2d.drawOval(p.x - holeDiameter / 2, p.y - holeDiameter / 2, holeDiameter,
+							holeDiameter);
+				}
+			}
+			super.drawCoordinates(g2d, spacing);
+		}
+	}
+
+	@EditableProperty(name = "Pad color")
+	public Color getPadColor() {
+		return padColor;
+	}
+
+	public void setPadColor(Color padColor) {
+		this.padColor = padColor;
+	}
+
+	@EditableProperty
+	public Size getSpacing() {
+		return spacing;
+	}
+
+	public void setSpacing(Size spacing) {
+		this.spacing = spacing;
+	}
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.setColor(BOARD_COLOR);
+		g2d.fillRect(2, 2, width - 4, height - 4);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(2, 2, width - 4, height - 4);
+		g2d.setColor(COPPER_COLOR);
+		g2d.fillOval(width / 4, width / 4, width / 2, width / 2);
+		g2d.setColor(COPPER_COLOR.darker());
+		g2d.drawOval(width / 4, width / 4, width / 2, width / 2);
+		g2d.setColor(Constants.CANVAS_COLOR);
+		g2d.fillOval(width / 2 - 2, width / 2 - 2, 5, 5);
+		g2d.setColor(COPPER_COLOR.darker());
+		g2d.drawOval(width / 2 - 2, width / 2 - 2, 5, 5);
+	}
+}

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

@@ -0,0 +1,143 @@
+package org.diylc.components.boards;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.Shape;
+
+import org.diylc.common.OrientationHV;
+import org.diylc.core.ComponentState;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.IDrawingObserver;
+import org.diylc.core.Project;
+import org.diylc.core.annotations.ComponentDescriptor;
+import org.diylc.core.annotations.EditableProperty;
+import org.diylc.core.measures.Size;
+import org.diylc.core.measures.SizeUnit;
+import org.diylc.utils.Constants;
+
+@ComponentDescriptor(name = "Vero Board", category = "Boards", author = "Branislav Stojkovic", zOrder = IDIYComponent.BOARD, instanceNamePrefix = "Board", description = "Perforated FR4 board with copper strips connecting all holes in a row")
+public class VeroBoard extends AbstractBoard {
+
+	private static final long serialVersionUID = 1L;
+
+	public static Color STRIP_COLOR = Color.decode("#DA8A67");
+	public static Color BORDER_COLOR = BOARD_COLOR.darker();
+
+	public static Size SPACING = new Size(0.1d, SizeUnit.in);
+	public static Size STRIP_SIZE = new Size(0.07d, SizeUnit.in);
+	public static Size HOLE_SIZE = new Size(0.7d, SizeUnit.mm);
+
+	protected Size spacing = SPACING;
+	protected Color stripColor = STRIP_COLOR;
+	protected OrientationHV orientation = OrientationHV.HORIZONTAL;
+
+	@Override
+	public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode,
+			Project project, IDrawingObserver drawingObserver) {
+		Shape clip = g2d.getClip();
+		if (checkPointsClipped(clip) && !clip.contains(firstPoint.x, secondPoint.y)
+				&& !clip.contains(secondPoint.x, firstPoint.y)) {
+			return;
+		}
+		super.draw(g2d, componentState, outlineMode, project, drawingObserver);
+		if (componentState != ComponentState.DRAGGING) {
+			Composite oldComposite = g2d.getComposite();
+			if (alpha < MAX_ALPHA) {
+				g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha
+						/ MAX_ALPHA));
+			}
+			Point p = new Point(firstPoint);
+			int stripSize = getClosestOdd((int) STRIP_SIZE.convertToPixels());
+			int holeSize = getClosestOdd((int) HOLE_SIZE.convertToPixels());
+			int spacing = (int) this.spacing.convertToPixels();
+
+			if (orientation == OrientationHV.HORIZONTAL) {
+				while (p.y < secondPoint.y - spacing) {
+					p.x = firstPoint.x;
+					p.y += spacing;
+					g2d.setColor(stripColor);
+					g2d.fillRect(p.x + spacing / 2, p.y - stripSize / 2, secondPoint.x - spacing
+							- p.x, stripSize);
+					g2d.setColor(stripColor.darker());
+					g2d.drawRect(p.x + spacing / 2, p.y - stripSize / 2, secondPoint.x - spacing
+							- p.x, stripSize);
+					while (p.x < secondPoint.x - spacing - holeSize) {
+						p.x += spacing;
+						g2d.setColor(Constants.CANVAS_COLOR);
+						g2d.fillOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+						g2d.setColor(stripColor.darker());
+						g2d.drawOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+					}
+				}
+			} else {
+				while (p.x < secondPoint.x - spacing) {
+					p.x += spacing;
+					p.y = firstPoint.y;
+					g2d.setColor(stripColor);
+					g2d.fillRect(p.x - stripSize / 2, p.y + spacing / 2, stripSize, secondPoint.y
+							- spacing - p.y);
+					g2d.setColor(stripColor.darker());
+					g2d.drawRect(p.x - stripSize / 2, p.y + spacing / 2, stripSize, secondPoint.y
+							- spacing - p.y);
+					while (p.y < secondPoint.y - spacing - holeSize) {
+						p.y += spacing;
+						g2d.setColor(Constants.CANVAS_COLOR);
+						g2d.fillOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+						g2d.setColor(stripColor.darker());
+						g2d.drawOval(p.x - holeSize / 2, p.y - holeSize / 2, holeSize, holeSize);
+					}
+				}
+			}
+			g2d.setComposite(oldComposite);
+			super.drawCoordinates(g2d, spacing);
+		}
+	}
+
+	@EditableProperty(name = "Strip color")
+	public Color getStripColor() {
+		return stripColor;
+	}
+
+	public void setStripColor(Color padColor) {
+		this.stripColor = padColor;
+	}
+
+	@EditableProperty
+	public Size getSpacing() {
+		return spacing;
+	}
+
+	public void setSpacing(Size spacing) {
+		this.spacing = spacing;
+	}
+
+	@EditableProperty
+	public OrientationHV getOrientation() {
+		return orientation;
+	}
+
+	public void setOrientation(OrientationHV orientation) {
+		this.orientation = orientation;
+	}
+
+	@Override
+	public void drawIcon(Graphics2D g2d, int width, int height) {
+		g2d.setColor(BOARD_COLOR);
+		g2d.fillRect(2, 2, width - 4, height - 4);
+		g2d.setColor(BORDER_COLOR);
+		g2d.drawRect(2, 2, width - 4, height - 4);
+		g2d.setColor(STRIP_COLOR);
+		g2d.fillRect(4, width / 4, width - 8, width / 2);
+		g2d.setColor(STRIP_COLOR.darker());
+		g2d.drawRect(4, width / 4, width - 8, width / 2);
+		g2d.setColor(Constants.CANVAS_COLOR);
+		g2d.fillOval(width / 3 - 2, width / 2 - 2, 5, 5);
+		g2d.fillOval(2 * width / 3 - 2, width / 2 - 2, 5, 5);
+		g2d.setColor(STRIP_COLOR.darker());
+		g2d.drawOval(width / 3 - 2, width / 2 - 2, 5, 5);
+		g2d.drawOval(2 * width / 3 - 2, width / 2 - 2, 5, 5);
+	}
+}