Merge remote-tracking branch 'Stan/development' into development

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 		for (int i = 0; i < parameters.length; i++) {
 			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 		}
-		return new FunctionHeader(null, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
+		return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
 	public FunctionHeader forTypeParameterInference() {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/Expression.java

 				if (body == function.body)
 					return function;
 				
-				return new FunctionExpression(function.position, (FunctionTypeID)function.type, function.closure, body);
+				return new FunctionExpression(function.position, (FunctionTypeID)function.type, function.closure, function.header, body);
 			} else {
 				return expression;
 			}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/FunctionExpression.java

 			CodePosition position,
 			FunctionTypeID type,
 			LambdaClosure closure,
+			FunctionHeader header,
 			Statement body) {
 		super(position, type, body.thrownType);
 		
-		this.header = type.header;
+		this.header = header;
 		this.closure = closure;
 		this.body = body;
 	}
 	@Override
 	public FunctionExpression transform(ExpressionTransformer transformer) {
 		Statement tBody = body.transform(transformer, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
-		return tBody == body ? this : new FunctionExpression(position, (FunctionTypeID)type, closure, tBody);
+		return tBody == body ? this : new FunctionExpression(position, (FunctionTypeID)type, closure, header, tBody);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/DefinitionScope.java

 		this.outer = outer;
 		this.definition = definition;
 		
-		ITypeID[] genericParameterList = null;
+		ITypeID[] genericParameterList = ITypeID.NONE;
 		if (definition.genericParameters != null) {
 			genericParameterList = new ITypeID[definition.genericParameters.length];
 			for (int i = 0; i < definition.genericParameters.length; i++) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

 		if (definition.genericParameters != null)
 			throw new IllegalArgumentException("Definition has type arguments!");
 		
-		return new DefinitionTypeID(definition, null);
+		return new DefinitionTypeID(definition, ITypeID.NONE);
 	}
 	
 	private static final OuterTypeEntry[] NO_OUTER_ENTRIES = new OuterTypeEntry[0];
 	
 	// For inner classes of generic outer classes
 	public DefinitionTypeID(HighLevelDefinition definition, ITypeID[] typeParameters, Map<TypeParameter, ITypeID> outerTypeParameters) {
+		if (typeParameters == null)
+			throw new NullPointerException("typeParameters cannot be null");
+		
 		this.definition = definition;
 		this.typeParameters = typeParameters;
 		this.outerTypeParameters = outerTypeParameters;
 	}
 	
 	public boolean hasTypeParameters() {
-		return typeParameters != null && typeParameters.length > 0;
+		return typeParameters.length > 0;
 	}
 	
 	public void init(GlobalTypeRegistry registry) {
 	// To be used exclusively by StaticDefinitionTypeID
 	protected DefinitionTypeID(HighLevelDefinition definition) {
 		this.definition = definition;
-		this.typeParameters = null;
+		this.typeParameters = ITypeID.NONE;
 		this.superType = definition.superType;
 		this.outerTypeParameters = Collections.emptyMap();
 		this.outerTypeEntries = NO_OUTER_ENTRIES;
 		if (!hasTypeParameters() && outerTypeParameters.isEmpty())
 			return this;
 		
-		ITypeID[] instancedArguments = null;
-		if (typeParameters != null) {
+		ITypeID[] instancedArguments = ITypeID.NONE;
+		if (hasTypeParameters()) {
 			instancedArguments = new ITypeID[typeParameters.length];
 			for (int i = 0; i < typeParameters.length; i++) {
 				// TODO: why was this line written like this?
 	
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
-		if (typeParameters != null) {
+		if (hasTypeParameters()) {
 			for (ITypeID typeParameter : typeParameters)
 				if (typeParameter.hasInferenceBlockingTypeParameters(parameters))
 					return true;
 	
 	@Override
 	public String toString() {
-		if (typeParameters == null) {
+		if (!hasTypeParameters()) {
 			return definition.name;
 		} else {
 			StringBuilder result = new StringBuilder();

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericName.java

 	public final ITypeID[] arguments;
 	
 	public GenericName(String name) {
-		this(name, null);
+		this(name, ITypeID.NONE);
 	}
 	
 	public GenericName(String name, ITypeID[] arguments) {
+		if (arguments == null)
+			throw new NullPointerException("Arguments cannot be null");
+		
 		this.name = name;
 		this.arguments = arguments;
 	}
 	
 	public int getNumberOfArguments() {
-		return arguments == null ? 0 : arguments.length;
+		return arguments.length;
 	}
 	
 	public boolean hasArguments() {
-		return arguments != null && arguments.length > 0;
+		return arguments.length > 0;
 	}
 	
 	public boolean hasNoArguments() {
-		return arguments == null || arguments.length == 0;
+		return arguments.length == 0;
 	}
 	
 	@Override
 	public String toString() {
 		StringBuilder result = new StringBuilder(name);
-		if (arguments != null) {
+		if (hasArguments()) {
 			result.append("<");
 			for (int i = 0; i < arguments.length; i++) {
 				if (i > 0)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GlobalTypeRegistry.java

 	
 	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] typeParameters, Map<TypeParameter, ITypeID> outerInstance) {
 		DefinitionTypeID id;
-		if ((definition instanceof FunctionDefinition) || (definition.genericParameters == null && typeParameters == null && outerInstance.isEmpty())) {
+		if ((definition instanceof FunctionDefinition) || (definition.genericParameters == null && typeParameters.length == 0 && outerInstance.isEmpty())) {
 			// make it a static one
 			id = new StaticDefinitionTypeID(definition);
 		} else {

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleLoader.java

 	}
 	
 	private SourcePackage loadPackage(String name, File directory) {
-		SourcePackage pkg = new SourcePackage(name);
+		SourcePackage pkg = new SourcePackage(directory, name);
 		
 		for (File file : directory.listFiles()) {
 			if (file.isDirectory()) {

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourcePackage.java

  */
 package org.openzen.zenscript.constructor.module;
 
+import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
 
  * @author Hoofdgebruiker
  */
 public class SourcePackage {
+	public final File directory;
 	public final String name;
 	public final Map<String, SourcePackage> subPackages = new HashMap<>();
 	public final Map<String, SourceFile> sourceFiles = new HashMap<>();
 	
-	public SourcePackage(String name) {
+	public SourcePackage(File directory, String name) {
+		this.directory = directory;
 		this.name = name;
 	}
 	

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

 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 public class DButton implements DComponent {
 	private final DStyleClass styleClass;
 	private final LiveString label;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final LiveBool disabled;
+	private final Runnable action;
 	
 	private DUIContext context;
 	private DIRectangle bounds;
 	private boolean hovering = false;
 	private boolean pressing = false;
 	
-	public DButton(DStyleClass styleClass, LiveString label, LiveBool disabled) {
+	public DButton(DStyleClass styleClass, LiveString label, LiveBool disabled, Runnable action) {
 		this.styleClass = styleClass;
 		this.label = label;
 		this.disabled = disabled;
+		this.action = action;
 	}
 
 	@Override
 		DStylePath path = parent.getChild("Button", styleClass);
 		this.style = new DButtonStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
+		
+		sizing.setValue(new DSizing(
+				style.paddingLeft + style.paddingRight + fontMetrics.getWidth(label.getValue()),
+				style.paddingTop + style.paddingBottom + fontMetrics.getAscent() + fontMetrics.getDescent()));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 	@Override
 	public void paint(DCanvas canvas) {
 		int backgroundColor = style.backgroundColorNormal;
-		if (hovering)
+		DShadow shadow = style.shadowNormal;
+		if (hovering) {
 			backgroundColor = style.backgroundColorHover;
-		if (pressing)
+			shadow = style.shadowNormal;
+		}
+		if (pressing) {
 			backgroundColor = style.backgroundColorPress;
-		if (disabled.getValue())
+			shadow = style.shadowPress;
+		}
+		if (disabled.getValue()) {
 			backgroundColor = style.backgroundColorDisabled;
+			shadow = style.shadowDisabled;
+		}
 		
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, backgroundColor);
+		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.drawText(style.font, style.textColor, bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent(), label.getValue());
 	}
 
 	@Override
 		pressing = false;
 		
 		if (!disabled.getValue()) {
-			// TODO
+			action.run();
 		}
 		
 		repaint();

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

 	public DButtonStyle(DStyleDefinition style) {
 		this.paddingTop = style.getDimension("paddingTop", new DDpDimension(4));
 		this.paddingBottom = style.getDimension("paddingBottom", new DDpDimension(4));
-		this.paddingLeft = style.getDimension("paddingLeft", new DDpDimension(4));
-		this.paddingRight = style.getDimension("paddingRight", new DDpDimension(4));
+		this.paddingLeft = style.getDimension("paddingLeft", new DDpDimension(8));
+		this.paddingRight = style.getDimension("paddingRight", new DDpDimension(8));
 		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, (int)(14 * context.getTextScale())));
 		textColor = style.getColor("textColor", 0xFF000000);
 		textColorDisabled = style.getColor("textColorDisabled", 0xFF888888);
 		backgroundColorPress = style.getColor("backgroundColorPress", 0xFFE5EFF8);
 		backgroundColorDisabled = style.getColor("backgroundColorDisabled", 0xFFE5EFF8);
 		
-		shadowNormal = style.getShadow("shadowNormal", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));
-		shadowHover = style.getShadow("shadowHover", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));
-		shadowPress = style.getShadow("shadowPress", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));
-		shadowDisabled = style.getShadow("shadowDisabled", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));
+		shadowNormal = style.getShadow("shadowNormal", context -> new DShadow(0xFF888888, 0, 1f * context.getScale(), 4 * context.getScale()));
+		shadowHover = style.getShadow("shadowHover", context -> new DShadow(0xFF888888, 0, 1f * context.getScale(), 4 * context.getScale()));
+		shadowPress = style.getShadow("shadowPress", context -> new DShadow(0xFF888888, 0, 1f * context.getScale(), 3 * context.getScale()));
+		shadowDisabled = style.getShadow("shadowDisabled", context -> new DShadow(0xFF888888, 0, 1f * context.getScale(), 3 * context.getScale()));
 	}
 }

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.DCanvas;
-import org.openzen.drawablegui.DTransform2D;
-
 /**
  *
  * @author Hoofdgebruiker

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

 public interface DComponent extends Closeable {
 	void setContext(DStylePath parent, DUIContext context);
 	
-	LiveObject<DDimensionPreferences> getDimensionPreferences();
+	LiveObject<DSizing> getSizing();
 	
 	DIRectangle getBounds();
 	

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

 public class DEmptyView implements DComponent {
 	public static final DEmptyView INSTANCE = new DEmptyView();
 	
-	private static final LiveObject<DDimensionPreferences> DIMENSION = new ImmutableLiveObject(new DDimensionPreferences(0, 0));
-	private static final DIRectangle NO_BOUNDS = new DIRectangle(0, 0, 0, 0);
+	private static final LiveObject<DSizing> DIMENSION = new ImmutableLiveObject(DSizing.EMPTY);
 	
 	private DEmptyView() {}
 
 	}
 	
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+	public LiveObject<DSizing> getSizing() {
 		return DIMENSION;
 	}
 	
 	@Override
 	public DIRectangle getBounds() {
-		return NO_BOUNDS;
+		return DIRectangle.EMPTY;
 	}
 
 	@Override

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

 import java.util.function.Predicate;
 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 final DStyleClass styleClass;
 	private final Alignment alignment;
 	private final Element[] components;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>>[] componentSizeListeners;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DUIContext context;
 	private DHorizontalLayoutStyle style;
 		totalShrink = 0;
 		
 		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i] = components[i].component.getDimensionPreferences().addListener((oldValue, newValue) -> updateDimensionPreferences());
+			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateDimensionPreferences());
 			
 			totalGrow += components[i].grow;
 			totalShrink += components[i].shrink;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		layout();
 	}
 
 	@Override
 		if (bounds == null || context == null)
 			return;
 		
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (bounds.width < myPreferences.preferredWidth) {
 			layoutShrinked();
 		} else {
 	}
 	
 	private void layoutShrinked() {
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (totalShrink == 0) {
 			// now what?
 			// shrink proportionally, we have to shrink...
 			
 			for (int i = 0; i < components.length; i++) {
 				Element element = components[i];
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newX = x + preferences.preferredWidth;
 				float idealUnspacedX = newX * scale;
 				int idealX = (int)(idealUnspacedX + 0.5f + i * style.spacing);
 			float deltaScaled = delta / totalShrink;
 			int x = 0;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredWidth + deltaScaled * element.shrink;
 				float idealUnspacedX = x + scaledSize;
 				int newX = (int)(idealUnspacedX + 0.5f);
 	
 	private void layoutGrown() {
 		// resize according to grow values
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		
 		if (totalGrow == 0) {
 			int deltaX = (int)(myPreferences.preferredWidth - bounds.width);
 			int x = bounds.x + (int)(deltaX * alignment.align);
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newX = x + preferences.preferredWidth;
 				layout(element, x, newX - x);
-				x = newX;
+				x = newX + style.spacing;
 			}
 		} else {
 			int delta = bounds.width - myPreferences.preferredWidth;
 			float deltaScaled = delta / totalGrow;
 			int x = 0;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredWidth + deltaScaled * element.grow;
 				float idealUnspacedX = x + scaledSize;
 				int newX = (int)(idealUnspacedX + 0.5f);
 	}
 	
 	private void layout(Element element, int x, int width) {
-		DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+		DSizing preferences = element.component.getSizing().getValue();
 		int height;
 		int y;
 		switch (element.alignment) {
 				y = bounds.y + style.paddingTop;
 				break;
 		}
-		element.component.setBounds(new DIRectangle(bounds.x + x, y, width, height));
+		element.component.setBounds(new DIRectangle(x, y, width, height));
 	}
 	
 	private void updateDimensionPreferences() {
 		int maximumWidth = -style.spacing;
 		int maximumHeight = Integer.MAX_VALUE;
 		for (Element element : components) {
-			DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+			DSizing preferences = element.component.getSizing().getValue();
 			preferredWidth += preferences.preferredWidth + style.spacing;
 			preferredHeight = Math.max(preferredHeight, preferences.preferredHeight);
 			
 			maximumHeight = Math.min(maximumHeight, preferences.maximumHeight);
 		}
 		
-		DDimensionPreferences preferences = new DDimensionPreferences(
+		DSizing preferences = new DSizing(
 				minimumWidth + style.paddingLeft + style.paddingRight,
 				minimumHeight + style.paddingTop + style.paddingBottom,
 				preferredWidth + style.paddingLeft + style.paddingRight,
 				preferredHeight + style.paddingTop + style.paddingBottom,
 				maximumWidth + style.paddingLeft + style.paddingRight,
 				maximumHeight + style.paddingTop + style.paddingBottom);
-		dimensionPreferences.setValue(preferences);
+		sizing.setValue(preferences);
 	}
 }

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

 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.live.MutableLiveString;
 import org.openzen.drawablegui.style.DDimension;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
  * @author Hoofdgebruiker
  */
 public class DInputField implements DComponent {
-	public final LiveString value;
+	public final MutableLiveString value;
 	private final ListenerHandle<LiveString.Listener> valueListener;
 	
 	private final DStyleClass styleClass;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private DIRectangle bounds = DIRectangle.EMPTY;
 	private final DDimension preferredWidth;
 	
 	private int cursorFrom = -1;
 	private int cursorTo = -1;
 	
+	private Runnable onEnter = null;
+	private Runnable onEscape = null;
+	
 	private boolean cursorBlink = true;
 	private DTimerHandle blinkTimer;
 	
-	public DInputField(DStyleClass styleClass, LiveString value, DDimension preferredWidth) {
+	public DInputField(DStyleClass styleClass, MutableLiveString value, DDimension preferredWidth) {
 		this.styleClass = styleClass;
 		this.value = value;
 		this.preferredWidth = preferredWidth;
 		cursorTo = value.getValue().length();
 	}
 	
+	public void setOnEnter(Runnable onEnter) {
+		this.onEnter = onEnter;
+	}
+	
+	public void setOnEscape(Runnable onEscape) {
+		this.onEscape = onEscape;
+	}
+	
 	@Override
 	public void close() {
 		valueListener.close();
 		DStylePath path = parent.getChild("input", styleClass);
 		style = new DInputFieldStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
-		dimensionPreferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				preferredWidth.evalInt(context) + style.paddingLeft + style.paddingRight + 2 * style.borderWidth,
 				fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingTop + style.paddingBottom + 2 * style.borderWidth));
 		
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		}
 	}
 	
+	@Override
+	public void onMouseEnter(DMouseEvent e) {
+		context.setCursor(DUIContext.Cursor.TEXT);
+	}
+	
+	@Override
+	public void onMouseExit(DMouseEvent e) {
+		context.setCursor(DUIContext.Cursor.NORMAL);
+	}
+	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
 		context.getWindow().focus(this);
 			case ENTER:
 				enter();
 				break;
+			case ESCAPE:
+				escape();
+				break;
 			default:
 				if (e.character == DKeyEvent.CHAR_UNDEFINED)
 					return;
 	}
 	
 	private void enter() {
-		
+		if (onEnter != null)
+			onEnter.run();
+	}
+	
+	private void escape() {
+		if (onEscape != null)
+			onEscape.run();
 	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/DLabel.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;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DLabel implements DComponent {
+	private final LiveString label;
+	private final DStyleClass styleClass;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	private final ListenerHandle<LiveString.Listener> labelListener;
+	
+	private DUIContext context;
+	private DIRectangle bounds;
+	private DLabelStyle style;
+	private DFontMetrics fontMetrics;
+	
+	public DLabel(DStyleClass styleClass, LiveString label) {
+		this.styleClass = styleClass;
+		this.label = label;
+		
+		labelListener = label.addListener(this::onLabelChanged);
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("label", styleClass);
+		style = new DLabelStyle(context.getStylesheets().get(context, path));
+		
+		fontMetrics = context.getFontMetrics(style.font);
+		calculateDimension();
+	}
+
+	@Override
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public int getBaselineY() {
+		return style.border.getPaddingTop() + fontMetrics.getAscent();
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		style.border.paint(canvas, bounds);
+		canvas.drawText(style.font, style.color, bounds.x + style.border.getPaddingLeft(), bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(), label.getValue());
+	}
+
+	@Override
+	public void close() {
+		labelListener.close();
+	}
+	
+	private void onLabelChanged(String oldValue, String newValue) {
+		calculateDimension();
+		context.repaint(bounds);
+	}
+	
+	private void calculateDimension() {
+		sizing.setValue(new DSizing(
+			style.border.getPaddingLeft() + fontMetrics.getWidth(label.getValue()) + style.border.getPaddingRight(),
+			style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingTop()));
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DLabelStyle.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;
+
+import org.openzen.drawablegui.border.DBorder;
+import org.openzen.drawablegui.border.DPaddedBorder;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DLabelStyle {
+	public final DBorder border;
+	public final DFont font;
+	public final int color;
+	
+	public DLabelStyle(DStyleDefinition style) {
+		border = style.getBorder("border", context -> new DPaddedBorder(
+				(int)(4 * context.getScale()),
+				(int)(4 * context.getScale()),
+				(int)(4 * context.getScale()),
+				(int)(4 * context.getScale())));
+		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, (int)(14 * context.getTextScale())));
+		color = style.getColor("color", 0xFF000000);
+	}
+}

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

 import java.util.function.Predicate;
 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 DComponent main;
 	private final List<SideComponent> sides = new ArrayList<>();
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DStylePath path;
 	private DUIContext context;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		int bottom = bounds.y + bounds.height;
 		for (int i = sides.size() - 1; i >= 0; i--) {
 			SideComponent side = sides.get(i);
-			DDimensionPreferences preferences = side.component.getDimensionPreferences().getValue();
+			DSizing preferences = side.component.getSizing().getValue();
 			
 			switch (side.side) {
 				case TOP: {
 	}
 	
 	private void recalculateSize() {
-		DDimensionPreferences mainPreferences = main.getDimensionPreferences().getValue();
+		DSizing mainPreferences = main.getSizing().getValue();
 		int minimumWidth = mainPreferences.minimumWidth;
 		int minimumHeight = mainPreferences.minimumHeight;
 		int preferredWidth = mainPreferences.preferredWidth;
 		int maximumHeight = mainPreferences.maximumHeight;
 		
 		for (SideComponent side : sides) {
-			DDimensionPreferences sidePreferences = side.component.getDimensionPreferences().getValue();
+			DSizing sidePreferences = side.component.getSizing().getValue();
 			switch (side.side) {
 				case LEFT:
 				case RIGHT:
 			}
 		}
 		
-		dimensionPreferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				minimumWidth,
 				minimumHeight,
 				preferredWidth,
 			side.close();
 	}
 	
-	public class SideComponent implements Closeable, LiveObject.Listener<DDimensionPreferences> {
+	public class SideComponent implements Closeable, LiveObject.Listener<DSizing> {
 		public final Side side;
 		public final DComponent component;
-		public final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> listenerHandle;
+		public final ListenerHandle<LiveObject.Listener<DSizing>> listenerHandle;
 
 		public SideComponent(Side side, DComponent component) {
 			this.side = side;
 			this.component = component;
-			listenerHandle = component.getDimensionPreferences().addListener(this);
+			listenerHandle = component.getSizing().addListener(this);
 		}
 		
 		@Override
 		}
 
 		@Override
-		public void onUpdated(DDimensionPreferences oldValue, DDimensionPreferences newValue) {
+		public void onUpdated(DSizing oldValue, DSizing newValue) {
 			recalculateSize();
 		}
 	}

DrawableGui/src/main/java/org/openzen/drawablegui/DSimpleTooltip.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;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSimpleTooltip {
+	private final DStyleClass styleClass;
+	private final LiveString tooltip;
+	private final ListenerHandle<LiveString.Listener> tooltipListener;
+	
+	private DUIContext context;
+	private DIRectangle bounds;
+	private DFontMetrics fontMetrics;
+	private DTooltipStyle style;
+	private boolean visible = false;
+	private DTimerHandle timerHandle = null;
+	
+	public DSimpleTooltip(DStyleClass styleClass, LiveString tooltip) {
+		this.styleClass = styleClass;
+		this.tooltip = tooltip;
+		tooltipListener = tooltip.addListener(this::onTooltipChanged);
+	}
+	
+	private void onTooltipChanged(String oldValue, String newValue) {
+		if (context == null || bounds == null)
+			return;
+		
+		bounds = new DIRectangle(
+				bounds.x,
+				bounds.y,
+				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
+				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom());
+		context.repaint(bounds);
+	}
+	
+	public void onTargetMouseEnter(DMouseEvent e) {
+		if (timerHandle != null)
+			timerHandle.close();
+		
+		timerHandle = context.setTimer(1000, this::show);
+		bounds = new DIRectangle(
+				e.x,
+				e.y,
+				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
+				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom());
+	}
+	
+	public void onTargetMouseExit(DMouseEvent e) {
+		if (timerHandle != null) {
+			timerHandle.close();
+			timerHandle = null;
+		}
+		
+		hide();
+	}
+	
+	private void show() {
+		System.out.println("Show tooltip");
+		visible = true;
+		context.repaint(bounds);
+		
+		if (timerHandle != null) {
+			timerHandle.close();
+			timerHandle = null;
+		}
+	}
+	
+	private void hide() {
+		System.out.println("Hide tooltip");
+		visible = false;
+		context.repaint(bounds);
+	}
+	
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("tooltip", styleClass);
+		style = new DTooltipStyle(context.getStylesheets().get(context, path));
+		fontMetrics = context.getFontMetrics(style.font);
+	}
+	
+	public void paint(DCanvas canvas) {
+		if (!visible)
+			return;
+		
+		System.out.println("Actually paint tooltip");
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		style.border.paint(canvas, bounds);
+		canvas.drawText(style.font, style.textColor, bounds.x + style.border.getPaddingLeft(), bounds.y + style.border.getPaddingTop(), tooltip.getValue());
+	}
+	
+	public void close() {
+		tooltipListener.close();
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DDimensionPreferences.java → DrawableGui/src/main/java/org/openzen/drawablegui/DSizing.java

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+
 /**
  *
  * @author Hoofdgebruiker
  */
-public class DDimensionPreferences {
-	public static final DDimensionPreferences EMPTY = new DDimensionPreferences(0, 0);
+public class DSizing {
+	public static MutableLiveObject<DSizing> create() {
+		return new SimpleLiveObject<>(DSizing.EMPTY);
+	}
+	
+	public static final DSizing EMPTY = new DSizing(0, 0);
 	
 	public final int minimumWidth;
 	public final int minimumHeight;
 	public final int maximumWidth;
 	public final int maximumHeight;
 	
-	public DDimensionPreferences(int preferredWidth, int preferredHeight) {
+	public DSizing(int preferredWidth, int preferredHeight) {
 		this.minimumWidth = 0;
 		this.minimumHeight = 0;
 		this.preferredWidth = preferredWidth;
 		this.maximumHeight = 1000000;
 	}
 	
-	public DDimensionPreferences(int minimumWidth, int minimumHeight, int preferredWidth, int preferredHeight, int maximumWidth, int maximumHeight) {
+	public DSizing(int minimumWidth, int minimumHeight, int preferredWidth, int preferredHeight, int maximumWidth, int maximumHeight) {
 		this.minimumWidth = minimumWidth;
 		this.minimumHeight = minimumHeight;
 		this.preferredWidth = preferredWidth;

DrawableGui/src/main/java/org/openzen/drawablegui/DTooltipStyle.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;
+
+import org.openzen.drawablegui.border.DBorder;
+import org.openzen.drawablegui.border.DCompositeBorder;
+import org.openzen.drawablegui.border.DLineBorder;
+import org.openzen.drawablegui.border.DPaddedBorder;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DTooltipStyle {
+	public final DBorder border;
+	public final DFont font;
+	public final int backgroundColor;
+	public final int textColor;
+	
+	public DTooltipStyle(DStyleDefinition style) {
+		border = style.getBorder("border", context -> new DCompositeBorder(
+				new DLineBorder(0xFF, 1),
+				new DPaddedBorder(context.dp(4), context.dp(4), context.dp(4), context.dp(4))));
+		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, context.sp(12)));
+		backgroundColor = style.getColor("backgroundColor", 0xFFFFFFE1);
+		textColor = style.getColor("textColor", 0xFF000000);
+	}
+}

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

 	
 	DUIWindow openView(int x, int y, DAnchor anchor, DComponent root);
 	
+	default int dp(float dp) {
+		return (int)(dp * getScale());
+	}
+	
+	default int sp(float sp) {
+		return (int)(sp * getTextScale());
+	}
+	
 	enum Cursor {
 		NORMAL,
 		HAND,

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

 import java.util.function.Predicate;
 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 final DStyleClass styleClass;
 	private final Alignment alignment;
 	private final Element[] components;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>>[] componentSizeListeners;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DUIContext context;
 	private DHorizontalLayoutStyle style;
 		totalShrink = 0;
 		
 		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i] = components[i].component.getDimensionPreferences().addListener((oldValue, newValue) -> updateDimensionPreferences());
+			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateDimensionPreferences());
 			
 			totalGrow += components[i].grow;
 			totalShrink += components[i].shrink;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		layout();
 	}
 
 	@Override
 
 	@Override
 	public void close() {
-		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i].close();
+		for (ListenerHandle<LiveObject.Listener<DSizing>> listener : componentSizeListeners) {
+			listener.close();
 		}
 	}
 	
 		if (bounds == null || context == null)
 			return;
 		
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (bounds.height < myPreferences.preferredHeight) {
 			layoutShrinked();
 		} else {
 	}
 	
 	private void layoutShrinked() {
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (totalShrink == 0) {
 			// now what?
 			// shrink proportionally, we have to shrink...
 			
 			for (int i = 0; i < components.length; i++) {
 				Element element = components[i];
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newY = y + preferences.preferredHeight;
 				float idealUnspacedY = newY * scale;
 				int idealY = (int)(idealUnspacedY + 0.5f + i * style.spacing);
 			float deltaScaled = delta / totalShrink;
 			int y = bounds.y;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
 				float idealUnspacedY = y + scaledSize;
 				int newY = (int)(idealUnspacedY + 0.5f);
 	
 	private void layoutGrown() {
 		// resize according to grow values
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		
 		if (totalGrow == 0) {
 			int deltaY = (int)(myPreferences.preferredHeight - bounds.height);
 			int y = bounds.y + (int)(deltaY * alignment.align);
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newY = y + preferences.preferredHeight;
 				layout(element, y, newY - y);
 				y = newY;
 			float deltaScaled = delta / totalGrow;
 			int y = bounds.y;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredHeight + deltaScaled * element.grow;
-				float idealUnspacedX = y + scaledSize;
-				int newY = (int)(idealUnspacedX + 0.5f);
+				float idealUnspacedY = y + scaledSize;
+				int newY = (int)(idealUnspacedY + 0.5f);
 				layout(element, y, newY - y);
 				y = newY + style.spacing;
 			}
 	}
 	
 	private void layout(Element element, int y, int height) {
-		DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+		DSizing preferences = element.component.getSizing().getValue();
 		int x;
 		int width;
 		switch (element.alignment) {
 		int maximumHeight = -style.spacing;
 		
 		for (Element element : components) {
-			DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+			DSizing preferences = element.component.getSizing().getValue();
 			preferredWidth = Math.max(preferredWidth, preferences.preferredWidth);
 			preferredHeight += preferences.preferredHeight + style.spacing;
 			
 			maximumHeight += preferences.maximumHeight + style.spacing;
 		}
 		
-		DDimensionPreferences preferences = new DDimensionPreferences(
+		DSizing preferences = new DSizing(
 				minimumWidth + style.paddingLeft + style.paddingRight,
 				minimumHeight + style.paddingTop + style.paddingBottom,
 				preferredWidth + style.paddingLeft + style.paddingRight,
 				preferredHeight + style.paddingTop + style.paddingBottom,
 				maximumWidth + style.paddingLeft + style.paddingRight,
 				maximumHeight + style.paddingTop + style.paddingBottom);
-		dimensionPreferences.setValue(preferences);
+		sizing.setValue(preferences);
 	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/border/DCompositeBorder.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DCompositeBorder implements DBorder {
+	private final DBorder[] borders;
+	
+	public DCompositeBorder(DBorder... borders) {
+		this.borders = borders;
+	}
+
+	@Override
+	public void paint(DCanvas canvas, DIRectangle bounds) {
+		for (DBorder border : borders) {
+			border.paint(canvas, bounds);
+			bounds = new DIRectangle(
+					bounds.x + border.getPaddingLeft(),
+					bounds.y + border.getPaddingTop(),
+					bounds.width - border.getPaddingLeft() - border.getPaddingRight(),
+					bounds.height - border.getPaddingTop() - border.getPaddingBottom());
+		}
+	}
+
+	@Override
+	public int getPaddingLeft() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingLeft();
+		return total;
+	}
+
+	@Override
+	public int getPaddingRight() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingRight();
+		return total;
+	}
+
+	@Override
+	public int getPaddingTop() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingTop();
+		return total;
+	}
+
+	@Override
+	public int getPaddingBottom() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingBottom();
+		return total;
+	}
+}

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 public class DCustomWindowBorder implements DComponent {
 	private final DStyleClass styleClass;
 	private final DComponent content;
-	private final LiveObject<DDimensionPreferences> preferences = new ImmutableLiveObject<>(DDimensionPreferences.EMPTY);
+	private final LiveObject<DSizing> sizing = new ImmutableLiveObject<>(DSizing.EMPTY);
 	
 	private DUIContext context;
 	private DCustomWindowBorderStyle style;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DUIContext;
 
 /**
  *
 public class DEmptyBorder implements DBorder {
 	public static final DEmptyBorder INSTANCE = new DEmptyBorder();
 	
+	private DEmptyBorder() {}
+	
 	@Override
 	public void paint(DCanvas canvas, DIRectangle bounds) {
 		

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DUIContext;
 
 /**
  *

DrawableGui/src/main/java/org/openzen/drawablegui/border/DPaddedBorder.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DPaddedBorder implements DBorder {
+	private final int left;
+	private final int top;
+	private final int right;
+	private final int bottom;
+	
+	public DPaddedBorder(int left, int top, int right, int bottom) {
+		this.left = left;
+		this.top = top;
+		this.right = right;
+		this.bottom = bottom;
+	}
+
+	@Override
+	public void paint(DCanvas canvas, DIRectangle bounds) {
+		// nothing to paint
+	}
+
+	@Override
+	public int getPaddingLeft() {
+		return left;
+	}
+
+	@Override
+	public int getPaddingRight() {
+		return right;
+	}
+
+	@Override
+	public int getPaddingTop() {
+		return top;
+	}
+
+	@Override
+	public int getPaddingBottom() {
+		return bottom;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/form/DForm.java

 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 public class DForm extends BaseComponentGroup {
 	private final DFormComponent[] components;
 	private final DStyleClass styleClass;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DIRectangle bounds;
 	private DUIContext context;
 		
 		for (DFormComponent component : components) {
 			maxLabelWidth = Math.max(maxLabelWidth, fontMetrics.getWidth(component.label));
-			int componentWidth = component.component.getDimensionPreferences().getValue().preferredWidth;
+			int componentWidth = component.component.getSizing().getValue().preferredWidth;
 			maxFieldWidth = Math.max(maxFieldWidth, componentWidth);
 		}
 		
 		for (DFormComponent component : components) {
-			height += component.component.getDimensionPreferences().getValue().preferredHeight;
+			height += component.component.getSizing().getValue().preferredHeight;
 			height += style.spacing;
 		}
 		
 		this.maxFieldWidth = maxFieldWidth;
 		this.maxLabelWidth = maxLabelWidth;
-		preferences.setValue(new DDimensionPreferences(maxLabelWidth + maxFieldWidth + style.paddingLeft + style.paddingRight + style.spacing, height));
+		sizing.setValue(new DSizing(maxLabelWidth + maxFieldWidth + style.paddingLeft + style.paddingRight + style.spacing, height));
 		
 		if (bounds != null)
 			layout();
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 			canvas.drawText(style.labelFont, style.labelColor, x, y + baseline, component.label);
 			component.component.paint(canvas);
 			
-			y += component.component.getDimensionPreferences().getValue().preferredHeight + style.spacing;
+			y += component.component.getSizing().getValue().preferredHeight + style.spacing;
 		}
 	}
 
 		int y = bounds.y + style.paddingBottom;
 		
 		for (DFormComponent component : components) {
-			int preferredHeight = component.component.getDimensionPreferences().getValue().preferredHeight;
+			int preferredHeight = component.component.getSizing().getValue().preferredHeight;
 			DIRectangle componentBounds = new DIRectangle(x + maxLabelWidth, y, bounds.width - maxLabelWidth - style.paddingLeft - style.paddingRight - style.spacing, preferredHeight);
 			component.component.setBounds(componentBounds);
 			

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

 		return value;
 	}
 
-	@Override
-	public void setValue(boolean value) {
-		throw new UnsupportedOperationException("Cannot modify an immutable value");
-	}
-
 	@Override
 	public ListenerHandle<Listener> addListener(Listener listener) {
 		return new DummyListenerHandle<>(listener);

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

 		return value;
 	}
 
-	@Override
-	public void setValue(T value) {
-		throw new UnsupportedOperationException("Immutable value");
-	}
-
 	@Override
 	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
 		return new DummyListenerHandle<>(listener);

DrawableGui/src/main/java/org/openzen/drawablegui/live/ImmutableLiveString.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.DummyListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ImmutableLiveString implements LiveString {
+	private final String value;
+
+	public ImmutableLiveString(String value) {
+		this.value = value;
+	}
+	
+	@Override
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return new DummyListenerHandle<>(listener);
+	}
+
+	@Override
+	public String getValue() {
+		return value;
+	}
+}

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

  *
  * @author Hoofdgebruiker
  */
-public class LiveArrayList<T> implements LiveList<T> {
+public class LiveArrayList<T> implements MutableLiveList<T> {
 	private final List<T> values = new ArrayList<>();
 	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
 
 	public T get(int index) {
 		return values.get(index);
 	}
+	
+	@Override
+	public void close() {
+		// TODO: close closeables
+	}
 
 	@Override
 	public Iterator<T> iterator() {

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

 public interface LiveBool {
 	public boolean getValue();
 	
-	public void setValue(boolean value);
-	
-	default void toggle() {
-		setValue(!getValue());
-	}
-	
 	public ListenerHandle<Listener> addListener(Listener listener);
 	
 	public interface Listener {

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

 		bListener.close();
 	}
 
-	@Override
-	public void add(T value) {
-		throw new UnsupportedOperationException("Cannot modify a concat list");
-	}
-
-	@Override
-	public void add(int index, T value) {
-		throw new UnsupportedOperationException("Cannot modify a concat list");
-	}
-
-	@Override
-	public void set(int index, T value) {
-		throw new UnsupportedOperationException("Cannot modify a concat list");
-	}
-
-	@Override
-	public void remove(int index) {
-		throw new UnsupportedOperationException("Cannot modify a concat list");
-	}
-
-	@Override
-	public void remove(T value) {
-		throw new UnsupportedOperationException("Cannot modify a concat list");
-	}
-
 	@Override
 	public int indexOf(T value) {
 		int result = a.indexOf(value);

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

 	public static <T> LiveEmptyList<T> get() {
 		return INSTANCE;
 	}
-
-	@Override
-	public void add(T value) {
-		throw new UnsupportedOperationException("Immutable list");
-	}
-
-	@Override
-	public void add(int index, T value) {
-		throw new UnsupportedOperationException("Immutable list");
-	}
-
-	@Override
-	public void set(int index, T value) {
-		throw new UnsupportedOperationException("Immutable list");
-	}
-
-	@Override
-	public void remove(int index) {
-		throw new UnsupportedOperationException("Immutable list");
-	}
-
+	
 	@Override
-	public void remove(T value) {
-		throw new UnsupportedOperationException("Immutable list");
+	public void close() {
+		
 	}
 
 	@Override

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

  * @author Hoofdgebruiker
  */
 public interface LiveList<T> extends Iterable<T> {
-	void add(T value);
-	
-	void add(int index, T value);
-	
-	void set(int index, T value);
-	
-	void remove(int index);
-	
-	void remove(T value);
-	
 	int indexOf(T value);
 	
 	int size();
 	
 	T get(int index);
 	
+	void close();
+	
 	@Override
 	Iterator<T> iterator();
 	

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

 		mappingListenerHandle.close();
 	}
 
-	@Override
-	public void add(U value) {
-		throw new UnsupportedOperationException("Cannot modify a mapped list");
-	}
-
-	@Override
-	public void add(int index, U value) {
-		throw new UnsupportedOperationException("Cannot modify a mapped list");
-	}
-
-	@Override
-	public void set(int index, U value) {
-		throw new UnsupportedOperationException("Cannot modify a mapped list");
-	}
-
-	@Override
-	public void remove(int index) {
-		throw new UnsupportedOperationException("Cannot modify a mapped list");
-	}
-
-	@Override
-	public void remove(U value) {
-		throw new UnsupportedOperationException("Cannot modify a mapped list");
-	}
-
 	@Override
 	public int indexOf(U value) {
 		return mapped.indexOf(value);

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

 public interface LiveObject<T> {
 	public T getValue();
 	
-	public void setValue(T value);
-	
 	public ListenerHandle<Listener<T>> addListener(Listener<T> listener);
 	
 	public interface Listener<T> {

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

 	public void close() {
 		sourceListener.close();
 	}
-	
-	@Override
-	public void setValue(boolean value) {
-		throw new UnsupportedOperationException("Cannot modify a calculated value");
-	}
 
 	@Override
 	public boolean getValue() {

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

 	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
 	private final T prefix;
 	private final LiveList<T> values;
+	private final ListenerHandle<LiveList.Listener<T>> baseListener;
 	
 	public LivePrefixedList(T prefix, LiveList<T> values) {
 		this.prefix = prefix;
 		this.values = values;
+		this.baseListener = values.addListener(new BaseListener());
 	}
-
+	
 	@Override
+	public void close() {
+		baseListener.close();
+	}
+
+	/*@Override
 	public void add(T value) {
 		values.add(value);
 	}
 	@Override
 	public void remove(T value) {
 		values.remove(value);
-	}
+	}*/
 
 	@Override
 	public int indexOf(T value) {

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

 	
 	String getValue();
 	
-	void setValue(String value);
-	
 	interface Listener {
 		void onChanged(String oldValue, String newValue);
 	}

DrawableGui/src/main/java/org/openzen/drawablegui/live/MutableLiveBool.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MutableLiveBool extends LiveBool {
+	void setValue(boolean value);
+	
+	default void toggle() {
+		setValue(!getValue());
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/live/MutableLiveList.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MutableLiveList<T> extends LiveList<T> {
+	void add(T value);
+	
+	void add(int index, T value);
+	
+	void set(int index, T value);
+	
+	void remove(int index);
+	
+	void remove(T value);
+}

DrawableGui/src/main/java/org/openzen/drawablegui/live/MutableLiveObject.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MutableLiveObject<T> extends LiveObject<T> {
+	public void setValue(T value);
+}

DrawableGui/src/main/java/org/openzen/drawablegui/live/MutableLiveString.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MutableLiveString extends LiveString {
+	void setValue(String value);
+}

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

  *
  * @author Hoofdgebruiker
  */
-public class SimpleLiveBool implements LiveBool {
+public class SimpleLiveBool implements MutableLiveBool {
 	private final ListenerList<LiveBool.Listener> listeners = new ListenerList<>();
 	private boolean value;
 	

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

  *
  * @author Hoofdgebruiker
  */
-public class SimpleLiveObject<T> implements LiveObject<T> {
+public class SimpleLiveObject<T> implements MutableLiveObject<T> {
 	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
 	private T value;
 	

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

  *
  * @author Hoofdgebruiker
  */
-public class SimpleLiveString implements LiveString {
+public class SimpleLiveString implements MutableLiveString {
 	private final ListenerList<Listener> listeners = new ListenerList<>();
 	
 	private String value;

DrawableGui/src/main/java/org/openzen/drawablegui/live/SortedLiveList.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 java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SortedLiveList<T> implements LiveList<T>, LiveList.Listener<T> {
+	private final LiveList<T> original;
+	private final Comparator<T> ordering;
+	private final List<T> sorted;
+	private final ListenerHandle<LiveList.Listener<T>> originalListener;
+	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
+	
+	public SortedLiveList(LiveList<T> original, Comparator<T> ordering) {
+		this.original = original;
+		this.ordering = ordering;
+		
+		sorted = new ArrayList<>();
+		for (T item : original)
+			sorted.add(item);
+		
+		Collections.sort(sorted, ordering);
+		originalListener = original.addListener(this);
+	}
+	
+	@Override
+	public void close() {
+		original.close();
+		originalListener.close();
+	}
+
+	@Override
+	public int indexOf(T value) {
+		return sorted.indexOf(value);
+	}
+
+	@Override
+	public int size() {
+		return sorted.size();
+	}
+
+	@Override
+	public T get(int index) {
+		return sorted.get(index);
+	}
+
+	@Override
+	public Iterator<T> iterator() {
+		return sorted.iterator();
+	}
+
+	@Override
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
+		return listeners.add(listener);
+	}
+
+	@Override
+	public void onInserted(int index, T value) {
+		internalAdd(value);
+	}
+
+	@Override
+	public void onChanged(int index, T oldValue, T newValue) {
+		internalRemove(oldValue);
+		internalAdd(newValue);
+	}
+
+	@Override
+	public void onRemoved(int index, T oldValue) {
+		internalRemove(oldValue);
+	}
+	
+	private void internalAdd(T value) {
+		int atIndex = 0;
+		while (atIndex < sorted.size() && ordering.compare(value, sorted.get(atIndex)) > 0)
+			atIndex++;
+		
+		sorted.add(atIndex, value);
+		final int finalAtIndex = atIndex;
+		listeners.accept(listener -> listener.onInserted(finalAtIndex, value));
+	}
+	
+	private void internalRemove(T value) {
+		int index = sorted.indexOf(value);
+		if (index < 0)
+			return;
+		
+		sorted.remove(index);
+		listeners.accept(listener -> listener.onRemoved(index, value));
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollBar.java

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveInt;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
  * @author Hoofdgebruiker
  */
 public class DScrollBar implements DComponent {
-	private final LiveObject<DDimensionPreferences> preferences;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private final DStyleClass styleClass;
 	private final LiveInt targetHeight;
 		this.styleClass = styleClass;
 		this.targetHeight = targetHeight;
 		this.offset = offset;
-		this.preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
 		
 		targetHeightListener = targetHeight.addListener(new ScrollListener());
 		offsetListener = offset.addListener(new ScrollListener());
 	public void setContext(DStylePath parent, DUIContext context) {
 		this.context = context;
 		this.style = new DScrollBarStyle(context.getStylesheets().get(context, parent.getChild("scrollbar", styleClass)));
-		preferences.setValue(new DDimensionPreferences(style.width, 0));
+		sizing.setValue(new DSizing(style.width, 0));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 
 	@Override
 	public void close() {
-		// nothing to clean up
+		targetHeightListener.close();
+		offsetListener.close();
 	}
 	
 	private void checkHover(DMouseEvent e) {

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollPane.java

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 		offsetXListener = offsetX.addListener(new ScrollListener());
 		offsetYListener = offsetY.addListener(new ScrollListener());
 		
-		contents.getDimensionPreferences().addListener((oldPreferences, newPreferences) -> {
+		contents.getSizing().addListener((oldPreferences, newPreferences) -> {
 			if (bounds == null)
 				return;
 			
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return contents.getDimensionPreferences(); // TODO: derived preferences
+	public LiveObject<DSizing> getSizing() {
+		return contents.getSizing(); // TODO: derived preferences
 	}
 
 	@Override
 		if (this.context == null)
 			return;
 		
-		int height = Math.max(
-				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom(),
-				contents.getDimensionPreferences().getValue().preferredHeight);
-		int scrollBarWidth = scrollBar.getDimensionPreferences().getValue().preferredWidth;
+		int height = Math.max(bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom(),
+				contents.getSizing().getValue().preferredHeight);
+		int scrollBarWidth = scrollBar.getSizing().getValue().preferredWidth;
 		scrollBar.setBounds(new DIRectangle(
 				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight(),
 				bounds.y + style.border.getPaddingTop(),

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollPaneStyle.java

 
 import org.openzen.drawablegui.border.DBorder;
 import org.openzen.drawablegui.border.DLineBorder;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**

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

 import javax.swing.JDialog;
 import javax.swing.JFrame;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
 
 	@Override
 	public void close() {
-		System.exit(0);
+		dispose();
 	}
 
 	@Override
 		SwingDialog result = new SwingDialog(this, title, component, false);
 		result.setResizable(false);
 		
-		DDimensionPreferences size = component.getDimensionPreferences().getValue();
+		DSizing size = component.getSizing().getValue();
 		result.setLocation(
 				getX() + (getWidth() - size.preferredWidth) / 2,
 				getY() + (getHeight() - size.preferredHeight) / 2);

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

 import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontMetrics;
 		windowContext.graphics = this.graphics; // help a little...
 		
 		root.setContext(DStylePathRoot.INSTANCE, windowContext);
-		DDimensionPreferences dimension = root.getDimensionPreferences().getValue();
+		DSizing dimension = root.getSizing().getValue();
 		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
 		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
 		
 		windowContext.graphics = this.graphics; // help a little...
 		
 		root.setContext(DStylePathRoot.INSTANCE, windowContext);
-		DDimensionPreferences dimension = root.getDimensionPreferences().getValue();
+		DSizing dimension = root.getSizing().getValue();
 		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
 		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
 		

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

 import java.awt.event.WindowStateListener;
 import javax.swing.JFrame;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
 		SwingWindow result = new SwingWindow(title, component, false);
 		result.setResizable(false);
 		
-		DDimensionPreferences size = component.getDimensionPreferences().getValue();
+		DSizing size = component.getSizing().getValue();
 		result.setLocation(
 				getX() + (getWidth() - size.preferredWidth) / 2,
 				getY() + (getHeight() - size.preferredHeight) / 2);

DrawableGui/src/main/java/org/openzen/drawablegui/tree/DTreeNode.java

 
 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DMouseEvent;
-import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.MutableLiveBool;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface DTreeNode<N extends DTreeNode<N>> {
+	void close();
+	
 	DColorableIcon getIcon();
 	
 	String getTitle();
 	
 	LiveList<N> getChildren();
 	
-	LiveBool isCollapsed();
+	MutableLiveBool isCollapsed();
 	
 	boolean isLeaf();
 	

DrawableGui/src/main/java/org/openzen/drawablegui/tree/DTreeView.java

 import java.util.List;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
-import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStylePath;
 
 /**
  * @author Hoofdgebruiker
  */
 public class DTreeView<N extends DTreeNode<N>> implements DComponent {
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private DIRectangle bounds;
 	
 	private int selectedRow = -1;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public MutableLiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 	
 	@Override
 		}
 		
 		if (rows.size() != oldRowCount) {
-			DDimensionPreferences preferences = dimensionPreferences.getValue();
-			dimensionPreferences.setValue(
-					new DDimensionPreferences(
+			DSizing preferences = sizing.getValue();
+			sizing.setValue(new DSizing(
 							preferences.minimumWidth,
 							preferences.minimumHeight,
 							preferences.preferredWidth,
 		// nothing to clean up
 	}
 	
-	private class Row implements Closeable, LiveBool.Listener {
+	private class Row implements Closeable, LiveBool.Listener, LiveList.Listener<N> {
 		private final int x;
 		private final N node;
 		private final ListenerHandle<LiveBool.Listener> collapseListener;
+		private final ListenerHandle<LiveList.Listener<N>> childListener;
 		
 		public Row(int x, N node) {
 			this.x = x;
 			this.node = node;
 			this.collapseListener = node.isCollapsed().addListener(this);
+			this.childListener = node.getChildren().addListener(this);
 		}
 
 		@Override
 			updateLayout();
 			context.repaint(bounds);
 		}
+
+		@Override
+		public void onInserted(int index, N value) {
+			updateLayout();
+			context.repaint(bounds);
+		}
+
+		@Override
+		public void onChanged(int index, N oldValue, N newValue) {
+			updateLayout();
+			context.repaint(bounds);
+		}
+
+		@Override
+		public void onRemoved(int index, N oldValue) {
+			updateLayout();
+			context.repaint(bounds);
+		}
 		
 		@Override
 		public void close() {
 			collapseListener.close();
+			childListener.close();
 		}
 	}
 }

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

 	public LiveList<IDEPackage> getSubPackages();
 	
 	public LiveList<IDESourceFile> getSourceFiles();
+	
+	public IDEPackage createSubPackage(String name);
+	
+	public IDESourceFile createSourceFile(String name);
 }

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

 
 import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.MutableLiveList;
 import org.openzen.zenscript.constructor.Library;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.ide.host.IDELibrary;
  */
 public class LocalLibrary implements IDELibrary {
 	private final Library library;
-	private final LiveList<IDEModule> modules;
+	private final MutableLiveList<IDEModule> modules;
 	
 	public LocalLibrary(Library library) {
 		this.library = library;

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

  */
 public class LocalModule implements IDEModule {
 	private final ModuleReference module;
+	private final LocalPackage rootPackage;
 	
 	public LocalModule(ModuleReference module) {
 		this.module = module;
+		rootPackage = new LocalPackage(module.getRootPackage());
 	}
 
 	@Override
 
 	@Override
 	public IDEPackage getRootPackage() {
-		return new LocalPackage(module.getRootPackage());
+		return rootPackage;
 	}
 }

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

  */
 package org.openzen.zenscript.ide.host.local;
 
+import java.io.File;
+import java.io.IOException;
 import java.util.Arrays;
 import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.MutableLiveList;
+import org.openzen.drawablegui.live.SortedLiveList;
+import org.openzen.zenscript.constructor.module.SourceFile;
 import org.openzen.zenscript.constructor.module.SourcePackage;
 import org.openzen.zenscript.ide.host.IDEPackage;
 import org.openzen.zenscript.ide.host.IDESourceFile;
  */
 public class LocalPackage implements IDEPackage {
 	private final SourcePackage pkg;
-	private final LiveList<IDEPackage> subPackages = new LiveArrayList<>();
-	private final LiveList<IDESourceFile> sourceFiles = new LiveArrayList<>();
+	private final MutableLiveList<IDEPackage> subPackages = new LiveArrayList<>();
+	private final MutableLiveList<IDESourceFile> sourceFiles = new LiveArrayList<>();
+	
+	private final LiveList<IDEPackage> subPackagesSorted;
+	private final LiveList<IDESourceFile> sourceFilesSorted;
 	
 	public LocalPackage(SourcePackage pkg) {
 		this.pkg = pkg;
 				.toArray(new String[pkg.sourceFiles.size()]);
 		Arrays.sort(sourceFileKeys);
 		
-		for (String subKey : subPackageKeys) {
-			subPackages.add(new LocalPackage(pkg.subPackages.get(subKey)));
+		for (SourcePackage subPackage : pkg.subPackages.values()) {
+			subPackages.add(new LocalPackage(subPackage));
 		}
-		for (String sourceFileKey : sourceFileKeys) {
-			sourceFiles.add(new LocalSourceFile(pkg.sourceFiles.get(sourceFileKey)));
+		for (SourceFile sourceFile : pkg.sourceFiles.values()) {
+			sourceFiles.add(new LocalSourceFile(sourceFile));
 		}
+		
+		subPackagesSorted = new SortedLiveList<>(subPackages, (a, b) -> a.getName().compareTo(b.getName()));
+		sourceFilesSorted = new SortedLiveList<>(sourceFiles, (a, b) -> a.getName().compareTo(b.getName()));
 	}
 	
 	@Override
 
 	@Override
 	public LiveList<IDEPackage> getSubPackages() {
-		return subPackages;
+		return subPackagesSorted;
 	}
 
 	@Override
 	public LiveList<IDESourceFile> getSourceFiles() {
-		return sourceFiles;
+		return sourceFilesSorted;
+	}
+	
+	@Override
+	public IDEPackage createSubPackage(String name) {
+		File file = new File(this.pkg.directory, name);
+		file.mkdir();
+		
+		SourcePackage sourcePackage = new SourcePackage(file, name);
+		IDEPackage pkg = new LocalPackage(sourcePackage);
+		this.pkg.subPackages.put(name, sourcePackage);
+		subPackages.add(pkg);
+		return pkg;
+	}
+	
+	@Override
+	public IDESourceFile createSourceFile(String name) {
+		File file = new File(this.pkg.directory, name);
+		try {
+			file.createNewFile();
+		} catch (IOException ex) {
+			ex.printStackTrace(); // TODO
+		}
+		
+		SourceFile sourceFile = new SourceFile(name, file);
+		IDESourceFile localSourceFile = new LocalSourceFile(sourceFile);
+		this.pkg.sourceFiles.put(name, sourceFile);
+		sourceFiles.add(localSourceFile);
+		return localSourceFile;
 	}
 }

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

  */
 package org.openzen.zenscript.ide.host.local;
 
-import java.util.List;
 import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.MutableLiveList;
 import org.openzen.zenscript.constructor.Library;
 import org.openzen.zenscript.constructor.Project;
 import org.openzen.zenscript.constructor.module.ModuleReference;
  */
 public class LocalProjectDevelopmentHost implements DevelopmentHost {
 	private final Project project;
-	private final LiveList<IDEModule> modules;
-	private final LiveList<IDELibrary> libraries;
-	private final LiveList<IDETarget> targets;
+	private final MutableLiveList<IDEModule> modules;
+	private final MutableLiveList<IDELibrary> libraries;
+	private final MutableLiveList<IDETarget> targets;
 	
 	public LocalProjectDevelopmentHost(Project project) {
 		this.project = project;

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

 package org.openzen.zenscript.ide.ui;
 
 import org.openzen.drawablegui.live.LiveArrayList;
-import org.openzen.drawablegui.live.LiveList;
-import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveList;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 
 /**
  * @author Hoofdgebruiker
  */
 public class IDEAspectBar {
-	public final LiveList<IDEAspectToolbar> toolbars = new LiveArrayList<>();
-	public final LiveObject<IDEAspectToolbar> active = new SimpleLiveObject<>(null);
+	public final MutableLiveList<IDEAspectToolbar> toolbars = new LiveArrayList<>();
+	public final MutableLiveObject<IDEAspectToolbar> active = new SimpleLiveObject<>(null);
 }

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

 
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.live.LiveArrayList;
-import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.MutableLiveList;
 
 /**
  *
 	public final DDrawable icon;
 	public final String title;
 	public final String description;
-	public final LiveList<IDEAspectBarControl> controls = new LiveArrayList<>();
+	public final MutableLiveList<IDEAspectBarControl> controls = new LiveArrayList<>();
 	
 	public IDEAspectToolbar(int order, DDrawable icon, String title, String description) {
 		this.order = order;

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

  */
 package org.openzen.zenscript.ide.ui;
 
-import org.openzen.drawablegui.DAnchor;
-import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DEmptyView;
-import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DInputField;
-import org.openzen.drawablegui.DUIWindow;
-import org.openzen.drawablegui.form.DForm;
-import org.openzen.drawablegui.form.DFormComponent;
 import org.openzen.drawablegui.live.LiveBool;
-import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LivePredicateBool;
-import org.openzen.drawablegui.live.SimpleLiveBool;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
-import org.openzen.drawablegui.live.SimpleLiveString;
-import org.openzen.drawablegui.style.DDpDimension;
 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;
 	
 	public IDEAspectToolbar projectToolbar;
 	
-	private final LiveObject<IDEModule> contextModule = new SimpleLiveObject<>(null);
-	private final LiveObject<IDEPackage> contextPackage = new SimpleLiveObject<>(null);
-	private final LiveObject<IDESourceFile> contextFile = new SimpleLiveObject<>(null);
+	private final MutableLiveObject<IDEModule> contextModule = new SimpleLiveObject<>(null);
+	private final MutableLiveObject<IDEPackage> contextPackage = new SimpleLiveObject<>(null);
+	private final MutableLiveObject<IDESourceFile> contextFile = new SimpleLiveObject<>(null);
 	private final LiveBool addContentDisabled = new LivePredicateBool(contextPackage, pkg -> pkg == null);
 	
 	public IDEWindow(DevelopmentHost host) {
 	private void init() {
 		projectToolbar = new IDEAspectToolbar(0, ShadedProjectIcon.PURPLE, "Project", "Project management");
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, AddBoxIcon.BLUE, AddBoxIcon.GRAY, addContentDisabled, e -> {
-			DComponent input = new DInputField(DStyleClass.EMPTY, new SimpleLiveString(""), new DDpDimension(100));
-			DForm root = new DForm(DStyleClass.EMPTY, new DFormComponent("Package name:", input));
-			
-			DUIWindow window = e.window;
-			DIRectangle rectangle = window.getWindowBounds();
-			DUIWindow newWindow = e.window.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_LEFT, "Create package", root);
-			
-			newWindow.focus(input);
+			CreatePackageDialog dialog = new CreatePackageDialog(this, contextModule.getValue(), contextPackage.getValue());
+			dialog.open(e.window);
 		}));
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, AddBoxIcon.ORANGE, AddBoxIcon.GRAY, addContentDisabled, e -> {
-			DComponent input = new DInputField(DStyleClass.EMPTY, new SimpleLiveString(""), new DDpDimension(100));
-			DForm root = new DForm(DStyleClass.EMPTY, new DFormComponent("Filename:", input));
-			
-			DUIWindow window = e.window;
-			DIRectangle rectangle = window.getWindowBounds();
-			DUIWindow newWindow = e.window.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_LEFT, "Create file", root);
-			
-			newWindow.focus(input);
+			CreateSourceFileDialog dialog = new CreateSourceFileDialog(this, contextModule.getValue(), contextPackage.getValue());
+			dialog.open(e.window);
 		}));
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, SettingsIcon.PURPLE, e -> {
 			
 		contextFile.setValue(null);
 	}
 	
-	public void setContextPackage(IDEPackage pkg) {
-		contextModule.setValue(null);
+	public void setContextPackage(IDEModule module, IDEPackage pkg) {
+		contextModule.setValue(module);
 		contextPackage.setValue(pkg);
 		contextFile.setValue(null);
 	}

IDE/src/main/java/org/openzen/zenscript/ide/ui/dialog/CreatePackageDialog.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.dialog;
+
+import org.openzen.drawablegui.DAnchor;
+import org.openzen.drawablegui.DButton;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.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.form.DForm;
+import org.openzen.drawablegui.form.DFormComponent;
+import org.openzen.drawablegui.live.ImmutableLiveBool;
+import org.openzen.drawablegui.live.ImmutableLiveString;
+import org.openzen.drawablegui.live.SimpleLiveString;
+import org.openzen.drawablegui.style.DDpDimension;
+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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CreatePackageDialog {
+	private final IDEWindow ideWindow;
+	private final IDEModule module;
+	private final IDEPackage pkg;
+	
+	private final SimpleLiveString name;
+	
+	private final DComponent root;
+	private final DInputField input;
+	
+	private DUIWindow window;
+	
+	public CreatePackageDialog(IDEWindow ideWindow, IDEModule module, IDEPackage pkg) {
+		this.ideWindow = ideWindow;
+		this.module = module;
+		this.pkg = pkg;
+		
+		name = new SimpleLiveString("");
+		input = new DInputField(DStyleClass.EMPTY, name, new DDpDimension(100));
+		input.setOnEnter(this::ok);
+		input.setOnEscape(this::cancel);
+		
+		DForm form = new DForm(
+				DStyleClass.EMPTY,
+				new DFormComponent("Module:", new DLabel(DStyleClass.EMPTY, new ImmutableLiveString(module.getName()))),
+				new DFormComponent("Parent package:", new DLabel(DStyleClass.EMPTY, new ImmutableLiveString(pkg.getName().isEmpty() ? "(module root)" : pkg.getName()))),
+				new DFormComponent("Package name:", input));
+
+		DButton ok = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Create"), ImmutableLiveBool.FALSE, this::ok);
+		DButton cancel = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Cancel"), ImmutableLiveBool.FALSE, this::cancel);
+		DHorizontalLayout buttons = new DHorizontalLayout(
+				DStyleClass.EMPTY,
+				DHorizontalLayout.Alignment.RIGHT,
+				new DHorizontalLayout.Element(cancel, 0, 0, DHorizontalLayout.ElementAlignment.TOP),
+				new DHorizontalLayout.Element(ok, 0, 0, DHorizontalLayout.ElementAlignment.TOP));
+
+		root = new DVerticalLayout(
+				DStyleClass.EMPTY,
+				DVerticalLayout.Alignment.MIDDLE,
+				new DVerticalLayout.Element(form, 1, 1, DVerticalLayout.ElementAlignment.CENTER),
+				new DVerticalLayout.Element(buttons, 0, 0, DVerticalLayout.ElementAlignment.RIGHT));
+	}
+	
+	public void open(DUIWindow parent) {
+		DIRectangle rectangle = parent.getWindowBounds();
+		window = parent.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_LEFT, "Create package", root);
+		window.focus(input);
+	}
+	
+	private void cancel() {
+		window.close();
+	}
+	
+	private void ok() {
+		window.close();
+		pkg.createSubPackage(name.getValue());
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/dialog/CreateSourceFileDialog.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.dialog;
+
+import org.openzen.drawablegui.DAnchor;
+import org.openzen.drawablegui.DButton;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.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.form.DForm;
+import org.openzen.drawablegui.form.DFormComponent;
+import org.openzen.drawablegui.live.ImmutableLiveBool;
+import org.openzen.drawablegui.live.ImmutableLiveString;
+import org.openzen.drawablegui.live.SimpleLiveString;
+import org.openzen.drawablegui.style.DDpDimension;
+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.host.IDESourceFile;
+import org.openzen.zenscript.ide.ui.IDEWindow;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CreateSourceFileDialog {
+	private final IDEWindow ideWindow;
+	private final IDEModule module;
+	private final IDEPackage pkg;
+	
+	private final SimpleLiveString name;
+	
+	private final DComponent root;
+	private final DInputField input;
+	
+	private DUIWindow window;
+	
+	public CreateSourceFileDialog(IDEWindow ideWindow, IDEModule module, IDEPackage pkg) {
+		this.ideWindow = ideWindow;
+		this.module = module;
+		this.pkg = pkg;
+		
+		name = new SimpleLiveString("");
+		input = new DInputField(DStyleClass.EMPTY, name, new DDpDimension(100));
+		input.setOnEnter(this::ok);
+		input.setOnEscape(this::cancel);
+		
+		DForm form = new DForm(
+				DStyleClass.EMPTY,
+				new DFormComponent("Module:", new DLabel(DStyleClass.EMPTY, new ImmutableLiveString(module.getName()))),
+				new DFormComponent("Package:", new DLabel(DStyleClass.EMPTY, new ImmutableLiveString(pkg.getName().isEmpty() ? "(module root)" : pkg.getName()))),
+				new DFormComponent("Filename:", input));
+
+		DButton ok = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Create"), ImmutableLiveBool.FALSE, this::ok);
+		DButton cancel = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Cancel"), ImmutableLiveBool.FALSE, this::cancel);
+		DHorizontalLayout buttons = new DHorizontalLayout(
+				DStyleClass.EMPTY,
+				DHorizontalLayout.Alignment.RIGHT,
+				new DHorizontalLayout.Element(cancel, 0, 0, DHorizontalLayout.ElementAlignment.TOP),
+				new DHorizontalLayout.Element(ok, 0, 0, DHorizontalLayout.ElementAlignment.TOP));
+
+		root = new DVerticalLayout(
+				DStyleClass.EMPTY,
+				DVerticalLayout.Alignment.MIDDLE,
+				new DVerticalLayout.Element(form, 1, 1, DVerticalLayout.ElementAlignment.CENTER),
+				new DVerticalLayout.Element(buttons, 0, 0, DVerticalLayout.ElementAlignment.RIGHT));
+	}
+	
+	public void open(DUIWindow parent) {
+		DIRectangle rectangle = parent.getWindowBounds();
+		window = parent.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_LEFT, "Create source file", root);
+		window.focus(input);
+	}
+	
+	private void cancel() {
+		window.close();
+	}
+	
+	private void ok() {
+		window.close();
+		IDESourceFile file = pkg.createSourceFile(name.getValue() + ".zs");
+		ideWindow.open(file);
+	}
+}

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

 import java.util.function.Consumer;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 	private DUIContext context;
 	private IconButtonControlStyle style;
 	private DIRectangle bounds;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> preferences = DSizing.create();
 	private boolean hover;
 	private boolean press;
 	private DPath shape;
 		int iconHeight = (int)(icon.getNominalWidth() * context.getScale() + 0.5f);
 		int width = iconWidth + 2 * style.padding + 2 * style.margin;
 		int height = iconHeight + 2 * style.padding + 2 * style.margin;
-		preferences.setValue(new DDimensionPreferences(width, height));
+		preferences.setValue(new DSizing(width, height));
 		
 		if (bounds != null)
 			setBounds(bounds);
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+	public LiveObject<DSizing> getSizing() {
 		return preferences;
 	}
 

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.live.LiveObject;
  * @author Hoofdgebruiker
  */
 public class StatusBarView implements DComponent {
-	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 0));
+	private final SimpleLiveObject<DSizing> dimensionPreferences = new SimpleLiveObject<>(new DSizing(0, 0));
 	
 	private final DStyleClass styleClass;
 	private final LiveString content;
 		style = new StatusBarStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
 		
-		dimensionPreferences.setValue(new DDimensionPreferences(0, style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingBottom));
+		dimensionPreferences.setValue(new DSizing(0, style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingBottom));
 	}
 	
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+	public LiveObject<DSizing> getSizing() {
 		return dimensionPreferences;
 	}
 	

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

 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
-import org.openzen.drawablegui.live.ImmutableLiveObject;
 import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveList;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
  */
 public class TabbedView extends BaseComponentGroup {
 	private final DStyleClass styleClass;
-	public final LiveList<TabbedViewComponent> tabs = new LiveArrayList<>();
-	private final LiveObject<DDimensionPreferences> preferences = new ImmutableLiveObject<>(DDimensionPreferences.EMPTY);
-	public final LiveObject<TabbedViewComponent> currentTab = new SimpleLiveObject<>(null);
+	public final MutableLiveList<TabbedViewComponent> tabs = new LiveArrayList<>();
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	public final MutableLiveObject<TabbedViewComponent> currentTab = new SimpleLiveObject<>(null);
 	
 	private DUIContext context;
 	private DStylePath path;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		
 		int x = bounds.x + style.tabBarSpacingLeft;
 		for (DComponent tab : tabComponents) {
-			DDimensionPreferences preferences = tab.getDimensionPreferences().getValue();
+			DSizing preferences = tab.getSizing().getValue();
 			tab.setBounds(new DIRectangle(
 					x, bounds.y + totalTabHeight - preferences.preferredHeight, preferences.preferredWidth, preferences.preferredHeight));
 			

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
  */
 public class TabbedViewTab implements DComponent {
 	private final TabbedViewComponent tab;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
-	private final LiveObject<TabbedViewComponent> currentTab;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	private final MutableLiveObject<TabbedViewComponent> currentTab;
 	
 	private final TabbedView parent;
 	public final TabbedViewTabClose closeButton;
 	private boolean hover;
 	private boolean press;
 	
-	public TabbedViewTab(TabbedView parent, LiveObject<TabbedViewComponent> currentTab, TabbedViewComponent tab) {
+	public TabbedViewTab(TabbedView parent, MutableLiveObject<TabbedViewComponent> currentTab, TabbedViewComponent tab) {
 		this.parent = parent;
 		this.currentTab = currentTab;
 		this.tab = tab;
 		closeButton.setContext(path, context);
 		
 		textWidth = fontMetrics.getWidth(tab.title);
-		preferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				style.paddingLeft + textWidth + style.paddingRight
 						+ style.closeIconPadding
-						+ closeButton.getDimensionPreferences().getValue().preferredWidth,
+						+ closeButton.getSizing().getValue().preferredWidth,
 				style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent()
 						+ style.paddingBottom));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
-		DDimensionPreferences close = closeButton.getDimensionPreferences().getValue();
+		DSizing close = closeButton.getSizing().getValue();
 		closeButton.setBounds(new DIRectangle(
 				bounds.x + bounds.width - close.preferredWidth - style.paddingRight,
 				bounds.y + (bounds.height - close.preferredHeight) / 2,
 	@Override
 	public void paint(DCanvas canvas) {
 		int width = style.paddingLeft + textWidth + style.paddingRight
-				+ closeButton.getDimensionPreferences().getValue().preferredWidth + style.closeIconPadding;
+				+ closeButton.getSizing().getValue().preferredWidth + style.closeIconPadding;
 
 		int color = style.tabColorNormal;
 		if (currentTab.getValue() == tab)

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
-import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
-import org.openzen.zenscript.ide.ui.icons.ColoredIcon;
 import org.openzen.zenscript.ide.ui.icons.ScalableCloseIcon;
 
 /**
  */
 public class TabbedViewTabClose implements DComponent {
 	private final TabbedViewTab tab;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DUIContext context;
 	private DIRectangle bounds;
 		
 		DStylePath path = parent.getChild("tabClose", DStyleClass.EMPTY);
 		style = new TabbedViewTabCloseStyle(context.getStylesheets().get(context, path));
-		preferences.setValue(new DDimensionPreferences(style.size, style.size));
+		sizing.setValue(new DSizing(style.size, style.size));
 		icon = new ScalableCloseIcon(style.size / 24);
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.ide.ui.view;
 
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DEmptyView;
 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.DSideLayout;
 		this.window = window;
 		
 		DTreeView projectView = new DTreeView(DTreeViewStyle.DEFAULT, new RootTreeNode(window, host), false);
-		projectView.getDimensionPreferences().setValue(new DDimensionPreferences(500, 500));
+		projectView.getSizing().setValue(new DSizing(500, 500));
 		setMain(tabs = new TabbedView(DStyleClass.EMPTY));
 		add(Side.LEFT, new DScrollPane(DStyleClass.forId("projectView"), projectView));
 		add(Side.BOTTOM, new StatusBarView(DStyleClass.EMPTY, status));

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

 import java.util.function.Consumer;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DSimpleTooltip;
 import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.ImmutableLiveString;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
  * @author Hoofdgebruiker
  */
 public class AspectBarSelectorButton implements DComponent {
-	
 	public final LiveBool active;
 	
 	private final DStyleClass styleClass;
 	private final DDrawable icon;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final Consumer<DMouseEvent> onClick;
 	private DUIContext context;
 	private AspectBarSelectorButtonStyle style;
 	private DPath shape;
 	private boolean hovering;
 	private boolean pressing;
+	private DSimpleTooltip tooltip;
 	
 	private final ListenerHandle<LiveBool.Listener> activeListener;
 	
-	public AspectBarSelectorButton(DStyleClass styleClass, DDrawable icon, LiveBool active, Consumer<DMouseEvent> onClick) {
+	public AspectBarSelectorButton(DStyleClass styleClass, DDrawable icon, LiveBool active, String tooltip, Consumer<DMouseEvent> onClick) {
 		this.active = active;
 		this.styleClass = styleClass;
 		this.icon = icon;
 		this.onClick = onClick;
+		this.tooltip = new DSimpleTooltip(DStyleClass.EMPTY, new ImmutableLiveString(tooltip));
 		
 		activeListener = active.addListener((oldValue, newValue) -> repaint());
 	}
 		this.context = context;
 		DStylePath path = parent.getChild("selectorbutton", styleClass);
 		style = new AspectBarSelectorButtonStyle(context.getStylesheets().get(context, path));
-		preferences.setValue(new DDimensionPreferences(style.width, style.height));
+		sizing.setValue(new DSizing(style.width, style.height));
 		shape = DPath.roundedRectangle(
 				0,
 				0,
 				style.width,
 				style.height,
 				style.roundingRadius);
+		
+		tooltip.setContext(parent, context);
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 				bounds.x + (style.width - icon.getNominalWidth() * context.getScale()) / 2,
 				bounds.y + (style.height - icon.getNominalHeight() * context.getScale()) / 2,
 				context.getScale()));
+		tooltip.paint(canvas);
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hovering = true;
+		tooltip.onTargetMouseEnter(e);
 		repaint();
 	}
 	
 	public void onMouseExit(DMouseEvent e) {
 		hovering = false;
 		pressing = false;
+		tooltip.onTargetMouseExit(e);
 		repaint();
 	}
 	
 	@Override
 	public void close() {
 		activeListener.close();
+		tooltip.close();
 	}
 	
 	private void repaint() {

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

 	public final DShadow windowControlShadow;
 	
 	public AspectBarStyle(DStyleDefinition style) {
-		height = style.getDimension("height", new DDpDimension(32));
+		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));

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

 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.zenscript.ide.ui.IDEAspectBar;
 import org.openzen.zenscript.ide.ui.IDEAspectToolbar;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.drawablegui.live.LivePredicateBool;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.zenscript.ide.ui.IDEAspectBarControl;
  * @author Hoofdgebruiker
  */
 public class AspectBarView extends BaseComponentGroup {
-	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 64));
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final DStyleClass styleClass;
 	private final IDEAspectBar aspectBar;
-	private final List<IDEAspectToolbar> contextBars = new ArrayList<>();
 	
 	private DIRectangle bounds;
 	private DUIContext context;
 	private WindowActionButton maximizeRestore;
 	private WindowActionButton close;
 	
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> minimizeRelayout;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> maximizeRestoreRelayout;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> closeRelayout;
+	private final ListenerHandle<LiveObject.Listener<DSizing>> minimizeRelayout;
+	private final ListenerHandle<LiveObject.Listener<DSizing>> maximizeRestoreRelayout;
+	private final ListenerHandle<LiveObject.Listener<DSizing>> closeRelayout;
 	
 	public AspectBarView(DStyleClass styleClass, IDEAspectBar aspectBar) {
 		this.styleClass = styleClass;
 		listener = aspectBar.toolbars.addListener(new ToolbarListListener());
 		
 		minimize = new WindowActionButton(scale -> new ScalableMinimizeIcon(scale), e -> context.getWindow().minimize());
-		minimizeRelayout = minimize.getDimensionPreferences().addListener((a, b) -> layout());
+		minimizeRelayout = minimize.getSizing().addListener((a, b) -> layout());
 		maximizeRestore = new WindowActionButton(ScalableMaximizeIcon::new, e -> {
 			if (context.getWindow().getWindowState().getValue() == DUIWindow.State.MAXIMIZED)
 				context.getWindow().restore();
 			else
 				context.getWindow().maximize();
 		});
-		maximizeRestoreRelayout = maximizeRestore.getDimensionPreferences().addListener((a, b) -> layout());
+		maximizeRestoreRelayout = maximizeRestore.getSizing().addListener((a, b) -> layout());
 		close = new WindowActionButton(scale -> new ScalableCloseIcon(scale), e -> context.getWindow().close());
-		closeRelayout = close.getDimensionPreferences().addListener((a, b) -> layout());
+		closeRelayout = close.getSizing().addListener((a, b) -> layout());
 		
 		selectorButtons = new LiveMappedList<>(
 				aspectBar.toolbars,
 				bar -> {
 					LiveBool buttonActive = new LivePredicateBool<>(aspectBar.active, activeBar -> activeBar == bar);
-					AspectBarSelectorButton button = new AspectBarSelectorButton(DStyleClass.EMPTY, bar.icon, buttonActive, e -> aspectBar.active.setValue(bar));
+					AspectBarSelectorButton button = new AspectBarSelectorButton(DStyleClass.EMPTY, bar.icon, buttonActive, bar.description, e -> aspectBar.active.setValue(bar));
 					if (context != null)
 						button.setContext(path, context);
 					
 		activeToolbarTitleFontMetrics = context.getFontMetrics(style.activeToolbarTitleFont);
 		showWindowControls = !context.getWindow().hasTitleBar();
 		
+		sizing.setValue(new DSizing(0, style.height));
+		
 		for (DComponent selectorButton : selectorButtons)
 			selectorButton.setContext(path, context);
 		
-		if (bounds != null) {
-			layout();
-			aspectBar.active.setValue(aspectBar.active.getValue());
-		}
-		
 		if (activeToolbarComponents != null)
 			for (DComponent component : activeToolbarComponents)
 				component.setContext(path, context);
 	}
 	
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 	
 	@Override
 		layoutActiveToolbarComponents();
 		
 		int x = bounds.x + bounds.width;
-		DDimensionPreferences closeSize = close.getDimensionPreferences().getValue();
-		DDimensionPreferences maximizeRestoreSize = maximizeRestore.getDimensionPreferences().getValue();
-		DDimensionPreferences minimizeSize = minimize.getDimensionPreferences().getValue();
+		DSizing closeSize = close.getSizing().getValue();
+		DSizing maximizeRestoreSize = maximizeRestore.getSizing().getValue();
+		DSizing minimizeSize = minimize.getSizing().getValue();
 		
 		x -= closeSize.preferredWidth;
 		close.setBounds(new DIRectangle(x, bounds.y, closeSize.preferredWidth, closeSize.preferredHeight));
 		int x = bounds.x + style.aspectSelectorPaddingLeft;
 		
 		for (DComponent component : selectorButtons) {
-			int width = component.getDimensionPreferences().getValue().preferredWidth;
-			int height = component.getDimensionPreferences().getValue().preferredHeight;
+			int width = component.getSizing().getValue().preferredWidth;
+			int height = component.getSizing().getValue().preferredHeight;
 			int y = bounds.y + (bounds.height - style.aspectSelectorBottomSize - height) / 2;
 			component.setBounds(new DIRectangle(x, y, width, height));
 			
 	}
 	
 	private void layoutActiveToolbarComponents() {
-		if (bounds == null)
+		if (bounds == null || bounds.height < (style.aspectBarPaddingTop + style.controlPaddingTop + style.controlPaddingBottom))
 			return;
 		
 		int x = aspectSelectorEndX
 		
 		int y = style.aspectBarPaddingTop + style.controlPaddingTop;
 		int height = bounds.height - y - style.controlPaddingBottom;
+		
 		for (DComponent toolbarComponent : activeToolbarComponents) {
-			int width = toolbarComponent.getDimensionPreferences().getValue().preferredWidth;
+			int width = toolbarComponent.getSizing().getValue().preferredWidth;
 			toolbarComponent.setBounds(
 					new DIRectangle(x, bounds.y + y, width, height));
 			x += width;

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 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.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.zenscript.ide.ui.icons.ScalableCloseIcon;
 
  * @author Hoofdgebruiker
  */
 public class WindowActionButton implements DComponent {
-	private final SimpleLiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private final Function<Float, DColorableIcon> scalableIcon;
 	private final Consumer<DMouseEvent> action;
 		windowFocusedListener = windowFocused.addListener((a, b) -> repaint());
 		
 		icon = scalableIcon == null ? null : scalableIcon.apply(context.getScale());
-		preferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				(int)(48 * context.getScale()),
 				(int)(24 * context.getScale())));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

 import java.io.IOException;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 public class SourceEditor implements DComponent {
 	private final DStyleClass styleClass;
 	private final DFont font = new DFont(DFontFamily.CODE, false, false, false, 24);
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 0));
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final String tab = "    ";
 	private final IDESourceFile sourceFile;
 	private final TokenModel tokens;
 		fullLineHeight = textLineHeight + fontMetrics.getLeading() + style.extraLineSpacing;
 		selectionLineHeight = textLineHeight + style.selectionPaddingTop + style.selectionPaddingBottom;
 		
-		dimensionPreferences.setValue(new DDimensionPreferences(0, fullLineHeight * tokens.getLineCount()));
+		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
 		
 		if (blinkTimer != null)
 			blinkTimer.close();
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		if (deleteSelection())
 			return;
 		
+		if (cursorEnd.line > 0) {
+			String indent = tokens.getLine(cursorEnd.line - 1).getIndent(); // TODO: get nominal indent for current scope
+			if (cursorEnd.offset == indent.length()) {
+				// remove entire indent
+				SourcePosition deleteFrom = new SourcePosition(tokens, cursorEnd.line - 1, tokens.getLine(cursorEnd.line - 1).length());
+				tokens.delete(deleteFrom, cursorEnd);
+				unchanged.setValue(false);
+				setCursor(deleteFrom, deleteFrom);
+				return;
+			}
+		}
+		
 		if (cursorEnd.offset == 0) {
 			if (cursorEnd.line == 0)
 				return;
 	private void type(String value) {
 		deleteSelection();
 		
-		tokens.insert(cursorEnd, value);
-		SourcePosition position = new SourcePosition(tokens, cursorEnd.line, cursorEnd.offset + value.length());
-		setCursor(position, position);
+		if (value.equals("{")) {
+			String indent = tokens.getLine(cursorEnd.line).getIndent();
+			tokens.insert(cursorEnd, "{\n" + indent + "\t\n" + indent + "}");
+			
+			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length() + 1);
+			setCursor(position, position);
+		} else if (value.equals(";")) {
+			String indent = tokens.getLine(cursorEnd.line).getIndent();
+			tokens.insert(cursorEnd, ";\n" + indent);
+			
+			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length());
+			setCursor(position, position);
+		} else {
+			tokens.insert(cursorEnd, value);
+			
+			SourcePosition position = new SourcePosition(tokens, cursorEnd.line, cursorEnd.offset + value.length());
+			setCursor(position, position);
+		}
+		
 		unchanged.setValue(false);
 	}
 	
 	}
 	
 	private void onLinesUpdated() {
-		dimensionPreferences.setValue(new DDimensionPreferences(0, fullLineHeight * tokens.getLineCount()));
+		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
 		
 		if (bounds != null)
 			context.repaint(bounds);

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

 		modules = new LiveMappedList<>(library.getModules(), module -> new ModuleTreeNode(window, module));
 	}
 	
+	@Override
+	public void close() {
+		modules.close();
+	}
+	
 	@Override
 	public DColorableIcon getIcon() {
 		return LibraryIcon.INSTANCE;

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

  * @author Hoofdgebruiker
  */
 public class ModuleTreeNode extends PackageTreeNode {
-	private final IDEModule module;
-	private final IDEWindow window;
-	
 	public ModuleTreeNode(IDEWindow window, IDEModule module) {
 		super(window, module.getRootPackage());
 		
-		this.module = module;
-		this.window = window;
+		init(module);
 	}
 
 	@Override

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

 package org.openzen.zenscript.ide.ui.view.project;
 
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.live.LiveConcatList;
 import org.openzen.drawablegui.live.LiveList;
 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 IDEModule module;
 	private final IDEPackage pkg;
-	private final LiveList<ProjectOverviewNode> contents;
+	private LiveList<ProjectOverviewNode> contents;
 	
 	public PackageTreeNode(IDEWindow window, IDEPackage pkg) {
+		this.window = window;
+		this.pkg = pkg;
+	}
+	
+	public PackageTreeNode(IDEWindow window, IDEModule module, IDEPackage pkg) {
+		this.window = window;
+		this.module = module;
 		this.pkg = pkg;
 		
+		init(module);
+	}
+	
+	protected final void init(IDEModule module) {
+		this.module = module;
 		contents = new LiveConcatList<>(
-				new LiveMappedList<>(pkg.getSubPackages(), sub -> new PackageTreeNode(window, sub)),
+				new LiveMappedList<>(pkg.getSubPackages(), sub -> new PackageTreeNode(window, module, sub)),
 				new LiveMappedList<>(pkg.getSourceFiles(), source -> new SourceFileTreeNode(window, source))
 		);
 	}
+	
+	@Override
+	public void close() {
+		contents.close();
+	}
 
 	@Override
 	public LiveList<ProjectOverviewNode> getChildren() {
 	public boolean isLeaf() {
 		return false;
 	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		window.setContextPackage(module, pkg);
+	}
 }

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

  */
 package org.openzen.zenscript.ide.ui.view.project;
 
-import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.MutableLiveBool;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.tree.DTreeNode;
 
  * @author Hoofdgebruiker
  */
 public abstract class ProjectOverviewNode implements DTreeNode<ProjectOverviewNode> {
-	private final LiveBool collapsed = new SimpleLiveBool();
+	private final MutableLiveBool collapsed = new SimpleLiveBool();
 	
 	public abstract Kind getKind();
 	
 	@Override
-	public LiveBool isCollapsed() {
+	public MutableLiveBool isCollapsed() {
 		return collapsed;
 	}
 	

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

 		modules = new LiveMappedList<>(host.getModules(), module -> new ModuleTreeNode(window, module));
 	}
 	
+	@Override
+	public void close(){
+		modules.close();
+	}
+	
 	@Override
 	public DColorableIcon getIcon() {
 		return ProjectIcon.INSTANCE;

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

 				new LiveMappedList<>(host.getLibraries(), library -> new LibraryTreeNode(window, library)));
 	}
 	
+	@Override
+	public void close() {
+		children.close();
+	}
+	
 	@Override
 	public DColorableIcon getIcon() {
 		return ProjectIcon.INSTANCE;

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

 		this.window = window;
 		this.sourceFile = sourceFile;
 	}
+	
+	@Override
+	public void close() {
+		
+	}
 
 	@Override
 	public Kind getKind() {

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedCallArguments.java

 			innerScope = scope.forCall(candidates.get(0));
 		} else {
 			candidates = candidates.stream()
-					.filter(candidate -> candidate.typeParameters == null)
+					.filter(candidate -> candidate.getNumberOfTypeParameters() == 0)
 					.collect(Collectors.toList());
 			
 			if (candidates.isEmpty()) {

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionFunction.java

 		}
 		
 		FunctionTypeID functionType = scope.getTypeRegistry().getFunction(genericHeader.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)));
-		return new FunctionExpression(position, functionType, closure, statements);
+		definedHeader = definedHeader.forLambda(functionType.header);
+		return new FunctionExpression(position, functionType, closure, definedHeader, statements);
 	}
 	
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionVariable.java

 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		ITypeID[] genericArguments = null;
+		ITypeID[] genericArguments = ITypeID.NONE;
 		if (genericParameters != null) {
 			genericArguments = new ITypeID[genericParameters.size()];
 			for (int i = 0; i < genericParameters.size(); i++) {

Parser/src/main/java/org/openzen/zenscript/parser/type/IParsedType.java

 	}
 	
 	public static ITypeID[] compileList(List<IParsedType> typeParameters, BaseScope scope) {
-		ITypeID[] result = null;
+		ITypeID[] result = ITypeID.NONE;
 		if (typeParameters != null) {
 			result = new ITypeID[typeParameters.size()];
 			for (int i = 0; i < typeParameters.size(); i++) {