move to new project directory names

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/DIYLCStarter.java

@@ -0,0 +1,76 @@
+package org.diylc;
+
+import java.io.FileInputStream;
+import java.net.URL;
+import java.util.Properties;
+
+import javax.swing.UIManager;
+
+import org.apache.log4j.Logger;
+import org.apache.log4j.PropertyConfigurator;
+import org.diylc.presenter.Presenter;
+import org.diylc.swing.gui.MainFrame;
+import org.diylc.swing.gui.TemplateDialog;
+
+import com.diyfever.gui.miscutils.ConfigurationManager;
+import com.diyfever.gui.miscutils.PropertyInjector;
+
+/**
+ * Main class that runs DIYLC.
+ * 
+ * @author Branislav Stojkovic
+ * 
+ * @see Presenter
+ * @see MainFrame
+ */
+public class DIYLCStarter {
+
+	private static final Logger LOG = Logger.getLogger(Presenter.class);
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		URL url = DIYLCStarter.class.getResource("log4j.properties");
+		Properties properties = new Properties();
+		try {
+			properties.load(url.openStream());
+			PropertyConfigurator.configure(properties);
+		} catch (Exception e) {
+			LOG.error("Could not initialize log4j configuration", e);
+		}
+		
+		LOG.debug("Java version: " + System.getProperty("java.runtime.version") + " by " + System.getProperty("java.vm.vendor"));
+
+		LOG.info("Starting DIYLC with working directory " + System.getProperty("user.dir"));
+
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		} catch (Exception e) {
+			LOG.error("Could not set Look&Feel", e);
+		}
+
+		MainFrame mainFrame = new MainFrame();
+		mainFrame.setLocationRelativeTo(null);
+		mainFrame.setVisible(true);
+
+		boolean showTemplates = ConfigurationManager.getInstance().readBoolean(
+				TemplateDialog.SHOW_TEMPLATES_KEY, true);
+		if (showTemplates) {
+			TemplateDialog templateDialog = new TemplateDialog(mainFrame, mainFrame.getPresenter());
+			if (!templateDialog.getFiles().isEmpty()) {
+				templateDialog.setVisible(true);
+			}
+		}
+
+		url = DIYLCStarter.class.getResource("/config.properties");
+		properties = new Properties();
+		try {
+			LOG.info("Injecting default properties.");
+			properties.load(new FileInputStream("config.properties"));
+			PropertyInjector.injectProperties(properties);
+		} catch (Exception e) {
+			LOG.error("Could not read config.properties file", e);
+		}
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/images/IconLoader.java

