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

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/DefinitionFormatter.java

 		
 		List<EnumConstantMember> enumConstants = definition.enumConstants;
 		boolean first = true;
-		ExpressionFormatter expressionFormatter = new ExpressionFormatter(settings, typeFormatter);
+		ExpressionFormatter expressionFormatter = new ExpressionFormatter(settings, typeFormatter, indent);
 		for (EnumConstantMember enumConstant : enumConstants) {
 			if (first)
 				first = false;

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
-import org.openzen.zenscript.formattershared.FormattableOperator;
+import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 
 /**
  *
 public class ExpressionFormatter implements ExpressionVisitor<ExpressionString> {
 	private final ScriptFormattingSettings settings;
 	public final TypeFormatter typeFormatter;
+	public final String indent;
 	
-	public ExpressionFormatter(ScriptFormattingSettings settings, TypeFormatter typeFormatter) {
+	public ExpressionFormatter(ScriptFormattingSettings settings, TypeFormatter typeFormatter, String indent) {
 		this.settings = settings;
 		this.typeFormatter = typeFormatter;
+		this.indent = indent;
 	}
 
 	@Override
 				default:
 					throw new UnsupportedOperationException("Unknown operator: " + expression.member.getOperator());
 			}
+		} else if (expression.member.isCaller()) {
+			StringBuilder result = new StringBuilder();
+			result.append(expression.target.accept(this).value);
+			FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
+			return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 		} else {
 			StringBuilder result = new StringBuilder();
 			result.append(expression.target.accept(this).value);
 
 	@Override
 	public ExpressionString visitFunction(FunctionExpression expression) {
-		//FIXME
-		return new ExpressionString("asdfghj", ZenScriptOperator.PRIMARY);
-		//throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		StringBuilder result = new StringBuilder();
+		if (expression.header.parameters.length == 1) {
+			result.append(expression.header.parameters[0].name);
+		} else {
+			result.append('(');
+			for (int i = 0; i < expression.header.parameters.length; i++) {
+				if (i > 0)
+					result.append(", ");
+				result.append(expression.header.parameters[i].name);
+			}
+			result.append(')');
+		}
+		result.append(" => ");
+		
+		if (expression.body instanceof ReturnStatement) {
+			result.append(((ReturnStatement) expression.body).value.accept(this));
+		} else if (expression.body instanceof ExpressionStatement) {
+			result.append(((ExpressionStatement) expression.body).expression.accept(this));
+		} else {
+			StatementFormatter formatter = new StatementFormatter(result, indent + settings.indent + settings.indent, settings, this);
+			expression.body.accept(formatter);
+		}
+		return new ExpressionString(result.toString(), ZenScriptOperator.FUNCTION);
 	}
 
 	@Override

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FileFormatter.java

 		FileImporter importer = new FileImporter(pkg);
 		
 		TypeFormatter typeFormatter = new TypeFormatter(settings, importer);
-		ExpressionFormatter expressionFormatter = new ExpressionFormatter(settings, typeFormatter);
+		ExpressionFormatter expressionFormatter = new ExpressionFormatter(settings, typeFormatter, "");
 		
 		List<DefinitionFormatter> definitionFormatters = new ArrayList<>();
 		for (HighLevelDefinition definition : definitions) {

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FormattingUtils.java

 	}
 	
 	public static void formatTypeParameters(StringBuilder result, TypeParameter[] parameters, TypeFormatter typeFormatter) {
-		if (parameters != null) {
+		if (parameters != null && parameters.length > 0) {
 			result.append("<");
 			int index = 0;
 			for (TypeParameter parameter : parameters) {
 			this.indent = indent;
 			this.typeFormatter = typeFormatter;
 			
-			statementFormatter = new StatementFormatter(output, indent, settings, new ExpressionFormatter(settings, typeFormatter)); 
+			statementFormatter = new StatementFormatter(output, indent, settings, new ExpressionFormatter(settings, typeFormatter, indent)); 
 		}
 
 		@Override
 				output.append("\n").append(indent).append(settings.indent).append("=> ");
 			}
 			
-			output.append(statement.expression.accept(new ExpressionFormatter(settings, typeFormatter)));
+			output.append(statement.expression.accept(new ExpressionFormatter(settings, typeFormatter, indent)));
 			output.append(";");
 			return null;
 		}
 				output.append("\n").append(indent).append(settings.indent).append("=> ");
 			}
 			
-			output.append(statement.value.accept(new ExpressionFormatter(settings, typeFormatter)));
+			output.append(statement.value.accept(new ExpressionFormatter(settings, typeFormatter, indent)));
 			output.append(";");
 			return null;
 		}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/MemberFormatter.java

 				.append(" as ")
 				.append(member.type.accept(typeFormatter))
 				.append(" = ")
-				.append(member.value.accept(new ExpressionFormatter(settings, typeFormatter)))
+				.append(member.value.accept(new ExpressionFormatter(settings, typeFormatter, indent)))
 				.append(";\n");
 		return null;
 	}
 		
 		if (member.initializer != null) {
 			output.append(" = ")
-					.append(member.initializer.accept(new ExpressionFormatter(settings, typeFormatter)));
+					.append(member.initializer.accept(new ExpressionFormatter(settings, typeFormatter, indent)));
 		}
 		output.append(";\n");
 		return null;

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ZenScriptOperator.java

 	CAST(9, null),
 	
 	PANIC(10, "panic "),
-	PRIMARY(10, null);
+	PRIMARY(10, null),
+	FUNCTION(10, null);
 	
 	private final int priority;
 	private final String operatorString;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/AccessScope.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.codemodel;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class AccessScope {
-	
-}

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

 		if (returnType == null)
 			throw new NullPointerException();
 		
-		this.typeParameters = null;
+		this.typeParameters = TypeParameter.NONE;
 		this.returnType = returnType;
 		this.parameters = NO_PARAMETERS;
 		this.thrownType = null;
 		if (returnType == null)
 			throw new NullPointerException();
 		
-		this.typeParameters = null;
+		this.typeParameters = TypeParameter.NONE;
 		this.returnType = returnType;
 		this.parameters = new FunctionParameter[parameterTypes.length];
 		this.thrownType = null;
 		if (returnType == null)
 			throw new NullPointerException();
 		
-		this.typeParameters = null;
+		this.typeParameters = TypeParameter.NONE;
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = null;
 	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
 		if (returnType == null)
 			throw new NullPointerException();
+		if (genericParameters == null)
+			throw new NullPointerException();
 		
 		this.typeParameters = genericParameters;
 		this.returnType = returnType;
 	}
 	
 	public int getNumberOfTypeParameters() {
-		return typeParameters == null ? 0 : typeParameters.length;
+		return typeParameters.length;
 	}
 	
 	public boolean matchesExactly(CallArguments arguments, TypeScope scope) {
 			return this;
 		
 		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
-		if (typeParameters != null)
-			for (int i = 0; i < typeParameters.length; i++)
-				typeArguments.put(typeParameters[i], arguments[i]);
+		for (int i = 0; i < typeParameters.length; i++)
+			typeArguments.put(typeParameters[i], arguments[i]);
 		GenericMapper mapper = new GenericMapper(registry, typeArguments);
 		
 		ITypeID returnType = this.returnType.instance(mapper);
 	@Override
 	public String toString() {
 		StringBuilder result = new StringBuilder();
-		if (typeParameters != null && typeParameters.length > 0) {
+		if (typeParameters.length > 0) {
 			result.append("<");
 			for (int i = 0; i < typeParameters.length; i++) {
 				if (i > 0)

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

 	public final String name;
 	public final int modifiers;
 	public final List<IDefinitionMember> members = new ArrayList<>();
-	public final AccessScope access = new AccessScope();
 	public TypeParameter[] genericParameters = null;
 	public DefinitionAnnotation[] annotations = DefinitionAnnotation.NONE;
 	

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

  * @author Hoofdgebruiker
  */
 public class ScriptBlock extends Taggable {
-	public final AccessScope access;
 	public final List<Statement> statements;
 	
-	public ScriptBlock(AccessScope access, List<Statement> statements) {
-		this.access = access;
+	public ScriptBlock(List<Statement> statements) {
 		this.statements = statements;
 	}
 	
 	public ScriptBlock withStatements(List<Statement> newStatements) {
-		ScriptBlock result = new ScriptBlock(access, newStatements);
+		ScriptBlock result = new ScriptBlock(newStatements);
 		result.addAllTagsFrom(this);
 		return result;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationProcessor.java

 	
 	@Override
 	public ScriptBlock process(ScriptBlock block) {
-		FileScope fileScope = new FileScope(block.access, rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		FileScope fileScope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
 		StatementScope scope = new GlobalScriptScope(fileScope);
 		List<Statement> transformed = new ArrayList<>();
 		boolean unchanged = true;
 	
 	@Override
 	public void process(HighLevelDefinition definition) {
-		FileScope fileScope = new FileScope(definition.access, rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		FileScope fileScope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
 		DefinitionScope scope = new DefinitionScope(fileScope, definition);
 		for (DefinitionAnnotation annotation : definition.annotations) {
 			annotation.apply(definition, scope);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameter.java

  * @author Hoofdgebruiker
  */
 public class TypeParameter {
+	public static final TypeParameter[] NONE = new TypeParameter[0];
+	
 	public final CodePosition position;
 	public final String name;
 	public final List<GenericParameterBound> bounds = new ArrayList<>();

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
 	
 	public FileScope(
-			AccessScope access,
 			ZSPackage rootPackage,
 			PackageDefinitions packageDefinitions,
 			GlobalTypeRegistry globalRegistry,
 		this.globalRegistry = globalRegistry;
 		this.globalSymbols = globalSymbols;
 		
-		memberCache = new LocalMemberCache(access, globalRegistry, expansions);
+		memberCache = new LocalMemberCache(globalRegistry, expansions);
 		
 		for (AnnotationDefinition annotation : annotations) {
 			this.annotations.put(annotation.getAnnotationName(), annotation);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/LocalMemberCache.java

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class LocalMemberCache {
-	private final AccessScope access;
 	private final GlobalTypeRegistry registry;
 	private final Map<ITypeID, TypeMembers> types = new HashMap<>();
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	
 	public LocalMemberCache(
-			AccessScope access,
 			GlobalTypeRegistry registry,
 			List<ExpansionDefinition> expansions) {
-		this.access = access;
 		this.registry = registry;
 		this.expansions.addAll(expansions);
 	}

CompilerShared/src/main/java/org/openzen/zenscript/compiler/CompileScope.java

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 	private final LocalMemberCache cache;
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
 	
-	public CompileScope(AccessScope access, GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, List<AnnotationDefinition> annotations) {
+	public CompileScope(GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, List<AnnotationDefinition> annotations) {
 		this.globalRegistry = globalRegistry;
 		this.expansions = expansions;
-		this.cache = new LocalMemberCache(access, globalRegistry, expansions);
+		this.cache = new LocalMemberCache(globalRegistry, expansions);
 		
 		for (AnnotationDefinition annotation : annotations) {
 			this.annotations.put(annotation.getAnnotationName(), annotation);

DrawableGui/src/main/java/org/openzen/drawablegui/DAnchor.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public enum DAnchor {
+	TOP_LEFT(0, 0),
+	TOP_CENTER(0.5f, 0),
+	TOP_RIGHT(1, 0),
+	MIDDLE_LEFT(0, 0.5f),
+	MIDDLE_CENTER(0.5f, 0.5f),
+	MIDDLE_RIGHT(1, 0.5f),
+	BOTTOM_LEFT(0, 1),
+	BOTTOM_CENTER(0.5f, 1),
+	BOTTOM_RIGHT(1, 1);
+	
+	public final float alignX;
+	public final float alignY;
+	
+	DAnchor(float alignX, float alignY) {
+		this.alignX = alignX;
+		this.alignY = alignY;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DButton.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.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DButton implements DComponent {
+	private final DStyleClass styleClass;
+	private final LiveString label;
+	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final LiveBool disabled;
+	
+	private DUIContext context;
+	private DIRectangle bounds;
+	
+	private DButtonStyle style;
+	private DFontMetrics fontMetrics;
+	
+	private boolean hovering = false;
+	private boolean pressing = false;
+	
+	public DButton(DStyleClass styleClass, LiveString label, LiveBool disabled) {
+		this.styleClass = styleClass;
+		this.label = label;
+		this.disabled = disabled;
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("Button", styleClass);
+		this.style = new DButtonStyle(context.getStylesheets().get(context, path));
+		fontMetrics = context.getFontMetrics(style.font);
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public int getBaselineY() {
+		return style.paddingTop + fontMetrics.getAscent();
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		int backgroundColor = style.backgroundColorNormal;
+		if (hovering)
+			backgroundColor = style.backgroundColorHover;
+		if (pressing)
+			backgroundColor = style.backgroundColorPress;
+		if (disabled.getValue())
+			backgroundColor = style.backgroundColorDisabled;
+		
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, backgroundColor);
+	}
+
+	@Override
+	public void close() {
+		
+	}
+	
+	@Override
+	public void onMouseEnter(DMouseEvent e) {
+		hovering = true;
+		repaint();
+	}
+	
+	@Override
+	public void onMouseExit(DMouseEvent e) {
+		hovering = false;
+		pressing = false;
+		repaint();
+	}
+	
+	@Override
+	public void onMouseDown(DMouseEvent e) {
+		pressing = true;
+		repaint();
+	}
+	
+	@Override
+	public void onMouseRelease(DMouseEvent e) {
+		pressing = false;
+		
+		if (!disabled.getValue()) {
+			// TODO
+		}
+		
+		repaint();
+	}
+	
+	private void repaint() {
+		if (context == null || bounds == null)
+			return;
+		
+		context.repaint(bounds);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DButtonStyle.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.style.DDpDimension;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DButtonStyle {
+	public final int paddingTop;
+	public final int paddingLeft;
+	public final int paddingRight;
+	public final int paddingBottom;
+	public final DFont font;
+	public final int textColor;
+	public final int textColorDisabled;
+	
+	public final int backgroundColorNormal;
+	public final int backgroundColorHover;
+	public final int backgroundColorPress;
+	public final int backgroundColorDisabled;
+	
+	public final DShadow shadowNormal;
+	public final DShadow shadowHover;
+	public final DShadow shadowPress;
+	public final DShadow shadowDisabled;
+	
+	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));
+		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);
+		
+		backgroundColorNormal = style.getColor("backgroundColorNormal", 0xFFE1E1E1);
+		backgroundColorHover = style.getColor("backgroundColorHover", 0xFFE5EFF8);
+		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()));
+	}
+}

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

 	
 	DIRectangle getBounds();
 	
+	int getBaselineY();
+	
 	void setBounds(DIRectangle bounds);
 	
 	void paint(DCanvas canvas);

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

 		return NO_BOUNDS;
 	}
 
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
+	
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		

DrawableGui/src/main/java/org/openzen/drawablegui/DHorizontalLayout.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 java.util.function.Consumer;
+import java.util.function.Predicate;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DHorizontalLayout extends BaseComponentGroup {
+	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 DUIContext context;
+	private DHorizontalLayoutStyle style;
+	private DIRectangle bounds;
+	private float totalGrow;
+	private float totalShrink;
+	
+	public DHorizontalLayout(DStyleClass styleClass, Alignment alignment, Element... components) {
+		this.styleClass = styleClass;
+		this.alignment = alignment;
+		this.components = components;
+		
+		componentSizeListeners = new ListenerHandle[components.length];
+		totalGrow = 0;
+		totalShrink = 0;
+		
+		for (int i = 0; i < componentSizeListeners.length; i++) {
+			componentSizeListeners[i] = components[i].component.getDimensionPreferences().addListener((oldValue, newValue) -> updateDimensionPreferences());
+			
+			totalGrow += components[i].grow;
+			totalShrink += components[i].shrink;
+		}
+	}
+
+	@Override
+	protected void forEachChild(Consumer<DComponent> children) {
+		for (Element element : components)
+			children.accept(element.component);
+	}
+
+	@Override
+	protected DComponent findChild(Predicate<DComponent> predicate) {
+		for (Element element : components)
+			if (predicate.test(element.component))
+				return element.component;
+		
+		return null;
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("horizontalLayout", styleClass);
+		style = new DHorizontalLayoutStyle(context.getStylesheets().get(context, path));
+		
+		for (Element element : components)
+			element.component.setContext(parent, context);
+		
+		layout();
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public int getBaselineY() {
+		return components[0].component.getBaselineY();
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		for (Element element : components) {
+			element.component.paint(canvas);
+		}
+	}
+
+	@Override
+	public void close() {
+		for (int i = 0; i < componentSizeListeners.length; i++) {
+			componentSizeListeners[i].close();
+		}
+	}
+	
+	public static enum Alignment {
+		LEFT(0),
+		CENTER(0.5f),
+		RIGHT(1);
+		
+		public final float align;
+		
+		Alignment(float align) {
+			this.align = align;
+		}
+	}
+	
+	public static enum ElementAlignment {
+		TOP,
+		MIDDLE,
+		BOTTOM,
+		STRETCH
+	}
+	
+	public static class Element {
+		public final DComponent component;
+		public final float grow;
+		public final float shrink;
+		public final ElementAlignment alignment;
+		
+		public Element(DComponent component, float grow, float shrink, ElementAlignment alignment) {
+			this.component = component;
+			this.grow = grow;
+			this.shrink = shrink;
+			this.alignment = alignment;
+		}
+	}
+	
+	private void layout() {
+		if (bounds == null || context == null)
+			return;
+		
+		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		if (bounds.width < myPreferences.preferredWidth) {
+			layoutShrinked();
+		} else {
+			layoutGrown();
+		}
+	}
+	
+	private void layoutShrinked() {
+		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		if (totalShrink == 0) {
+			// now what?
+			// shrink proportionally, we have to shrink...
+			float scale = (float)(bounds.width - (components.length - 1) * style.spacing) / (myPreferences.preferredWidth - (components.length - 1) * style.spacing);
+			int x = 0;
+			
+			for (int i = 0; i < components.length; i++) {
+				Element element = components[i];
+				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				int newX = x + preferences.preferredWidth;
+				float idealUnspacedX = newX * scale;
+				int idealX = (int)(idealUnspacedX + 0.5f + i * style.spacing);
+				layout(element, x, idealX - x);
+				x = idealX;
+			}
+		} else {
+			int delta = bounds.width - myPreferences.preferredWidth;
+			float deltaScaled = delta / totalShrink;
+			int x = 0;
+			for (Element element : components) {
+				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				float scaledSize = preferences.preferredWidth + deltaScaled * element.shrink;
+				float idealUnspacedX = x + scaledSize;
+				int newX = (int)(idealUnspacedX + 0.5f);
+				layout(element, x, newX - x);
+				x = newX + style.spacing;
+			}
+		}
+	}
+	
+	private void layoutGrown() {
+		// resize according to grow values
+		DDimensionPreferences myPreferences = dimensionPreferences.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();
+				int newX = x + preferences.preferredWidth;
+				layout(element, x, newX - x);
+				x = newX;
+			}
+		} else {
+			int delta = bounds.width - myPreferences.preferredWidth;
+			float deltaScaled = delta / totalGrow;
+			int x = 0;
+			for (Element element : components) {
+				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				float scaledSize = preferences.preferredWidth + deltaScaled * element.grow;
+				float idealUnspacedX = x + scaledSize;
+				int newX = (int)(idealUnspacedX + 0.5f);
+				layout(element, x, newX - x);
+				x = newX + style.spacing;
+			}
+		}
+	}
+	
+	private void layout(Element element, int x, int width) {
+		DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+		int height;
+		int y;
+		switch (element.alignment) {
+			case BOTTOM:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.paddingTop - style.paddingBottom);
+				y = bounds.y + style.paddingTop;
+				break;
+			case MIDDLE:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.paddingTop - style.paddingBottom);
+				y = bounds.y + style.paddingTop + (bounds.height - style.paddingTop - style.paddingBottom - height) / 2;
+				break;
+			case TOP:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.paddingTop - style.paddingBottom);
+				y = bounds.y + bounds.height - style.paddingBottom - height;
+				break;
+			case STRETCH:
+			default:
+				height = bounds.height - style.paddingTop - style.paddingBottom;
+				y = bounds.y + style.paddingTop;
+				break;
+		}
+		element.component.setBounds(new DIRectangle(bounds.x + x, y, width, height));
+	}
+	
+	private void updateDimensionPreferences() {
+		int preferredWidth = -style.spacing;
+		int preferredHeight = 0;
+		int minimumWidth = -style.spacing;
+		int minimumHeight = 0;
+		int maximumWidth = -style.spacing;
+		int maximumHeight = Integer.MAX_VALUE;
+		for (Element element : components) {
+			DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+			preferredWidth += preferences.preferredWidth + style.spacing;
+			preferredHeight = Math.max(preferredHeight, preferences.preferredHeight);
+			
+			minimumWidth += preferences.minimumWidth + style.spacing;
+			minimumHeight = Math.max(minimumHeight, preferences.minimumHeight);
+			
+			maximumWidth += preferences.maximumWidth + style.spacing;
+			maximumHeight = Math.min(maximumHeight, preferences.maximumHeight);
+		}
+		
+		DDimensionPreferences preferences = new DDimensionPreferences(
+				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);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DHorizontalLayoutStyle.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.style.DDpDimension;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DHorizontalLayoutStyle {
+	public final int spacing;
+	
+	public final int paddingTop;
+	public final int paddingLeft;
+	public final int paddingRight;
+	public final int paddingBottom;
+	
+	public DHorizontalLayoutStyle(DStyleDefinition style) {
+		spacing = style.getDimension("spacing", new DDpDimension(8));
+		
+		paddingTop = style.getDimension("paddingTop", new DDpDimension(8));
+		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(8));
+		paddingRight = style.getDimension("paddingRight", new DDpDimension(8));
+		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(8));
+	}
+}

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

 	public final int height;
 	
 	public DIRectangle(int x, int y, int width, int height) {
+		if (width < 0)
+			throw new IllegalArgumentException("Width must be >= 0");
+		if (height < 0)
+			throw new IllegalArgumentException("Height must be >= 0");
+		
 		this.x = x;
 		this.y = y;
 		this.width = width;
 		this.height = height;
 	}
 	
+	public int getCenterX() {
+		return (x + width) / 2;
+	}
+	
+	public int getCenterY() {
+		return (y + height) / 2;
+	}
+	
 	public boolean contains(int x, int y) {
 		return x >= this.x && x < (this.x + this.width)
 				&& y >= this.y && y < (this.y + this.height);
 	}
+	
+	@Override
+	public String toString() {
+		return "(x = " + x + ", y = " + y + ", width = " + width + ", height = " + height + ")";
+	}
 }

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

 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DDimension;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 	private final DStyleClass styleClass;
 	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
 	private DIRectangle bounds = DIRectangle.EMPTY;
+	private final DDimension preferredWidth;
 	
 	private DUIContext context;
 	private DInputFieldStyle style;
 	private int cursorFrom = -1;
 	private int cursorTo = -1;
 	
-	public DInputField(DStyleClass styleClass, LiveString value) {
+	private boolean cursorBlink = true;
+	private DTimerHandle blinkTimer;
+	
+	public DInputField(DStyleClass styleClass, LiveString value, DDimension preferredWidth) {
 		this.styleClass = styleClass;
 		this.value = value;
+		this.preferredWidth = preferredWidth;
+		
 		valueListener = value.addListener((oldValue, newValue) -> handleValueUpdated(newValue));
+		cursorFrom = 0;
+		cursorTo = value.getValue().length();
+	}
+	
+	@Override
+	public void close() {
+		valueListener.close();
+		blinkTimer.close();
 	}
 
 	@Override
 		DStylePath path = parent.getChild("input", styleClass);
 		style = new DInputFieldStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
+		dimensionPreferences.setValue(new DDimensionPreferences(
+				preferredWidth.evalInt(context) + style.paddingLeft + style.paddingRight + 2 * style.borderWidth,
+				fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingTop + style.paddingBottom + 2 * style.borderWidth));
+		
+		if (blinkTimer != null)
+			blinkTimer.close();
+		blinkTimer = context.setTimer(300, this::blink);
+	}
+	
+	private void blink() {
+		cursorBlink = !cursorBlink;
+		context.repaint(bounds);
 	}
 
 	@Override
 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return style.borderWidth + style.paddingTop + fontMetrics.getAscent();
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 	@Override
 	public void paint(DCanvas canvas) {
 		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
-		canvas.drawText(style.font, style.color, bounds.x + style.paddingLeft, bounds.y + style.paddingBottom, value.getValue());
+		if (style.borderWidth > 0) {
+			canvas.strokePath(
+					DPath.rectangle(bounds.x, bounds.y, bounds.width - style.borderWidth, bounds.height - style.borderWidth),
+					DTransform2D.IDENTITY,
+					style.borderColor,
+					style.borderWidth);
+		}
+		
+		int cursorXFrom = fontMetrics.getWidth(value.getValue(), 0, Math.min(cursorFrom, cursorTo));
+		int cursorXTo = fontMetrics.getWidth(value.getValue(), 0, Math.max(cursorFrom, cursorTo));
+		if (cursorFrom != cursorTo) {
+			canvas.fillRectangle(
+					bounds.x + style.paddingLeft + cursorXFrom,
+					bounds.y + style.paddingTop,
+					cursorXTo - cursorXFrom,
+					fontMetrics.getAscent() + fontMetrics.getDescent(),
+					style.selectionColor);
+		}
+		
+		canvas.drawText(style.font, style.color, bounds.x + style.paddingLeft + style.borderWidth, bounds.y + style.paddingBottom + style.borderWidth + fontMetrics.getAscent(), value.getValue());
+		
+		if (cursorBlink) {
+			canvas.fillRectangle(
+					bounds.x + style.paddingLeft + cursorXTo,
+					bounds.y + style.paddingTop,
+					style.cursorWidth,
+					fontMetrics.getAscent() + fontMetrics.getDescent(),
+					style.cursorColor);
+		}
 	}
-
+	
 	@Override
-	public void close() {
-		valueListener.close();
+	public void onMouseClick(DMouseEvent e) {
+		context.getWindow().focus(this);
 	}
 	
 	@Override
-	public void onMouseClick(DMouseEvent e) {
-		context.focus(this);
+	public void onKeyPressed(DKeyEvent e) {
+		boolean shift = e.has(DKeyEvent.SHIFT);
+		switch (e.keyCode) {
+			case UP:
+				setCursor(0, 0);
+				break;
+			case DOWN:
+				setCursor(value.getValue().length(), value.getValue().length());
+				break;
+			case LEFT: {
+				int to = Math.max(0, cursorTo - 1);
+				setCursor(shift ? cursorFrom : to, to);
+				break;
+			}
+			case RIGHT: {
+				int to = Math.min(value.getValue().length(), cursorTo + 1);
+				setCursor(shift ? cursorFrom : to, to);
+				break;
+			}
+			case DELETE:
+				delete();
+				break;
+			case BACKSPACE:
+				backspace();
+				break;
+			case ENTER:
+				enter();
+				break;
+			default:
+				if (e.character == DKeyEvent.CHAR_UNDEFINED)
+					return;
+				
+				insert(Character.toString(e.character));
+				break;
+		}
+	}
+	
+	private void setCursor(int from, int to) {
+		cursorFrom = from;
+		cursorTo = to;
+		context.repaint(bounds);
 	}
 	
 	private void handleValueUpdated(String newValue) {
+		context.repaint(bounds);
+	}
+	
+	private void backspace() {
+		if (cursorFrom == 0 && cursorTo == 0)
+			return;
+		
+		if (cursorFrom == cursorTo) {
+			value.setValue(value.getValue().substring(0, cursorFrom - 1) + value.getValue().substring(cursorFrom));
+			setCursor(cursorFrom - 1, cursorTo - 1);
+		} else {
+			int from = Math.min(cursorFrom, cursorTo);
+			int to = Math.max(cursorFrom, cursorTo);
+			setCursor(from, from);
+			value.setValue(value.getValue().substring(0, from) + value.getValue().substring(to));
+		}
+	}
+	
+	private void delete() {
+		if (cursorFrom == 0 && cursorTo == 0)
+			return;
+		
+		if (cursorFrom == cursorTo) {
+			if (cursorFrom < value.getValue().length()) {
+				value.setValue(value.getValue().substring(0, cursorFrom) + value.getValue().substring(cursorFrom + 1));
+			}
+		} else {
+			int from = Math.min(cursorFrom, cursorTo);
+			int to = Math.max(cursorFrom, cursorTo);
+			setCursor(from, from);
+			value.setValue(value.getValue().substring(0, from) + value.getValue().substring(to));
+		}
+	}
+	
+	private void insert(String value) {
+		int from = Math.min(cursorFrom, cursorTo);
+		int to = Math.max(cursorFrom, cursorTo);
+		this.value.setValue(this.value.getValue().substring(0, from) + value + this.value.getValue().substring(to));
+		setCursor(from + value.length(), from + value.length());
+	}
+	
+	private void enter() {
 		
 	}
 }

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

 package org.openzen.drawablegui;
 
 import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.style.DPxDimension;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
 	public final int paddingRight;
 	public final int paddingBottom;
 	
+	public final int borderWidth;
+	public final int borderColor;
+	
 	public final int color;
 	public final DFont font;
 	
 	public final int selectionColor;
 	
 	public DInputFieldStyle(DStyleDefinition style) {
-		backgroundColor = style.getColor("backgroundColor", 0);
+		backgroundColor = style.getColor("backgroundColor", 0xFFFFFFFF);
 		paddingTop = style.getDimension("paddingTop", new DDpDimension(2));
 		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(2));
 		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(2));
 		paddingRight = style.getDimension("paddingRight", new DDpDimension(2));
 		
+		borderWidth = style.getDimension("borderWidth", new DPxDimension(1));
+		borderColor = style.getColor("borderColor", 0xFFABADB3);
+		
 		color = style.getColor("color", 0xFF000000);
 		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, (int)(14 * context.getScale())));
 		

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

 	public static final int META = 2048;
 	public static final int ALT_GRAPH = 4096;
 	
+	public final DUIWindow window;
 	public final int x;
 	public final int y;
 	public final int modifiers;
 	public final int deltaZ;
 	public final int clickCount;
 	
-	public DMouseEvent(int x, int y, int modifiers, int deltaZ, int clickCount) {
+	public DMouseEvent(DUIWindow window, int x, int y, int modifiers, int deltaZ, int clickCount) {
+		this.window = window;
 		this.x = x;
 		this.y = y;
 		this.modifiers = modifiers;

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		for (int i = sides.size() - 1; i >= 0; i--) {
+			SideComponent side = sides.get(i);
+			if (side.side == Side.TOP)
+				return side.component.getBaselineY();
+		}
+		
+		return main.getBaselineY();
+	}
 
 	@Override
 	public LiveObject<DDimensionPreferences> getDimensionPreferences() {

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.style.DStyleSheets;
 
 /**
 	
 	float getScale();
 	
+	float getTextScale();
+	
 	void repaint(int x, int y, int width, int height);
 	
 	default void repaint(DIRectangle rectangle) {
 	
 	void setCursor(Cursor cursor);
 	
-	void focus(DComponent component);
-	
 	void scrollInView(int x, int y, int width, int height);
 	
 	DTimerHandle setTimer(int millis, Runnable target);
 	DFontMetrics getFontMetrics(DFont font);
 	
 	DUIWindow getWindow();
-		
+	
+	DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root);
+	
+	DUIWindow openView(int x, int y, DAnchor anchor, DComponent root);
+	
 	enum Cursor {
 		NORMAL,
 		HAND,

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

  * @author Hoofdgebruiker
  */
 public interface DUIWindow {
+	DIRectangle getWindowBounds();
+	
+	DUIContext getContext();
+	
 	boolean hasTitleBar();
 	
 	void close();
 	
 	LiveBool getActive();
 	
+	void focus(DComponent component);
+	
 	DUIWindow openModal(String title, DComponent root);
 	
 	enum State {

DrawableGui/src/main/java/org/openzen/drawablegui/DVerticalLayout.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 java.util.function.Consumer;
+import java.util.function.Predicate;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DVerticalLayout extends BaseComponentGroup {
+	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 DUIContext context;
+	private DHorizontalLayoutStyle style;
+	private DIRectangle bounds;
+	private float totalGrow;
+	private float totalShrink;
+	
+	public DVerticalLayout(DStyleClass styleClass, Alignment alignment, Element... components) {
+		this.styleClass = styleClass;
+		this.alignment = alignment;
+		this.components = components;
+		
+		componentSizeListeners = new ListenerHandle[components.length];
+		totalGrow = 0;
+		totalShrink = 0;
+		
+		for (int i = 0; i < componentSizeListeners.length; i++) {
+			componentSizeListeners[i] = components[i].component.getDimensionPreferences().addListener((oldValue, newValue) -> updateDimensionPreferences());
+			
+			totalGrow += components[i].grow;
+			totalShrink += components[i].shrink;
+		}
+	}
+
+	@Override
+	protected void forEachChild(Consumer<DComponent> children) {
+		for (Element element : components)
+			children.accept(element.component);
+	}
+
+	@Override
+	protected DComponent findChild(Predicate<DComponent> predicate) {
+		for (Element element : components)
+			if (predicate.test(element.component))
+				return element.component;
+		
+		return null;
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("verticalLayout", styleClass);
+		style = new DHorizontalLayoutStyle(context.getStylesheets().get(context, path));
+		
+		for (Element element : components)
+			element.component.setContext(parent, context);
+		
+		layout();
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public int getBaselineY() {
+		return components[0].component.getBaselineY();
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		for (Element element : components) {
+			element.component.paint(canvas);
+		}
+	}
+
+	@Override
+	public void close() {
+		for (int i = 0; i < componentSizeListeners.length; i++) {
+			componentSizeListeners[i].close();
+		}
+	}
+	
+	public static enum Alignment {
+		TOP(0),
+		MIDDLE(0.5f),
+		BOTTOM(1);
+		
+		public final float align;
+		
+		Alignment(float align) {
+			this.align = align;
+		}
+	}
+	
+	public static enum ElementAlignment {
+		LEFT,
+		CENTER,
+		RIGHT,
+		STRETCH
+	}
+	
+	public static class Element {
+		public final DComponent component;
+		public final float grow;
+		public final float shrink;
+		public final ElementAlignment alignment;
+		
+		public Element(DComponent component, float grow, float shrink, ElementAlignment alignment) {
+			this.component = component;
+			this.grow = grow;
+			this.shrink = shrink;
+			this.alignment = alignment;
+		}
+	}
+	
+	private void layout() {
+		if (bounds == null || context == null)
+			return;
+		
+		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		if (bounds.height < myPreferences.preferredHeight) {
+			layoutShrinked();
+		} else {
+			layoutGrown();
+		}
+	}
+	
+	private void layoutShrinked() {
+		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		if (totalShrink == 0) {
+			// now what?
+			// shrink proportionally, we have to shrink...
+			float scale = (float)(bounds.height - (components.length - 1) * style.spacing) / (myPreferences.preferredHeight - (components.length - 1) * style.spacing);
+			int y = 0;
+			
+			for (int i = 0; i < components.length; i++) {
+				Element element = components[i];
+				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				int newY = y + preferences.preferredHeight;
+				float idealUnspacedY = newY * scale;
+				int idealY = (int)(idealUnspacedY + 0.5f + i * style.spacing);
+				layout(element, bounds.y + y, idealY - y);
+				y = idealY;
+			}
+		} else {
+			int delta = bounds.height - myPreferences.preferredHeight;
+			float deltaScaled = delta / totalShrink;
+			int y = bounds.y;
+			for (Element element : components) {
+				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
+				float idealUnspacedY = y + scaledSize;
+				int newY = (int)(idealUnspacedY + 0.5f);
+				layout(element, y, newY - y);
+				y = newY + style.spacing;
+			}
+		}
+	}
+	
+	private void layoutGrown() {
+		// resize according to grow values
+		DDimensionPreferences myPreferences = dimensionPreferences.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();
+				int newY = y + preferences.preferredHeight;
+				layout(element, y, newY - y);
+				y = newY;
+			}
+		} else {
+			int delta = bounds.width - myPreferences.preferredWidth;
+			float deltaScaled = delta / totalGrow;
+			int y = bounds.y;
+			for (Element element : components) {
+				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				float scaledSize = preferences.preferredHeight + deltaScaled * element.grow;
+				float idealUnspacedX = y + scaledSize;
+				int newY = (int)(idealUnspacedX + 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();
+		int x;
+		int width;
+		switch (element.alignment) {
+			case LEFT:
+				width = Math.min(preferences.preferredWidth, bounds.width - style.paddingLeft - style.paddingRight);
+				x = bounds.x + style.paddingLeft;
+				break;
+			case CENTER:
+				width = Math.min(preferences.preferredWidth, bounds.width - style.paddingLeft - style.paddingRight);
+				x = bounds.x + style.paddingLeft + (bounds.width - style.paddingLeft - style.paddingRight - width) / 2;
+				break;
+			case RIGHT:
+				width = Math.min(preferences.preferredWidth, bounds.width - style.paddingLeft - style.paddingRight);
+				x = bounds.x + bounds.width - style.paddingLeft - width;
+				break;
+			case STRETCH:
+			default:
+				width = bounds.width - style.paddingLeft - style.paddingRight;
+				x = bounds.x + style.paddingLeft;
+				break;
+		}
+		element.component.setBounds(new DIRectangle(x, y, width, height));
+	}
+	
+	private void updateDimensionPreferences() {
+		int preferredWidth = 0;
+		int preferredHeight = -style.spacing;
+		int minimumWidth = 0;
+		int minimumHeight = -style.spacing;
+		int maximumWidth = Integer.MAX_VALUE;
+		int maximumHeight = -style.spacing;
+		
+		for (Element element : components) {
+			DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+			preferredWidth = Math.max(preferredWidth, preferences.preferredWidth);
+			preferredHeight += preferences.preferredHeight + style.spacing;
+			
+			minimumWidth = Math.max(minimumWidth, preferences.minimumWidth);
+			minimumHeight += preferences.minimumHeight + style.spacing;
+			
+			maximumWidth = Math.min(maximumWidth, preferences.maximumWidth);
+			maximumHeight += preferences.maximumHeight + style.spacing;
+		}
+		
+		DDimensionPreferences preferences = new DDimensionPreferences(
+				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);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DVerticalLayoutStyle.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.style.DDpDimension;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DVerticalLayoutStyle {
+	public final int spacing;
+	
+	public final int paddingTop;
+	public final int paddingLeft;
+	public final int paddingRight;
+	public final int paddingBottom;
+	
+	public DVerticalLayoutStyle(DStyleDefinition style) {
+		spacing = style.getDimension("spacing", new DDpDimension(8));
+		
+		paddingTop = style.getDimension("paddingTop", new DDpDimension(8));
+		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(8));
+		paddingRight = style.getDimension("paddingRight", new DDpDimension(8));
+		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(8));
+	}
+}

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		int contentBaseline = content.getBaselineY();
+		return contentBaseline == -1 ? -1 : style.padding + style.borderWidth + contentBaseline;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

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

  */
 package org.openzen.drawablegui.form;
 
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DDimensionPreferences;
  *
  * @author Hoofdgebruiker
  */
-public class DForm implements DComponent {
+public class DForm extends BaseComponentGroup {
 	private final DFormComponent[] components;
 	private final DStyleClass styleClass;
 	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
 	private DUIContext context;
 	private DFormStyle style;
 	private DFontMetrics fontMetrics;
+	private int maxFieldWidth;
+	private int maxLabelWidth;
 	
 	public DForm(DStyleClass styleClass, DFormComponent... components) {
 		this.styleClass = styleClass;
 			component.component.setContext(path, context);
 		
 		int height = style.paddingBottom + style.paddingTop;
-		int maxTextWidth = style.minimumLabelSize;
-		int maxComponentWidth = style.minimumFieldSize;
+		int maxLabelWidth = style.minimumLabelSize;
+		int maxFieldWidth = style.minimumFieldSize;
 		
 		for (DFormComponent component : components) {
-			maxTextWidth = Math.max(maxTextWidth, fontMetrics.getWidth(component.label));
+			maxLabelWidth = Math.max(maxLabelWidth, fontMetrics.getWidth(component.label));
 			int componentWidth = component.component.getDimensionPreferences().getValue().preferredWidth;
-			maxComponentWidth = Math.max(maxComponentWidth, componentWidth);
+			maxFieldWidth = Math.max(maxFieldWidth, componentWidth);
 		}
 		
 		for (DFormComponent component : components) {
 			height += style.spacing;
 		}
 		
-		preferences.setValue(new DDimensionPreferences(maxTextWidth + maxComponentWidth, height));
+		this.maxFieldWidth = maxFieldWidth;
+		this.maxLabelWidth = maxLabelWidth;
+		preferences.setValue(new DDimensionPreferences(maxLabelWidth + maxFieldWidth + style.paddingLeft + style.paddingRight + style.spacing, height));
+		
+		if (bounds != null)
+			layout();
 	}
 
 	@Override
 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		int contentBaseline = components[0].component.getBaselineY();
+		return contentBaseline == -1 ? -1 : contentBaseline + style.paddingTop;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		layout();
+		
+		if (context != null)
+			layout();
 	}
 
 	@Override
 	public void paint(DCanvas canvas) {
+		int x = style.paddingLeft;
+		int y = style.paddingTop;
 		for (DFormComponent component : components) {
+			int baseline = component.component.getBaselineY();
+			if (baseline == -1)
+				baseline = fontMetrics.getAscent();
+			canvas.drawText(style.labelFont, style.labelColor, x, y + baseline, component.label);
+			component.component.paint(canvas);
 			
+			y += component.component.getDimensionPreferences().getValue().preferredHeight + style.spacing;
 		}
 	}
 
 	private void layout() {
 		int x = bounds.x + style.paddingLeft;
 		int y = bounds.y + style.paddingBottom;
-		int maxTextWidth = style.minimumLabelSize;
-		
-		for (DFormComponent component : components)
-			maxTextWidth = Math.max(maxTextWidth, fontMetrics.getWidth(component.label));
 		
 		for (DFormComponent component : components) {
 			int preferredHeight = component.component.getDimensionPreferences().getValue().preferredHeight;
-			DIRectangle componentBounds = new DIRectangle(x + maxTextWidth, y, bounds.width - maxTextWidth, preferredHeight);
+			DIRectangle componentBounds = new DIRectangle(x + maxLabelWidth, y, bounds.width - maxLabelWidth - style.paddingLeft - style.paddingRight - style.spacing, preferredHeight);
 			component.component.setBounds(componentBounds);
 			
 			y += preferredHeight + style.spacing;
 		}
 	}
+
+	@Override
+	protected void forEachChild(Consumer<DComponent> children) {
+		for (DFormComponent component : components)
+			children.accept(component.component);
+	}
+
+	@Override
+	protected DComponent findChild(Predicate<DComponent> predicate) {
+		for (DFormComponent component : components)
+			if (predicate.test(component.component))
+				return component.component;
+		
+		return null;
+	}
 }

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

 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
 import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.style.DPxDimension;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
 		spacing = style.getDimension("spacing", new DDpDimension(8));
 		
 		labelColor = style.getColor("labelColor", 0xFF000000);
-		labelFont = style.getFont("labelFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(16 * context.getScale())));
+		labelFont = style.getFont("labelFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(14 * context.getScale())));
 		minimumLabelSize = style.getDimension("minimumLabelSize", new DDpDimension(150));
 		minimumFieldSize = style.getDimension("minimumFieldSize", new DDpDimension(150));
 	}

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

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

  */
 package org.openzen.drawablegui.scroll;
 
+import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 	
 	private DMouseEvent translateMouseEvent(DMouseEvent e) {
 		return new DMouseEvent(
+				e.window,
 				e.x - bounds.x + offsetX.getValue(),
 				e.y - bounds.y + offsetY.getValue(),
 				e.modifiers,
 		public float getScale() {
 			return context.getScale();
 		}
+		
+		@Override
+		public float getTextScale() {
+			return context.getTextScale();
+		}
 
 		@Override
 		public void repaint(int x, int y, int width, int height) {
 			return context.getFontMetrics(font);
 		}
 
-		@Override
-		public void focus(DComponent component) {
-			context.focus(component);
-		}
-
 		@Override
 		public void scrollInView(int x, int y, int width, int height) {
 			if (y < offsetY.getValue())
 		public DUIWindow getWindow() {
 			return context.getWindow();
 		}
+
+		@Override
+		public DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root) {
+			return context.openDialog(x, y, anchor, title, root);
+		}
+
+		@Override
+		public DUIWindow openView(int x, int y, DAnchor anchor, DComponent root) {
+			return context.openView(x, y, anchor, root);
+		}
 	}
 	
 	private class ScrollListener implements LiveInt.Listener {

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSpDimension implements DDimension {
+	private final float value;
+	
+	public DSpDimension(float value) {
+		this.value = value;
+	}
+
+	@Override
+	public float eval(DUIContext context) {
+		return value * context.getTextScale();
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingDialog.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.swing;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.awt.event.WindowStateListener;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.border.DCustomWindowBorder;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveBool;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class SwingDialog extends JDialog implements WindowListener, WindowStateListener, DUIWindow {
+	public final SwingRoot swingComponent;
+	private final boolean noTitleBar;
+	private final SimpleLiveObject<State> state = new SimpleLiveObject<>(State.NORMAL);
+	private final SimpleLiveBool active = new SimpleLiveBool(true);
+	
+	public SwingDialog(SwingWindow owner, String title, DComponent root, boolean noTitleBar) {
+		super(owner, title);
+		this.noTitleBar = noTitleBar;
+		
+		if (noTitleBar) {
+		    setUndecorated(true);
+			root = new DCustomWindowBorder(DStyleClass.EMPTY, root);
+			setBackground(new Color(0, 0, 0, 0));
+		}
+		
+		addWindowListener(this);
+		addWindowStateListener(this);
+		
+		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
+		swingComponent.setWindow(this);
+		swingComponent.requestFocusInWindow();
+	}
+	
+	public SwingDialog(SwingDialog owner, String title, DComponent root, boolean noTitleBar) {
+		super(owner, title);
+		this.noTitleBar = noTitleBar;
+		
+		if (noTitleBar) {
+		    setUndecorated(true);
+			root = new DCustomWindowBorder(DStyleClass.EMPTY, root);
+			setBackground(new Color(0, 0, 0, 0));
+		}
+		
+		addWindowListener(this);
+		addWindowStateListener(this);
+		
+		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
+		swingComponent.setWindow(this);
+		swingComponent.requestFocusInWindow();
+	}
+	
+	@Override
+	public DUIContext getContext() {
+		return swingComponent.context;
+	}
+
+	@Override
+	public DIRectangle getWindowBounds() {
+		return new DIRectangle(getX(), getY(), getWidth(), getHeight());
+	}
+
+	@Override
+	public boolean hasTitleBar() {
+		return !noTitleBar;
+	}
+
+	@Override
+	public void close() {
+		System.exit(0);
+	}
+
+	@Override
+	public void maximize() {
+		// cannot maximize
+	}
+
+	@Override
+	public void restore() {
+		// cannot restore
+	}
+
+	@Override
+	public void minimize() {
+		// TODO
+	}
+
+	@Override
+	public LiveObject<State> getWindowState() {
+		return state;
+	}
+	
+	@Override
+	public LiveBool getActive() {
+		return active;
+	}
+	
+	@Override
+	public void focus(DComponent component) {
+		swingComponent.focus(component);
+	}
+	
+	@Override
+	public DUIWindow openModal(String title, DComponent component) {
+		SwingDialog result = new SwingDialog(this, title, component, false);
+		result.setResizable(false);
+		
+		DDimensionPreferences size = component.getDimensionPreferences().getValue();
+		result.setLocation(
+				getX() + (getWidth() - size.preferredWidth) / 2,
+				getY() + (getHeight() - size.preferredHeight) / 2);
+		result.setSize(size.preferredWidth, size.preferredHeight);
+		return result;
+	}
+
+	@Override
+	public void windowOpened(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowClosing(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowClosed(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowIconified(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowDeiconified(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowActivated(WindowEvent e) {
+		active.setValue(true);
+	}
+
+	@Override
+	public void windowDeactivated(WindowEvent e) {
+		active.setValue(false);
+	}
+
+	@Override
+	public void windowStateChanged(WindowEvent e) {
+		state.setValue(getStateFromWindowState());
+	}
+	
+	private State getStateFromWindowState() {
+		/*switch (ge()) {
+			case NORMAL:
+				return State.NORMAL;
+			case ICONIFIED:
+				return State.MINIMIZED;
+			case MAXIMIZED_HORIZ:
+			case MAXIMIZED_VERT:
+			case MAXIMIZED_BOTH:
+				return State.MAXIMIZED;
+			default:
+				return State.NORMAL;
+		}*/
+		return State.NORMAL;
+	}
+}

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

  */
 package org.openzen.drawablegui.swing;
 
+import java.awt.Dimension;
 import java.awt.Font;
 import java.awt.Graphics;
 import java.awt.geom.GeneralPath;
 import java.util.WeakHashMap;
+import javax.swing.JFrame;
 import javax.swing.Timer;
+import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DTimerHandle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.style.DStylePathRoot;
 import org.openzen.drawablegui.style.DStyleSheets;
 
 /**
 public class SwingGraphicsContext implements DUIContext {
 	private final DStyleSheets stylesheets;
 	private final float scale;
+	private final float textScale;
 	private final WeakHashMap<DPath, GeneralPath> preparedPaths = new WeakHashMap<>();
 	private final SwingRoot root;
 	private final JavaClipboard clipboard = new JavaClipboard();
 	private Graphics graphics;
 	private DUIWindow window;
 	
-	public SwingGraphicsContext(DStyleSheets stylesheets, float scale, SwingRoot root) {
+	public SwingGraphicsContext(DStyleSheets stylesheets, float scale, float textScale, SwingRoot root) {
 		this.stylesheets = stylesheets;
 		this.scale = scale;
+		this.textScale = textScale;
 		this.root = root;
 	}
 	
 		return scale;
 	}
 	
+	@Override
+	public float getTextScale() {
+		return textScale;
+	}
+	
 	@Override
 	public void repaint(int x, int y, int width, int height) {
 		root.repaint(x, y, width, height);
 		if (graphics == null)
 			graphics = root.getGraphics();
 		
+		if (graphics == null)
+			throw new AssertionError("No graphics available!");
+		
 		SwingCanvas.prepare(font);
 		return new SwingFontMetrics(graphics.getFontMetrics((Font) font.cached), graphics);
 	}
-	
-	@Override
-	public void focus(DComponent component) {
-		this.root.focus(component);
-	}
 
 	@Override
 	public void scrollInView(int x, int y, int width, int height) {
 	public DUIWindow getWindow() {
 		return window;
 	}
+
+	@Override
+	public DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root) {
+		SwingDialog window = new SwingDialog((SwingWindow)this.window, title, root, false);
+		SwingGraphicsContext windowContext = new SwingGraphicsContext(stylesheets, scale, textScale, window.swingComponent);
+		windowContext.setWindow(window);
+		windowContext.graphics = this.graphics; // help a little...
+		
+		root.setContext(DStylePathRoot.INSTANCE, windowContext);
+		DDimensionPreferences dimension = root.getDimensionPreferences().getValue();
+		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
+		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
+		
+		window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+		window.swingComponent.setPreferredSize(new Dimension(dimension.preferredWidth, dimension.preferredHeight));
+		window.setLocation(tx, ty);
+		window.pack();
+		window.setVisible(true);
+		return window;
+	}
+
+	@Override
+	public DUIWindow openView(int x, int y, DAnchor anchor, DComponent root) {
+		SwingDialog window = new SwingDialog((SwingWindow)this.window, "", root, false);
+		SwingGraphicsContext windowContext = new SwingGraphicsContext(stylesheets, scale, textScale, window.swingComponent);
+		windowContext.setWindow(window);
+		windowContext.graphics = this.graphics; // help a little...
+		
+		root.setContext(DStylePathRoot.INSTANCE, windowContext);
+		DDimensionPreferences dimension = root.getDimensionPreferences().getValue();
+		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
+		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
+		
+		window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+		window.swingComponent.setPreferredSize(new Dimension(dimension.preferredWidth, dimension.preferredHeight));
+		window.setLocation(tx, ty);
+		window.pack();
+		window.setVisible(true);
+		return window;
+	}
 	
 	private class PathTracer implements DPathTracer {
 		private final GeneralPath path;

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

 		context = new SwingGraphicsContext(
 				DEmptyStylesheets.INSTANCE,
 				Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f,
+				Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f,
 				this);
-		component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
+		
 		addComponentListener(this);
 		addMouseListener(this);
 		addMouseMotionListener(this);
 		if (firstPaint) {
 			firstPaint = false;
 			component.setContext(DStylePathRoot.INSTANCE, context);
+			component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
 		}
 		
 		Rectangle clipBounds = g.getClipBounds();
 	}
 
 	private DMouseEvent translateMouseEvent(MouseEvent e) {
-		return new DMouseEvent(e.getX(), e.getY(), getModifiers(e.getModifiersEx()), 0, e.getClickCount());
+		return new DMouseEvent(context.getWindow(), e.getX(), e.getY(), getModifiers(e.getModifiersEx()), 0, e.getClickCount());
 	}
 
 	private DMouseEvent translateScrollEvent(MouseWheelEvent e) {
-		return new DMouseEvent(e.getX(), e.getY(), getModifiers(e.getModifiersEx()), e.getUnitsToScroll(), e.getClickCount());
+		return new DMouseEvent(context.getWindow(), e.getX(), e.getY(), getModifiers(e.getModifiersEx()), e.getUnitsToScroll(), e.getClickCount());
 	}
 	
 	private DKeyEvent translateKeyEvent(KeyEvent e) {

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

 import javax.swing.JFrame;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
 import org.openzen.drawablegui.border.DCustomWindowBorder;
 		swingComponent.requestFocusInWindow();
 	}
 	
+	@Override
 	public DUIContext getContext() {
 		return swingComponent.context;
 	}
 
+	@Override
+	public DIRectangle getWindowBounds() {
+		return new DIRectangle(getX(), getY(), getWidth(), getHeight());
+	}
+
 	@Override
 	public boolean hasTitleBar() {
 		return !noTitleBar;
 		return active;
 	}
 	
+	@Override
+	public void focus(DComponent component) {
+		swingComponent.focus(component);
+	}
+	
 	@Override
 	public DUIWindow openModal(String title, DComponent component) {
 		SwingWindow result = new SwingWindow(title, component, false);

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

IDE/src/main/java/org/openzen/zenscript/ide/Arguments.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;
+
+import java.io.File;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Arguments {
+	public final File projectDirectory;
+	
+	public Arguments(String[] arguments) {
+		File projectDir = new File("../../ZenCode"); // TODO: remove this and open a project chooser/creator instead
+		int positional = 0;
+		for (int i = 0; i < arguments.length; i++) {
+			switch (positional) {
+				case 0:
+					projectDir = new File(arguments[0]);
+					break;
+				default:
+					throw new IllegalArgumentException("Too many arguments");
+			}
+			positional++;
+		}
+		
+		this.projectDirectory = projectDir;
+	}
+}

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

 
 import java.io.File;
 import java.io.IOException;
+import java.util.Arrays;
 import javax.swing.JFrame;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.local.LocalProjectDevelopmentHost;
      * @param args the command line arguments
      */
     public static void main(String[] args) throws IOException {
-		File directory = new File("../../ZenCode");
+		Arguments arguments = new Arguments(args);
+		File directory = arguments.projectDirectory;
+		
 		CompilationUnit compilationUnit = new CompilationUnit();
 		ModuleLoader loader = new ModuleLoader(compilationUnit);
 		Project project = new Project(loader, directory);

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

  * @author Hoofdgebruiker
  */
 public class IDEAspectBar {
-	public final LiveList<IDEAspectToolbar> toolbars = new LiveArrayList<>(); // TODO: only expose read-only variant
+	public final LiveList<IDEAspectToolbar> toolbars = new LiveArrayList<>();
 	public final LiveObject<IDEAspectToolbar> active = new SimpleLiveObject<>(null);
 }

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.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.icons.AddBoxIcon;
 	
 	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 LiveBool addContentDisabled = new LivePredicateBool(contextPackage, pkg -> pkg == null);
+	
 	public IDEWindow(DevelopmentHost host) {
 		this.host = host;
 		
 	
 	private void init() {
 		projectToolbar = new IDEAspectToolbar(0, ShadedProjectIcon.PURPLE, "Project", "Project management");
-		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, AddBoxIcon.ORANGE, e -> {}));
-		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, SettingsIcon.PURPLE, e -> {}));
+		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);
+		}));
+		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);
+		}));
+		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, SettingsIcon.PURPLE, e -> {
+			
+		}));
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, BuildIcon.BLUE, e -> {
 			for (IDETarget target : host.getTargets()) {
 				if (target.canBuild())
 		}));
 		aspectBar.toolbars.add(projectToolbar);
 	}
+	
+	public void setContextModule(IDEModule module) {
+		contextModule.setValue(module);
+		contextPackage.setValue(module.getRootPackage());
+		contextFile.setValue(null);
+	}
+	
+	public void setContextPackage(IDEPackage pkg) {
+		contextModule.setValue(null);
+		contextPackage.setValue(pkg);
+		contextFile.setValue(null);
+	}
+	
+	public void setContextFile(IDESourceFile file) {
+		contextModule.setValue(null);
+		contextPackage.setValue(null);
+		contextFile.setValue(file);
+	}
 }

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

 	public static final ColoredIcon BLUE = new ColoredIcon(INSTANCE, 0xFF1B1464);
 	public static final ColoredIcon GREEN = new ColoredIcon(INSTANCE, 0xFF006266);
 	public static final ColoredIcon ORANGE = new ColoredIcon(INSTANCE, 0xFFEE5A24);
+	public static final ColoredIcon GRAY = new ColoredIcon(INSTANCE, 0xFF888888);
 	
 	private AddBoxIcon() {}
 	

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 	}
 	
 	private void repaint() {
+		if (context == null || bounds == null)
+			return;
+		
 		context.repaint(bounds);
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui.view;
+
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontFamily;
+import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StatusBarStyle {
+	public final int paddingTop;
+	public final int paddingBottom;
+	public final int paddingLeft;
+	public final int paddingRight;
+	public final DFont font;
+	public final int backgroundColor;
+	public final int textColor;
+	
+	public StatusBarStyle(DStyleDefinition style) {
+		paddingTop = style.getDimension("paddingTop", new DDpDimension(4));
+		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(4));
+		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(4));
+		paddingRight = style.getDimension("paddingRight", new DDpDimension(4));
+		
+		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, (int)(14 * context.getScale())));
+		backgroundColor = style.getColor("backgroundColor", 0xFFF0F0F0);
+		textColor = style.getColor("textColor", 0xFF000000);
+	}
+}

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.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 /**
  * @author Hoofdgebruiker
  */
 public class StatusBarView implements DComponent {
-	private static final int COLOR = 0xFFF0F0F0;
-	//private static final int COLOR = 0xFFFFFFFF;
+	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 0));
 	
-	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 40));
+	private final DStyleClass styleClass;
+	private final LiveString content;
 	private DIRectangle bounds;
 	private DUIContext context;
+	private StatusBarStyle style;
+	private DFontMetrics fontMetrics;
 
+	public StatusBarView(DStyleClass styleClass, LiveString content) {
+		this.styleClass = styleClass;
+		this.content = content;
+	}
+	
 	@Override
 	public void setContext(DStylePath parent, DUIContext context) {
 		this.context = context;
+		
+		DStylePath path = parent.getChild("StatusBar", styleClass);
+		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));
 	}
 	
 	@Override
 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return style.paddingTop + fontMetrics.getAscent();
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 
 	@Override
 	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, COLOR);
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		canvas.drawText(style.font, style.textColor, style.paddingLeft, style.paddingTop + fontMetrics.getAscent(), content.getValue());
 	}
 
 	@Override

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

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

 import org.openzen.drawablegui.DEmptyView;
 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.DSideLayout;
