Added some UI improvements to the IDE and performed some minor refactoring.

DrawableGui/src/main/java/org/openzen/drawablegui/DButton.java

 		}
 		
 		DPath shape = DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * context.getScale());
-		canvas.shadowPath(shape, DTransform2D.IDENTITY, shadow);
-		canvas.fillPath(shape, DTransform2D.IDENTITY, backgroundColor);
+		canvas.shadowPath(shape, DTransform2D.IDENTITY, backgroundColor, shadow);
 		canvas.drawText(style.font, style.textColor, bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent(), label.getValue());
 	}
 

DrawableGui/src/main/java/org/openzen/drawablegui/DCanvas.java

 	 * @param transform
 	 * @param shadow
 	 */
-	void shadowPath(DPath path, DTransform2D transform, DShadow shadow);
+	void shadowPath(DPath path, DTransform2D transform, int color, DShadow shadow);
 	
 	/**
 	 * Fills a rectangle.

DrawableGui/src/main/java/org/openzen/drawablegui/DPath.java

  * @author Hoofdgebruiker
  */
 public interface DPath {
+	public static DPath line(float x1, float y1, float x2, float y2) {
+		return tracer -> {
+			tracer.moveTo(x1, y1);
+			tracer.lineTo(x2, y2);
+		};
+	}
+	
 	public static DPath circle(float x, float y, float radius) {
 		// see http://spencermortensen.com/articles/bezier-circle/
 		return tracer -> {
 	}
 	
 	public static DPath roundedRectangle(float x, float y, float width, float height, float radius) {
+		if (radius < 0.01f)
+			return rectangle(x, y, width, height);
+		
 		return tracer -> {
 			float c = radius - radius * 0.551915024494f;
 			tracer.moveTo(x + width - radius, y + height);

DrawableGui/src/main/java/org/openzen/drawablegui/DUIWindow.java

  * @author Hoofdgebruiker
  */
 public interface DUIWindow {
-	DIRectangle getWindowBounds();
+	LiveObject<DIRectangle> getWindowBounds();
 	
 	DUIContext getContext();
 	

DrawableGui/src/main/java/org/openzen/drawablegui/border/DCustomWindowBorder.java

 					|| canvasBounds.y < bounds.y + spacing
 					|| canvasBounds.x + canvasBounds.width > bounds.x + bounds.width - spacing
 					|| canvasBounds.y + canvasBounds.height > bounds.y + bounds.height - spacing) {
-				canvas.shadowPath(border, DTransform2D.IDENTITY, style.shadow);
-				canvas.fillPath(border, DTransform2D.IDENTITY, style.backgroundColor);
+				canvas.shadowPath(border, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 				canvas.strokePath(
 						border,
 						DTransform2D.IDENTITY,

DrawableGui/src/main/java/org/openzen/drawablegui/border/DEmptyBorder.java

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.style.DBorderElement;
 
 /**
  *
  */
 public class DEmptyBorder implements DBorder {
 	public static final DEmptyBorder INSTANCE = new DEmptyBorder();
+	public static final DBorderElement ELEMENT = context -> INSTANCE;
 	
 	private DEmptyBorder() {}
 	

DrawableGui/src/main/java/org/openzen/drawablegui/border/DSideBorder.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.border;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSideBorder implements DBorder {
+	public final int leftWidth;
+	public final int leftColor;
+	public final int topWidth;
+	public final int topColor;
+	public final int rightWidth;
+	public final int rightColor;
+	public final int bottomWidth;
+	public final int bottomColor;
+	
+	public DSideBorder(
+			int leftWidth, int leftColor,
+			int topWidth, int topColor,
+			int rightWidth, int rightColor,
+			int bottomWidth, int bottomColor) {
+		this.leftWidth = leftWidth;
+		this.leftColor = leftColor;
+		this.topWidth = topWidth;
+		this.topColor = topColor;
+		this.rightWidth = rightWidth;
+		this.rightColor = rightColor;
+		this.bottomWidth = bottomWidth;
+		this.bottomColor = bottomColor;
+	}
+
+	@Override
+	public void paint(DCanvas canvas, DIRectangle bounds) {
+		if (leftWidth > 0) {
+			int x = bounds.x;
+			canvas.strokePath(DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+		if (topWidth > 0) {
+			int y = bounds.y;
+			canvas.strokePath(DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+		if (rightWidth > 0) {
+			int x = bounds.x + bounds.width - rightWidth;
+			canvas.strokePath(DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+		if (bottomWidth > 0) {
+			int y = bounds.y + bounds.height - bottomWidth;
+			canvas.strokePath(DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+	}
+
+	@Override
+	public int getPaddingLeft() {
+		return leftWidth;
+	}
+
+	@Override
+	public int getPaddingRight() {
+		return rightWidth;
+	}
+
+	@Override
+	public int getPaddingTop() {
+		return topWidth;
+	}
+
+	@Override
+	public int getPaddingBottom() {
+		return bottomWidth;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DHorizontalLayout.java → DrawableGui/src/main/java/org/openzen/drawablegui/layout/DHorizontalLayout.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.drawablegui;
+package org.openzen.drawablegui.layout;
 
 import java.util.function.Consumer;
 import java.util.function.Predicate;
+import org.openzen.drawablegui.BaseComponentGroup;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DSizing;
+import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 	@Override
 	public void paint(DCanvas canvas) {
 		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		style.border.paint(canvas, bounds);
 		for (Element element : components) {
 			element.component.paint(canvas);
 		}

DrawableGui/src/main/java/org/openzen/drawablegui/DHorizontalLayoutStyle.java → DrawableGui/src/main/java/org/openzen/drawablegui/layout/DHorizontalLayoutStyle.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.drawablegui;
+package org.openzen.drawablegui.layout;
 
 import org.openzen.drawablegui.border.DBorder;
 import org.openzen.drawablegui.border.DPaddedBorder;

DrawableGui/src/main/java/org/openzen/drawablegui/DSideLayout.java → DrawableGui/src/main/java/org/openzen/drawablegui/layout/DSideLayout.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.drawablegui;
+package org.openzen.drawablegui.layout;
 
 import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
+import org.openzen.drawablegui.BaseComponentGroup;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DSizing;
+import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 	
 	private DStylePath path;
 	private DUIContext context;
+	private DSideLayoutStyle style;
 	private DIRectangle bounds;
 	
 	public DSideLayout(DStyleClass styleClass, DComponent main) {
 	public void setContext(DStylePath parent, DUIContext context) {
 		this.context = context;
 		this.path = parent.getChild("sidelayout", styleClass);
+		style = new DSideLayoutStyle(context.getStylesheets().get(context, path));
 		
 		main.setContext(path, context);
 		for (SideComponent side : sides)
 
 	@Override
 	public void paint(DCanvas canvas) {
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
 		main.paint(canvas);
 		
 		for (SideComponent component : sides)

DrawableGui/src/main/java/org/openzen/drawablegui/layout/DSideLayoutStyle.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.layout;
+
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSideLayoutStyle {
+	public final int backgroundColor;
+	
+	public DSideLayoutStyle(DStyleDefinition style) {
+		backgroundColor = style.getColor("backgroundColor", 0);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DVerticalLayout.java → DrawableGui/src/main/java/org/openzen/drawablegui/layout/DVerticalLayout.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.drawablegui;
+package org.openzen.drawablegui.layout;
 
 import java.util.function.Consumer;
 import java.util.function.Predicate;
+import org.openzen.drawablegui.BaseComponentGroup;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DSizing;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 	private DIRectangle bounds;
 	private float totalGrow;
 	private float totalShrink;
+	private DPath shape;
 	
 	public DVerticalLayout(DStyleClass styleClass, Alignment alignment, Element... components) {
 		this.styleClass = styleClass;
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		shape = DPath.roundedRectangle(
+				bounds.x + style.margin.left,
+				bounds.y + style.margin.top,
+				bounds.width - style.margin.getHorizontal(),
+				bounds.height - style.margin.getVertical(),
+				style.cornerRadius);
 		layout();
 	}
 
 	@Override
 	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		canvas.shadowPath(shape, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		for (Element element : components) {
 			element.component.paint(canvas);
 		}
 		}
 	}
 	
-	private void layoutShrinked() {
+	private int getInnerWidth() {
+		return bounds.width - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
+	}
+	
+	private int getInnerHeight() {
+		return bounds.height - style.margin.getVertical() - style.border.getPaddingVertical();
+	}
+	
+	private int getPreferredInnerWidth() {
+		DSizing myPreferences = sizing.getValue();
+		return myPreferences.preferredWidth - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
+	}
+	
+	private int getPreferredInnerHeight() {
 		DSizing myPreferences = sizing.getValue();
+		return myPreferences.preferredHeight - style.margin.getVertical() - style.border.getPaddingVertical();
+	}
+	
+	private void layoutShrinked() {
 		if (totalShrink == 0) {
 			// now what?
 			// shrink proportionally, we have to shrink...
-			float scale = (float)(bounds.height - (components.length - 1) * style.spacing) / (myPreferences.preferredHeight - (components.length - 1) * style.spacing);
-			int y = 0;
+			float availableHeight = getInnerHeight() - (components.length - 1) * style.spacing;
+			float scale = (float)(availableHeight) / (getPreferredInnerHeight() - (components.length - 1) * style.spacing);
+			int y = bounds.y + style.margin.top + style.border.getPaddingTop();
 			
 			for (int i = 0; i < components.length; i++) {
 				Element element = components[i];
 				y = idealY;
 			}
 		} else {
-			int delta = bounds.height - myPreferences.preferredHeight;
+			int delta = getInnerHeight() - getPreferredInnerHeight();
 			float deltaScaled = delta / totalShrink;
 			int y = bounds.y;
 			for (Element element : components) {
 	
 	private void layoutGrown() {
 		// resize according to grow values
-		DSizing myPreferences = sizing.getValue();
-		
 		if (totalGrow == 0) {
-			int deltaY = (int)(myPreferences.preferredHeight - bounds.height);
-			int y = bounds.y + (int)(deltaY * alignment.align);
+			int deltaY = getPreferredInnerHeight() - getInnerHeight();
+			int y = bounds.y + style.margin.top + style.border.getPaddingTop() + (int)(deltaY * alignment.align);
 			for (Element element : components) {
 				DSizing preferences = element.component.getSizing().getValue();
 				int newY = y + preferences.preferredHeight;
 				y = newY;
 			}
 		} else {
-			int delta = bounds.width - myPreferences.preferredWidth;
+			int delta = getPreferredInnerHeight() - getInnerHeight();
 			float deltaScaled = delta / totalGrow;
-			int y = bounds.y;
+			int y = bounds.y + style.margin.top + style.border.getPaddingTop();
 			for (Element element : components) {
 				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredHeight + deltaScaled * element.grow;
 		int width;
 		switch (element.alignment) {
 			case LEFT:
-				width = Math.min(preferences.preferredWidth, bounds.width - style.border.getPaddingHorizontal());
-				x = bounds.x + style.border.getPaddingLeft();
+				width = Math.min(preferences.preferredWidth, bounds.width - style.border.getPaddingHorizontal() - style.margin.getHorizontal());
+				x = bounds.x + style.margin.left + style.border.getPaddingLeft();
 				break;
 			case CENTER:
 				width = Math.min(preferences.preferredWidth, bounds.width - style.border.getPaddingHorizontal());
-				x = bounds.x + style.border.getPaddingLeft() + (bounds.width - style.border.getPaddingHorizontal() - width) / 2;
+				x = bounds.x + style.margin.left + style.border.getPaddingLeft() + (bounds.width - style.border.getPaddingHorizontal() - width) / 2;
 				break;
 			case RIGHT:
 				width = Math.min(preferences.preferredWidth, bounds.width - style.border.getPaddingHorizontal());
-				x = bounds.x + bounds.width - style.border.getPaddingLeft() - width;
+				x = bounds.x + bounds.width - style.margin.right - style.border.getPaddingRight() - width;
 				break;
 			case STRETCH:
 			default:
-				width = bounds.width - style.border.getPaddingHorizontal();
-				x = bounds.x + style.border.getPaddingLeft();
+				width = bounds.width - style.border.getPaddingHorizontal() - style.margin.getHorizontal();
+				x = bounds.x + style.margin.left + style.border.getPaddingLeft();
 				break;
 		}
 		element.component.setBounds(new DIRectangle(x, y, width, height));

DrawableGui/src/main/java/org/openzen/drawablegui/DVerticalLayoutStyle.java → DrawableGui/src/main/java/org/openzen/drawablegui/layout/DVerticalLayoutStyle.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.drawablegui;
+package org.openzen.drawablegui.layout;
 
 import org.openzen.drawablegui.border.DBorder;
 import org.openzen.drawablegui.border.DPaddedBorder;
 import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.style.DMargin;
+import org.openzen.drawablegui.style.DPxDimension;
+import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
 	public final int spacing;
 	public final DBorder border;
 	public final int backgroundColor;
+	public final DMargin margin;
+	public final int cornerRadius;
+	public final DShadow shadow;
 	
 	public DVerticalLayoutStyle(DStyleDefinition style) {
 		spacing = style.getDimension("spacing", new DDpDimension(8));
 		border = style.getBorder("border", context -> new DPaddedBorder(context.dp(8)));
 		backgroundColor = style.getColor("backgroundColor", 0);
+		margin = style.getMargin("margin", DMargin.EMPTY_ELEMENT);
+		cornerRadius = style.getDimension("cornerRadius", DPxDimension.ZERO);
+		shadow = style.getShadow("shadow", DShadow.NONE_ELEMENT);
 	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/live/InverseLiveBool.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.live;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InverseLiveBool implements LiveBool {
+	private final LiveBool source;
+	
+	public InverseLiveBool(LiveBool source) {
+		this.source = source;
+	}
+
+	@Override
+	public boolean getValue() {
+		return !source.getValue();
+	}
+
+	@Override
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return source.addListener((oldValue, newValue) -> listener.onChanged(!oldValue, !newValue));
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/live/SimpleLiveInt.java

 
 	@Override
 	public void setValue(int value) {
+		if (value == this.value)
+			return;
+		
 		int oldValue = this.value;
 		this.value = value;
 		listeners.accept(listener -> listener.onChanged(oldValue, value));

DrawableGui/src/main/java/org/openzen/drawablegui/live/SimpleLiveObject.java

 	
 	@Override
 	public void setValue(T value) {
+		if (value == this.value)
+			return;
+		
 		T oldValue = this.value;
 		this.value = value;
 		listeners.accept(listener -> listener.onUpdated(oldValue, value));

DrawableGui/src/main/java/org/openzen/drawablegui/live/SimpleLiveString.java

 
 	@Override
 	public void setValue(String value) {
+		if (value.equals(this.value))
+			return;
+		
 		String oldValue = this.value;
 		this.value = value;
 		listeners.accept(listener -> listener.onChanged(oldValue, value));

DrawableGui/src/main/java/org/openzen/drawablegui/style/DEmptyStyleDefinition.java

 	public DBorder getBorder(String name, DBorderElement defaultValue) {
 		return defaultValue.eval(context);
 	}
+	
+	@Override
+	public DMargin getMargin(String name, DMarginElement defaultValue) {
+		return defaultValue.eval(context);
+	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/style/DMargin.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DMargin {
+	public static final DMargin EMPTY = new DMargin(0);
+	public static final DMarginElement EMPTY_ELEMENT = context -> EMPTY;
+	
+	public final int left;
+	public final int right;
+	public final int top;
+	public final int bottom;
+	
+	public DMargin(int left, int right, int top, int bottom) {
+		this.left = left;
+		this.right = right;
+		this.top = top;
+		this.bottom = bottom;
+	}
+	
+	public DMargin(int amount) {
+		this(amount, amount, amount, amount);
+	}
+	
+	public int getVertical() {
+		return top + bottom;
+	}
+	
+	public int getHorizontal() {
+		return left + right;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/style/DMarginElement.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DMarginElement extends DStyleElement {
+	DMargin eval(DUIContext context);
+	
+	default DMarginElement asMargin() {
+		return this;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/style/DPxDimension.java

  * @author Hoofdgebruiker
  */
 public class DPxDimension implements DDimension {
+	public static final DPxDimension ZERO = new DPxDimension(0);
+	
 	private final float pixels;
 	
 	public DPxDimension(float pixels) {

DrawableGui/src/main/java/org/openzen/drawablegui/style/DShadow.java

  */
 public class DShadow {
 	public static final DShadow NONE = new DShadow(0, 0, 0, 0);
+	public static final DShadowElement NONE_ELEMENT = context -> NONE;
 	
 	public final int color;
 	public final float offsetX;

DrawableGui/src/main/java/org/openzen/drawablegui/style/DSimpleStylesheet.java

 			
 			return elements.get(name).asBorder().eval(context);
 		}
+		
+		@Override
+		public DMargin getMargin(String name, DMarginElement defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asMargin().eval(context);
+		}
 	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/style/DStyleDefinition.java

 	public DFont getFont(String name, DFontElement defaultValue);
 	
 	public DBorder getBorder(String name, DBorderElement defaultValue);
+	
+	public DMargin getMargin(String name, DMarginElement defaultValue);
 }

DrawableGui/src/main/java/org/openzen/drawablegui/style/DStyleElement.java

 		throw new RuntimeException("Not a border!");
 	}
 	
+	default DMarginElement asMargin() {
+		throw new RuntimeException("Not a margin!");
+	}
+	
 	default DShadowElement asShadow() {
 		throw new RuntimeException("Not a shadow!");
 	}

DrawableGui/src/main/java/org/openzen/drawablegui/style/DStylesheetBuilder.java

 		return this;
 	}
 	
+	public DStylesheetBuilder marginDp(String name, float value) {
+		elements.put(name, (DMarginElement)context -> new DMargin(context.dp(value)));
+		return this;
+	}
+	
 	public DStylesheet build() {
 		return new DSimpleStylesheet(elements);
 	}

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingCanvas.java

 	}
 
 	@Override
-	public void shadowPath(DPath path, DTransform2D transform, DShadow shadow) {
-		if (shadow.color == 0)
+	public void shadowPath(DPath path, DTransform2D transform, int color, DShadow shadow) {
+		if (shadow.color == 0) {
+			fillPath(path, transform, color);
 			return;
+		}
 		
 		if (shadow.radius == 0) {
 			fillPath(path, transform, shadow.color);
+			fillPath(path, transform, color);
 			return;
 		}
 		
 		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), true).filter(image, null);
 		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), false).filter(image, null);
 		g.drawImage(image, bounds.x - offset, bounds.y - offset, null);
+		
+		fillPath(path, transform, color);
 	}
 
 	@Override

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingDialog.java

 
 import java.awt.BorderLayout;
 import java.awt.Color;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
 import java.awt.event.WindowEvent;
 import java.awt.event.WindowListener;
 import java.awt.event.WindowStateListener;
 import org.openzen.drawablegui.border.DCustomWindowBorder;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 	private final boolean noTitleBar;
 	private final SimpleLiveObject<State> state = new SimpleLiveObject<>(State.NORMAL);
 	private final SimpleLiveBool active = new SimpleLiveBool(true);
+	private final MutableLiveObject<DIRectangle> bounds = new SimpleLiveObject<>(DIRectangle.EMPTY);
 	
 	public SwingDialog(SwingWindow owner, String title, DComponent root, boolean noTitleBar) {
 		super(owner, title);
 		
 		addWindowListener(this);
 		addWindowStateListener(this);
+		addComponentListener(new ComponentAdapter() {
+			@Override
+			public void componentMoved(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+			
+			@Override
+			public void componentResized(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+		});
 		
 		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
 		swingComponent.setWindow(this);
 	}
 
 	@Override
-	public DIRectangle getWindowBounds() {
-		return new DIRectangle(getX(), getY(), getWidth(), getHeight());
+	public LiveObject<DIRectangle> getWindowBounds() {
+		return bounds;
 	}
 
 	@Override
 
 	@Override
 	public void windowOpened(WindowEvent e) {
-		
+		updateBounds();
 	}
 
 	@Override
 		state.setValue(getStateFromWindowState());
 	}
 	
+	private void updateBounds() {
+		bounds.setValue(new DIRectangle(getX(), getY(), getWidth(), getHeight()));
+	}
+	
 	private State getStateFromWindowState() {
 		/*switch (ge()) {
 			case NORMAL:

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingGraphicsContext.java

 
 	@Override
 	public DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root) {
-		SwingDialog window = new SwingDialog((SwingWindow)this.window, title, root, false);
+		SwingWindow swingWindow = (SwingWindow)this.window;
+		SwingDialog window = new SwingDialog(swingWindow, title, root, false);
 		SwingGraphicsContext windowContext = new SwingGraphicsContext(stylesheets, scale, textScale, window.swingComponent);
 		windowContext.setWindow(window);
 		windowContext.graphics = this.graphics; // help a little...
 		
+		Point rootLocation = swingWindow.swingComponent.getLocationOnScreen();
+		
 		root.setContext(DStylePathRoot.INSTANCE, windowContext);
 		DSizing dimension = root.getSizing().getValue();
-		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
-		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
+		int tx = (int)(x + rootLocation.x - anchor.alignX * dimension.preferredWidth);
+		int ty = (int)(y + rootLocation.y - anchor.alignY * dimension.preferredHeight);
 		
 		window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
 		window.swingComponent.setPreferredSize(new Dimension(dimension.preferredWidth, dimension.preferredHeight));
 		
 		int tx = (int)(x + rootLocation.x - anchor.alignX * dimension.preferredWidth);
 		int ty = (int)(y + rootLocation.y - anchor.alignY * dimension.preferredHeight);
-		System.out.println("Position: " + tx + ", " + ty);
 		
 		window.swingComponent.setPreferredSize(new Dimension(dimension.preferredWidth, dimension.preferredHeight));
 		window.setLocation(tx, ty);
 		window.setVisible(true);
 		window.swingComponent.repaint();
 		
-		System.out.println("Window size: " + window.getWidth() + " x " + window.getHeight());
 		return window;
 	}
 	

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingInlineWindow.java

 package org.openzen.drawablegui.swing;
 
 import java.awt.BorderLayout;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
 import java.awt.event.WindowEvent;
 import java.awt.event.WindowListener;
 import java.awt.event.WindowStateListener;
 import org.openzen.drawablegui.live.ImmutableLiveObject;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
+import org.openzen.drawablegui.live.SimpleLiveObject;
 
 /**
  *
 	public final SwingRoot swingComponent;
 	private final LiveObject<State> state = new ImmutableLiveObject<>(State.NORMAL);
 	private final SimpleLiveBool active = new SimpleLiveBool(true);
+	private final MutableLiveObject<DIRectangle> bounds = new SimpleLiveObject<>(DIRectangle.EMPTY);
 	
 	public SwingInlineWindow(SwingWindow owner, String title, DComponent root) {
 		super(owner);
 		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
 		swingComponent.setWindow(this);
 		swingComponent.requestFocusInWindow();
+		addComponentListener(new ComponentAdapter() {
+			@Override
+			public void componentMoved(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+			
+			@Override
+			public void componentResized(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+		});
 	}
 	
 	@Override
 	}
 
 	@Override
-	public DIRectangle getWindowBounds() {
-		return new DIRectangle(getX(), getY(), getWidth(), getHeight());
+	public LiveObject<DIRectangle> getWindowBounds() {
+		return bounds;
 	}
 
 	@Override
 
 	@Override
 	public void windowOpened(WindowEvent e) {
-		
+		updateBounds();
 	}
 
 	@Override
 	public void windowStateChanged(WindowEvent e) {
 		
 	}
+	
+	private void updateBounds() {
+		bounds.setValue(new DIRectangle(getX(), getY(), getWidth(), getHeight()));
+	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingRoot.java

 
 	@Override
 	public void componentResized(ComponentEvent e) {
+		if (firstPaint)
+			return;
+		
 		component.setBounds(new DIRectangle(0, 0,
 				e.getComponent().getWidth(),
 				e.getComponent().getHeight()));

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingWindow.java

 
 import java.awt.BorderLayout;
 import java.awt.Color;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
 import java.awt.event.WindowEvent;
 import java.awt.event.WindowListener;
 import java.awt.event.WindowStateListener;
 import org.openzen.drawablegui.border.DCustomWindowBorder;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 	private final boolean noTitleBar;
 	private final SimpleLiveObject<State> state = new SimpleLiveObject<>(State.NORMAL);
 	private final SimpleLiveBool active = new SimpleLiveBool(true);
+	private final MutableLiveObject<DIRectangle> bounds = new SimpleLiveObject<>(DIRectangle.EMPTY);
 	
 	public SwingWindow(String title, DComponent root, boolean noTitleBar) {
 		super(title);
 		
 		addWindowListener(this);
 		addWindowStateListener(this);
+		addComponentListener(new ComponentAdapter() {
+			@Override
+			public void componentMoved(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+			
+			@Override
+			public void componentResized(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+		});
 		
 		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
 		swingComponent.setWindow(this);
 		swingComponent.requestFocusInWindow();
+		
 	}
 	
 	@Override
 	}
 
 	@Override
-	public DIRectangle getWindowBounds() {
-		return new DIRectangle(getX(), getY(), getWidth(), getHeight());
+	public LiveObject<DIRectangle> getWindowBounds() {
+		return bounds;
 	}
 
 	@Override
 
 	@Override
 	public void windowOpened(WindowEvent e) {
-		
+		updateBounds();
 	}
 
 	@Override
 		state.setValue(getStateFromWindowState());
 	}
 	
+	private void updateBounds() {
+		state.setValue(getStateFromWindowState());
+		bounds.setValue(new DIRectangle(getX(), getY(), getWidth(), getHeight()));
+	}
+	
 	private State getStateFromWindowState() {
 		switch (getExtendedState()) {
 			case NORMAL:

IDE/src/main/java/org/openzen/zenscript/ide/Main.java

 import java.io.IOException;
 import java.util.Arrays;
 import javax.swing.JFrame;
+import org.openzen.drawablegui.DUIWindow;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.local.LocalProjectDevelopmentHost;
 import org.openzen.drawablegui.swing.SwingWindow;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.constructor.Project;
+import org.openzen.zenscript.ide.host.IDEPropertyDirectory;
+import org.openzen.zenscript.ide.host.IDEPropertyStore;
 import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.view.WindowView;
 
 		Project project = new Project(loader, directory);
 		
 		DevelopmentHost host = new LocalProjectDevelopmentHost(project);
-		
-		int pixelPerInch = java.awt.Toolkit.getDefaultToolkit().getScreenResolution();
+		open(host);
+    }
+	
+	private static void open(DevelopmentHost host) {
+		IDEPropertyStore properties = host.getPropertyStore();
 		
 		IDEWindow window = new IDEWindow(host);
 		WindowView root = new WindowView(window, host);
 		
+		IDEPropertyDirectory uiState = properties.getRoot().getSubdirectory("uiState");
+		
+		int pixelPerInch = java.awt.Toolkit.getDefaultToolkit().getScreenResolution();
 		SwingWindow swingWindow = new SwingWindow("ZenCode IDE - " + host.getName(), root, false);
-		swingWindow.setSize(800 * pixelPerInch / 96, 600 * pixelPerInch / 96);
+		swingWindow.setSize(
+				uiState.getInt("width", 800 * pixelPerInch / 96),
+				uiState.getInt("height", 600 * pixelPerInch / 96));
+		swingWindow.setLocation(
+				uiState.getInt("x", 0),
+				uiState.getInt("y", 0));
 		swingWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		swingWindow.setExtendedState(uiState.getBool("maximized", false) ? JFrame.MAXIMIZED_BOTH : JFrame.NORMAL);
 		swingWindow.setVisible(true);
-    }
+		
+		swingWindow.getWindowBounds().addListener((oldBounds, newBounds) -> {
+			if (swingWindow.getWindowState().getValue() == DUIWindow.State.NORMAL) {
+				uiState.setInt("x", newBounds.x);
+				uiState.setInt("y", newBounds.y);
+				uiState.setInt("width", newBounds.width);
+				uiState.setInt("height", newBounds.height);
+				properties.save();
+			}
+		});
+		swingWindow.getWindowState().addListener((oldState, newState) -> {
+			boolean isMaximized = newState == DUIWindow.State.MAXIMIZED;
+			if (isMaximized != uiState.getBool("maximized", false)) {
+				uiState.setBool("maximized", isMaximized);
+				properties.save();
+			}
+		});
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/codemodel/IDECodeSpace.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.codemodel;
+
+import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDECodeSpace {
+	private final DevelopmentHost host;
+	
+	public IDECodeSpace(DevelopmentHost host) {
+		this.host = host;
+	}
+	
+	public void onSaved(IDESourceFile file) {
+		
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/DevelopmentHost.java

 public interface DevelopmentHost {
 	public String getName();
 	
+	public IDEPropertyStore getPropertyStore();
+	
 	public LiveList<IDEModule> getModules();
 	
 	public LiveList<IDELibrary> getLibraries();

IDE/src/main/java/org/openzen/zenscript/ide/host/IDEPropertyDirectory.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDEPropertyDirectory {
+	public boolean getBool(String name, boolean defaultValue);
+	
+	public void setBool(String name, boolean value);
+	
+	public int getInt(String name, int defaultValue);
+	
+	public void setInt(String name, int value);
+	
+	public String getString(String name, String defaultValue);
+	
+	public void setString(String name, String value);
+	
+	public IDEPropertyDirectory getSubdirectory(String name);
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/IDEPropertyStore.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDEPropertyStore {
+	IDEPropertyDirectory getRoot();
+	
+	void save();
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/IDESourceFile.java

 
 import java.io.IOException;
 import java.io.Reader;
+import org.openzen.drawablegui.live.LiveString;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface IDESourceFile {
-	public String getName();
+	public LiveString getName();
 	
 	public Reader read() throws IOException;
 	

IDE/src/main/java/org/openzen/zenscript/ide/host/local/FilePropertyStore.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+import org.openzen.zenscript.ide.host.IDEPropertyDirectory;
+import org.openzen.zenscript.ide.host.IDEPropertyStore;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FilePropertyStore implements IDEPropertyStore {
+	private final File file;
+	private JSONObject data;
+	
+	public FilePropertyStore(File file) {
+		this.file = file;
+		
+		if (!file.exists()) {
+			data = new JSONObject();
+			save();
+		} else {
+			try (InputStreamReader input = new InputStreamReader(new BufferedInputStream(new FileInputStream(file)), StandardCharsets.UTF_8)) {
+				data = new JSONObject(new JSONTokener(input));
+			} catch (IOException ex) {
+				data = new JSONObject();
+			}
+		}
+	}
+	
+	@Override
+	public IDEPropertyDirectory getRoot() {
+		return new JSONPropertyDirectory(data);
+	}
+	
+	@Override
+	public void save() {
+		try (OutputStreamWriter output = new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8)) {
+			output.write(data.toString(2));
+		} catch (IOException ex) {
+			ex.printStackTrace();
+		}
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/JSONPropertyDirectory.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import org.json.JSONObject;
+import org.openzen.zenscript.ide.host.IDEPropertyDirectory;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JSONPropertyDirectory implements IDEPropertyDirectory {
+	private final JSONObject data;
+	
+	public JSONPropertyDirectory(JSONObject data) {
+		this.data = data;
+	}
+	
+	@Override
+	public boolean getBool(String name, boolean defaultValue) {
+		return data.optBoolean(name, defaultValue);
+	}
+	
+	@Override
+	public void setBool(String name, boolean value) {
+		data.put(name, value);
+	}
+	
+	@Override
+	public int getInt(String name, int defaultValue) {
+		return data.optInt(name, defaultValue);
+	}
+	
+	@Override
+	public void setInt(String name, int value) {
+		data.put(name, value);
+	}
+
+	@Override
+	public String getString(String name, String defaultValue) {
+		return data.optString(name, defaultValue);
+	}
+	
+	@Override
+	public void setString(String name, String value) {
+		data.put(name, value);
+	}
+
+	@Override
+	public IDEPropertyDirectory getSubdirectory(String name) {
+		if (!data.has(name)) {
+			data.put(name, new JSONObject());
+		}
+		
+		return new JSONPropertyDirectory(data.getJSONObject(name));
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalPackage.java

 		}
 		
 		subPackagesSorted = new SortedLiveList<>(subPackages, (a, b) -> a.getName().compareTo(b.getName()));
-		sourceFilesSorted = new SortedLiveList<>(sourceFiles, (a, b) -> a.getName().compareTo(b.getName()));
+		sourceFilesSorted = new SortedLiveList<>(sourceFiles, (a, b) -> a.getName().getValue().compareTo(b.getName().getValue()));
 	}
 	
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalProjectDevelopmentHost.java

  */
 package org.openzen.zenscript.ide.host.local;
 
+import java.io.File;
 import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.MutableLiveList;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDELibrary;
+import org.openzen.zenscript.ide.host.IDEPropertyStore;
 import org.openzen.zenscript.ide.host.IDETarget;
 
 /**
 	public String getName() {
 		return project.name;
 	}
+	
+	@Override
+	public IDEPropertyStore getPropertyStore() {
+		return new FilePropertyStore(new File(project.directory, "ide.json"));
+	}
 
 	@Override
 	public LiveList<IDEModule> getModules() {

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalSourceFile.java

 import java.io.Reader;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
+import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.MutableLiveString;
+import org.openzen.drawablegui.live.SimpleLiveString;
 import org.openzen.zenscript.constructor.module.SourceFile;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 
  */
 public class LocalSourceFile implements IDESourceFile {
 	private final SourceFile file;
+	private final MutableLiveString name;
 	
 	public LocalSourceFile(SourceFile file) {
 		this.file = file;
+		this.name = new SimpleLiveString(file.name);
 	}
 
 	@Override
-	public String getName() {
-		return file.name;
+	public LiveString getName() {
+		return name;
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEWindow.java

 package org.openzen.zenscript.ide.ui;
 
 import org.openzen.drawablegui.live.ImmutableLiveString;
-import org.openzen.drawablegui.live.LiveBool;
-import org.openzen.drawablegui.live.LivePredicateBool;
-import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
-import org.openzen.zenscript.ide.host.IDEModule;
-import org.openzen.zenscript.ide.host.IDEPackage;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 import org.openzen.zenscript.ide.host.IDETarget;
-import org.openzen.zenscript.ide.ui.dialog.CreatePackageDialog;
-import org.openzen.zenscript.ide.ui.dialog.CreateSourceFileDialog;
-import org.openzen.zenscript.ide.ui.icons.AddBoxIcon;
 import org.openzen.zenscript.ide.ui.icons.BuildIcon;
 import org.openzen.zenscript.ide.ui.icons.PlayIcon;
 import org.openzen.zenscript.ide.ui.icons.SettingsIcon;
 	
 	public IDEAspectToolbar projectToolbar;
 	
-	public final MutableLiveObject<IDEModule> contextModule = new SimpleLiveObject<>(null);
-	public final MutableLiveObject<IDEPackage> contextPackage = new SimpleLiveObject<>(null);
-	public final MutableLiveObject<IDESourceFile> contextFile = new SimpleLiveObject<>(null);
-	public final LiveBool addContentDisabled = new LivePredicateBool(contextPackage, pkg -> pkg == null);
-	
 	public IDEWindow(DevelopmentHost host) {
 		this.host = host;
 		
 		}));
 		aspectBar.toolbars.add(projectToolbar);
 	}
-	
-	public void setContextModule(IDEModule module) {
-		contextModule.setValue(module);
-		contextPackage.setValue(module.getRootPackage());
-		contextFile.setValue(null);
-	}
-	
-	public void setContextPackage(IDEModule module, IDEPackage pkg) {
-		contextModule.setValue(module);
-		contextPackage.setValue(pkg);
-		contextFile.setValue(null);
-	}
-	
-	public void setContextFile(IDESourceFile file) {
-		contextModule.setValue(null);
-		contextPackage.setValue(null);
-		contextFile.setValue(file);
-	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/dialog/CreatePackageDialog.java

 import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DButton;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DHorizontalLayout;
+import org.openzen.drawablegui.layout.DHorizontalLayout;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DInputField;
 import org.openzen.drawablegui.DLabel;
 import org.openzen.drawablegui.DUIWindow;
-import org.openzen.drawablegui.DVerticalLayout;
+import org.openzen.drawablegui.layout.DVerticalLayout;
 import org.openzen.drawablegui.form.DForm;
 import org.openzen.drawablegui.form.DFormComponent;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEPackage;
-import org.openzen.zenscript.ide.ui.IDEWindow;
 
 /**
  *
 	}
 	
 	public void open(DUIWindow parent) {
-		DIRectangle rectangle = parent.getWindowBounds();
-		window = parent.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_LEFT, "Create package", root);
+		DIRectangle rectangle = parent.getWindowBounds().getValue();
+		window = parent.getContext().openDialog(rectangle.width / 2, rectangle.height / 2, DAnchor.MIDDLE_CENTER, "Create package", root);
 		window.focus(input);
 	}
 	

IDE/src/main/java/org/openzen/zenscript/ide/ui/dialog/CreateSourceFileDialog.java

 import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DButton;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DHorizontalLayout;
+import org.openzen.drawablegui.layout.DHorizontalLayout;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DInputField;
 import org.openzen.drawablegui.DLabel;
 import org.openzen.drawablegui.DUIWindow;
-import org.openzen.drawablegui.DVerticalLayout;
+import org.openzen.drawablegui.layout.DVerticalLayout;
 import org.openzen.drawablegui.form.DForm;
 import org.openzen.drawablegui.form.DFormComponent;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 	}
 	
 	public void open(DUIWindow parent) {
-		DIRectangle rectangle = parent.getWindowBounds();
-		window = parent.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_LEFT, "Create source file", root);
+		DIRectangle rectangle = parent.getWindowBounds().getValue();
+		window = parent.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_CENTER, "Create source file", root);
 		window.focus(input);
 	}
 	

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/AddBoxIcon.java

 	
 	@Override
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
-		canvas.shadowPath(PATH, transform, new DShadow(0xFF999999, 0, 1, 6));
-		canvas.fillPath(PATH, transform, color);
+		canvas.shadowPath(PATH, transform, color, new DShadow(0xFF999999, 0, 1, 6));
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/BuildIcon.java

 	
 	@Override
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
-		canvas.shadowPath(PATH, transform, new DShadow(0xFFCCCCCC, 0, 1, 4));
-		canvas.fillPath(PATH, transform, color);
+		canvas.shadowPath(PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/PlayIcon.java

 	
 	@Override
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
-		canvas.shadowPath(PATH, transform, new DShadow(0xFFCCCCCC, 0, 1, 4));
-		canvas.fillPath(PATH, transform, color);
+		canvas.shadowPath(PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/SettingsIcon.java

 	
 	@Override
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
-		canvas.shadowPath(PATH, transform, new DShadow(0xFF888888, 0, 1, 4));
-		canvas.fillPath(PATH, transform, color);
+		canvas.shadowPath(PATH, transform, color, new DShadow(0xFF888888, 0, 1, 4));
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/ShadedSaveIcon.java

 	
 	@Override
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
-		canvas.shadowPath(PATH, transform, new DShadow(0xFFCCCCCC, 0, 1, 4));
-		canvas.fillPath(PATH, transform, color);
+		canvas.shadowPath(PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/IconButtonControl.java

 	@Override
 	public void paint(DCanvas canvas) {
 		if (disabled.getValue()) {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.shadowDisabled);
-			canvas.fillPath(shape, DTransform2D.IDENTITY, style.colorDisabled);
+			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorDisabled, style.shadowDisabled);
 		} else if (press) {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.shadowPress);
-			canvas.fillPath(shape, DTransform2D.IDENTITY, style.colorPress);
+			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorPress, style.shadowPress);
 		} else if (hover) {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.shadowHover);
-			canvas.fillPath(shape, DTransform2D.IDENTITY, style.colorHover);
+			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorHover, style.shadowHover);
 		} else {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.shadowNormal);
-			canvas.fillPath(shape, DTransform2D.IDENTITY, style.colorNormal);
+			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorNormal, style.shadowNormal);
 		}
 		
 		DDrawable icon = disabled.getValue() ? iconDisabled : this.icon;

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/TabbedView.java

  */
 package org.openzen.zenscript.ide.ui.view;
 
+import java.util.HashMap;
+import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.LiveMappedList;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	public final MutableLiveObject<TabbedViewComponent> currentTab = new SimpleLiveObject<>(null);
 	
+	private final Map<TabbedViewTab, ListenerHandle<LiveObject.Listener<DSizing>>> tabSizeListeners = new HashMap<>();
+	
 	private DUIContext context;
 	private DStylePath path;
 	private DIRectangle bounds;
 		TabbedViewTab result = new TabbedViewTab(this, currentTab, tab);
 		if (context != null)
 			result.setContext(path, context);
+		
+		tabSizeListeners.put(result, result.getSizing().addListener((oldSize, newSize) -> layoutTabs()));
 		return result;
 	});
 	

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/TabbedViewComponent.java

 
 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveString;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class TabbedViewComponent {
-	public final String title;
+	public final LiveString title;
 	public final DDrawable icon;
 	public final DComponent content;
+	public final LiveBool updated;
 	
-	public TabbedViewComponent(String title, DDrawable icon, DComponent content) {
+	public TabbedViewComponent(LiveString title, DDrawable icon, DComponent content, LiveBool updated) {
 		this.title = title;
 		this.icon = icon;
 		this.content = content;
+		this.updated = updated;
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/TabbedViewTab.java

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private int textWidth;
 	private DIRectangle bounds;
 	
+	private final ListenerHandle<LiveString.Listener> titleListener;
+	private final ListenerHandle<LiveBool.Listener> updatedListener;
+	
 	private boolean hover;
 	private boolean press;
 	
 		this.currentTab = currentTab;
 		this.tab = tab;
 		this.closeButton = new TabbedViewTabClose(this);
+		
+		titleListener = tab.title.addListener((oldValue, newValue) -> calculateSizing());
+		updatedListener = tab.updated.addListener((oldValue, newValue) -> calculateSizing());
 	}
 	
 	public void closeTab() {
 		fontMetrics = context.getFontMetrics(style.tabFont);
 		closeButton.setContext(path, context);
 		
-		textWidth = fontMetrics.getWidth(tab.title);
-		sizing.setValue(new DSizing(
-				style.paddingLeft + textWidth + style.paddingRight
+		calculateSizing();
+	}
+	
+	private void calculateSizing() {
+		textWidth = fontMetrics.getWidth(tab.title.getValue());
+		
+		int width = style.paddingLeft + textWidth + style.paddingRight
 						+ style.closeIconPadding
-						+ closeButton.getSizing().getValue().preferredWidth,
+						+ closeButton.getSizing().getValue().preferredWidth;
+		
+		if (tab.updated.getValue()) {
+			width += style.updatedDiameter + style.updatedPadding;
+		}
+		
+		sizing.setValue(new DSizing(
+				width,
 				style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent()
 						+ style.paddingBottom));
 	}
 	public void paint(DCanvas canvas) {
 		int width = style.paddingLeft + textWidth + style.paddingRight
 				+ closeButton.getSizing().getValue().preferredWidth + style.closeIconPadding;
+		
+		if (tab.updated.getValue())
+			width += style.updatedDiameter + style.updatedPadding;
 
 		int color = style.tabColorNormal;
 		if (currentTab.getValue() == tab)
 
 		canvas.fillRectangle(bounds.x, bounds.y, width, bounds.height, color);
 		canvas.strokePath(DPath.rectangle(bounds.x, bounds.y, width, bounds.height), DTransform2D.IDENTITY, style.borderColor, style.borderWidth);
-
-		canvas.drawText(style.tabFont, style.tabFontColor, bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent(), tab.title);
+		
+		canvas.drawText(style.tabFont, style.tabFontColor, bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent(), tab.title.getValue());
+		
+		if (tab.updated.getValue()) {
+			canvas.fillPath(
+					DPath.circle(
+						bounds.x + bounds.width - style.paddingRight - closeButton.getBounds().width - style.closeIconPadding - style.updatedDiameter / 2,
+						bounds.y + style.paddingTop + ((bounds.height - style.paddingTop - style.paddingBottom) / 2), style.updatedDiameter / 2),
+					DTransform2D.IDENTITY,
+					style.updatedColor);
+		}
 		
 		closeButton.paint(canvas);
 	}
 
 	@Override
 	public void close() {
-		
+		titleListener.close();
+		updatedListener.close();
 	}
 	
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/TabbedViewTabStyle.java

 	public final int closeIconSize;
 	public final int closeIconPadding;
 	
+	public final int updatedDiameter;
+	public final int updatedPadding;
+	public final int updatedColor;
+	
 	public TabbedViewTabStyle(DStyleDefinition style) {
 		tabFont = style.getFont("tabFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(12 * context.getScale())));
 		tabFontColor = style.getColor("tabFontColor", 0xFF000000);
 		
 		closeIconSize = style.getDimension("closeIconSize", new DDpDimension(16));
 		closeIconPadding = style.getDimension("closeIconPadding", new DDpDimension(6));
+		
+		updatedDiameter = style.getDimension("updatedDiameter", new DDpDimension(6));
+		updatedPadding = style.getDimension("updatedPadding", new DDpDimension(8));
+		updatedColor = style.getColor("updatedColor", 0xFF000000);
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/WindowView.java

  */
 package org.openzen.zenscript.ide.ui.view;
 
-import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DEmptyView;
-import org.openzen.drawablegui.DHorizontalLayout;
 import org.openzen.drawablegui.scroll.DScrollPane;
-import org.openzen.drawablegui.DSideLayout;
-import org.openzen.drawablegui.DVerticalLayout;
-import org.openzen.drawablegui.border.DEmptyBorder;
-import org.openzen.drawablegui.live.ImmutableLiveString;
+import org.openzen.drawablegui.layout.DSideLayout;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.SimpleLiveString;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylesheetBuilder;
-import org.openzen.drawablegui.tree.DTreeView;
-import org.openzen.drawablegui.tree.DTreeViewStyle;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 import org.openzen.zenscript.ide.ui.IDEDockWindow;
 import org.openzen.zenscript.ide.ui.IDEWindow;
-import org.openzen.zenscript.ide.ui.dialog.CreatePackageDialog;
-import org.openzen.zenscript.ide.ui.dialog.CreateSourceFileDialog;
-import org.openzen.zenscript.ide.ui.icons.AddBoxIcon;
 import org.openzen.zenscript.ide.ui.view.aspectbar.AspectBarView;
 import org.openzen.zenscript.ide.ui.view.editor.SourceEditor;
-import org.openzen.zenscript.ide.ui.view.project.RootTreeNode;
+import org.openzen.zenscript.ide.ui.view.project.ProjectBrowser;
 
 /**
  *
 	private final IDEWindow window;
 	private final TabbedView tabs;
 	public final LiveString status = new SimpleLiveString("IDE initialized");
+	private final ProjectBrowser projectBrowser;
 	
 	public WindowView(IDEWindow window, DevelopmentHost host) {
-		super(DStyleClass.EMPTY, DEmptyView.INSTANCE);
+		super(DStyleClass.inline(
+				new DStylesheetBuilder().color("backgroundColor", 0xFFEEEEEE).build()),
+				DEmptyView.INSTANCE);
 		this.window = window;
 		
-		DStyleClass minimalButtonPadding = DStyleClass.inline(new DStylesheetBuilder()
-				.dimensionDp("margin", 3)
-				.dimensionDp("padding", 0)
-				.build());
-		
-		IconButtonControl addPackageButton = new IconButtonControl(
-				minimalButtonPadding,
-				AddBoxIcon.BLUE,
-				AddBoxIcon.GRAY,
-				window.addContentDisabled,
-				new ImmutableLiveString("Create package"),
-				e -> {
-					CreatePackageDialog dialog = new CreatePackageDialog(window.contextModule.getValue(), window.contextPackage.getValue());
-					dialog.open(e.window);
-				});
-		IconButtonControl addFileButton = new IconButtonControl(
-				minimalButtonPadding,
-				AddBoxIcon.ORANGE,
-				AddBoxIcon.GRAY,
-				window.addContentDisabled,
-				new ImmutableLiveString("Create source file"),
-				e -> {
-					CreateSourceFileDialog dialog = new CreateSourceFileDialog(window, window.contextModule.getValue(), window.contextPackage.getValue());
-					dialog.open(e.window);
-				});
-		
-		DHorizontalLayout toolbar = new DHorizontalLayout(
-				DStyleClass.inline(new DStylesheetBuilder()
-						.border("border", context -> DEmptyBorder.INSTANCE)
-						.dimensionPx("spacing", 0)
-						.color("backgroundColor", 0xFFFFFFFF)
-						.build()),
-				DHorizontalLayout.Alignment.LEFT,
-				new DHorizontalLayout.Element(addPackageButton, 0, 0, DHorizontalLayout.ElementAlignment.TOP),
-				new DHorizontalLayout.Element(addFileButton, 0, 0, DHorizontalLayout.ElementAlignment.TOP));
-		DTreeView projectTree = new DTreeView(DTreeViewStyle.DEFAULT, new RootTreeNode(window, host), false);
-		projectTree.getSizing().setValue(new DSizing(500, 500));
-		
-		DVerticalLayout projectView = new DVerticalLayout(
-				DStyleClass.inline(new DStylesheetBuilder()
-						.border("border", context -> DEmptyBorder.INSTANCE)
-						.dimensionPx("spacing", 0)
-						.build()),
-				DVerticalLayout.Alignment.TOP,
-				new DVerticalLayout.Element(toolbar, 0, 0, DVerticalLayout.ElementAlignment.STRETCH),
-				new DVerticalLayout.Element(new DScrollPane(DStyleClass.forId("projectView"), projectTree), 1, 1, DVerticalLayout.ElementAlignment.STRETCH));
+		projectBrowser = new ProjectBrowser(window, host);
 		
 		setMain(tabs = new TabbedView(DStyleClass.EMPTY));
-		add(Side.LEFT,projectView);
+		add(Side.LEFT, projectBrowser.view);
 		add(Side.BOTTOM, new StatusBarView(DStyleClass.EMPTY, status));
 		add(Side.TOP, new AspectBarView(DStyleClass.EMPTY, window.aspectBar));
 		
 	private class DockWindowListener implements IDEDockWindow.Listener {
 		@Override
 		public void onOpen(IDESourceFile sourceFile) {
+			SourceEditor editor = new SourceEditor(DStyleClass.EMPTY, window, sourceFile);
 			TabbedViewComponent tab = new TabbedViewComponent(
 					sourceFile.getName(),
 					null,
-					new DScrollPane(DStyleClass.EMPTY, new SourceEditor(DStyleClass.EMPTY, window, sourceFile)));
+					new DScrollPane(DStyleClass.EMPTY, editor),
+					editor.isUpdated());
 			tabs.tabs.add(tab);
 			tabs.currentTab.setValue(tab);
 		}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/aspectbar/AspectBarSelectorButton.java

 		canvas.shadowPath(
 					shape,
 					DTransform2D.translate(bounds.x, bounds.y),
+					color,
 					shadow);
-		canvas.fillPath(
-				shape,
-				DTransform2D.translate(bounds.x, bounds.y),
-				color);
 		icon.draw(canvas, DTransform2D.scaleAndTranslate(
 				bounds.x + (style.width - icon.getNominalWidth() * context.getScale()) / 2,
 				bounds.y + (style.height - icon.getNominalHeight() * context.getScale()) / 2,

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/aspectbar/AspectBarStyle.java

 	public final int aspectSelectorToToolbarSpacing;
 	public final int aspectSelectorBottomSize;
 	public final int backgroundColor;
+	public final int backgroundColorBottom;
 	public final int foregroundColor;
+	public final int marginBottom;
 	
 	public final int aspectSelectorButtonSpacing;
 	public final int toolbarTitleToControlsSpacing;
 	public final DShadow aspectBarShadow;
 	public final int aspectBarPaddingTop;
 	
+	public final int controlHeight;
 	public final int controlPaddingTop;
 	public final int controlPaddingBottom;
 	
 	public final DShadow windowControlShadow;
 	
 	public AspectBarStyle(DStyleDefinition style) {
-		height = style.getDimension("height", new DDpDimension(38));
 		aspectSelectorPaddingLeft = style.getDimension("aspectSelectorPaddingLeft", new DDpDimension(4));
 		aspectSelectorToToolbarSpacing = style.getDimension("aspectSelectorToToolbarSpacing", new DDpDimension(16));
 		toolbarTitleToControlsSpacing = style.getDimension("toolbarTitleToControlsSpacing", new DDpDimension(8));
 		aspectSelectorBottomSize = style.getDimension("aspectSelectorBottomSize", new DDpDimension(4));
 		backgroundColor = style.getColor("backgroundColor", 0xFFCCCCCC); // 0xFFF0F0F0
+		backgroundColorBottom = style.getColor("backgroundColorBottom", 0xFFEEEEEE);
 		foregroundColor = style.getColor("foregroundColor", 0xFFFFFFFF);
+		marginBottom = style.getDimension("marginBottom", new DDpDimension(2));
 		
 		aspectSelectorButtonSpacing = style.getDimension("aspectSelectorButtonSpacing", new DDpDimension(4));
 		
 		aspectBarShadow = style.getShadow("aspectBarShadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 2 * context.getScale()));
 		aspectBarPaddingTop = style.getDimension("aspectBarPaddingTop", new DDpDimension(4));
 		
+		controlHeight = style.getDimension("controlHeight", new DDpDimension(28));
 		controlPaddingTop = style.getDimension("controlPaddingTop", new DDpDimension(2));
 		controlPaddingBottom = style.getDimension("controlPaddingBottom", new DDpDimension(2));
 		
 		windowControlSpacingBottom = style.getDimension("windowControlSpacingBottom", new DDpDimension(4));
 		//windowControlShadow = style.getShadow("windowControlShadow", context -> DShadow.NONE);
 		windowControlShadow = style.getShadow("windowControlShadow", context -> new DShadow(0x80888888, 0, 0, 2 * context.getScale()));
+		
+		height = aspectBarPaddingTop + controlPaddingTop + controlHeight + controlPaddingBottom + marginBottom;
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/aspectbar/AspectBarView.java

 	public void paint(DCanvas canvas) {
 		canvas.pushBounds(bounds);
 		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		canvas.fillRectangle(bounds.x, bounds.y + bounds.height - style.marginBottom, bounds.width, style.marginBottom, style.backgroundColorBottom);
 		
 		for (DComponent button : selectorButtons) {
 			if (button.getBounds() == null)
 		canvas.shadowPath(
 				aspectBarShape,
 				DTransform2D.IDENTITY,
+				style.foregroundColor,
 				style.aspectBarShadow);
-		canvas.fillPath(
-				aspectBarShape,
-				DTransform2D.IDENTITY,
-				style.foregroundColor);
 		
 		if (aspectBar.active.getValue() != null) {
 			int y = bounds.y
 		}
 		
 		if (showWindowControls) {
-			canvas.shadowPath(windowControlsShape, DTransform2D.IDENTITY, style.windowControlShadow);
+			canvas.shadowPath(windowControlsShape, DTransform2D.IDENTITY, style.backgroundColor, style.windowControlShadow);
 			minimize.paint(canvas);
 			maximizeRestore.paint(canvas);
 			close.paint(canvas);
 		for (DComponent component : selectorButtons) {
 			int width = component.getSizing().getValue().preferredWidth;
 			int height = component.getSizing().getValue().preferredHeight;
-			int y = bounds.y + (bounds.height - style.aspectSelectorBottomSize - height) / 2;
+			int y = bounds.y + (bounds.height - style.marginBottom - style.aspectSelectorBottomSize - height) / 2;
 			component.setBounds(new DIRectangle(x, y, width, height));
 			
 			x += width + style.aspectSelectorButtonSpacing;
 		int toX = aspectSelectorEndX;
 		
 		aspectBarShape = tracer -> {
-			int baseY = bounds.y + bounds.height - style.aspectSelectorBottomSize;
+			int height = bounds.height - style.marginBottom;
+			int baseY = bounds.y + height - style.aspectSelectorBottomSize;
 			int barBaseX = toX + style.aspectSelectorToToolbarSpacing;
 			int barBaseY = bounds.y + style.aspectBarPaddingTop;
 			
 				tracer.lineTo(bounds.x + bounds.width, bounds.y + style.aspectBarPaddingTop);
 			}
 			
-			tracer.lineTo(bounds.x + bounds.width, bounds.y + bounds.height);
-			tracer.lineTo(bounds.x, bounds.y + bounds.height);
+			tracer.lineTo(bounds.x + bounds.width, bounds.y + height);
+			tracer.lineTo(bounds.x, bounds.y + height);
 			tracer.close();
 		};
 		

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditor.java

 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.ImmutableLiveString;
+import org.openzen.drawablegui.live.InverseLiveBool;
+import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.style.DStyleClass;
 	private final IDEWindow window;
 	private final IDEAspectToolbar editToolbar = new IDEAspectToolbar(0, ShadedCodeIcon.BLUE, "Edit", "Source code editor");
 	
+	private final LiveBool updated;
+	
 	public SourceEditor(DStyleClass styleClass, IDEWindow window, IDESourceFile sourceFile) {
 		this.styleClass = styleClass;
 		this.window = window;
 		this.sourceFile = sourceFile;
 		
-		tokens = new TokenModel(sourceFile.getName(), tab.length());
+		tokens = new TokenModel(sourceFile.getName().getValue(), tab.length());
 		tokenListener = tokens.addListener(new TokenListener());
 		
 		editToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, ShadedSaveIcon.PURPLE, SaveIcon.GREY, unchanged, new ImmutableLiveString("Save file"), e -> save()));
+		updated = new InverseLiveBool(unchanged);
 		
 		try {
 			TokenParser<ZSToken, ZSTokenType> parser = ZSTokenParser.createRaw(
-					sourceFile.getName(),
+					sourceFile.getName().getValue(),
 					new ReaderCharReader(sourceFile.read()),
 					tab.length());
 			tokens.set(parser);
 		}
 	}
 	
+	public LiveBool isUpdated() {
+		return updated;
+	}
+	
 	@Override
 	public void onMounted() {
 		window.aspectBar.toolbars.add(editToolbar);

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/output/BasicOutputSpan.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui.view.output;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class BasicOutputSpan implements OutputSpan {
+	private final String value;
+	
+	public BasicOutputSpan(String value) {
+		this.value = value;
+	}
+	
+	@Override
+	public String toString() {
+		return value;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/output/ErrorOutputSpan.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui.view.output;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ErrorOutputSpan implements OutputSpan {
+	private final String value;
+	
+	public ErrorOutputSpan(String value) {
+		this.value = value;
+	}
+	
+	@Override
+	public String toString() {
+		return value;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/output/OutputLine.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui.view.output;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class OutputLine {
+	public final OutputSpan[] spans;
+	
+	public OutputLine(OutputSpan[] spans) {
+		this.spans = spans;
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+		for (OutputSpan span : spans)
+			result.append(span.toString());
+		return result.toString();
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/output/OutputSpan.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui.view.output;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface OutputSpan {
+	
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/output/OutputView.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui.view.output;
+
+import org.openzen.drawablegui.live.LiveList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class OutputView {
+	public final LiveList<OutputLine> lines;
+	
+	public OutputView(LiveList<OutputLine> lines) {
+		this.lines = lines;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/LibraryTreeNode.java

 	private final IDELibrary library;
 	private final LiveList<ProjectOverviewNode> modules;
 	
-	public LibraryTreeNode(IDEWindow window, IDELibrary library) {
+	public LibraryTreeNode(ProjectBrowser browser, IDELibrary library) {
 		this.library = library;
 		
-		modules = new LiveMappedList<>(library.getModules(), module -> new ModuleTreeNode(window, module));
+		modules = new LiveMappedList<>(library.getModules(), module -> new ModuleTreeNode(browser, module));
 	}
 	
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/ModuleTreeNode.java

  * @author Hoofdgebruiker
  */
 public class ModuleTreeNode extends PackageTreeNode {
-	public ModuleTreeNode(IDEWindow window, IDEModule module) {
-		super(window, module.getRootPackage());
+	public ModuleTreeNode(ProjectBrowser projectBrowser, IDEModule module) {
+		super(projectBrowser, module.getRootPackage());
 		
 		init(module);
 	}
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		window.setContextModule(module);
+		browser.setContextModule(module);
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/PackageTreeNode.java

 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEPackage;
-import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.icons.FolderIcon;
 
 /**
  * @author Hoofdgebruiker
  */
 public class PackageTreeNode extends ProjectOverviewNode {
-	protected final IDEWindow window;
+	protected final ProjectBrowser browser;
 	protected IDEModule module;
 	private final IDEPackage pkg;
 	private LiveList<ProjectOverviewNode> contents;
 	
-	public PackageTreeNode(IDEWindow window, IDEPackage pkg) {
-		this.window = window;
+	public PackageTreeNode(ProjectBrowser browser, IDEPackage pkg) {
+		this.browser = browser;
 		this.pkg = pkg;
 	}
 	
-	public PackageTreeNode(IDEWindow window, IDEModule module, IDEPackage pkg) {
-		this.window = window;
+	public PackageTreeNode(ProjectBrowser browser, IDEModule module, IDEPackage pkg) {
+		this.browser = browser;
 		this.module = module;
 		this.pkg = pkg;
 		
 	protected final void init(IDEModule module) {
 		this.module = module;
 		contents = new LiveConcatList<>(
-				new LiveMappedList<>(pkg.getSubPackages(), sub -> new PackageTreeNode(window, module, sub)),
-				new LiveMappedList<>(pkg.getSourceFiles(), source -> new SourceFileTreeNode(window, source))
+				new LiveMappedList<>(pkg.getSubPackages(), sub -> new PackageTreeNode(browser, module, sub)),
+				new LiveMappedList<>(pkg.getSourceFiles(), source -> new SourceFileTreeNode(browser, source))
 		);
 	}
 	
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		window.setContextPackage(module, pkg);
+		browser.setContextPackage(module, pkg);
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/ProjectBrowser.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui.view.project;
+
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.layout.DHorizontalLayout;
+import org.openzen.drawablegui.DSizing;
+import org.openzen.drawablegui.layout.DVerticalLayout;
+import org.openzen.drawablegui.border.DEmptyBorder;
+import org.openzen.drawablegui.border.DPaddedBorder;
+import org.openzen.drawablegui.live.ImmutableLiveString;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LivePredicateBool;
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.scroll.DScrollPane;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylesheetBuilder;
+import org.openzen.drawablegui.tree.DTreeView;
+import org.openzen.drawablegui.tree.DTreeViewStyle;
+import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.IDEModule;
+import org.openzen.zenscript.ide.host.IDEPackage;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+import org.openzen.zenscript.ide.ui.IDEWindow;
+import org.openzen.zenscript.ide.ui.dialog.CreatePackageDialog;
+import org.openzen.zenscript.ide.ui.dialog.CreateSourceFileDialog;
+import org.openzen.zenscript.ide.ui.icons.AddBoxIcon;
+import org.openzen.zenscript.ide.ui.view.IconButtonControl;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ProjectBrowser {
+	public final IDEWindow window;
+	public final DComponent view;
+	
+	public final MutableLiveObject<IDEModule> contextModule = new SimpleLiveObject<>(null);
+	public final MutableLiveObject<IDEPackage> contextPackage = new SimpleLiveObject<>(null);
+	public final MutableLiveObject<IDESourceFile> contextFile = new SimpleLiveObject<>(null);
+	public final LiveBool addContentDisabled = new LivePredicateBool(contextPackage, pkg -> pkg == null);
+	
+	public ProjectBrowser(IDEWindow window, DevelopmentHost host) {
+		this.window = window;
+		
+		DStyleClass minimalButtonPadding = DStyleClass.inline(new DStylesheetBuilder()
+				.dimensionDp("margin", 3)
+				.dimensionDp("padding", 0)
+				.build());
+		
+		IconButtonControl addPackageButton = new IconButtonControl(
+				minimalButtonPadding,
+				AddBoxIcon.BLUE,
+				AddBoxIcon.GRAY,
+				addContentDisabled,
+				new ImmutableLiveString("Create package"),
+				e -> {
+					CreatePackageDialog dialog = new CreatePackageDialog(contextModule.getValue(), contextPackage.getValue());
+					dialog.open(e.window);
+				});
+		IconButtonControl addFileButton = new IconButtonControl(
+				minimalButtonPadding,
+				AddBoxIcon.ORANGE,
+				AddBoxIcon.GRAY,
+				addContentDisabled,
+				new ImmutableLiveString("Create source file"),
+				e -> {
+					CreateSourceFileDialog dialog = new CreateSourceFileDialog(window, contextModule.getValue(), contextPackage.getValue());
+					dialog.open(e.window);
+				});
+		
+		DHorizontalLayout toolbar = new DHorizontalLayout(
+				DStyleClass.inline(new DStylesheetBuilder()
+						.border("border", context -> new DPaddedBorder(0, context.dp(2), 0, 0))
+						.dimensionPx("spacing", 0)
+						.build()),
+				DHorizontalLayout.Alignment.LEFT,
+				new DHorizontalLayout.Element(addPackageButton, 0, 0, DHorizontalLayout.ElementAlignment.TOP),
+				new DHorizontalLayout.Element(addFileButton, 0, 0, DHorizontalLayout.ElementAlignment.TOP));
+		DTreeView projectTree = new DTreeView(
+				DTreeViewStyle.DEFAULT,
+				new RootTreeNode(this, host), false);
+		projectTree.getSizing().setValue(new DSizing(500, 500));
+		
+		view = new DVerticalLayout(
+				DStyleClass.inline(new DStylesheetBuilder()
+						.border("border", DEmptyBorder.ELEMENT)
+						.dimensionPx("spacing", 0)
+						.marginDp("margin", 3)
+						.dimensionDp("cornerRadius", 2)
+						.color("backgroundColor", 0xFFFFFFFF)
+						.shadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()))
+						.build()),
+				DVerticalLayout.Alignment.TOP,
+				new DVerticalLayout.Element(toolbar, 0, 0, DVerticalLayout.ElementAlignment.STRETCH),
+				new DVerticalLayout.Element(new DScrollPane(DStyleClass.forId("projectView"), projectTree), 1, 1, DVerticalLayout.ElementAlignment.STRETCH));
+	}
+	
+	public void setContextModule(IDEModule module) {
+		contextModule.setValue(module);
+		contextPackage.setValue(module.getRootPackage());
+		contextFile.setValue(null);
+	}
+	
+	public void setContextPackage(IDEModule module, IDEPackage pkg) {
+		contextModule.setValue(module);
+		contextPackage.setValue(pkg);
+		contextFile.setValue(null);
+	}
+	
+	public void setContextFile(IDESourceFile file) {
+		contextModule.setValue(null);
+		contextPackage.setValue(null);
+		contextFile.setValue(file);
+	}
+	
+	public void setContextProject() {
+		contextModule.setValue(null);
+		contextPackage.setValue(null);
+		contextFile.setValue(null);
+		window.aspectBar.active.setValue(window.projectToolbar);
+	}
+	
+	public void open(IDESourceFile file) {
+		window.open(file);
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/ProjectTreeNode.java

 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
-import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.icons.ProjectIcon;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ProjectTreeNode extends ProjectOverviewNode {
-	private final IDEWindow window;
+	private final ProjectBrowser browser;
 	private final DevelopmentHost host;
 	private final LiveList<ProjectOverviewNode> modules;
 	
-	public ProjectTreeNode(IDEWindow window, DevelopmentHost host) {
-		this.window = window;
+	public ProjectTreeNode(ProjectBrowser browser, DevelopmentHost host) {
+		this.browser = browser;
 		this.host = host;
 		
-		modules = new LiveMappedList<>(host.getModules(), module -> new ModuleTreeNode(window, module));
+		modules = new LiveMappedList<>(host.getModules(), module -> new ModuleTreeNode(browser, module));
 	}
 	
 	@Override
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		window.aspectBar.active.setValue(window.projectToolbar);
+		browser.setContextProject();
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/RootTreeNode.java

 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.drawablegui.live.LivePrefixedList;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
-import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.icons.ProjectIcon;
 
 /**
 	private final DevelopmentHost host;
 	private final LiveList<ProjectOverviewNode> children;
 	
-	public RootTreeNode(IDEWindow window, DevelopmentHost host) {
+	public RootTreeNode(ProjectBrowser browser, DevelopmentHost host) {
 		this.host = host;
 		
 		children = new LivePrefixedList<>(
-				new ProjectTreeNode(window, host),
-				new LiveMappedList<>(host.getLibraries(), library -> new LibraryTreeNode(window, library)));
+				new ProjectTreeNode(browser, host),
+				new LiveMappedList<>(host.getLibraries(), library -> new LibraryTreeNode(browser, library)));
 	}
 	
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/SourceFileTreeNode.java

 import org.openzen.drawablegui.live.LiveEmptyList;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.zenscript.ide.host.IDESourceFile;
-import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.icons.CodeIcon;
 
 /**
  * @author Hoofdgebruiker
  */
 public class SourceFileTreeNode extends ProjectOverviewNode {
-	private final IDEWindow window;
+	private final ProjectBrowser browser;
 	private final IDESourceFile sourceFile;
 	
-	public SourceFileTreeNode(IDEWindow window, IDESourceFile sourceFile) {
-		this.window = window;
+	public SourceFileTreeNode(ProjectBrowser browser, IDESourceFile sourceFile) {
+		this.browser = browser;
 		this.sourceFile = sourceFile;
 	}
 	
 
 	@Override
 	public String getTitle() {
-		return sourceFile.getName();
+		return sourceFile.getName().getValue(); // TODO: live strings for node names
 	}
 
 	@Override
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		window.setContextFile(sourceFile);
+		browser.setContextFile(sourceFile);
 		if (e.isDoubleClick()) {
-			window.open(sourceFile);
+			browser.open(sourceFile);
 		}
 	}
 }