@@ -0,0 +1,61 @@
+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;
+
+/**
+ * Loads image resources as Icons.
+ * 
+ * @author Branislav Stojkovic
+ */
+public enum IconLoader {
+
+	Delete("delete.png"), Add("add.png"), FolderOut("folder_out.png"), Garbage("garbage.png"), DiskBlue(
+			"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"), 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"), 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");
+
+	protected String name;
+
+	private IconLoader(String name) {
+		this.name = name;
+	}
+
+	public Icon getIcon() {
+		java.net.URL imgURL = getClass().getResource(name);
+		if (imgURL != null) {
+			return new ImageIcon(imgURL, name);
+		} else {
+			System.err.println("Couldn't find file: " + name);
+			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;
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/log4j.properties

@@ -0,0 +1,9 @@
+log4j.rootLogger = DEBUG, fileout, stdout
+log4j.appender.fileout = com.diyfever.gui.miscutils.NewLogForEachRunFileAppender
+log4j.appender.fileout.layout.ConversionPattern = %d{ABSOLUTE} %5p [%t] %c{1} - %m%n
+log4j.appender.fileout.layout = org.apache.log4j.PatternLayout
+log4j.appender.fileout.File = log/log.log
+
+log4j.appender.stdout = org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout.ConversionPattern = %d{ABSOLUTE} %5p [%t] %c{1} - %m%n
+log4j.appender.stdout.layout = org.apache.log4j.PatternLayout

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/ActionFactory.java

@@ -0,0 +1,870 @@
+package org.diylc.swing;
+
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.ClipboardOwner;
+import java.awt.event.ActionEvent;
+import java.awt.event.KeyEvent;
+import java.awt.print.PrinterException;
+import java.io.File;
+import java.util.List;
+
+import javax.swing.AbstractAction;
+import javax.swing.KeyStroke;
+
+import org.apache.log4j.Logger;
+import org.diylc.common.IPlugInPort;
+import org.diylc.common.ITask;
+import org.diylc.common.PropertyWrapper;
+import org.diylc.core.IDIYComponent;
+import org.diylc.core.IView;
+import org.diylc.core.Theme;
+import org.diylc.images.IconLoader;
+import org.diylc.swing.gui.DialogFactory;
+import org.diylc.swing.gui.editor.PropertyEditorDialog;
+import org.diylc.swing.plugins.edit.ComponentTransferable;
+import org.diylc.swing.plugins.file.BomDialog;
+import org.diylc.swing.plugins.file.BomEntry;
+import org.diylc.swing.plugins.file.BomMaker;
+import org.diylc.swing.plugins.file.FileFilterEnum;
+
+import com.diyfever.gui.ButtonDialog;
+import com.diyfever.gui.IDrawingProvider;
+import com.diyfever.gui.export.DrawingExporter;
+import com.diyfever.gui.miscutils.ConfigurationManager;
+import com.rits.cloning.Cloner;
+
+public class ActionFactory {
+
+	private static final Logger LOG = Logger.getLogger(ActionFactory.class);
+
+	private static ActionFactory instance;
+	private static Cloner cloner = new Cloner();
+
+	public static ActionFactory getInstance() {
+		if (instance == null) {
+			instance = new ActionFactory();
+		}
+		return instance;
+	}
+
+	private ActionFactory() {
+	}
+
+	// File menu actions.
+
+	public NewAction createNewAction(IPlugInPort plugInPort) {
+		return new NewAction(plugInPort);
+	}
+
+	public OpenAction createOpenAction(IPlugInPort plugInPort, ISwingUI swingUI) {
+		return new OpenAction(plugInPort, swingUI);
+	}
+
+	public SaveAction createSaveAction(IPlugInPort plugInPort, ISwingUI swingUI) {
+		return new SaveAction(plugInPort, swingUI);
+	}
+
+	public SaveAsAction createSaveAsAction(IPlugInPort plugInPort, ISwingUI swingUI) {
+		return new SaveAsAction(plugInPort, swingUI);
+	}
+
+	public CreateBomAction createBomAction(IPlugInPort plugInPort) {
+		return new CreateBomAction(plugInPort);
+	}
+
+	public ExportPDFAction createExportPDFAction(IDrawingProvider drawingProvider, ISwingUI swingUI) {
+		return new ExportPDFAction(drawingProvider, swingUI);
+	}
+
+	public ExportPNGAction createExportPNGAction(IDrawingProvider drawingProvider, ISwingUI swingUI) {
+		return new ExportPNGAction(drawingProvider, swingUI);
+	}
+
+	public PrintAction createPrintAction(IDrawingProvider drawingProvider) {
+		return new PrintAction(drawingProvider);
+	}
+
+	public ExitAction createExitAction(IPlugInPort plugInPort) {
+		return new ExitAction(plugInPort);
+	}
+
+	// Edit menu actions.
+
+	public CutAction createCutAction(IPlugInPort plugInPort, Clipboard clipboard,
+			ClipboardOwner clipboardOwner) {
+		return new CutAction(plugInPort, clipboard, clipboardOwner);
+	}
+
+	public CopyAction createCopyAction(IPlugInPort plugInPort, Clipboard clipboard,
+			ClipboardOwner clipboardOwner) {
+		return new CopyAction(plugInPort, clipboard, clipboardOwner);
+	}
+
+	public PasteAction createPasteAction(IPlugInPort plugInPort, Clipboard clipboard) {
+		return new PasteAction(plugInPort, clipboard);
+	}
+
+	public SelectAllAction createSelectAllAction(IPlugInPort plugInPort) {
+		return new SelectAllAction(plugInPort);
+	}
+
+	public GroupAction createGroupAction(IPlugInPort plugInPort) {
+		return new GroupAction(plugInPort);
+	}
+
+	public UngroupAction createUngroupAction(IPlugInPort plugInPort) {
+		return new UngroupAction(plugInPort);
+	}
+
+	public EditProjectAction createEditProjectAction(IPlugInPort plugInPort) {
+		return new EditProjectAction(plugInPort);
+	}
+
+	public EditSelectionAction createEditSelectionAction(IPlugInPort plugInPort) {
+		return new EditSelectionAction(plugInPort);
+	}
+
+	public DeleteSelectionAction createDeleteSelectionAction(IPlugInPort plugInPort) {
+		return new DeleteSelectionAction(plugInPort);
+	}
+
+	public SendToBackAction createSendToBackAction(IPlugInPort plugInPort) {
+		return new SendToBackAction(plugInPort);
+	}
+
+	public BringToFrontAction createBringToFrontAction(IPlugInPort plugInPort) {
+		return new BringToFrontAction(plugInPort);
+	}
+
+	// Config actions.
+
+	public ConfigAction createConfigAction(IPlugInPort plugInPort, String title, String configKey,
+			boolean defaultValue) {
+		return new ConfigAction(plugInPort, title, configKey, defaultValue);
+	}
+	
+	public ThemeAction createThemeAction(IPlugInPort plugInPort, Theme theme) {
+		return new ThemeAction(plugInPort, theme);
+	}
+	
+	public RenumberAction createRenumberAction(IPlugInPort plugInPort, boolean xAxisFirst) {
+		return new RenumberAction(plugInPort, xAxisFirst);
+	}
+
+	// File menu actions.
+
+	public static class NewAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public NewAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "New");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_N,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.DocumentPlainYellow.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("NewAction triggered");
+			if (!plugInPort.allowFileAction()) {
+				return;
+			}
+			plugInPort.createNewProject();
+			List<PropertyWrapper> properties = plugInPort.getProjectProperties();
+			PropertyEditorDialog editor = DialogFactory.getInstance().createPropertyEditorDialog(
+					properties, "Edit Project");
+			editor.setVisible(true);
+			if (ButtonDialog.OK.equals(editor.getSelectedButtonCaption())) {
+				plugInPort.applyPropertiesToProject(properties);
+			}
+			// Save default values.
+			for (PropertyWrapper property : editor.getDefaultedProperties()) {
+				if (property.getValue() != null) {
+					plugInPort.setProjectDefaultPropertyValue(property.getName(), property
+							.getValue());
+				}
+			}
+		}
+	}
+
+	public static class OpenAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private ISwingUI swingUI;
+
+		public OpenAction(IPlugInPort plugInPort, ISwingUI swingUI) {
+			super();
+			this.plugInPort = plugInPort;
+			this.swingUI = swingUI;
+			putValue(AbstractAction.NAME, "Open");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_O,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.FolderOut.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("OpenAction triggered");
+			if (!plugInPort.allowFileAction()) {
+				return;
+			}
+			final File file = DialogFactory.getInstance().showOpenDialog(
+					FileFilterEnum.DIY.getFilter(), null, FileFilterEnum.DIY.getExtensions()[0],
+					null);
+			if (file != null) {
+				swingUI.executeBackgroundTask(new ITask<Void>() {
+
+					@Override
+					public Void doInBackground() throws Exception {
+						LOG.debug("Opening from " + file.getAbsolutePath());
+						plugInPort.loadProjectFromFile(file.getAbsolutePath());
+						return null;
+					}
+
+					@Override
+					public void complete(Void result) {
+					}
+
+					@Override
+					public void failed(Exception e) {
+						swingUI.showMessage("Could not open file. " + e.getMessage(), "Error",
+								ISwingUI.ERROR_MESSAGE);
+					}
+				});
+			}
+		}
+	}
+
+	public static class SaveAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private ISwingUI swingUI;
+
+		public SaveAction(IPlugInPort plugInPort, ISwingUI swingUI) {
+			super();
+			this.plugInPort = plugInPort;
+			this.swingUI = swingUI;
+			putValue(AbstractAction.NAME, "Save");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_S,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.DiskBlue.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("SaveAction triggered");
+			if (plugInPort.getCurrentFileName() == null) {
+				final File file = DialogFactory.getInstance().showSaveDialog(
+						FileFilterEnum.DIY.getFilter(), null,
+						FileFilterEnum.DIY.getExtensions()[0], null);
+				if (file != null) {
+					swingUI.executeBackgroundTask(new ITask<Void>() {
+
+						@Override
+						public Void doInBackground() throws Exception {
+							LOG.debug("Saving to " + file.getAbsolutePath());
+							plugInPort.saveProjectToFile(file.getAbsolutePath(), false);
+							return null;
+						}
+
+						@Override
+						public void complete(Void result) {
+						}
+
+						@Override
+						public void failed(Exception e) {
+							swingUI.showMessage("Could not save to file. " + e.getMessage(),
+									"Error", ISwingUI.ERROR_MESSAGE);
+						}
+					});
+				}
+			} else {
+				swingUI.executeBackgroundTask(new ITask<Void>() {
+
+					@Override
+					public Void doInBackground() throws Exception {
+						LOG.debug("Saving to " + plugInPort.getCurrentFileName());
+						plugInPort.saveProjectToFile(plugInPort.getCurrentFileName(), false);
+						return null;
+					}
+
+					@Override
+					public void complete(Void result) {
+					}
+
+					@Override
+					public void failed(Exception e) {
+						swingUI.showMessage("Could not save to file. " + e.getMessage(), "Error",
+								ISwingUI.ERROR_MESSAGE);
+					}
+				});
+			}
+		}
+	}
+
+	public static class SaveAsAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private ISwingUI swingUI;
+
+		public SaveAsAction(IPlugInPort plugInPort, ISwingUI swingUI) {
+			super();
+			this.plugInPort = plugInPort;
+			this.swingUI = swingUI;
+			putValue(AbstractAction.NAME, "Save As");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_S,
+					ActionEvent.CTRL_MASK | ActionEvent.SHIFT_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.DiskBlue.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("SaveAsAction triggered");
+			final File file = DialogFactory.getInstance().showSaveDialog(
+					FileFilterEnum.DIY.getFilter(), null, FileFilterEnum.DIY.getExtensions()[0],
+					null);
+			if (file != null) {
+				swingUI.executeBackgroundTask(new ITask<Void>() {
+
+					@Override
+					public Void doInBackground() throws Exception {
+						LOG.debug("Saving to " + file.getAbsolutePath());
+						plugInPort.saveProjectToFile(file.getAbsolutePath(), false);
+						return null;
+					}
+
+					@Override
+					public void complete(Void result) {
+					}
+
+					@Override
+					public void failed(Exception e) {
+						swingUI.showMessage("Could not save to file. " + e.getMessage(), "Error",
+								ISwingUI.ERROR_MESSAGE);
+					}
+				});
+			}
+		}
+	}
+
+	public static class CreateBomAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public CreateBomAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Create B.O.M.");
+			putValue(AbstractAction.SMALL_ICON, IconLoader.BOM.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("CreateBomAction triggered");
+			List<BomEntry> bom = BomMaker.getInstance().createBom(
+					plugInPort.getCurrentProject().getComponents());
+			BomDialog dialog = DialogFactory.getInstance().createBomDialog(bom);
+			dialog.setVisible(true);
+		}
+	}
+
+	public static class ExportPDFAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IDrawingProvider drawingProvider;
+		private ISwingUI swingUI;
+
+		public ExportPDFAction(IDrawingProvider drawingProvider, ISwingUI swingUI) {
+			super();
+			this.drawingProvider = drawingProvider;
+			this.swingUI = swingUI;
+			putValue(AbstractAction.NAME, "Export to PDF");
+			putValue(AbstractAction.SMALL_ICON, IconLoader.PDF.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("ExportPDFAction triggered");
+			final File file = DialogFactory.getInstance().showSaveDialog(
+					FileFilterEnum.PDF.getFilter(), null, FileFilterEnum.PDF.getExtensions()[0],
+					null);
+			if (file != null) {
+				swingUI.executeBackgroundTask(new ITask<Void>() {
+
+					@Override
+					public Void doInBackground() throws Exception {
+						LOG.debug("Exporting to " + file.getAbsolutePath());
+						DrawingExporter.getInstance().exportPDF(
+								ExportPDFAction.this.drawingProvider, file);
+						return null;
+					}
+
+					@Override
+					public void complete(Void result) {
+					}
+
+					@Override
+					public void failed(Exception e) {
+						swingUI.showMessage("Could not export to PDF. " + e.getMessage(), "Error",
+								ISwingUI.ERROR_MESSAGE);
+					}
+				});
+			}
+		}
+	}
+
+	public static class ExportPNGAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IDrawingProvider drawingProvider;
+		private ISwingUI swingUI;
+
+		public ExportPNGAction(IDrawingProvider drawingProvider, ISwingUI swingUI) {
+			super();
+			this.drawingProvider = drawingProvider;
+			this.swingUI = swingUI;
+			putValue(AbstractAction.NAME, "Export to PNG");
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Image.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("ExportPNGAction triggered");
+			final File file = DialogFactory.getInstance().showSaveDialog(
+					FileFilterEnum.PNG.getFilter(), null, FileFilterEnum.PNG.getExtensions()[0],
+					null);
+			if (file != null) {
+				swingUI.executeBackgroundTask(new ITask<Void>() {
+
+					@Override
+					public Void doInBackground() throws Exception {
+						LOG.debug("Exporting to " + file.getAbsolutePath());
+						DrawingExporter.getInstance().exportPNG(
+								ExportPNGAction.this.drawingProvider, file);
+						return null;
+					}
+
+					@Override
+					public void complete(Void result) {
+					}
+
+					@Override
+					public void failed(Exception e) {
+						swingUI.showMessage("Could not export to PNG. " + e.getMessage(), "Error",
+								ISwingUI.ERROR_MESSAGE);
+					}
+				});
+			}
+		}
+	}
+
+	public static class PrintAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IDrawingProvider drawingProvider;
+
+		public PrintAction(IDrawingProvider drawingProvider) {
+			super();
+			this.drawingProvider = drawingProvider;
+			putValue(AbstractAction.NAME, "Print...");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_P,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Print.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("ExportPNGAction triggered");
+			try {
+				DrawingExporter.getInstance().print(this.drawingProvider);
+			} catch (PrinterException e1) {
+				// TODO Auto-generated catch block
+				e1.printStackTrace();
+			}
+		}
+	}
+
+	public static class ExitAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public ExitAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Exit");
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Exit.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			if (plugInPort.allowFileAction()) {
+				System.exit(0);
+			}
+		}
+	}
+
+	// Edit menu actions.
+
+	public static class CutAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private Clipboard clipboard;
+		private ClipboardOwner clipboardOwner;
+
+		public CutAction(IPlugInPort plugInPort, Clipboard clipboard, ClipboardOwner clipboardOwner) {
+			super();
+			this.plugInPort = plugInPort;
+			this.clipboard = clipboard;
+			this.clipboardOwner = clipboardOwner;
+			putValue(AbstractAction.NAME, "Cut");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_X,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Cut.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Cut triggered");
+			clipboard.setContents(new ComponentTransferable(cloner.deepClone(plugInPort
+					.getSelectedComponents())), clipboardOwner);
+			plugInPort.deleteSelectedComponents();
+		}
+	}
+
+	public static class CopyAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private Clipboard clipboard;
+		private ClipboardOwner clipboardOwner;
+
+		public CopyAction(IPlugInPort plugInPort, Clipboard clipboard, ClipboardOwner clipboardOwner) {
+			super();
+			this.plugInPort = plugInPort;
+			this.clipboard = clipboard;
+			this.clipboardOwner = clipboardOwner;
+			putValue(AbstractAction.NAME, "Copy");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_C,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Copy.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Copy triggered");
+			clipboard.setContents(new ComponentTransferable(cloner.deepClone(plugInPort
+					.getSelectedComponents())), clipboardOwner);
+		}
+	}
+
+	public static class PasteAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private Clipboard clipboard;
+
+		public PasteAction(IPlugInPort plugInPort, Clipboard clipboard) {
+			super();
+			this.plugInPort = plugInPort;
+			this.clipboard = clipboard;
+			putValue(AbstractAction.NAME, "Paste");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_V,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Paste.getIcon());
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Paste triggered");
+			try {
+				List<IDIYComponent<?>> components = (List<IDIYComponent<?>>) clipboard
+						.getData(ComponentTransferable.listFlavor);
+				plugInPort.pasteComponents(cloner.deepClone(components));
+			} catch (Exception ex) {
+				LOG.error("Coule not paste.", ex);
+			}
+		}
+	}
+
+	public static class SelectAllAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public SelectAllAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Select All");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_A,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Selection.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Select All triggered");
+			plugInPort.selectAll();
+		}
+	}
+
+	public static class GroupAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public GroupAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Group Selection");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_G,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Group.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Group Selection triggered");
+			plugInPort.groupSelectedComponents();
+		}
+	}
+
+	public static class UngroupAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public UngroupAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Ungroup Selection");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_U,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Ungroup.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Ungroup Selection triggered");
+			plugInPort.ungroupSelectedComponents();
+		}
+	}
+
+	public static class EditProjectAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public EditProjectAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Edit Project");
+			putValue(AbstractAction.SMALL_ICON, IconLoader.DocumentEdit.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Edit Project triggered");
+			List<PropertyWrapper> properties = plugInPort.getProjectProperties();
+			PropertyEditorDialog editor = DialogFactory.getInstance().createPropertyEditorDialog(
+					properties, "Edit Project");
+			editor.setVisible(true);
+			if (ButtonDialog.OK.equals(editor.getSelectedButtonCaption())) {
+				plugInPort.applyPropertiesToProject(properties);
+			}
+			// Save default values.
+			for (PropertyWrapper property : editor.getDefaultedProperties()) {
+				if (property.getValue() != null) {
+					plugInPort.setProjectDefaultPropertyValue(property.getName(), property
+							.getValue());
+				}
+			}
+		}
+	}
+
+	public static class EditSelectionAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public EditSelectionAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Edit Selection");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_E,
+					ActionEvent.CTRL_MASK));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.EditComponent.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Edit Selection triggered");
+			List<PropertyWrapper> properties = plugInPort.getMutualSelectionProperties();
+			if (properties == null || properties.isEmpty()) {
+				LOG.info("Nothing to edit");
+				return;
+			}
+			plugInPort.editSelection();
+		}
+	}
+
+	public static class DeleteSelectionAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public DeleteSelectionAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Delete Selection");
+			putValue(AbstractAction.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0));
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Delete.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Delete Selection triggered");
+			plugInPort.deleteSelectedComponents();
+		}
+	}
+
+	public static class SendToBackAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public SendToBackAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Send Backward");
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Back.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Send to Back triggered");
+			plugInPort.sendSelectionToBack();
+		}
+	}
+
+	public static class BringToFrontAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+
+		public BringToFrontAction(IPlugInPort plugInPort) {
+			super();
+			this.plugInPort = plugInPort;
+			putValue(AbstractAction.NAME, "Bring Forward");
+			putValue(AbstractAction.SMALL_ICON, IconLoader.Front.getIcon());
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info("Bring to Front triggered");
+			plugInPort.bringSelectionToFront();
+		}
+	}
+
+	public static class ConfigAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private String configKey;
+
+		public ConfigAction(IPlugInPort plugInPort, String title, String configKey,
+				boolean defaultValue) {
+			super();
+			this.plugInPort = plugInPort;
+			this.configKey = configKey;
+			putValue(AbstractAction.NAME, title);
+			putValue(IView.CHECK_BOX_MENU_ITEM, true);
+			putValue(AbstractAction.SELECTED_KEY, ConfigurationManager.getInstance().readBoolean(
+					configKey, defaultValue));
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info(getValue(AbstractAction.NAME) + " triggered");
+			ConfigurationManager.getInstance().writeValue(configKey,
+					getValue(AbstractAction.SELECTED_KEY));
+			plugInPort.refresh();
+		}
+	}
+
+	public static class ThemeAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private Theme theme;
+
+		public ThemeAction(IPlugInPort plugInPort, Theme theme) {
+			super();
+			this.plugInPort = plugInPort;
+			this.theme = theme;
+			putValue(AbstractAction.NAME, theme.getName());
+			putValue(IView.RADIO_BUTTON_GROUP_KEY, "theme");
+			putValue(AbstractAction.SELECTED_KEY, plugInPort.getSelectedTheme().getName().equals(
+					theme.getName()));
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info(getValue(AbstractAction.NAME) + " triggered");
+			plugInPort.setSelectedTheme(theme);
+		}
+	}
+	
+	public static class RenumberAction extends AbstractAction {
+
+		private static final long serialVersionUID = 1L;
+
+		private IPlugInPort plugInPort;
+		private boolean xAxisFirst;
+
+		public RenumberAction(IPlugInPort plugInPort, boolean xAxisFirst) {
+			super();
+			this.plugInPort = plugInPort;
+			this.xAxisFirst = xAxisFirst;
+			putValue(AbstractAction.NAME, xAxisFirst ? "X Axis First" : "Y Axis First");
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			LOG.info(getValue(AbstractAction.NAME) + " triggered");
+			plugInPort.renumberSelectedComponents(xAxisFirst);
+		}
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/ISwingUI.java

@@ -0,0 +1,64 @@
+package org.diylc.swing;
+
+import javax.swing.Action;
+import javax.swing.Icon;
+import javax.swing.JComponent;
+import javax.swing.SwingConstants;
+import javax.swing.JPopupMenu.Separator;
+
+import org.diylc.common.BadPositionException;
+import org.diylc.common.ITask;
+import org.diylc.core.IView;
+
+/**
+ * Interface for plugin access to the swing front end.
+ * 
+ * @author Branislav Stojkovic
+ */
+public interface ISwingUI extends IView {
+
+	/**
+	 * Injects a custom GUI panels provided by the plug-in and desired position
+	 * in the window. Application will layout plug-in panels accordingly. <br>
+	 * Valid positions are:
+	 * <ul>
+	 * <li> {@link SwingConstants#TOP}</li>
+	 * <li> {@link SwingConstants#BOTTOM}</li>
+	 * <li> {@link SwingConstants#LEFT}</li>
+	 * <li> {@link SwingConstants#RIGHT}</li>
+	 * </ul>
+	 * 
+	 * Center position is reserved for the main canvas panel and cannot be used.
+	 * 
+	 * @param component
+	 * @param position
+	 * @throws BadPositionException
+	 *             in case invalid position is specified
+	 */
+	void injectGUIComponent(JComponent component, int position) throws BadPositionException;
+
+	/**
+	 * Injects a custom menu action into application's main menu. If
+	 * <code>action</code> is set to null {@link Separator} will be added. If
+	 * the specified menu does not exist it will be automatically created.
+	 * 
+	 * @param action
+	 *            {@link Action} to inser
+	 * @param menuName
+	 *            name of the menu to insert into
+	 */
+	void injectMenuAction(Action action, String menuName);
+
+	/**
+	 * Injects a custom submenu into application's main menu. If
+	 * <code>action</code> is set to null {@link Separator} will be added. If
+	 * the specified menu does not exist it will be automatically created.
+	 * 
+	 * @param name
+	 * @param icon
+	 * @param parentMenuName
+	 */
+	void injectSubmenu(String name, Icon icon, String parentMenuName);
+	
+	<T extends Object> void executeBackgroundTask(ITask<T> task);
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/CustomGlassPane.java

@@ -0,0 +1,42 @@
+package org.diylc.swing.gui;
+
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionAdapter;
+
+import javax.swing.Icon;
+import javax.swing.JComponent;
+
+public class CustomGlassPane extends JComponent {
+
+	private static final long serialVersionUID = 1L;
+	private Icon icon;
+
+	public CustomGlassPane() {
+		super();
+		addMouseMotionListener(new MouseMotionAdapter() {
+
+			@Override
+			public void mouseMoved(MouseEvent e) {
+				if (icon != null) {
+					repaint();
+				}
+			}
+		});
+	}
+
+	public void setCursorIcon(Icon icon) {
+		this.icon = icon;
+	}
+
+	@Override
+	public void paint(Graphics g) {
+		Point cursor = getMousePosition();
+		if ((icon != null) && (cursor != null)) {
+			Graphics2D g2d = (Graphics2D) g;
+			icon.paintIcon(this, g2d, cursor.x + 10, cursor.y + 10);
+		}
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/DialogFactory.java

@@ -0,0 +1,155 @@
+package org.diylc.swing.gui;
+
+import java.io.File;
+import java.util.List;
+
+import javax.swing.Icon;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.filechooser.FileFilter;
+
+import org.diylc.common.PropertyWrapper;
+import org.diylc.swing.gui.components.OverwritePromptFileChooser;
+import org.diylc.swing.gui.editor.PropertyEditorDialog;
+import org.diylc.swing.plugins.file.BomDialog;
+import org.diylc.swing.plugins.file.BomEntry;
+import org.diylc.swing.plugins.online.view.LoginDialog;
+import org.diylc.swing.plugins.online.view.NewUserDialog;
+import org.diylc.swing.plugins.online.view.UploadDialog;
+
+import com.diyfever.gui.AboutDialog;
+import com.diyfever.gui.IFileChooserAccessory;
+import com.diyfever.gui.ProgressDialog;
+import com.diyfever.gui.miscutils.ConfigurationManager;
+
+public class DialogFactory {
+
+	private static DialogFactory instance;
+
+	private static final String PATH_KEY = "lastPath";
+
+	public static DialogFactory getInstance() {
+		if (instance == null) {
+			instance = new DialogFactory();
+		}
+		return instance;
+	}
+
+	private JFrame mainFrame;
+	private File lastDirectory;
+
+	private DialogFactory() {
+	}
+
+	/**
+	 * Sets the frame to be used as dialog parent. This should be called prior
+	 * to any other methods in this class.
+	 * 
+	 * @param mainFrame
+	 */
+	public void initialize(JFrame mainFrame) {
+		this.mainFrame = mainFrame;
+		String lastDirectoryPath = (String) ConfigurationManager.getInstance()
+				.readString(PATH_KEY, null);
+		if (lastDirectoryPath != null) {
+			lastDirectory = new File(lastDirectoryPath);
+		}
+	}
+
+	public PropertyEditorDialog createPropertyEditorDialog(List<PropertyWrapper> properties,
+			String title) {
+		PropertyEditorDialog editor = new PropertyEditorDialog(mainFrame, properties, title);
+		return editor;
+	}
+
+	public BomDialog createBomDialog(List<BomEntry> bom) {
+		BomDialog dialog = new BomDialog(mainFrame, bom);
+		return dialog;
+	}
+
+	public File showOpenDialog(FileFilter fileFilter, File initialFile, String defaultExtension,
+			IFileChooserAccessory accessory) {
+		JFileChooser openFileChooser = new JFileChooser();
+		initializeFileChooser(openFileChooser, fileFilter, initialFile, defaultExtension, accessory);
+
+		int result = openFileChooser.showOpenDialog(mainFrame);
+
+		return processFileChooserResult(result, openFileChooser, defaultExtension);
+	}
+
+	public File showSaveDialog(FileFilter fileFilter, File initialFile, String defaultExtension,
+			IFileChooserAccessory accessory) {
+		JFileChooser saveFileChooser = new OverwritePromptFileChooser();
+		initializeFileChooser(saveFileChooser, fileFilter, initialFile, defaultExtension, accessory);
+
+		int result = saveFileChooser.showSaveDialog(mainFrame);
+
+		return processFileChooserResult(result, saveFileChooser, defaultExtension);
+	}
+
+	private void initializeFileChooser(JFileChooser fileChooser, FileFilter fileFilter,
+			File initialFile, String defaultExtension, IFileChooserAccessory accessory) {
+		if (accessory != null) {
+			accessory.install(fileChooser);
+		}
+		for (FileFilter filter : fileChooser.getChoosableFileFilters()) {
+			fileChooser.removeChoosableFileFilter(filter);
+		}
+		if (fileChooser instanceof OverwritePromptFileChooser) {
+			((OverwritePromptFileChooser) fileChooser).setFileFilter(fileFilter, defaultExtension);
+		} else {
+			fileChooser.setFileFilter(fileFilter);
+		}
+		if (lastDirectory != null) {
+			fileChooser.setCurrentDirectory(lastDirectory);
+		}
+		fileChooser.setSelectedFile(initialFile);
+	}
+
+	private File processFileChooserResult(int result, JFileChooser fileChooser,
+			String defaultExtension) {
+		fileChooser.setAccessory(null);
+		if (result == JFileChooser.APPROVE_OPTION) {
+			lastDirectory = fileChooser.getCurrentDirectory();
+			ConfigurationManager.getInstance().writeValue(PATH_KEY,
+					lastDirectory.getAbsolutePath());
+			if (fileChooser.getSelectedFile().getAbsolutePath().contains(".")) {
+				return fileChooser.getSelectedFile();
+			} else {
+				return new File(fileChooser.getSelectedFile().getAbsoluteFile() + "."
+						+ defaultExtension);
+			}
+		} else {
+			return null;
+		}
+	}
+
+	public AboutDialog createAboutDialog(String appName, Icon icon, String version, String author,
+			String url, String mail, String htmlContent) {
+		AboutDialog dialog = new AboutDialog(mainFrame, appName, icon, version, author, url, mail,
+				htmlContent);
+		return dialog;
+	}
+
+	public NewUserDialog createNewUserDialog() {
+		NewUserDialog dialog = new NewUserDialog(mainFrame);
+		return dialog;
+	}
+
+	public LoginDialog createLoginDialog() {
+		LoginDialog dialog = new LoginDialog(mainFrame);
+		return dialog;
+	}
+
+	public UploadDialog createUploadDialog() {
+		UploadDialog dialog = new UploadDialog(mainFrame);
+		return dialog;
+	}
+
+	public ProgressDialog createProgressDialog(String title, String[] buttonCaptions,
+			String description, boolean useProgress) {
+		ProgressDialog dialog = new ProgressDialog(mainFrame, title, buttonCaptions, description,
+				useProgress);
+		return dialog;
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/MainFrame.java

@@ -0,0 +1,370 @@
+package org.diylc.swing.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.swing.Action;
+import javax.swing.BoxLayout;
+import javax.swing.ButtonGroup;
+import javax.swing.Icon;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JRadioButtonMenuItem;
+import javax.swing.SwingConstants;
+import javax.swing.SwingWorker;
+import javax.swing.Timer;
+
+import org.apache.log4j.Logger;
+import org.diylc.common.BadPositionException;
+import org.diylc.common.EventType;
+import org.diylc.common.IPlugIn;
+import org.diylc.common.IPlugInPort;
+import org.diylc.common.ITask;
+import org.diylc.common.PropertyWrapper;
+import org.diylc.core.IView;
+import org.diylc.images.IconLoader;
+import org.diylc.presenter.Presenter;
+import org.diylc.swing.ISwingUI;
+import org.diylc.swing.gui.editor.PropertyEditorDialog;
+import org.diylc.swing.plugins.autosave.AutoSavePlugin;
+import org.diylc.swing.plugins.canvas.CanvasPlugin;
+import org.diylc.swing.plugins.config.ConfigPlugin;
+import org.diylc.swing.plugins.edit.EditMenuPlugin;
+import org.diylc.swing.plugins.file.FileMenuPlugin;
+import org.diylc.swing.plugins.help.HelpMenuPlugin;
+import org.diylc.swing.plugins.layers.LayersMenuPlugin;
+import org.diylc.swing.plugins.statusbar.StatusBar;
+import org.diylc.swing.plugins.toolbox.ToolBox;
+
+import com.diyfever.gui.ButtonDialog;
+import com.diyfever.gui.miscutils.ConfigurationManager;
+
+public class MainFrame extends JFrame implements ISwingUI {
+
+	private static final Logger LOG = Logger.getLogger(MainFrame.class);
+
+	private static final long serialVersionUID = 1L;
+
+	private JPanel centerPanel;
+	private JPanel leftPanel;
+	private JPanel rightPanel;
+	private JPanel topPanel;
+	private JPanel bottomPanel;
+
+	private Presenter presenter;
+
+	private JMenuBar mainMenuBar;
+	private Map<String, JMenu> menuMap;
+	private Map<String, ButtonGroup> buttonGroupMap;
+
+	private CanvasPlugin canvasPlugin;
+
+	public MainFrame() {
+		super("DIYLC 3");
+		setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+		setPreferredSize(new Dimension(800, 600));
+		createBasePanels();
+		menuMap = new HashMap<String, JMenu>();
+		buttonGroupMap = new HashMap<String, ButtonGroup>();
+		setIconImages(Arrays.asList(IconLoader.IconSmall.getImage(), IconLoader.IconMedium
+				.getImage(), IconLoader.IconLarge.getImage()));
+		DialogFactory.getInstance().initialize(this);
+
+		this.presenter = new Presenter(this);
+
+		presenter.installPlugin(new ToolBox(this));
+		presenter.installPlugin(new FileMenuPlugin(this));
+		presenter.installPlugin(new EditMenuPlugin(this));
+		presenter.installPlugin(new ConfigPlugin(this));
+		presenter.installPlugin(new LayersMenuPlugin(this));
+		// presenter.installPlugin(new OnlineManager());
+		presenter.installPlugin(new HelpMenuPlugin(this));
+
+		presenter.installPlugin(new StatusBar(this));
+		canvasPlugin = new CanvasPlugin(this);
+		presenter.installPlugin(canvasPlugin);
+		presenter.installPlugin(new FramePlugin());
+
+		try {
+			File testFile = new File("test.tmp");
+			Writer out = new OutputStreamWriter(new FileOutputStream(testFile));
+			out.write("This is a test");
+			out.close();
+			testFile.delete();
+			presenter.installPlugin(new AutoSavePlugin(this));
+		} catch (Exception e) {
+			showMessage(
+					"The current user does not have permissions to access folder "
+							+ new File(".").getAbsolutePath()
+							+ ".\nAuto-save feature will not be available, contact your system administrator.",
+					"Warning", IView.WARNING_MESSAGE);
+		}
+
+		presenter.createNewProject();
+
+		addWindowListener(new WindowAdapter() {
+
+			@Override
+			public void windowClosed(WindowEvent e) {
+				if (presenter.allowFileAction()) {
+					ConfigurationManager.getInstance().writeValue(IPlugInPort.ABNORMAL_EXIT_KEY,
+							false);
+					dispose();
+					presenter.dispose();
+					System.exit(0);
+				}
+			}
+
+			@Override
+			public void windowClosing(WindowEvent e) {
+				if (presenter.allowFileAction()) {
+					ConfigurationManager.getInstance().writeValue(IPlugInPort.ABNORMAL_EXIT_KEY,
+							false);
+					dispose();
+					presenter.dispose();
+					System.exit(0);
+				}
+			}
+		});
+
+		// setGlassPane(new CustomGlassPane());
+		// getGlassPane().setVisible(true);
+	}
+
+	public Presenter getPresenter() {
+		return presenter;
+	}
+
+	@Override
+	public void setVisible(boolean b) {
+		super.setVisible(b);
+		// TODO: hack to prevent painting issues in the scroll bar rulers. Find
+		// a better fix if possible.
+		Timer timer = new Timer(500, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				canvasPlugin.refresh();
+			}
+
+		});
+		timer.setRepeats(false);
+		timer.start();
+		// if (b) {
+		// SwingUtilities.invokeLater(new Runnable() {
+		// @Override
+		// public void run() {
+		//					
+		// }
+		// });
+		// }
+	}
+
+	private void createBasePanels() {
+		Container c = new Container();
+		c.setLayout(new BorderLayout());
+
+		centerPanel = new JPanel(new BorderLayout());
+		c.add(centerPanel, BorderLayout.CENTER);
+
+		topPanel = new JPanel();
+		topPanel.setLayout(new BoxLayout(topPanel, BoxLayout.Y_AXIS));
+		c.add(topPanel, BorderLayout.NORTH);
+
+		leftPanel = new JPanel();
+		leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.X_AXIS));
+		c.add(leftPanel, BorderLayout.WEST);
+
+		bottomPanel = new JPanel();
+		bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.Y_AXIS));
+		c.add(bottomPanel, BorderLayout.SOUTH);
+
+		rightPanel = new JPanel();
+		rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.X_AXIS));
+		c.add(rightPanel, BorderLayout.EAST);
+
+		setContentPane(c);
+	}
+
+	private JMenuBar getMainMenuBar() {
+		if (mainMenuBar == null) {
+			mainMenuBar = new JMenuBar();
+			setJMenuBar(mainMenuBar);
+		}
+		return mainMenuBar;
+	}
+
+	// IView
+
+	@Override
+	public void showMessage(String message, String title, int messageType) {
+		JOptionPane.showMessageDialog(this, message, title, messageType);
+	}
+
+	@Override
+	public int showConfirmDialog(String message, String title, int optionType, int messageType) {
+		return JOptionPane.showConfirmDialog(this, message, title, optionType, messageType);
+	}
+
+	@Override
+	public boolean editProperties(List<PropertyWrapper> properties,
+			Set<PropertyWrapper> defaultedProperties) {
+		PropertyEditorDialog editor = DialogFactory.getInstance().createPropertyEditorDialog(
+				properties, "Edit Selection");
+		editor.setVisible(true);
+		defaultedProperties.addAll(editor.getDefaultedProperties());
+		return ButtonDialog.OK.equals(editor.getSelectedButtonCaption());
+	}
+
+	private JMenu findOrCreateMenu(String menuName) {
+		JMenu menu;
+		if (menuMap.containsKey(menuName)) {
+			menu = menuMap.get(menuName);
+		} else {
+			menu = new JMenu(menuName);
+			menuMap.put(menuName, menu);
+			getMainMenuBar().add(menu);
+		}
+		return menu;
+	}
+
+	@Override
+	public void injectGUIComponent(JComponent component, int position) throws BadPositionException {
+		LOG.info(String.format("injectGUIComponent(%s, %s)", component.getClass().getName(),
+				position));
+		switch (position) {
+		case SwingConstants.TOP:
+			topPanel.add(component);
+			break;
+		case SwingConstants.LEFT:
+			leftPanel.add(component);
+			break;
+		case SwingConstants.BOTTOM:
+			bottomPanel.add(component);
+			break;
+		case SwingConstants.RIGHT:
+			rightPanel.add(component);
+			break;
+		case SwingConstants.CENTER:
+			centerPanel.add(component, BorderLayout.CENTER);
+			break;
+		default:
+			throw new BadPositionException();
+		}
+		pack();
+	}
+
+	@Override
+	public void injectMenuAction(Action action, String menuName) {
+		LOG.info(String.format("injectMenuAction(%s, %s)", action == null ? "Separator" : action
+				.getValue(Action.NAME), menuName));
+		JMenu menu = findOrCreateMenu(menuName);
+		if (action == null) {
+			menu.addSeparator();
+		} else {
+			Boolean isCheckBox = (Boolean) action.getValue(IView.CHECK_BOX_MENU_ITEM);
+			String groupName = (String) action.getValue(IView.RADIO_BUTTON_GROUP_KEY);
+			if (isCheckBox != null && isCheckBox) {
+				menu.add(new JCheckBoxMenuItem(action));
+			} else if (groupName != null) {
+				ButtonGroup group;
+				if (buttonGroupMap.containsKey(groupName)) {
+					group = buttonGroupMap.get(groupName);
+				} else {
+					group = new ButtonGroup();
+					buttonGroupMap.put(groupName, group);
+				}
+				JRadioButtonMenuItem item = new JRadioButtonMenuItem(action);
+				group.add(item);
+				menu.add(item);
+			} else {
+				menu.add(action);
+			}
+		}
+	}
+
+	@Override
+	public void injectSubmenu(String name, Icon icon, String parentMenuName) {
+		LOG.info(String.format("injectSubmenu(%s, icon, %s)", name, parentMenuName));
+		JMenu menu = findOrCreateMenu(parentMenuName);
+		JMenu submenu = new JMenu(name);
+		submenu.setIcon(icon);
+		menu.add(submenu);
+		menuMap.put(name, submenu);
+	}
+
+	@Override
+	public <T extends Object> void executeBackgroundTask(final ITask<T> task) {
+		setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+		SwingWorker<T, Void> worker = new SwingWorker<T, Void>() {
+
+			@Override
+			protected T doInBackground() throws Exception {
+				return task.doInBackground();
+			}
+
+			@Override
+			protected void done() {
+				try {
+					T result = get();
+					task.complete(result);
+				} catch (Exception e) {
+					LOG.error("Task failed", e);
+					task.failed(e);
+				}
+				setCursor(Cursor.getDefaultCursor());
+			}
+		};
+		worker.execute();
+	}
+
+	class FramePlugin implements IPlugIn {
+
+		private IPlugInPort plugInPort;
+
+		@Override
+		public void connect(IPlugInPort plugInPort) {
+			this.plugInPort = plugInPort;
+		}
+
+		@Override
+		public EnumSet<EventType> getSubscribedEventTypes() {
+			return EnumSet.of(EventType.FILE_STATUS_CHANGED);
+		}
+
+		@Override
+		public void processMessage(EventType eventType, Object... params) {
+			if (eventType == EventType.FILE_STATUS_CHANGED) {
+				String fileName = (String) params[0];
+				if (fileName == null) {
+					fileName = "Untitled";
+				}
+				String modified = (Boolean) params[1] ? " (modified)" : "";
+				setTitle(String.format("DIYLC %s beta - %s %s", plugInPort
+						.getCurrentVersionNumber(), fileName, modified));
+			}
+		}
+	}
+
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/TemplateDialog.java