+import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.SimpleLiveString;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.tree.DTreeView;
 import org.openzen.drawablegui.tree.DTreeViewStyle;
 public final class WindowView extends DSideLayout {
 	private final IDEWindow window;
 	private final TabbedView tabs;
+	public final LiveString status = new SimpleLiveString("IDE initialized");
 	
 	public WindowView(IDEWindow window, DevelopmentHost host) {
 		super(DStyleClass.EMPTY, DEmptyView.INSTANCE);
 		projectView.getDimensionPreferences().setValue(new DDimensionPreferences(500, 500));
 		setMain(tabs = new TabbedView(DStyleClass.EMPTY));
 		add(Side.LEFT, new DScrollPane(DStyleClass.forId("projectView"), projectView));
-		add(Side.BOTTOM, new StatusBarView());
+		add(Side.BOTTOM, new StatusBarView(DStyleClass.EMPTY, status));
 		add(Side.TOP, new AspectBarView(DStyleClass.EMPTY, window.aspectBar));
 		
 		window.dockWindow.addListener(new DockWindowListener());

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

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

 		colorNormal = style.getColor("colorNormal", 0xFFFFFFFF);
 		colorHover = style.getColor("colorHover", 0xFFE0E0E0);
 		colorPress = style.getColor("colorPress", 0xFFCCCCCC);
-		colorActive = style.getColor("colorActive", 0xFFCCCCCC);
+		colorActive = style.getColor("colorActive", 0xFFF0F0F0);
 		
 		shadowNormal = style.getShadow("shadowNormal", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));
 		shadowHover = style.getShadow("shadowNormal", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));

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

 		aspectSelectorToToolbarSpacing = style.getDimension("aspectSelectorToToolbarSpacing", new DDpDimension(16));
 		toolbarTitleToControlsSpacing = style.getDimension("toolbarTitleToControlsSpacing", new DDpDimension(8));
 		aspectSelectorBottomSize = style.getDimension("aspectSelectorBottomSize", new DDpDimension(4));
-		backgroundColor = style.getColor("backgroundColor", 0xFFF0F0F0);
+		backgroundColor = style.getColor("backgroundColor", 0xFFCCCCCC); // 0xFFF0F0F0
 		foregroundColor = style.getColor("foregroundColor", 0xFFFFFFFF);
 		
 		aspectSelectorButtonSpacing = style.getDimension("aspectSelectorButtonSpacing", new DDpDimension(4));
 		
 		aspectBarShadow = style.getShadow("aspectBarShadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 2 * context.getScale()));
-		aspectBarPaddingTop = style.getDimension("aspectBarPaddingTop", new DDpDimension(2));
+		aspectBarPaddingTop = style.getDimension("aspectBarPaddingTop", new DDpDimension(4));
 		
 		controlPaddingTop = style.getDimension("controlPaddingTop", new DDpDimension(2));
 		controlPaddingBottom = style.getDimension("controlPaddingBottom", new DDpDimension(2));

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		
 		aspectBarShape = tracer -> {
 			int baseY = bounds.y + bounds.height - style.aspectSelectorBottomSize;
+			int barBaseX = toX + style.aspectSelectorToToolbarSpacing;
+			int barBaseY = bounds.y + style.aspectBarPaddingTop;
+			
 			tracer.moveTo(bounds.x, baseY);
-			tracer.lineTo(toX, baseY);
+			tracer.lineTo(toX - 3 * context.getScale(), baseY);
+			tracer.bezierCubic(
+					toX + 0 * context.getScale(), baseY,
+					toX + 2 * context.getScale(), baseY,
+					toX + 3.5f * context.getScale(), baseY - 4 * context.getScale());
+			tracer.lineTo(barBaseX - 3.5f * context.getScale(), barBaseY + 4 * context.getScale());
 			tracer.bezierCubic(
-					toX + 6 * context.getScale(), baseY,
-					toX + style.aspectSelectorToToolbarSpacing - 6 * context.getScale(), bounds.y + style.aspectBarPaddingTop,
-					toX + style.aspectSelectorToToolbarSpacing, bounds.y + style.aspectBarPaddingTop);
+					barBaseX - 2 * context.getScale(), barBaseY,
+					barBaseX - 0 * context.getScale(), barBaseY,
+					barBaseX + 3 * context.getScale(), barBaseY);
 			
 			if (showWindowControls) {
 				int spacingLeft = style.windowControlSpacingLeft;

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {

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

 	public DIRectangle getBounds() {
 		return bounds;
 	}
+	
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		context.focus(this);
+		context.getWindow().focus(this);
 		
 		SourcePosition position = getPositionAt(e.x, e.y);
 		if (e.isDoubleClick()) {

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

 package org.openzen.zenscript.ide.ui.view.project;
 
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.icons.ModuleIcon;
  */
 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;
 	}
 
 	@Override
 	public String getTitle() {
 		return module.getName();
 	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		window.setContextModule(module);
+	}
 
 	@Override
 	public boolean isLeaf() {

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

 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
+		window.setContextFile(sourceFile);
 		if (e.isDoubleClick()) {
 			window.open(sourceFile);
 		}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.java

 	
 	private JavaSourceFileScope createScope(HighLevelDefinition definition) {
 		SemanticModule module = modules.get(definition);
-		CompileScope scope = new CompileScope(definition.access, module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations);
+		CompileScope scope = new CompileScope(module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations);
 		return new JavaSourceFileScope(file.importer, compiler.typeGenerator, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition);
 	}
 

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.java

 			list.addMethod("constructor", new JavaSourceMethod(arrayList, JavaSourceMethod.Kind.CONSTRUCTOR, "", false));
 			list.addInstanceMethod("add", "add");
 			list.addInstanceMethod("insert", "add");
+			list.addInstanceMethod("remove", "remove");
+			list.addInstanceMethod("indexOf", "indexOf");
 			list.addInstanceMethod("getAtIndex", "get");
 			list.addInstanceMethod("setAtIndex", "set");
+			list.addInstanceMethod("contains", "contains");
 			list.addMethod("toArray", new JavaSourceMethod((formatter, call) -> formatter.listToArray((CastExpression)call)));
 			list.addInstanceMethod("length", "length");
 			list.addInstanceMethod("isEmpty", "isEmpty");

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 	private final List<ParsedImport> imports = new ArrayList<>();
 	private final List<ParsedDefinition> definitions = new ArrayList<>();
 	private final List<ParsedStatement> statements = new ArrayList<>();
-	private final AccessScope access = new AccessScope();
 	private WhitespacePostComment postComment = null;
 	
 	public ParsedFile(String filename) {
 			List<ExpansionDefinition> expansions,
 			Map<String, ISymbol> globalSymbols,
 			List<AnnotationDefinition> annotations) {
-		FileScope scope = new FileScope(access, rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
+		FileScope scope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
 		loadImports(scope, rootPackage, modulePackage);
 		for (ParsedDefinition definition : this.definitions) {
 			definition.compileTypes(scope);
 			List<ExpansionDefinition> expansions,
 			Map<String, ISymbol> globalSymbols,
 			List<AnnotationDefinition> annotations) {
-		FileScope scope = new FileScope(access, rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
+		FileScope scope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
 		loadImports(scope, rootPackage, modulePackage);
 		for (ParsedDefinition definition : this.definitions) {
 			definition.compileMembers(scope);
 			List<ScriptBlock> scripts,
 			Map<String, ISymbol> globalSymbols,
 			List<AnnotationDefinition> annotations) {
-		FileScope scope = new FileScope(access, rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
+		FileScope scope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
 		loadImports(scope, rootPackage, modulePackage);
 		for (ParsedDefinition definition : this.definitions) {
 			definition.compileCode(scope);
 				statements.add(statement.compile(statementScope));
 			}
 			
-			ScriptBlock block = new ScriptBlock(access, statements);
+			ScriptBlock block = new ScriptBlock(statements);
 			block.setTag(SourceFile.class, new SourceFile(filename));
 			block.setTag(WhitespacePostComment.class, postComment);
 			scripts.add(block);

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedGenericParameter.java

 		}
 	}
 	
-	private static TypeParameter[] NO_TYPE_PARAMETERS = new TypeParameter[0];
 	public static TypeParameter[] getCompiled(List<ParsedGenericParameter> parameters) {
 		if (parameters == null)
-			return null;
+			return TypeParameter.NONE;
 		
 		TypeParameter[] result = new TypeParameter[parameters.size()];
 		for (int i = 0; i < result.length; i++)