@@ -0,0 +1,285 @@
+package org.diylc.swing.gui;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.swing.BorderFactory;
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextField;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+
+import org.apache.log4j.Logger;
+import org.diylc.common.DrawOption;
+import org.diylc.common.IPlugInPort;
+import org.diylc.common.PropertyWrapper;
+import org.diylc.core.IView;
+import org.diylc.presenter.Presenter;
+
+import com.diyfever.gui.miscutils.ConfigurationManager;
+
+public class TemplateDialog extends JDialog {
+
+	private static final long serialVersionUID = 1L;
+
+	private static final Logger LOG = Logger.getLogger(TemplateDialog.class);
+
+	private static final Dimension panelSize = new Dimension(400, 300);
+	public static final String SHOW_TEMPLATES_KEY = "showTemplatesAtStartup";
+
+	private IPlugInPort plugInPort;
+
+	private JList fileList;
+	private JPanel canvasPanel;
+	private Presenter presenter;
+	private List<File> files;
+	private JCheckBox showTemplatesBox;
+	private JPanel mainPanel;
+	private JButton loadButton;
+	private JPanel infoPanel;
+
+	public TemplateDialog(JFrame owner, IPlugInPort plugInPort) {
+		super(owner, "Templates");
+		setModal(true);
+		setResizable(false);
+		this.plugInPort = plugInPort;
+		this.presenter = new Presenter(new IView() {
+
+			@Override
+			public int showConfirmDialog(String message, String title, int optionType,
+					int messageType) {
+				return JOptionPane.showConfirmDialog(TemplateDialog.this, message, title,
+						optionType, messageType);
+			}
+
+			@Override
+			public void showMessage(String message, String title, int messageType) {
+				JOptionPane.showMessageDialog(TemplateDialog.this, message, title, messageType);
+			}
+			
+			@Override
+			public boolean editProperties(List<PropertyWrapper> properties, Set<PropertyWrapper> defaultedProperties) {
+				return false;
+			}
+		});
+		// this.presenter.installPlugin(new IPlugIn() {
+		//
+		// @Override
+		// public void connect(IPlugInPort plugInPort) {
+		// }
+		//
+		// @Override
+		// public EnumSet<EventType> getSubscribedEventTypes() {
+		// return EnumSet.of(EventType.REPAINT);
+		// }
+		//
+		// @Override
+		// public void processMessage(EventType eventType, Object... params) {
+		// if (eventType == EventType.REPAINT) {
+		// getCanvasPanel().repaint();
+		// }
+		// }
+		// });
+		setContentPane(getMainPanel());
+		pack();
+		setLocationRelativeTo(owner);
+	}
+
+	public JPanel getMainPanel() {
+		if (mainPanel == null) {
+			mainPanel = new JPanel(new GridBagLayout());
+			mainPanel.setBorder(BorderFactory.createEmptyBorder(4, 4, 4, 4));
+
+			GridBagConstraints c = new GridBagConstraints();
+			c.gridx = 0;
+			c.gridy = 0;
+			c.weightx = 0;
+			c.weighty = 1;
+			c.weightx = 1;
+			c.gridwidth = 2;
+			c.fill = GridBagConstraints.BOTH;
+			c.insets = new Insets(0, 0, 4, 0);
+			mainPanel.add(getInfoPanel(), c);
+
+			c.gridy = 1;
+			c.weightx = 0;
+			c.gridwidth = 1;
+			c.insets = new Insets(0, 0, 0, 0);
+			JScrollPane scrollPane = new JScrollPane(getFileList());
+			mainPanel.add(scrollPane, c);
+
+			c.gridx = 1;
+			c.weightx = 1;
+
+			JPanel panel = new JPanel(new BorderLayout());
+			panel.setBorder(scrollPane.getBorder());
+			panel.add(getCanvasPanel(), BorderLayout.CENTER);
+			mainPanel.add(panel, c);
+
+			c.gridx = 0;
+			c.gridy = 2;
+			c.weightx = 0;
+			c.weighty = 0;
+			c.anchor = GridBagConstraints.LAST_LINE_START;
+			c.fill = GridBagConstraints.NONE;
+			mainPanel.add(getShowTemplatesBox(), c);
+
+			c.gridx = 1;
+			c.anchor = GridBagConstraints.LAST_LINE_END;
+			c.insets = new Insets(4, 0, 0, 0);
+			mainPanel.add(getLoadButton(), c);
+		}
+		return mainPanel;
+	}
+
+	public JButton getLoadButton() {
+		if (loadButton == null) {
+			loadButton = new JButton("Load Template");
+			loadButton.addActionListener(new ActionListener() {
+
+				@Override
+				public void actionPerformed(ActionEvent e) {
+					plugInPort.loadProject(presenter.getCurrentProject(), true);
+					dispose();
+				}
+			});
+		}
+		return loadButton;
+	}
+
+	public JPanel getInfoPanel() {
+		if (infoPanel == null) {
+			infoPanel = new JPanel();
+			infoPanel.setBackground(Color.decode("#FFFFCC"));
+			infoPanel.setBorder(new JTextField().getBorder());
+			JLabel infoLabel = new JLabel(
+					"<html>Templates are semi-product layouts that are used as a starting point for your projects.<br>"
+							+ "Pick a templete in the left list and click \"Load Template\" to load it or close this dialog to continue.<br>"
+							+ "You can create your own templates by placing a DIY file into <b>diylc/templates</b> directory.</html>");
+			infoLabel.setOpaque(false);
+			infoPanel.add(infoLabel);
+		}
+		return infoPanel;
+	}
+
+	public JList getFileList() {
+		if (fileList == null) {
+			fileList = new JList(getFiles().toArray());
+			fileList.setPreferredSize(new Dimension(128, -1));
+			fileList.setCellRenderer(new DefaultListCellRenderer() {
+
+				private static final long serialVersionUID = 1L;
+
+				@Override
+				public Component getListCellRendererComponent(JList list, Object value, int index,
+						boolean isSelected, boolean cellHasFocus) {
+					JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index,
+							isSelected, cellHasFocus);
+					if (value instanceof File) {
+						label.setText(((File) value).getName());
+					}
+					return label;
+				}
+
+			});
+			fileList.addListSelectionListener(new ListSelectionListener() {
+
+				@Override
+				public void valueChanged(ListSelectionEvent e) {
+					File file = (File) fileList.getSelectedValue();
+					if (file != null) {
+						presenter.loadProjectFromFile(file.getAbsolutePath());
+						Dimension dim = presenter.getCanvasDimensions(true);
+						double xFactor = panelSize.getWidth() / dim.getWidth();
+						double yFactor = panelSize.getHeight() / dim.getHeight();
+						presenter.setZoomLevel(Math.min(xFactor, yFactor));
+						getCanvasPanel().repaint();
+					}
+				}
+			});
+			fileList.setSelectedIndex(0);
+		}
+		return fileList;
+	}
+
+	public JCheckBox getShowTemplatesBox() {
+		if (showTemplatesBox == null) {
+			showTemplatesBox = new JCheckBox("Show this dialog at startup");
+			showTemplatesBox.setSelected(true);
+			showTemplatesBox.addActionListener(new ActionListener() {
+
+				@Override
+				public void actionPerformed(ActionEvent e) {
+					ConfigurationManager.getInstance().writeValue(SHOW_TEMPLATES_KEY,
+							showTemplatesBox.isSelected());
+				}
+			});
+		}
+		return showTemplatesBox;
+	}
+
+	public List<File> getFiles() {
+		if (files == null) {
+			files = new ArrayList<File>();
+			File dir = new File("templates");
+			if (dir.exists()) {
+				for (File f : dir.listFiles()) {
+					if (f.isFile() && f.getName().toLowerCase().endsWith(".diy")) {
+						files.add(f);
+					}
+				}
+			}
+			LOG.debug("Found " + files.size() + " templates");
+		}
+		return files;
+	}
+
+	public JPanel getCanvasPanel() {
+		if (canvasPanel == null) {
+			canvasPanel = new JPanel() {
+
+				private static final long serialVersionUID = 1L;
+
+				@Override
+				public void paint(Graphics g) {
+					super.paint(g);
+					// Graphics2D g2d = (Graphics2D) g;
+					// AffineTransform transform = g2d.getTransform();
+					presenter.draw((Graphics2D) g, EnumSet.of(DrawOption.ZOOM,
+							DrawOption.ANTIALIASING), null);
+					// g2d.setTransform(transform);
+					// Rectangle rect = canvasPanel.getBounds();
+					// BorderFactory.createEtchedBorder().paintBorder(canvasPanel,
+					// g, 0, 0,
+					// (int) rect.getWidth(), (int) rect.getHeight());
+				}
+			};
+			canvasPanel.setBackground(Color.white);
+			canvasPanel.setPreferredSize(panelSize);
+		}
+		return canvasPanel;
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/components/OverwritePromptFileChooser.java

@@ -0,0 +1,38 @@
+package org.diylc.swing.gui.components;
+
+import java.io.File;
+
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+import javax.swing.filechooser.FileFilter;
+
+public class OverwritePromptFileChooser extends JFileChooser {
+
+	private static final long serialVersionUID = 1L;
+	private String defaultExtension;
+
+	public void approveSelection() {
+		File lSelectedFile;
+		if (getSelectedFile().getAbsolutePath().contains(".")) {
+			lSelectedFile = getSelectedFile();
+		} else {
+			lSelectedFile = new File(getSelectedFile().getAbsoluteFile() + "." + defaultExtension);
+		}
+
+		if (lSelectedFile != null && lSelectedFile.exists()) {
+			int lResponse = JOptionPane.showConfirmDialog(this, lSelectedFile.getAbsolutePath()
+					+ " already exists.\nDo you " + "want to replace it?", "Warning",
+					JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
+
+			if (lResponse != JOptionPane.YES_OPTION) {
+				return;
+			}
+		}
+		super.approveSelection();
+	}
+
+	public void setFileFilter(FileFilter filter, String defaultExtension) {
+		this.defaultExtension = defaultExtension;
+		super.setFileFilter(filter);
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/editor/BooleanEditor.java

@@ -0,0 +1,34 @@
+package org.diylc.swing.gui.editor;
+
+import java.awt.Color;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JCheckBox;
+
+import org.diylc.common.PropertyWrapper;
+import org.diylc.utils.Constants;
+
+public class BooleanEditor extends JCheckBox {
+
+	private static final long serialVersionUID = 1L;
+
+	private Color oldBg = getBackground();
+
+	public BooleanEditor(final PropertyWrapper property) {
+		super();
+		setSelected((Boolean) property.getValue());
+		addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				property.setChanged(true);
+				setBackground(oldBg);
+				property.setValue(isSelected());
+			}
+		});
+		if (!property.isUnique()) {
+			setBackground(Constants.MULTI_VALUE_COLOR);
+		}
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/editor/ByteEditor.java

@@ -0,0 +1,36 @@
+package org.diylc.swing.gui.editor;
+
+import java.awt.Color;
+
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.diylc.common.PropertyWrapper;
+import org.diylc.utils.Constants;
+
+public class ByteEditor extends JSlider {
+
+	private static final long serialVersionUID = 1L;
+
+	private Color oldBg = getBackground();
+
+	public ByteEditor(final PropertyWrapper property) {
+		super();
+		setMinimum(0);
+		setMaximum(127);
+		setValue((Byte) property.getValue());
+		addChangeListener(new ChangeListener() {
+
+			@Override
+			public void stateChanged(ChangeEvent e) {
+				property.setChanged(true);
+				setBackground(oldBg);
+				property.setValue(new Integer(getValue()).byteValue());
+			}
+		});
+		if (!property.isUnique()) {
+			setBackground(Constants.MULTI_VALUE_COLOR);
+		}
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/editor/ColorEditor.java

@@ -0,0 +1,52 @@
+package org.diylc.swing.gui.editor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.BorderFactory;
+import javax.swing.JColorChooser;
+import javax.swing.JLabel;
+import javax.swing.SwingConstants;
+
+import org.diylc.common.PropertyWrapper;
+
+public class ColorEditor extends JLabel  {
+
+	private static final long serialVersionUID = 1L;
+
+	private static final String title = "Click to edit";
+
+	public ColorEditor(final PropertyWrapper property) {
+		super(property.isUnique() ? title : ("(multi value) " + title));
+		setOpaque(true);
+		setHorizontalAlignment(SwingConstants.CENTER);
+		setBorder(BorderFactory.createEtchedBorder());
+		setBackground((Color) property.getValue());
+		setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
+		addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				Color newColor = JColorChooser.showDialog(ColorEditor.this, "Choose Color",
+						getBackground());
+				if (newColor != null) {
+					property.setChanged(true);
+					property.setValue(newColor);
+					setBackground(newColor);
+				}
+			}
+		});
+	}
+
+	@Override
+	public void setBackground(Color bg) {
+		if (bg.getRed() < 127 || bg.getBlue() < 127 || bg.getGreen() < 127) {
+			setForeground(Color.white);
+		} else {
+			setForeground(Color.black);
+		}
+		super.setBackground(bg);
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/editor/EnumEditor.java

@@ -0,0 +1,41 @@
+package org.diylc.swing.gui.editor;
+
+import java.awt.Color;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+
+import javax.swing.DefaultComboBoxModel;
+import javax.swing.JComboBox;
+
+import org.diylc.common.PropertyWrapper;
+import org.diylc.utils.Constants;
+
+public class EnumEditor extends JComboBox {
+
+	private static final long serialVersionUID = 1L;
+
+	private Color oldBg = getBackground();
+
+	private final PropertyWrapper property;
+
+	public EnumEditor(final PropertyWrapper property) {
+		this.property = property;
+		Object[] values = property.getType().getEnumConstants();
+		setModel(new DefaultComboBoxModel(values));
+		setSelectedItem(property.getValue());
+		addItemListener(new ItemListener() {
+
+			@Override
+			public void itemStateChanged(ItemEvent e) {
+				if (e.getStateChange() == ItemEvent.SELECTED) {
+					property.setChanged(true);
+					setBackground(oldBg);
+					EnumEditor.this.property.setValue(e.getItem());
+				}
+			}
+		});
+		if (!property.isUnique()) {
+			setBackground(Constants.MULTI_VALUE_COLOR);
+		}
+	}
+}

diy-layout-creator --username bancika@gmail.com/diylc-swing/src/org/diylc/swing/gui/editor/FieldEditorFactory.java

@@ -0,0 +1,61 @@
+package org.diylc.swing.gui.editor;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Font;
+
+import javax.swing.ImageIcon;
+import javax.swing.JLabel;
+
+import org.apache.log4j.Logger;
+import org.diylc.common.PropertyWrapper;
+import org.diylc.core.measures.AbstractMeasure;
+
+public class FieldEditorFactory {
+
+	private static final Logger LOG = Logger.getLogger(FieldEditorFactory.class);
+
+	public static Component createFieldEditor(PropertyWrapper property) {
+		if (property.getType().equals(String.class)) {
+			StringEditor editor = new StringEditor(property);
+			return editor;
+		}
+		if (property.getType().equals(Color.class)) {
+			ColorEditor editor = new ColorEditor(property);
+			return editor;
+		}
+		if (AbstractMeasure.class.isAssignableFrom(property.getType())) {
+			MeasureEditor editor = new MeasureEditor(property);
+			return editor;
+		}
+		if (ImageIcon.class.isAssignableFrom(property.getType())) {
+			ImageEditor editor = new ImageEditor(property);
+			return editor;
+		}
+		if (property.getType().isEnum()) {
+			EnumEditor editor = new EnumEditor(property);
+			return editor;
+		}
+		if (Byte.class.isAssignableFrom(property.getType())
+				|| byte.class.isAssignableFrom(property.getType())) {
+			ByteEditor editor = new ByteEditor(property);
+			return editor;
+		}
+		if (Boolean.class.isAssignableFrom(property.getType())
+				|| boolean.class.isAssignableFrom(property.getType())) {
+			BooleanEditor editor = new BooleanEditor(property);
+			return editor;
+		}
+		if (Font.class.isAssignableFrom(property.getType())) {
+			FontEditor editor = new FontEditor(property);
+			return editor;
+		}
+		if (Integer.class.isAssignableFrom(property.getType())
+				|| int.class.isAssignableFrom(property.getType())) {
+			IntEditor editor = new IntEditor(property);
+			return editor;
+		}
+		LOG.error("Unrecognized parameter type: " + property.getType().getName());
+		return new JLabel("Unrecognized");
+	}
+}