- Added bracket handlers

- Fixed crash formatting scripts without script statements
- Fixed bug causing lambda headers not to be inferred anymore
- Refactored some IDE code, also fixes scrolling not working properly

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

 		}
 		
 		StringBuilder scriptOutput = new StringBuilder();
-		StatementFormatter scriptFormatter = new StatementFormatter(scriptOutput, "", settings, expressionFormatter);
-		for (Statement statement : script.statements) {
-			statement.accept(scriptFormatter);
+		if (script != null) {
+			StatementFormatter scriptFormatter = new StatementFormatter(scriptOutput, "", settings, expressionFormatter);
+			for (Statement statement : script.statements) {
+				statement.accept(scriptFormatter);
+			}
 		}
 		
 		StringBuilder output = new StringBuilder();
 			output.append(definition.toString());
 		}
 		
-		if (script.statements.size() > 0) {
+		if (script != null && script.statements.size() > 0) {
 			if (definitionFormatters.size() > 0)
 				output.append("\n");
 			

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

 		return false;
 	}
 	
-	public boolean canCastTo(TypeScope scope, FunctionHeader header) {
-		if (parameters.length != header.parameters.length)
-			return false;
-		
-		if (!scope.getTypeMembers(returnType).canCastImplicit(header.returnType))
-			return false;
-		
-		for (int i = 0; i < parameters.length; i++) {
-			if (!scope.getTypeMembers(header.parameters[i].type).canCastImplicit(parameters[i].type))
-				return false;
-		}
-		
-		return true;
-	}
-	
 	public boolean accepts(TypeScope scope, Expression... arguments) {
 		if (parameters.length != arguments.length)
 			return false;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 
 /**
 	public EnumConstantMember evaluateEnumConstant() {
 		return constant.member.value.evaluateEnumConstant();
 	}
+	
+	@Override
+	public IDefinitionMember getMember() {
+		return constant.member;
+	}
 }

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.StatementTransformer;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 
 /**
 	public Expression(CodePosition position, ITypeID type, ITypeID thrownType) {
 		if (type == null)
 			throw new NullPointerException();
+		if (type == BasicTypeID.UNDETERMINED)
+			throw new IllegalArgumentException("Cannot use undetermined type as expression type");
 		
 		this.position = position;
 		this.type = type;

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

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		Expression tTarget = target.transform(transformer);
 		return tTarget == target ? this : new GetFieldExpression(position, tTarget, field);
 	}
+	
+	@Override
+	public IDefinitionMember getMember() {
+		return field.member;
+	}
 }

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

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+	
+	@Override
+	public IDefinitionMember getMember() {
+		return field.member;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/IPartialExpression.java

 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 	
 	ITypeID[] getGenericCallTypes();
 	
+	/**
+	 * Retrieves the (primary) member this expression refers to, or null if there is no primary target.
+	 * 
+	 * @return 
+	 */
+	default IDefinitionMember getMember() {
+		return null;
+	}
+	
 	default Expression assign(CodePosition position, TypeScope scope, Expression value) {
 		throw new CompileException(position, CompileExceptionCode.CANNOT_ASSIGN, "This expression is not assignable");
 	}

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

 	}
 	
 	public OptionalTypeID getOptional(ITypeID original) {
+		if (original == null)
+			throw new NullPointerException("original cannot be null");
+		
 		if (optionalTypes.containsKey(original)) {
 			return optionalTypes.get(original);
 		} else {

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

 	public final ITypeID baseType;
 	
 	public OptionalTypeID(ITypeID baseType) {
+		if (baseType == null)
+			throw new NullPointerException("baseType cannot be null");
+		
 		this.baseType = baseType;
 	}
 	
 	@Override
 	public ITypeID instance(GenericMapper mapper) {
+		if (mapper == null)
+			throw new NullPointerException("mapper cannot be null");
+		
 		return mapper.registry.getModified(TypeMembers.MODIFIER_OPTIONAL, baseType.instance(mapper));
 	}
 

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 import org.openzen.zenscript.constructor.module.ModuleSpace;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
 
 /**
 	}
 	
 	public ParsedFile[] parse(ZSPackage pkg) throws IOException {
+		// TODO: load bracket parsers from host plugins
 		List<ParsedFile> files = new ArrayList<>();
-		parse(files, pkg, sourceDirectory);
+		parse(files, pkg, null, sourceDirectory);
 		return files.toArray(new ParsedFile[files.size()]);
 	}
 	
-	private void parse(List<ParsedFile> files, ZSPackage pkg, File directory) throws IOException {
+	private void parse(List<ParsedFile> files, ZSPackage pkg, BracketExpressionParser bracketParser, File directory) throws IOException {
 		for (File file : directory.listFiles()) {
 			if (file.getName().endsWith(".zs")) {
 				try {
-					files.add(ParsedFile.parse(pkg, file));
+					files.add(ParsedFile.parse(pkg, bracketParser, file));
 				} catch (CompileException ex) {
 					exceptionLogger.accept(ex);
 				}
 			} else if (file.isDirectory()) {
-				parse(files, pkg.getOrCreatePackage(file.getName()), file);
+				parse(files, pkg.getOrCreatePackage(file.getName()), bracketParser, file);
 			}
 		}
 	}

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final LiveBool disabled;
 	private final Runnable action;
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DIRectangle bounds;
 	
 	private DButtonStyle style;
 	}
 	
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("Button", styleClass);
-		this.style = new DButtonStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.font);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("button", styleClass);
+		style = context.getStyle(DButtonStyle::new);
+		fontMetrics = context.getFontMetrics(style.font);
 		
 		sizing.setValue(new DSizing(
 				style.paddingLeft + style.paddingRight + fontMetrics.getWidth(label.getValue()),
 	
 	@Override
 	public void unmount() {
-		surface = null;
+		context = null;
 		
 		if (shape != null)
 			shape.close();
 		if (text != null)
 			text.close();
 		
-		shape = surface.shadowPath(
-				z,
-				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * surface.getScale()),
+		shape = context.shadowPath(
+				0,
+				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * context.getScale()),
 				DTransform2D.IDENTITY,
 				getBackgroundColor(),
 				currentShadow);
-		text = surface.drawText(
-				z +  1, 
+		text = context.drawText(
+				1, 
 				style.font,
 				style.textColor,
 				bounds.x + style.paddingLeft,
 			if (shape != null)
 				shape.close();
 			
-			shape = surface.shadowPath(
-				z,
-				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * surface.getScale()),
+			shape = context.shadowPath(
+				0,
+				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * context.getScale()),
 				DTransform2D.IDENTITY,
 				getBackgroundColor(),
 				currentShadow);

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface DComponent extends Destructible {
-	void mount(DStylePath parent, int z, DDrawSurface surface);
+	void mount(DComponentContext context);
 	
 	void unmount();
 	
 	
 	void setBounds(DIRectangle bounds);
 	
-	default void onMounted() {}
-	
-	default void onUnmounted() {}
-	
 	default void onMouseEnter(DMouseEvent e) {}
 	
 	default void onMouseExit(DMouseEvent e) {}

DrawableGui/src/main/java/org/openzen/drawablegui/DComponentContext.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.Function;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.draw.DSubSurface;
+import org.openzen.drawablegui.scroll.DScrollContext;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStyleDefinition;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DComponentContext {
+	public final DScrollContext scrollContext;
+	public final DStylePath path;
+	public final int z;
+	public final DDrawSurface surface;
+	
+	public DComponentContext(DScrollContext scrollContext, DStylePath path, int z, DDrawSurface surface) {
+		this.scrollContext = scrollContext;
+		this.path = path;
+		this.z = z;
+		this.surface = surface;
+	}
+	
+	public DComponentContext getChildContext(String component, DStyleClass styleClass) {
+		return getChildContext(10, component, styleClass);
+	}
+	
+	public DComponentContext getChildContext(int deltaz, String component, DStyleClass styleClass) {
+		return new DComponentContext(scrollContext, path.getChild(component, styleClass), z + deltaz, surface);
+	}
+	
+	public DUIContext getUIContext() {
+		return surface.getContext();
+	}
+	
+	public DStyleDefinition getStyle() {
+		return surface.getStylesheet(path);
+	}
+	
+	public <S> S getStyle(Function<DStyleDefinition, S> factory) {
+		return factory.apply(surface.getStylesheet(path));
+	}
+
+	public DFontMetrics getFontMetrics(DFont font) {
+		return surface.getFontMetrics(font);
+	}
+	
+	public float getScale() {
+		return surface.getScale();
+	}
+	
+	public float getTextScale() {
+		return surface.getTextScale();
+	}
+	
+	public DDrawnText drawText(int deltaz, DFont font, int color, float x, float y, String text) {
+		return surface.drawText(z + deltaz, font, color, x, y, text);
+	}
+	
+	public DDrawnRectangle fillRect(int deltaz, DIRectangle rectangle, int color) {
+		return surface.fillRect(z + deltaz, rectangle, color);
+	}
+	
+	public DDrawnShape strokePath(int deltaz, DPath path, DTransform2D transform, int color, float lineWidth) {
+		return surface.strokePath(z + deltaz, path, transform, color, lineWidth);
+	}
+	
+	public DDrawnShape fillPath(int deltaz, DPath path, DTransform2D transform, int color) {
+		return surface.fillPath(z + deltaz, path, transform, color);
+	}
+	
+	public DDrawnShape shadowPath(int deltaz, DPath path, DTransform2D transform, int color, DShadow shadow) {
+		return surface.shadowPath(z + deltaz, path, transform, color, shadow);
+	}
+	
+	public DSubSurface createSubSurface(int deltaz) {
+		return surface.createSubSurface(z + deltaz);
+	}
+}

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.ImmutableLiveObject;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private DEmptyView() {}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DComponentContext parent) {
 		
 	}
 	

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.live.MutableLiveString;
 import org.openzen.drawablegui.style.DDimension;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private DIRectangle bounds = DIRectangle.EMPTY;
 	private final DDimension preferredWidth;
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DInputFieldStyle style;
 	private DFontMetrics fontMetrics;
 	private int cursorFrom = -1;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("input", styleClass);
-		style = new DInputFieldStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.font);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("input", styleClass);
+		style = context.getStyle(DInputFieldStyle::new);
+		fontMetrics = context.getFontMetrics(style.font);
 		
 		sizing.setValue(new DSizing(
-				preferredWidth.evalInt(surface.getContext()) + style.margin.getHorizontal() + style.border.getPaddingHorizontal(),
+				preferredWidth.evalInt(context.getUIContext()) + style.margin.getHorizontal() + style.border.getPaddingHorizontal(),
 				fontMetrics.getAscent() + fontMetrics.getDescent() + style.margin.getVertical() + style.border.getPaddingVertical()));
 		
 		if (blinkTimer != null)
 			blinkTimer.close();
-		blinkTimer = surface.getContext().setTimer(300, this::blink);
+		blinkTimer = context.getUIContext().setTimer(300, this::blink);
 		
 		if (text != null)
 			text.close();
-		text = surface.drawText(
-				z + 2,
+		text = parent.drawText(
+				2,
 				style.font,
 				style.color,
 				bounds.x + style.margin.left + style.border.getPaddingLeft(),
 		
 		if (cursor != null)
 			cursor.close();
-		cursor = surface.fillRect(z + 2, DIRectangle.EMPTY, cursorBlink ? style.cursorColor : 0);
+		cursor = parent.fillRect(2, DIRectangle.EMPTY, cursorBlink ? style.cursorColor : 0);
 		
 		if (selection != null)
 			selection.close();
-		selection = surface.fillRect(z + 1, DIRectangle.EMPTY, 0);
+		selection = parent.fillRect(1, DIRectangle.EMPTY, 0);
 		
 		setCursor(cursorFrom, cursorTo);
 	}
 		
 		if (shape != null)
 			shape.close();
-		shape = surface.fillPath(z, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor);
+		shape = context.fillPath(0, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor);
 		text.setPosition(
 				bounds.x + style.margin.left + style.border.getPaddingLeft(),
 				bounds.y + style.margin.top + style.border.getPaddingTop() + fontMetrics.getAscent());
-		style.border.update(surface, z, bounds);
+		style.border.update(context, bounds);
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
-		surface.getContext().setCursor(DUIContext.Cursor.TEXT);
+		context.getUIContext().setCursor(DUIContext.Cursor.TEXT);
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
-		surface.getContext().setCursor(DUIContext.Cursor.NORMAL);
+		context.getUIContext().setCursor(DUIContext.Cursor.NORMAL);
 	}
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		surface.getContext().getWindow().focus(this);
+		context.getUIContext().getWindow().focus(this);
 	}
 	
 	@Override
 	private void handleValueUpdated(String newValue) {
 		if (text != null)
 			text.close();
-		text = surface.drawText(
-				z + 2,
+		text = context.drawText(
+				2,
 				style.font,
 				style.color,
 				bounds.x + style.margin.left + style.border.getPaddingLeft(),

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final ListenerHandle<LiveString.Listener> labelListener;
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DIRectangle bounds;
 	private DLabelStyle style;
 	private DFontMetrics fontMetrics;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("label", styleClass);
-		style = new DLabelStyle(surface.getStylesheet(path));
-		
-		fontMetrics = surface.getFontMetrics(style.font);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("label", styleClass);
+		style = context.getStyle(DLabelStyle::new);
+		fontMetrics = context.getFontMetrics(style.font);
 		calculateDimension();
 		
 		if (text != null)
 			text.close();
-		text = surface.drawText(z, style.font, style.color, 0, 0, label.getValue());
+		text = context.drawText(0, style.font, style.color, 0, 0, label.getValue());
 	}
 	
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		style.border.update(surface, z + 1, bounds);
+		style.border.update(context, bounds);
 		text.setPosition(
 				bounds.x + style.border.getPaddingLeft(),
 				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent());
 		
 		if (text != null)
 			text.close();
-		text = surface.drawText(
-				z,
+		text = context.drawText(
+				0,
 				style.font,
 				style.color,
 				bounds.x + style.border.getPaddingLeft(),

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final ListenerHandle<LiveString.Listener> tooltipListener;
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DIRectangle bounds;
 	private DFontMetrics fontMetrics;
 	private DSimpleTooltipStyle style;
 	}
 	
 	private void onTooltipChanged(String oldValue, String newValue) {
-		if (surface == null || bounds == null)
+		if (context == null || bounds == null)
 			return;
 		
 		calculateSize();
 		if (text != null)
 			text.close();
 		
-		text = surface.drawText(
-				z,
+		text = context.drawText(
+				0,
 				style.font,
 				style.textColor,
 				bounds.x + style.border.getPaddingLeft(),
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		style.border.update(surface, z + 1, bounds);
+		style.border.update(context, bounds);
 		
 		if (background != null)
 			background.close();
-		background = surface.fillRect(z, bounds, style.backgroundColor);
+		background = context.fillRect(0, bounds, style.backgroundColor);
 		text.setPosition(
 				bounds.x + style.border.getPaddingLeft(),
 				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent());
 	}
 	
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("tooltip", styleClass);
-		style = new DSimpleTooltipStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.font);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("tooltip", styleClass);
+		style = context.getStyle(DSimpleTooltipStyle::new);
+		fontMetrics = context.getFontMetrics(style.font);
 		calculateSize();
 		
 		if (text != null)
 			text.close();
-		text = surface.drawText(z + 1, style.font, style.textColor, 0, 0, tooltip.getValue());
+		text = parent.drawText(1, style.font, style.textColor, 0, 0, tooltip.getValue());
 	}
 	
 	@Override

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

 	
 	void setCursor(Cursor cursor);
 	
-	void scrollInView(int x, int y, int width, int height);
-	
 	DTimerHandle setTimer(int millis, Runnable target);
 	
 	DClipboard getClipboard();

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

 package org.openzen.drawablegui.border;
 
 import java.io.Closeable;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface DBorder extends Closeable {
-	public void update(DDrawSurface surface, int z, DIRectangle bounds);
+	public void update(DComponentContext context, DIRectangle bounds);
 	
 	public int getPaddingLeft();
 	

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

  */
 package org.openzen.drawablegui.border;
 
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 
 /**
  *
 	}
 
 	@Override
-	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
+	public void update(DComponentContext context, DIRectangle bounds) {
 		for (DBorder border : borders) {
-			border.update(surface, z, bounds);
+			border.update(context, bounds);
 			bounds = new DIRectangle(
 					bounds.x + border.getPaddingLeft(),
 					bounds.y + border.getPaddingTop(),

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

 package org.openzen.drawablegui.border;
 
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIWindow;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final DComponent content;
 	private final LiveObject<DSizing> sizing = new ImmutableLiveObject<>(DSizing.EMPTY);
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DCustomWindowBorderStyle style;
 	private DIRectangle bounds;
 	
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		content.mount(parent, z + 1, surface);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("customwindowborder", styleClass);
+		content.mount(context);
 		
-		state = surface.getContext().getWindow().getWindowState();
-		active = surface.getContext().getWindow().getActive();
+		state = parent.getUIContext().getWindow().getWindowState();
+		active = parent.getUIContext().getWindow().getActive();
 		stateListener = state.addListener(this::onStateChanged);
 		activeListener = active.addListener(this::onActiveChanged);
 		
-		DStylePath path = parent.getChild("customwindowborder", styleClass);
-		style = new DCustomWindowBorderStyle(surface.getStylesheet(path));
+		style = parent.getStyle(DCustomWindowBorderStyle::new);
 		
 		if (bounds != null)
 			layout();
 					bounds.height - 2 * style.padding - style.borderWidth);
 			if (border != null)
 				border.close();
-			border = surface.strokePath(
-					z + 1,
+			border = context.strokePath(
+					1,
 					path,
 					DTransform2D.IDENTITY,
 					active.getValue() ? style.focusedBorderColor : style.inactiveBorderColor,
 				background.close();
 				background = null;
 			}
-			shadowedBackground = surface.shadowPath(z, path, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+			shadowedBackground = context.shadowPath(0, path, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		} else {
 			content.setBounds(bounds);
 			
 				border = null;
 			}
 			if (background == null) {
-				background = surface.fillRect(z, bounds, style.backgroundColor);
+				background = context.fillRect(0, bounds, style.backgroundColor);
 			} else {
 				background.setRectangle(bounds);
 			}

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

  */
 package org.openzen.drawablegui.border;
 
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.style.DBorderElement;
 
 /**
 	private DEmptyBorder() {}
 	
 	@Override
-	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
+	public void update(DComponentContext context, DIRectangle bounds) {
 		
 	}
 

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

  */
 package org.openzen.drawablegui.border;
 
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 
 /**
 	}
 
 	@Override
-	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
+	public void update(DComponentContext context, DIRectangle bounds) {
 		if (shape != null)
 			shape.close();
 		
-		shape = surface.strokePath(z, tracer -> {
+		shape = context.strokePath(1, tracer -> {
 				tracer.moveTo(bounds.x, bounds.y);
 				tracer.lineTo(bounds.x + bounds.width - borderWidth, bounds.y);
 				tracer.lineTo(bounds.x + bounds.width - borderWidth, bounds.y + bounds.height - borderWidth);

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

  */
 package org.openzen.drawablegui.border;
 
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 
 /**
  *
 	}
 
 	@Override
-	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
+	public void update(DComponentContext context, DIRectangle bounds) {
 		// nothing to paint
 	}
 

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

  */
 package org.openzen.drawablegui.border;
 
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 
 /**
 	}
 
 	@Override
-	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
+	public void update(DComponentContext context, DIRectangle bounds) {
 		if (leftWidth > 0) {
 			int x = bounds.x;
 			if (left != null)
 				left.close();
-			left = surface.strokePath(z, DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
+			left = context.strokePath(1, DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
 		}
 		if (topWidth > 0) {
 			int y = bounds.y;
 			if (top != null)
 				top.close();
-			top = surface.strokePath(z, DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
+			top = context.strokePath(1, DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
 		}
 		if (rightWidth > 0) {
 			int x = bounds.x + bounds.width - rightWidth;
 			if (right != null)
 				right.close();
-			right = surface.strokePath(z, DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
+			right = context.strokePath(1, DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
 		}
 		if (bottomWidth > 0) {
 			int y = bounds.y + bounds.height - bottomWidth;
 			if (bottom != null)
 				bottom.close();
-			bottom = surface.strokePath(z, DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
+			bottom = context.strokePath(1, DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
 		}
 	}
 

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final DStyleClass styleClass;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
+	private DComponentContext context;
 	private DIRectangle bounds;
-	private DDrawSurface context;
 	private DFormStyle style;
 	private DFontMetrics fontMetrics;
 	private int maxFieldWidth;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.context = surface;
-		
-		DStylePath path = parent.getChild("form", styleClass);
-		style = new DFormStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.labelFont);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("form", styleClass);
+		style = context.getStyle(DFormStyle::new);
+		fontMetrics = context.getFontMetrics(style.labelFont);
 		
 		for (DFormComponent component : components)
-			component.component.mount(path, z + 1, surface);
+			component.component.mount(context);
 		
 		int height = style.paddingBottom + style.paddingTop;
 		int maxLabelWidth = style.minimumLabelSize;
 		for (int i = 0; i < labels.length; i++) {
 			if (labels[i] != null)
 				labels[i].close();
-			labels[i] = surface.drawText(z + 1, style.labelFont, style.labelColor, 0, 0, components[i].label);
+			labels[i] = parent.drawText(1, style.labelFont, style.labelColor, 0, 0, components[i].label);
 		}
 	}
 	

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DLinearLayoutStyle style;
 	private DIRectangle bounds;
 	private float totalGrow;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("linearlayout", styleClass);
-		style = new DLinearLayoutStyle(surface.getStylesheet(path));
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("linearlayout", styleClass);
+		style = context.getStyle(DLinearLayoutStyle::new);
 		
 		for (Element element : components)
-			element.component.mount(parent, z + 1, surface);
+			element.component.mount(context);
 	}
 	
 	@Override
 			return;
 		
 		this.bounds = bounds;
-		style.border.update(surface, z + 1, bounds);
+		style.border.update(context, bounds);
 		
 		if (shape != null)
 			shape.close();
-		shape = surface.shadowPath(z, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		shape = context.shadowPath(0, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		
 		layout();
 	}
 	}
 	
 	private void layout() {
+		if (bounds == null || context == null)
+			return;
+		
 		if (orientation == Orientation.HORIZONTAL) {
 			layoutHorizontal();
 		} else {
 	}
 	
 	private void layoutHorizontal() {
-		if (bounds == null || surface == null)
-			return;
-		
 		DSizing myPreferences = sizing.getValue();
 		if (bounds.width < myPreferences.preferredWidth) {
 			layoutHorizontalShrinked();
 	}
 	
 	private void layoutVertical() {
-		if (bounds == null || surface == null)
-			return;
-		
 		DSizing myPreferences = sizing.getValue();
 		if (bounds.height < myPreferences.preferredHeight) {
 			layoutVerticalShrinked();

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DSizing;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final List<SideComponent> sides = new ArrayList<>();
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
-	private DStylePath path;
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DSideLayoutStyle style;
 	private DIRectangle bounds;
 	
 	}
 	
 	public void add(Side side, DComponent component) {
-		if (surface != null)
-			component.mount(path, z + 1, surface);
+		if (context != null)
+			component.mount(context);
 		
 		sides.add(new SideComponent(side, component));
 	}
 		
 		this.main = component;
 		
-		if (surface != null && bounds != null) {
-			main.mount(path, z + 1, surface);
+		if (context != null && bounds != null) {
+			main.mount(context);
 			setBounds(bounds);
 		}
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		this.path = parent.getChild("sidelayout", styleClass);
-		style = new DSideLayoutStyle(surface.getStylesheet(path));
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("sidelayout", styleClass);
+		style = context.getStyle(DSideLayoutStyle::new);
 		
-		main.mount(path, z + 1, surface);
+		main.mount(context);
 		for (SideComponent side : sides)
-			side.component.mount(path, z + 1, surface);
+			side.component.mount(context);
 		
 		if (background != null)
 			background.close();
-		background = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
+		background = context.fillRect(0, DIRectangle.EMPTY, style.backgroundColor);
 	}
 	
 	@Override

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

 		
 		remove(index);
 	}
+	
+	@Override
+	public void clear() {
+		for (int i = size() - 1; i >= 0; i--)
+			remove(i);
+	}
 
 	@Override
 	public int indexOf(T value) {

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

 	void remove(int index);
 	
 	void remove(T value);
+	
+	void clear();
 }

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

 package org.openzen.drawablegui.scroll;
 
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveInt;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final ListenerHandle<LiveInt.Listener> targetHeightListener;
 	private final ListenerHandle<LiveInt.Listener> offsetListener;
 	
-	private DDrawSurface surface;
+	private DComponentContext context;
 	private DScrollBarStyle style;
-	private int z;
 	private DIRectangle bounds;
 	
 	private int fromY = 0;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		this.style = new DScrollBarStyle(surface.getStylesheet(parent.getChild("scrollbar", styleClass)));
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("scrollbar", styleClass);
+		style = context.getStyle(DScrollBarStyle::new);
 		sizing.setValue(new DSizing(style.width, 0));
 		
-		background = surface.fillRect(z, DIRectangle.EMPTY, style.scrollBarBackgroundColor);
+		background = context.fillRect(0, DIRectangle.EMPTY, style.scrollBarBackgroundColor);
 	}
 	
 	@Override
 		
 		if (bar != null)
 			bar.close();
-		bar = surface.fillPath(z + 1, DPath.rectangle(bounds.x, fromY, bounds.width, toY - fromY), DTransform2D.IDENTITY, style.scrollBarNormalColor);
+		bar = context.fillPath(1, DPath.rectangle(bounds.x, fromY, bounds.width, toY - fromY), DTransform2D.IDENTITY, style.scrollBarNormalColor);
 		updateBarColor();
 	}
 	

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollContext.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.scroll;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DScrollContext {
+	void scrollInView(int x, int y, int width, int height);
+	
+	int getViewportWidth();
+	
+	int getViewportHeight();
+}

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

  */
 package org.openzen.drawablegui.scroll;
 
-import org.openzen.drawablegui.DAnchor;
-import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
-import org.openzen.drawablegui.DFont;
-import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
-import org.openzen.drawablegui.DTimerHandle;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveInt;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.SimpleLiveInt;
-import org.openzen.drawablegui.DUIContext;
-import org.openzen.drawablegui.DUIWindow;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DSubSurface;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
-import org.openzen.drawablegui.style.DStyleSheets;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class DScrollPane implements DComponent {
+public class DScrollPane implements DComponent, DScrollContext {
 	private final DStyleClass styleClass;
 	private final DComponent contents;
 	private final DScrollBar scrollBar;
-	private DDrawSurface surface;
-	private DIRectangle bounds;
 	
+	private DComponentContext context;
 	private DScrollPaneStyle style;
-	private int z;
+	private DIRectangle bounds;
+	
 	private DDrawnShape shape;
 	private final LiveInt contentsHeight;
 	private final LiveInt offsetX;
 			contentsHeight.setValue(newPreferences.preferredHeight);
 		});
 	}
-	
-	@Override
-	public void onMounted() {
-		contents.onMounted();
-	}
-	
-	@Override
-	public void onUnmounted() {
-		contents.onUnmounted();
-	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("scrollpane", styleClass);
+		style = context.getStyle(DScrollPaneStyle::new);
 		
-		DStylePath path = parent.getChild("scrollpane", styleClass);
-		subSurface = surface.createSubSurface(z + 1);
-		contents.mount(path, 1, subSurface);
-		scrollBar.mount(path, z + 2, surface);
-		style = new DScrollPaneStyle(surface.getStylesheet(path));
+		subSurface = context.createSubSurface(1);
+		DComponentContext newContext = new DComponentContext(this, context.path, 0, subSurface);
+		contents.mount(newContext);
+		scrollBar.mount(context);
 	}
 	
 	@Override
 	public void unmount() {
 		subSurface.close();
+		style.border.close();
 		
 		contents.unmount();
 		scrollBar.unmount();
 		
 		if (shape != null)
 			shape.close();
-		shape = surface.shadowPath(z, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
-		style.border.update(surface, z + 1, style.margin.apply(bounds));
+		shape = context.shadowPath(0, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		style.border.update(context, style.margin.apply(bounds));
 		
 		int height = Math.max(
 				bounds.height - style.border.getPaddingHorizontal(),
 	private int toLocalY(int y) {
 		return y - bounds.y + offsetY.getValue();
 	}
+
+	@Override
+	public void scrollInView(int x, int y, int width, int height) {
+		if (y < offsetY.getValue())
+			offsetY.setValue(y);
+		if (y + height > offsetY.getValue() + bounds.height)
+			offsetY.setValue(y + height - bounds.height);
+	}
+
+	@Override
+	public int getViewportWidth() {
+		return bounds.width;
+	}
+
+	@Override
+	public int getViewportHeight() {
+		return bounds.height;
+	}
 	
 	private class ScrollListener implements LiveInt.Listener {
 

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

 import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DFont;
 		return new SwingFontMetrics(graphics.getFontMetrics((Font) font.cached), graphics);
 	}
 
-	@Override
-	public void scrollInView(int x, int y, int width, int height) {
-		// not in a scrollable context
-	}
-
 	@Override
 	public DTimerHandle setTimer(int millis, Runnable target) {
 		Timer timer = new Timer(millis, e -> target.run());
 		
 		Point rootLocation = swingWindow.swingComponent.getLocationOnScreen();
 		
-		root.mount(DStylePathRoot.INSTANCE, 0, windowContext.surface);
+		root.mount(new DComponentContext(null, DStylePathRoot.INSTANCE, 0, windowContext.surface));
 		DSizing dimension = root.getSizing().getValue();
-		int tx = (int)(x + rootLocation.x - anchor.alignX * dimension.preferredWidth);
-		int ty = (int)(y + rootLocation.y - anchor.alignY * dimension.preferredHeight);
+		//int tx = (int)(x + rootLocation.x - anchor.alignX * dimension.preferredWidth);
+		//int ty = (int)(y + rootLocation.y - anchor.alignY * dimension.preferredHeight);
+		int dx = (int)(anchor.alignX * dimension.preferredWidth);
+		int dy = (int)(anchor.alignY * dimension.preferredHeight);
+		int tx = rootLocation.x + x - dx;
+		int ty = rootLocation.y + y - dy;
 		
 		window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
 		window.swingComponent.setPreferredSize(new Dimension(dimension.preferredWidth, dimension.preferredHeight));
-		window.setLocation(tx, ty);
 		window.pack();
+		window.setLocation(tx, ty);
 		window.setVisible(true);
 		return window;
 	}
 		windowContext.graphics = this.graphics; // help a little...
 		windowContext.setSurface(window.swingComponent.surface);
 		
-		root.mount(DStylePathRoot.INSTANCE, 0, windowContext.surface);
+		root.mount(new DComponentContext(null, DStylePathRoot.INSTANCE, 0, windowContext.surface));
 		DSizing dimension = root.getSizing().getValue();
 		
 		Point rootLocation = swingWindow.swingComponent.getLocationOnScreen();

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

 import java.awt.event.MouseWheelEvent;
 import java.awt.event.MouseWheelListener;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DKeyEvent;
 import static org.openzen.drawablegui.DKeyEvent.KeyCode.*;
 	public void paint(Graphics g) {
 		if (firstPaint) {
 			firstPaint = false;
-			component.mount(DStylePathRoot.INSTANCE, 0, surface);
+			component.mount(new DComponentContext(null, DStylePathRoot.INSTANCE, 0, surface));
 			component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
 		}
 		

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

 import java.util.List;
 import org.openzen.drawablegui.DColorableIconInstance;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 public class DTreeView<N extends DTreeNode<N>> implements DComponent {
 	private final DStyleClass styleClass;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	
+	private DComponentContext context;
 	private DIRectangle bounds = DIRectangle.EMPTY;
-	private int z;
 	
 	private int selectedRow = -1;
 	private N selectedNode = null;
 	private final DDrawable nodeOpenedIcon;
 	private final DDrawable nodeClosedIcon;
 	
-	private DDrawSurface surface;
 	private final N root;
 	private final boolean showRoot;
 	private final List<Row> rows = new ArrayList<>();
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		style = new DTreeViewStyle(surface.getStylesheet(parent.getChild("tree", styleClass)));
-		fontMetrics = surface.getFontMetrics(style.font);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("tree", styleClass);
+		style = context.getStyle(DTreeViewStyle::new);
+		fontMetrics = context.getFontMetrics(style.font);
 		
-		background = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
-		selectedBackground = surface.fillRect(z + 1, DIRectangle.EMPTY, 0);
+		background = context.fillRect(0, DIRectangle.EMPTY, style.backgroundColor);
+		selectedBackground = context.fillRect(1, DIRectangle.EMPTY, 0);
 		
 		updateLayout();
 	}
 			
 			icon = node.isCollapsed().getValue() ? nodeClosedIcon : nodeOpenedIcon;
 			nodeIcon = new DColorableIconInstance(
-					surface,
-					z + 2,
+					context.surface,
+					context.z + 2,
 					node.getIcon(),
 					DTransform2D.translate(baseX + icon.getNominalWidth() + style.iconTextSpacing, baseY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()),
 					node == selectedNode ? style.selectedNodeTextColor : style.nodeTextColor);
 			
 			if (!node.isLeaf())
 				collapseIcon = new DDrawableInstance(
-						surface, 
-						z + 2,
+						context.surface, 
+						context.z + 2,
 						icon,
 						DTransform2D.translate(baseX, baseY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()));
 			
-			text = surface.drawText(
-					z + 2,
+			text = context.drawText(
+					2,
 					style.font,
 					node == selectedNode ? style.selectedNodeTextColor : style.nodeTextColor,
 					baseX + style.iconTextSpacing + icon.getNominalWidth() + style.iconTextSpacing + node.getIcon().getNominalWidth(),

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

 	
 	private ZenCodeCompiler buildInternal(Consumer<OutputLine> output) {
 		CompilationUnit compilationUnit = new CompilationUnit();
-		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit, exception -> output.accept(new OutputLine(new ErrorOutputSpan(exception.getMessage()))));
+		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit, exception -> {
+			String[] lines = Strings.split(exception.getMessage(), '\n');
+			for (String line : lines) {
+				output.accept(new OutputLine(new ErrorOutputSpan(line)));
+			}
+		});
 		moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
 		Set<String> compiledModules = new HashSet<>();
 		

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

 			
 		}));
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, BuildIcon.BLUE, new ImmutableLiveString("Build"), e -> {
+			output.clear();
 			for (IDETarget target : host.getTargets()) {
 				if (target.canBuild())
 					target.build(line -> output.add(line));

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

 	
 	public void open(DUIWindow parent) {
 		DIRectangle rectangle = parent.getWindowBounds().getValue();
-		window = parent.getContext().openDialog(rectangle.getCenterX(), rectangle.getCenterY(), DAnchor.MIDDLE_CENTER, "Create source file", root);
+		window = parent.getContext().openDialog(rectangle.width / 2, rectangle.height / 2, DAnchor.MIDDLE_CENTER, "Create source file", root);
 		window.focus(input);
 	}
 	

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

 
 import java.util.function.Consumer;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DDrawableInstance;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DSimpleTooltip;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final LiveBool disabled;
 	private final ListenerHandle<LiveBool.Listener> disabledListener;
 	private final DSimpleTooltip tooltip;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private IconButtonControlStyle style;
 	private DIRectangle bounds;
-	private final MutableLiveObject<DSizing> preferences = DSizing.create();
 	private boolean hover;
 	private boolean press;
 	
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("iconbutton", styleClass);
+		style = context.getStyle(IconButtonControlStyle::new);
 		
-		tooltip.setContext(surface.getContext());
+		tooltip.setContext(context.getUIContext());
 		
-		DStylePath path = parent.getChild("iconbutton", styleClass);
-		style = new IconButtonControlStyle(surface.getStylesheet(path));
-		
-		int iconWidth = (int)(icon.getNominalWidth() * surface.getScale() + 0.5f);
-		int iconHeight = (int)(icon.getNominalWidth() * surface.getScale() + 0.5f);
+		int iconWidth = (int)(icon.getNominalWidth() * context.getScale() + 0.5f);
+		int iconHeight = (int)(icon.getNominalWidth() * context.getScale() + 0.5f);
 		int width = iconWidth + 2 * style.padding + 2 * style.margin;
 		int height = iconHeight + 2 * style.padding + 2 * style.margin;
-		preferences.setValue(new DSizing(width, height));
+		sizing.setValue(new DSizing(width, height));
 		
 		if (bounds != null)
 			setBounds(bounds);
 
 	@Override
 	public LiveObject<DSizing> getSizing() {
-		return preferences;
+		return sizing;
 	}
 
 	@Override
 			shape.close();
 		
 		shadow = getShadow();
-		shape = surface.shadowPath(z, DPath.roundedRectangle(
+		shape = context.shadowPath(0, DPath.roundedRectangle(
 				bounds.x + style.margin,
 				bounds.y + style.margin,
 				bounds.width - 2 * style.margin,
 		if (drawnIcon != null)
 			drawnIcon.close();
 		
-		drawnIcon = new DDrawableInstance(surface, z + 1, icon, DTransform2D.scaleAndTranslate(
-				bounds.x + (bounds.width - icon.getNominalWidth() * surface.getScale()) / 2,
-				bounds.y + (bounds.height - icon.getNominalHeight() * surface.getScale()) / 2,
-				surface.getScale()));
+		drawnIcon = new DDrawableInstance(context.surface, context.z + 1, icon, DTransform2D.scaleAndTranslate(
+				bounds.x + (bounds.width - icon.getNominalWidth() * context.getScale()) / 2,
+				bounds.y + (bounds.height - icon.getNominalHeight() * context.getScale()) / 2,
+				context.getScale()));
 	}
 	
 	private void update() {
 				shape.close();
 			
 			shadow = newShadow;
-			shape = surface.shadowPath(z, DPath.roundedRectangle(
+			shape = context.shadowPath(0, DPath.roundedRectangle(
 					bounds.x + style.margin,
 					bounds.y + style.margin,
 					bounds.width - 2 * style.margin,

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

 package org.openzen.zenscript.ide.ui.view;
 
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	
 	private final DStyleClass styleClass;
 	private final LiveString content;
-	private DIRectangle bounds;
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private StatusBarStyle style;
 	private DFontMetrics fontMetrics;
+	private DIRectangle bounds;
 
 	private DDrawnShape shape;
 	private DDrawnText text;
 	}
 	
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("StatusBar", styleClass);
-		style = new StatusBarStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.font);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("statusbar", styleClass);
+		style = context.getStyle(StatusBarStyle::new);
+		fontMetrics = context.getFontMetrics(style.font);
 		
 		dimensionPreferences.setValue(new DSizing(0, style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingBottom));
-		text = surface.drawText(z + 1, style.font, style.textColor, 0, 0, content.getValue());
+		text = context.drawText(1, style.font, style.textColor, 0, 0, content.getValue());
 	}
 	
 	@Override
 		
 		if (shape != null)
 			shape.close();
-		shape = surface.shadowPath(z, DPath.rectangle(bounds.x, bounds.y, bounds.width, bounds.height), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		shape = context.shadowPath(0, DPath.rectangle(bounds.x, bounds.y, bounds.width, bounds.height), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		text.setPosition(bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent());
 	}
 

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 	
 	private final Map<TabbedViewTab, ListenerHandle<LiveObject.Listener<DSizing>>> tabSizeListeners = new HashMap<>();
 	
-	private DDrawSurface surface;
-	private DStylePath path;
-	private DIRectangle bounds;
+	private DComponentContext context;
 	private TabbedViewStyle style;
+	private DIRectangle bounds;
 	private int totalTabHeight;
 	private DFontMetrics fontMetrics;
-	private int z;
 
 	private final LiveList<TabbedViewTab> tabComponents = new LiveMappedList<>(tabs, tab -> {
-		TabbedViewTab result = new TabbedViewTab(this, currentTab, tab);
-		if (surface != null)
-			result.mount(path, z + 2, surface);
+		TabbedViewTab result = new TabbedViewTab(DStyleClass.EMPTY, this, currentTab, tab);
+		if (context != null)
+			result.mount(context);
 		
 		tabSizeListeners.put(result, result.getSizing().addListener((oldSize, newSize) -> layoutTabs()));
 		return result;
 		tabs.addListener(new TabListListener());
 		
 		currentTab.addListener((oldValue, newValue) -> {
-			if (oldValue != null) {
-				oldValue.content.onUnmounted();
+			if (oldValue != null)
 				oldValue.content.unmount();
-			}
-			if (newValue != null) {
-				newValue.content.onMounted();
-				newValue.content.mount(path, z + 1, surface);
-			}
+			if (newValue != null)
+				newValue.content.mount(context);
 			
 			if (newValue != null && bounds != null) {
 				DIRectangle contentBounds = new DIRectangle(
 	}
 	
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		path = parent.getChild("tabbedView", styleClass);
-		style = new TabbedViewStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.tabFont);
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("tabbedview", styleClass);
+		style = context.getStyle(TabbedViewStyle::new);
+		fontMetrics = context.getFontMetrics(style.tabFont);
 		totalTabHeight = style.tabBorder.getPaddingVertical() + fontMetrics.getAscent() + fontMetrics.getDescent();
 		
 		for (TabbedViewComponent tab : tabs)
 	}
 	
 	private void prepare(TabbedViewComponent tab) {
-		tab.content.mount(path, z + 1, surface);
+		tab.content.mount(context);
 	}
 	
 	private void layoutTabs() {

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

 package org.openzen.zenscript.ide.ui.view;
 
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final MutableLiveObject<TabbedViewComponent> currentTab;
 	
+	private final DStyleClass styleClass;
 	private final TabbedView parent;
 	public final TabbedViewTabClose closeButton;
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private TabbedViewTabStyle style;
 	private DFontMetrics fontMetrics;
 	private int textWidth;
 	private DDrawnShape updated;
 	private DDrawnText text;
 	
-	public TabbedViewTab(TabbedView parent, MutableLiveObject<TabbedViewComponent> currentTab, TabbedViewComponent tab) {
+	public TabbedViewTab(DStyleClass styleClass, TabbedView parent, MutableLiveObject<TabbedViewComponent> currentTab, TabbedViewComponent tab) {
+		this.styleClass = styleClass;
 		this.parent = parent;
 		this.currentTab = currentTab;
 		this.tab = tab;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("tab", styleClass);
+		style = context.getStyle(TabbedViewTabStyle::new);
+		fontMetrics = context.getFontMetrics(style.tabFont);
+		closeButton.mount(context);
 		
-		DStylePath path = parent.getChild("tab", DStyleClass.EMPTY);
-		style = new TabbedViewTabStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.tabFont);
-		closeButton.mount(path, z + 1, surface);
-		
-		text = surface.drawText(z + 1, style.tabFont, style.tabFontColor, 0, 0, tab.title.getValue());
+		text = context.drawText(1, style.tabFont, style.tabFontColor, 0, 0, tab.title.getValue());
 		calculateSizing();
 	}
 	
 		this.bounds = bounds;
 		
 		DSizing close = closeButton.getSizing().getValue();
-		style.border.update(surface, z + 1, style.margin.apply(bounds));
+		style.border.update(context, style.margin.apply(bounds));
 		
 		closeButton.setBounds(new DIRectangle(
 				bounds.x + bounds.width - close.preferredWidth - style.border.getPaddingRight(),
 		
 		if (shape != null)
 			shape.close();
-		shape = surface.shadowPath(z, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		shape = context.shadowPath(0, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		text.setPosition(
 				bounds.x + style.margin.left + style.border.getPaddingLeft(),
 				bounds.y + style.margin.top + style.border.getPaddingTop() + fontMetrics.getAscent());
 		if (tab.updated.getValue()) {
 			if (updated != null)
 				updated.close();
-			updated = surface.fillPath(
-					z + 1,
+			updated = context.fillPath(
+					1,
 					DPath.circle(
 						bounds.x + bounds.width - style.margin.right - style.border.getPaddingRight() - closeButton.getBounds().width - style.closeIconPadding - style.updatedDiameter / 2,
 						bounds.y + style.margin.top + style.border.getPaddingTop() + ((bounds.height - style.margin.getVertical() - style.border.getPaddingVertical()) / 2), style.updatedDiameter / 2),

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

 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DColorableIconInstance;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.zenscript.ide.ui.icons.ScalableCloseIcon;
 
 /**
 	private final TabbedViewTab tab;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DIRectangle bounds;
 	private TabbedViewTabCloseStyle style;
 	private DColorableIcon icon;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("tabClose", DStyleClass.EMPTY);
-		style = new TabbedViewTabCloseStyle(surface.getStylesheet(path));
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("tabclose", DStyleClass.EMPTY);
+		style = context.getStyle(TabbedViewTabCloseStyle::new);
 		sizing.setValue(new DSizing(style.size, style.size));
 		icon = new ScalableCloseIcon(style.size / 24);
 		
 		if (background != null)
 			background.close();
-		background = surface.fillRect(z, DIRectangle.EMPTY, hover ? 0xFFE81123 : 0);
+		background = context.fillRect(9, DIRectangle.EMPTY, hover ? 0xFFE81123 : 0);
 		if (drawnIcon != null)
 			drawnIcon.close();
-		drawnIcon = new DColorableIconInstance(surface, z + 1, icon, DTransform2D.IDENTITY, 0xFF000000);
+		drawnIcon = new DColorableIconInstance(context.surface, context.z + 1, icon, DTransform2D.IDENTITY, 0xFF000000);
 	}
 	
 	@Override
 		
 		if (drawnIcon != null)
 			drawnIcon.close();
-		drawnIcon = new DColorableIconInstance(surface, z + 1, icon, DTransform2D.translate(
+		drawnIcon = new DColorableIconInstance(context.surface, context.z + 1, icon, DTransform2D.translate(
 				bounds.x + (bounds.width - icon.getNominalWidth()) / 2,
 				bounds.y + (bounds.height - icon.getNominalHeight()) / 2), 0xFF000000);
 	}

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

 
 import java.util.function.Consumer;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DDrawableInstance;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DSimpleTooltip;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.ImmutableLiveString;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final DDrawable icon;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final Consumer<DMouseEvent> onClick;
-	private DDrawSurface surface;
-	private int z;
+	
+	private DComponentContext context;
 	private AspectBarSelectorButtonStyle style;
 	private DIRectangle bounds = DIRectangle.EMPTY;
 	private DDrawnShape shape;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		DStylePath path = parent.getChild("selectorbutton", styleClass);
-		style = new AspectBarSelectorButtonStyle(surface.getStylesheet(path));
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("selectorbutton", styleClass);
+		style = context.getStyle(AspectBarSelectorButtonStyle::new);
 		sizing.setValue(new DSizing(style.width, style.height));
 		
-		tooltip.setContext(surface.getContext());
+		tooltip.setContext(context.getUIContext());
 	}
 
 	@Override
 			shape.close();
 		
 		shadow = getShadow();
-		shape = surface.shadowPath(
-				z,
+		shape = context.shadowPath(
+				0,
 				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.roundingRadius),
 				DTransform2D.IDENTITY,
 				getColor(),
 		
 		if (iconInstance != null)
 			iconInstance.close();
-		iconInstance = new DDrawableInstance(surface, z + 1, icon, DTransform2D.scaleAndTranslate(
-				bounds.x + (style.width - icon.getNominalWidth() * surface.getScale()) / 2,
-				bounds.y + (style.height - icon.getNominalHeight() * surface.getScale()) / 2,
-				surface.getScale()));
+		iconInstance = new DDrawableInstance(context.surface, context.z + 1, icon, DTransform2D.scaleAndTranslate(
+				bounds.x + (style.width - icon.getNominalWidth() * context.getScale()) / 2,
+				bounds.y + (style.height - icon.getNominalHeight() * context.getScale()) / 2,
+				context.getScale()));
 	}
 	
 	@Override
 	}
 	
 	private void update() {
-		if (surface == null)
+		if (context == null)
 			return;
 		
 		DShadow newShadow = getShadow();
 			if (shape != null)
 				shape.close();
 			
-			shape = surface.shadowPath(
-				z,
+			shape = context.shadowPath(
+				0,
 				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.roundingRadius),
 				DTransform2D.IDENTITY,
 				getColor(),

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DPath;
 	private final DStyleClass styleClass;
 	private final IDEAspectBar aspectBar;
 	
-	private DIRectangle bounds;
-	private DDrawSurface surface;
-	private int z;
-	
-	private DStylePath path;
+	private DComponentContext context;
 	private AspectBarStyle style;
+	private DIRectangle bounds;
 	private DFontMetrics activeToolbarTitleFontMetrics;
 	private boolean showWindowControls;
 	
 		aspectBar.active.addListener(this::onActiveChanged);
 		listener = aspectBar.toolbars.addListener(new ToolbarListListener());
 		
-		minimize = new WindowActionButton(scale -> new ScalableMinimizeIcon(scale), e -> surface.getContext().getWindow().minimize());
+		minimize = new WindowActionButton(scale -> new ScalableMinimizeIcon(scale), e -> context.getUIContext().getWindow().minimize());
 		minimizeRelayout = minimize.getSizing().addListener((a, b) -> layout());
 		maximizeRestore = new WindowActionButton(ScalableMaximizeIcon::new, e -> {
-			if (surface.getContext().getWindow().getWindowState().getValue() == DUIWindow.State.MAXIMIZED)
-				surface.getContext().getWindow().restore();
+			if (context.getUIContext().getWindow().getWindowState().getValue() == DUIWindow.State.MAXIMIZED)
+				context.getUIContext().getWindow().restore();
 			else
-				surface.getContext().getWindow().maximize();
+				context.getUIContext().getWindow().maximize();
 		});
 		maximizeRestoreRelayout = maximizeRestore.getSizing().addListener((a, b) -> layout());
-		close = new WindowActionButton(scale -> new ScalableCloseIcon(scale), e -> surface.getContext().getWindow().close());
+		close = new WindowActionButton(scale -> new ScalableCloseIcon(scale), e -> context.getUIContext().getWindow().close());
 		closeRelayout = close.getSizing().addListener((a, b) -> layout());
 		
 		selectorButtons = new LiveMappedList<>(
 				bar -> {
 					LiveBool buttonActive = new LivePredicateBool<>(aspectBar.active, activeBar -> activeBar == bar);
 					AspectBarSelectorButton button = new AspectBarSelectorButton(DStyleClass.EMPTY, bar.icon, buttonActive, bar.description, e -> aspectBar.active.setValue(bar));
-					if (surface != null)
-						button.mount(path, z + 1, surface);
+					if (context != null)
+						button.mount(context);
 					
 					return button;
 				});
 	}
 	
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
-		this.path = parent.getChild("aspectbar", styleClass);
-		this.style = new AspectBarStyle(surface.getStylesheet(path));
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("aspectbar", styleClass);
+		style = context.getStyle(AspectBarStyle::new);
 		
-		activeToolbarTitleFontMetrics = surface.getFontMetrics(style.activeToolbarTitleFont);
-		showWindowControls = !surface.getContext().getWindow().hasTitleBar();
+		activeToolbarTitleFontMetrics = context.getFontMetrics(style.activeToolbarTitleFont);
+		showWindowControls = !context.getUIContext().getWindow().hasTitleBar();
 		
 		sizing.setValue(new DSizing(0, style.height));
 		
 		for (DComponent selectorButton : selectorButtons)
-			selectorButton.mount(path, z + 2, surface);
+			selectorButton.mount(context);
 		
 		if (activeToolbarComponents != null)
 			for (DComponent component : activeToolbarComponents)
-				component.mount(path, z + 2, surface);
+				component.mount(context);
 		
-		minimize.mount(path, z + 2, surface);
-		maximizeRestore.mount(path, z + 2, surface);
-		close.mount(path, z + 2, surface);
+		minimize.mount(context);
+		maximizeRestore.mount(context);
+		close.mount(context);
 		
 		if (topBackground != null)
 			topBackground.close();
 		if (bottomBackground != null)
 			bottomBackground.close();
 		
-		topBackground = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
-		bottomBackground = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColorBottom);
+		topBackground = context.fillRect(0, DIRectangle.EMPTY, style.backgroundColor);
+		bottomBackground = context.fillRect(0, DIRectangle.EMPTY, style.backgroundColorBottom);
 	}
 	
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
-		if (surface != null) {
+		if (context != null) {
 			layout();
 			setupActiveBarText();
 		}
 		
 		activeToolbarComponents = new LiveMappedList<>(aspectBar.controls, control -> {
 			DComponent result = control.instantiate();
-			if (surface != null)
-				result.mount(path, z + 2, surface);
+			if (context != null)
+				result.mount(context);
 			return result;
 		});
 		
 				+ (int)(activeToolbarTitleFontMetrics.getAscent() * 0.35f)
 				+ (bounds.height - style.aspectBarPaddingTop) / 2;
 		int x = aspectSelectorEndX + style.aspectSelectorToToolbarSpacing;
-		activeBarText = surface.drawText(z + 3, style.activeToolbarTitleFont, style.activeToolbarTitleColor, x, y, aspectBar.active.getValue().title);
-		activeBarSeparator = surface.fillRect(
-				z + 3,
+		activeBarText = context.drawText(3, style.activeToolbarTitleFont, style.activeToolbarTitleColor, x, y, aspectBar.active.getValue().title);
+		activeBarSeparator = context.fillRect(
+				3,
 				new DIRectangle(
 					x + activeBarText.getBounds().width + 8,
 					bounds.y + style.aspectBarPaddingTop + 8,
 			activeBarText.setPosition(activeBarX, activeBarY);
 			
 			activeBarSeparator.close();
-			activeBarSeparator = surface.fillRect(
-				z + 3,
+			activeBarSeparator = context.fillRect(
+				3,
 				new DIRectangle(
 					activeBarX + activeBarText.getBounds().width + 8,
 					bounds.y + style.aspectBarPaddingTop + 8,
 			if (windowControlsBackground != null)
 				windowControlsBackground.close();
 			
-			windowControlsBackground = surface.shadowPath(
-					z + 1,
+			windowControlsBackground = context.shadowPath(
+					1,
 					windowControlsShape,
 					DTransform2D.IDENTITY,
 					style.backgroundColor,
 		if (aspectBarShape != null)
 			aspectBarShape.close();
 		
-		aspectBarShape = surface.shadowPath(z + 1, tracer -> {
+		aspectBarShape = context.shadowPath(1, tracer -> {
 			int height = bounds.height - style.marginBottom;
 			int baseY = bounds.y + height - style.aspectSelectorBottomSize;
 			int barBaseX = toX + style.aspectSelectorToToolbarSpacing;
 			int barBaseY = bounds.y + style.aspectBarPaddingTop;
 			
 			tracer.moveTo(bounds.x, baseY);
-			tracer.lineTo(toX - 3 * surface.getScale(), baseY);
+			tracer.lineTo(toX - 3 * context.getScale(), baseY);
 			tracer.bezierCubic(
-					toX + 0 * surface.getScale(), baseY,
-					toX + 2 * surface.getScale(), baseY,
-					toX + 3.5f * surface.getScale(), baseY - 4 * surface.getScale());
-			tracer.lineTo(barBaseX - 3.5f * surface.getScale(), barBaseY + 4 * surface.getScale());
+					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(
-					barBaseX - 2 * surface.getScale(), barBaseY,
-					barBaseX - 0 * surface.getScale(), barBaseY,
-					barBaseX + 3 * surface.getScale(), barBaseY);
+					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

 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DColorableIconInstance;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.style.DStylePath;
+import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.zenscript.ide.ui.icons.ScalableCloseIcon;
 
 /**
 	private LiveBool windowFocused;
 	private ListenerHandle<LiveBool.Listener> windowFocusedListener;
 	
+	private DComponentContext context;
 	private DColorableIcon icon;
 	private DIRectangle bounds;
 	private boolean hover;
 	private boolean press;
-	private DDrawSurface surface;
-	private int z;
 	
 	private DDrawnRectangle background;
 	private DColorableIconInstance drawnIcon;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		this.surface = surface;
-		this.z = z;
+	public void mount(DComponentContext parent) {
+		context = parent.getChildContext("windowactionbutton", DStyleClass.EMPTY);
 		
-		windowFocused = surface.getContext().getWindow().getActive();
+		windowFocused = context.getUIContext().getWindow().getActive();
 		windowFocusedListener = windowFocused.addListener((a, b) -> update());
 		
-		icon = scalableIcon == null ? null : scalableIcon.apply(surface.getScale());
+		icon = scalableIcon == null ? null : scalableIcon.apply(context.getScale());
 		sizing.setValue(new DSizing(
-				(int)(48 * surface.getScale()),
-				(int)(24 * surface.getScale())));
+				(int)(48 * context.getScale()),
+				(int)(24 * context.getScale())));
 		
-		background = surface.fillRect(z, DIRectangle.EMPTY, getBackgroundColor());
+		background = context.fillRect(0, DIRectangle.EMPTY, getBackgroundColor());
 	}
 	
 	@Override
 			
 			int iconX = bounds.x + (int)(bounds.width - icon.getNominalWidth()) / 2;
 			int iconY = bounds.y + (int)(bounds.height - icon.getNominalHeight()) / 2;
-			drawnIcon = new DColorableIconInstance(surface, z + 1, icon, DTransform2D.translate(iconX, iconY), getIconColor());
+			drawnIcon = new DColorableIconInstance(context.surface, context.z + 1, icon, DTransform2D.translate(iconX, iconY), getIconColor());
 		}
 	}
 
 	
 	private int getBackgroundColor() {
 		int color = 0xFFFFFFFF;
-		int iconColor = windowFocused.getValue() ? 0xFF000000 : 0xFF999999;
 		
 		if (hover) {
 			if (icon instanceof ScalableCloseIcon) {
 				color = 0xFFE81123;
-				iconColor = 0xFFFFFFFF;
 			} else {
 				color = 0xFFE0E0E0;
 			}

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

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.Destructible;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.zenscript.ide.ui.icons.SaveIcon;
 import org.openzen.zenscript.ide.ui.icons.ShadedCodeIcon;
 import org.openzen.zenscript.ide.ui.icons.ShadedSaveIcon;
 	private final ListenerHandle<TokenModel.Listener> tokenListener;
 	private final SimpleLiveBool unchanged = new SimpleLiveBool(true);
 	
+	private DComponentContext context;
 	private DIRectangle bounds;
-	private int z;
-	private DDrawSurface surface;
 	private SourceEditorStyle style;
 	private DTimerHandle blinkTimer;
 	
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		if (surface != null)
+	public void mount(DComponentContext parent) {
+		if (context != null)
 			unmount();
 		
-		this.surface = surface;
-		this.z = z;
-		this.style = new SourceEditorStyle(surface.getStylesheet(parent.getChild("sourceeditor", styleClass)));
+		context = parent.getChildContext("sourceeditor", styleClass);
+		style = context.getStyle(SourceEditorStyle::new);
 		
-		fontMetrics = surface.getFontMetrics(font);
+		fontMetrics = context.getFontMetrics(font);
 		textLineHeight = fontMetrics.getAscent() + fontMetrics.getDescent();
 		fullLineHeight = textLineHeight + fontMetrics.getLeading() + style.extraLineSpacing;
 		selectionLineHeight = textLineHeight + style.selectionPaddingTop + style.selectionPaddingBottom;
 		
 		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
 		
-		blinkTimer = surface.getContext().setTimer(300, this::blink);
+		blinkTimer = context.getUIContext().setTimer(300, this::blink);
 		
-		selection = surface.fillRect(z + 2, DIRectangle.EMPTY, style.selectionColor);
-		cursor = surface.fillRect(z + 4, DIRectangle.EMPTY, style.cursorColor);
-		currentLineHighlight = surface.fillRect(z + 1, DIRectangle.EMPTY, style.currentLineHighlight);
+		selection = context.fillRect(2, DIRectangle.EMPTY, style.selectionColor);
+		cursor = context.fillRect(4, DIRectangle.EMPTY, style.cursorColor);
+		currentLineHighlight = context.fillRect(1, DIRectangle.EMPTY, style.currentLineHighlight);
 		
 		for (int i = 0; i < tokens.getLineCount(); i++)
-			lineNumbers.add(surface.drawText(z + 3, font, style.lineBarTextColor, 0, 0, Integer.toString(i + 1)));
+			lineNumbers.add(context.drawText(3, font, style.lineBarTextColor, 0, 0, Integer.toString(i + 1)));
 		
 		for (TokenLine line : tokens.getLines())
 			drawnTokens.add(lineToTokens(line));
 	public void unmount() {
 		window.aspectBar.toolbars.remove(editToolbar);
 		
-		surface = null;
+		context = null;
 		
 		if (background != null) {
 			background.close();
 			lineBarBackground.close();
 		if (lineBarLine != null)
 			lineBarLine.close();
-		background = surface.fillRect(z, new DIRectangle(bounds.x + lineBarWidth, bounds.y, bounds.width - lineBarWidth, bounds.height), style.backgroundColor);
-		lineBarBackground = surface.fillRect(z, new DIRectangle(bounds.x, bounds.y, lineBarWidth, bounds.height), style.lineBarBackgroundColor);
-		lineBarLine = surface.strokePath(z + 1, tracer -> {
+		background = context.fillRect(0, new DIRectangle(bounds.x + lineBarWidth, bounds.y, bounds.width - lineBarWidth, bounds.height), style.backgroundColor);
+		lineBarBackground = context.fillRect(0, new DIRectangle(bounds.x, bounds.y, lineBarWidth, bounds.height), style.lineBarBackgroundColor);
+		lineBarLine = context.strokePath(1, tracer -> {
 				tracer.moveTo(bounds.x + lineBarWidth, bounds.y);
 				tracer.lineTo(bounds.x + lineBarWidth, bounds.y + bounds.height);
 			}, DTransform2D.IDENTITY, style.lineBarStrokeColor, style.lineBarStrokeWidth);
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
-		surface.getContext().setCursor(DUIContext.Cursor.TEXT);
+		context.getUIContext().setCursor(DUIContext.Cursor.TEXT);
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
-		surface.getContext().setCursor(DUIContext.Cursor.NORMAL);
+		context.getUIContext().setCursor(DUIContext.Cursor.NORMAL);
 	}
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		surface.getContext().getWindow().focus(this);
+		context.getUIContext().getWindow().focus(this);
 		
 		SourcePosition position = getPositionAt(e.x, e.y);
 		if (e.isDoubleClick()) {
 				SourcePosition to = SourcePosition.max(cursorStart, cursorEnd);
 				
 				int fromX = getX(from);
-				multiLineSelection.add(surface.fillRect(
-						z + 2,
+				multiLineSelection.add(context.fillRect(
+						2,
 						new DIRectangle(fromX, getY(from), bounds.width - fromX, selectionLineHeight),
 						style.selectionColor));
 				
 				for (int i = from.line + 1; i < to.line; i++) {
-					multiLineSelection.add(surface.fillRect(z + 2, new DIRectangle(x, lineToY(i), bounds.width - x, selectionLineHeight), style.selectionColor));
+					multiLineSelection.add(context.fillRect(2, new DIRectangle(x, lineToY(i), bounds.width - x, selectionLineHeight), style.selectionColor));
 				}
 				
 				int toX = getX(to);
-				multiLineSelection.add(surface.fillRect(z + 2, new DIRectangle(x, getY(to), Math.max(0, toX - x), selectionLineHeight), style.selectionColor));
+				multiLineSelection.add(context.fillRect(2, new DIRectangle(x, getY(to), Math.max(0, toX - x), selectionLineHeight), style.selectionColor));
 				selection.setRectangle(DIRectangle.EMPTY);
 			}
 		} else {
 		setCursor(start, getPositionAt(e.x, e.y));
 	}
 	
+	private void moveLines(boolean shift, int lines) {
+		if (cursorEnd == null)
+			return;
+		
+		int line = cursorEnd.line + lines;
+		if (line < 0)
+			line = 0;
+		if (line >= tokens.getLineCount())
+			line = tokens.getLineCount() - 1;
+		
+		SourcePosition position = new SourcePosition(
+				tokens,
+				line,
+				Math.min(tokens.getLineLength(line), cursorEnd.offset));
+		setCursor(shift ? cursorStart : position, position);
+	}
+	
 	@Override
 	public void onKeyPressed(DKeyEvent e) {
 		boolean shift = e.has(DKeyEvent.SHIFT);
 		switch (e.keyCode) {
+			case PAGE_UP:
+				moveLines(shift, -getWindowLines());
+				break;
+			case PAGE_DOWN:
+				moveLines(shift, getWindowLines());
+				break;
 			case UP:
-				if (cursorEnd == null || cursorEnd.line == 0)
-					return;
-				
-				{
-					int line = cursorEnd.line - 1;
-					SourcePosition position = new SourcePosition(
-							tokens,
-							line,
-							Math.min(tokens.getLineLength(line), cursorEnd.offset));
-					setCursor(shift ? cursorStart : position, position);
-				}
+				moveLines(shift, -1);
 				break;
 			case DOWN:
-				if (cursorEnd == null || cursorEnd.line >= tokens.getLineCount() - 1)
-					return;
-				
-				{
-					int line = cursorEnd.line + 1;
-					SourcePosition position = new SourcePosition(
-							tokens,
-							line,
-							Math.min(tokens.getLineLength(line), cursorEnd.offset));
-					setCursor(shift ? cursorStart : position, position);
-				}
+				moveLines(shift, 1);
 				break;
 			case LEFT:
 				if (cursorEnd == null || (cursorEnd.line == 0 && cursorEnd.offset == 0))
 		String extract = tokens.extract(
 				SourcePosition.min(cursorStart, cursorEnd),
 				SourcePosition.max(cursorStart, cursorEnd));
-		surface.getContext().getClipboard().copyAsString(extract);
+		context.getUIContext().getClipboard().copyAsString(extract);
 	}
 	
 	private void cut() {
 	}
 	
 	private void paste() {
-		String text = surface.getContext().getClipboard().getAsString();
+		String text = context.getUIContext().getClipboard().getAsString();
 		if (text == null)
 			return;
 		
 		if (deleteSelection())
 			return;
 		
-		if (cursorEnd.line > 0) {
+		/*if (cursorEnd.line > 0) {
 			String indent = tokens.getLine(cursorEnd.line - 1).getIndent(); // TODO: get nominal indent for current scope
 			if (cursorEnd.offset == indent.length()) {
 				// remove entire indent
 				setCursor(deleteFrom, deleteFrom);
 				return;
 			}
-		}
+		}*/
 		
 		if (cursorEnd.offset == 0) {
 			if (cursorEnd.line == 0)
 	}
 	
 	public void scrollTo(SourcePosition position) {
-		surface.getContext().scrollInView(getX(position), getY(position), 2, selectionLineHeight);
+		if (context.scrollContext != null)
+			context.scrollContext.scrollInView(getX(position), getY(position), 2, selectionLineHeight);
 	}
 	
 	private void blink() {
 		}
 	}
 	
+	private int getWindowLines() {
+		if (context.scrollContext == null) {
+			return 20;
+		} else {
+			return context.scrollContext.getViewportHeight() / fullLineHeight;
+		}
+	}
+	
 	public SourcePosition getPositionAt(int x, int y) {
 		int line = yToLine(y);
 		int offset = xToOffset(line, x);
 		List<DDrawnText> tokenLine = new ArrayList<>();
 		for (ZSToken token : line.getTokens()) {
 			String content = getDisplayContent(token);
-			tokenLine.add(surface.drawText(z + 3, font, TokenClass.get(token.type).color, 0, 0, content));
+			tokenLine.add(context.drawText(3, font, TokenClass.get(token.type).color, 0, 0, content));
 		}
 		return tokenLine;
 	}
 				String str = Integer.toString(lineNumbers.size() + 1);
 				int x = bounds.x + lineBarWidth - style.lineBarSpacingRight - style.lineBarMargin - fontMetrics.getWidth(str);
 				int y = bounds.y + style.selectionPaddingTop + lineNumbers.size() * fullLineHeight + fontMetrics.getAscent();
-				lineNumbers.add(surface.drawText(z + 3, font, style.lineBarTextColor, x, y, str));
+				lineNumbers.add(context.drawText(3, font, style.lineBarTextColor, x, y, str));
 				
 				drawnTokens.add(index, lineToTokens(tokens.getLine(index)));
 				layoutLines(index);

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

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DComponentContext;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.Destructible;
-import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
 
 /**
  *
 	private final DStyleClass styleClass;
 	private final LiveList<OutputLine> lines;
 	
-	private DDrawSurface surface;
-	private int z;
+	private DComponentContext context;
 	private DIRectangle bounds;
 	private OutputViewStyle style;
 	private DFontMetrics fontMetrics;
 	}
 
 	@Override
-	public void mount(DStylePath parent, int z, DDrawSurface surface) {
-		if (this.surface != null)
+	public void mount(DComponentContext parent) {
+		if (context != null)
 			unmount();
 		
-		this.surface = surface;
-		this.z = z;
-		
-		DStylePath path = parent.getChild("outputview", styleClass);
-		style = new OutputViewStyle(surface.getStylesheet(path));
-		fontMetrics = surface.getFontMetrics(style.font);
+		context = parent.getChildContext("outputview", styleClass);
+		style = context.getStyle(OutputViewStyle::new);
+		fontMetrics = context.getFontMetrics(style.font);
 		
 		for (OutputLine line : lines)
 			outputText.add(draw(line));
 	
 	@Override
 	public void unmount() {
-		surface = null;
+		context = null;
 		
 		if (shape != null) {
 			shape.close();
 		this.bounds = bounds;
 		
 		DIRectangle available = style.margin.apply(bounds);
-		shape = surface.shadowPath(z, style.shape.instance(available), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		shape = context.shadowPath(0, style.shape.instance(available), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		
 		layout(0);
 	}
 	private List<DDrawnText> draw(OutputLine line) {
 		List<DDrawnText> lineText = new ArrayList<>();
 		for (OutputSpan span : line.spans)
-			lineText.add(surface.drawText(z + 1, style.font, span.getColor(), 0, 0, span.getText()));
+			lineText.add(context.drawText(1, style.font, span.getColor(), 0, 0, span.getText()));
 		return lineText;
 	}
 	

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenParser.java

 package org.openzen.zenscript.lexer;
 
 import java.io.IOException;
-import java.io.Reader;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
+import org.openzen.zenscript.parser.BracketExpressionParser;
 
 /**
  *
 				new ZSTokenFactory(spacesPerTab));
 	}
 	
-	public static ZSTokenParser create(SourceFile file, int spacesPerTab) throws IOException {
-		return new ZSTokenParser(createRaw(file, new ReaderCharReader(file.open()), spacesPerTab));
+	public static ZSTokenParser create(SourceFile file, BracketExpressionParser bracketParser, int spacesPerTab) throws IOException {
+		return new ZSTokenParser(createRaw(file, new ReaderCharReader(file.open()), spacesPerTab), bracketParser);
 	}
 	
-	public ZSTokenParser(TokenStream<ZSTokenType, ZSToken> parser) {
+	public final BracketExpressionParser bracketParser;
+	
+	public ZSTokenParser(TokenStream<ZSTokenType, ZSToken> parser, BracketExpressionParser bracketParser) {
 		super(parser);
+		
+		this.bracketParser = bracketParser;
 	}
 	
 	public SourceFile getFile() {

Parser/src/main/java/org/openzen/zenscript/parser/BracketExpressionParser.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.parser;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface BracketExpressionParser {
+	/**
+	 * Parses the given bracket expression. Note that the "<" token is already
+	 * processed.
+	 * 
+	 * @param position start of the expression (which is the location of the > token)
+	 * @param tokens tokens to be parsed
+	 * @return parsed expression
+	 */
+	ParsedExpression parse(CodePosition position, ZSTokenParser tokens) throws CompileException;
+}

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

 	
 	public abstract void listMembers(BaseScope scope, PrecompilationState state);
 	
+	public abstract void precompile(BaseScope scope, PrecompilationState state);
+	
 	public abstract void compileCode(BaseScope scope, PrecompilationState state);
 }

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

  * @author Hoofdgebruiker
  */
 public class ParsedFile {
-	public static ParsedFile parse(ZSPackage pkg, File file) throws IOException {
-		return parse(pkg, new FileSourceFile(file.getName(), file));
+	public static ParsedFile parse(ZSPackage pkg, BracketExpressionParser bracketParser, File file) throws IOException {
+		return parse(pkg, bracketParser, new FileSourceFile(file.getName(), file));
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, String filename, String content) {
+	public static ParsedFile parse(ZSPackage pkg, BracketExpressionParser bracketParser, String filename, String content) {
 		try {
-			return parse(pkg, new LiteralSourceFile(filename, content));
+			return parse(pkg, bracketParser, new LiteralSourceFile(filename, content));
 		} catch (IOException ex) {
 			throw new AssertionError(); // shouldn't happen
 		}
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, SourceFile file) throws IOException {
-		ZSTokenParser tokens = ZSTokenParser.create(file, 4);
+	public static ParsedFile parse(ZSPackage pkg, BracketExpressionParser bracketParser, SourceFile file) throws IOException {
+		ZSTokenParser tokens = ZSTokenParser.create(file, bracketParser, 4);
 		return parse(pkg, tokens);
 	}
 	
 		for (ParsedDefinition definition : this.definitions) {
 			definition.listMembers(scope, state);
 		}
-		
+		for (ParsedDefinition definition : this.definitions) {
+			definition.precompile(scope, state);
+		}
 		for (ParsedDefinition definition : this.definitions) {
 			definition.compileCode(scope, state);
 		}

Parser/src/main/java/org/openzen/zenscript/parser/PrefixedBracketParser.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.parser;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PrefixedBracketParser implements BracketExpressionParser {
+	private final Map<String, BracketExpressionParser> subParsers = new HashMap<>();
+	private final BracketExpressionParser defaultParser;
+	
+	public PrefixedBracketParser(BracketExpressionParser defaultParser) {
+		this.defaultParser = defaultParser;
+	}
+	
+	public void register(String name, BracketExpressionParser parser) {
+		subParsers.put(name, parser);
+	}
+
+	@Override
+	public ParsedExpression parse(CodePosition position, ZSTokenParser tokens) {
+		if (defaultParser == null) {
+			ZSToken start = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected");
+			tokens.required(ZSTokenType.T_COLON, ": expected");
+			BracketExpressionParser subParser = subParsers.get(start.content);
+			if (subParser == null)
+				throw new CompileException(position, CompileExceptionCode.INVALID_BRACKET_EXPRESSION, "Invalid bracket expression");
+			
+			return subParser.parse(position, tokens);
+		} else {
+			tokens.pushMark();
+			ZSToken start = tokens.next();
+			if (start.type == ZSTokenType.T_IDENTIFIER && subParsers.containsKey(start.content)) {
+				tokens.popMark();
+				tokens.required(ZSTokenType.T_COLON, ": expected");
+				return subParsers.get(start.content).parse(position, tokens);
+			} else {
+				tokens.reset();
+				return defaultParser.parse(position, tokens);
+			}
+		}
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/SimpleBracketSubParser.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.parser;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SimpleBracketSubParser implements BracketExpressionParser {
+	private final FunctionalMemberRef method;
+	private final ITypeID targetType;
+	
+	public SimpleBracketSubParser(GlobalTypeRegistry registry, FunctionalMemberRef method) {
+		if (!method.isStatic())
+			throw new IllegalArgumentException("Method must be static");
+		if (method.header.getNumberOfTypeParameters() > 0)
+			throw new IllegalArgumentException("Method cannot have type parameters");
+		
+		this.method = method;
+		this.targetType = registry.getForDefinition(method.getTarget().definition);
+	}
+
+	@Override
+	public ParsedExpression parse(CodePosition position, ZSTokenParser tokens) {
+		StringBuilder string = new StringBuilder();
+		while (tokens.optional(ZSTokenType.T_GREATER) == null) {
+			string.append(tokens.next().content);
+			string.append(tokens.getLastWhitespace());
+		}
+		return new StaticMethodCallExpression(position, string.toString());
+	}
+	
+	private class StaticMethodCallExpression extends ParsedExpression {
+		private final String value;
+		
+		public StaticMethodCallExpression(CodePosition position, String value) {
+			super(position);
+			
+			this.value = value;
+		}
+
+		@Override
+		public IPartialExpression compile(ExpressionScope scope) {
+			return new CallStaticExpression(position, targetType, method, method.header, new CallArguments(new ConstantStringExpression(position, value)), scope);
+		}
+
+		@Override
+		public boolean hasStrongType() {
+			return true;
+		}
+
+		@Override
+		public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+			return method.header.returnType;
+		}
+	}
+}

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

 		for (ParsedDefinitionMember member : members)
 			state.register(innerScope, member);
 	}
+	
+	@Override
+	public void precompile(BaseScope scope, PrecompilationState state) {
+		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled());
+		for (ParsedDefinitionMember member : members)
+			state.precompile(member.getCompiled());
+	}
 
 	@Override
 	public void compileCode(BaseScope scope, PrecompilationState state) {

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

 	public void listMembers(BaseScope scope, PrecompilationState state) {
 		// nothing to do
 	}
+	
+	@Override
+	public void precompile(BaseScope scope, PrecompilationState state) {
+		// nothing to do
+	}
 
 	@Override
 	public void compileCode(BaseScope scope, PrecompilationState state) {

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

 	public void listMembers(BaseScope scope, PrecompilationState state) {
 		
 	}
-
+	
 	@Override
-	public void compileCode(BaseScope scope, PrecompilationState state) {
-		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
-		compiled.setCode(body.compile(innerScope, compiled.header));
-		
+	public void precompile(BaseScope scope, PrecompilationState state) {
 		if (compiled.header.returnType == BasicTypeID.UNDETERMINED) {
 			ITypeID result = body.precompileForResultType(new FunctionScope(scope, compiled.header), state);
 			if (result == null)
 			compiled.header = compiled.header.withReturnType(result);
 		}
 	}
+
+	@Override
+	public void compileCode(BaseScope scope, PrecompilationState state) {
+		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
+		compiled.setCode(body.compile(innerScope, compiled.header));
+	}
 }

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

 					// try! can thus be used to convert from exception-based to result-based and vice versa
 					return new ParsedTryRethrowExpression(position, readUnaryExpression(position, parser, options));
 				}
+			case T_LESS:// bracket expression
+				parser.next();
+				if (parser.bracketParser == null)
+					throw new CompileException(position, CompileExceptionCode.NO_BRACKET_PARSER, "Bracket expression detected but no bracket parser present");
+				
+				return parser.bracketParser.parse(position, parser);
 			default:
 				return readPostfixExpression(position, parser, options);
 		}

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

 		for (ITypeID hint : scope.hints) {
 			if (hint instanceof FunctionTypeID) {
 				FunctionTypeID functionHint = (FunctionTypeID) hint;
-				if (header.canCastTo(scope, functionHint.header)) {
+				if (header.canOverride(scope, functionHint.header)) {
 					if (header != definedHeader)
 						throw new CompileException(position, CompileExceptionCode.MULTIPLE_MATCHING_HINTS, "Ambiguity trying to resolve function types, can't decide for the type");
 					
 		if (type instanceof FunctionTypeID) {
 			FunctionHeader definedHeader = header.compile(scope);
 			FunctionTypeID targetFunction = (FunctionTypeID) type;
-			return definedHeader.canCastTo(scope, targetFunction.header);
+			return definedHeader.canOverride(scope, targetFunction.header);
 		} else {
 			return false;
 		}

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 			
 			throw new CompileException(position, CompileExceptionCode.UNDEFINED_VARIABLE, "No such symbol: " + name);
 		} else {
-			return result.eval().type;
+			if (result.getMember() != null) {
+				state.precompile(result.getMember());
+				result = scope.get(position, new GenericName(name, genericArguments));
+			}
+			
+			Expression resultExpression = result.eval();
+			if (resultExpression.type == BasicTypeID.UNDETERMINED)
+				System.out.println("Could not determine type");
+			
+			return resultExpression.type;
 		}
 	}
 }

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

 		for (ParsedNamePart namePart : name)
 			genericNames.add(namePart.compile(scope));
 		
-		ITypeID result = scope.getTypeRegistry().getModified(modifiers, scope.getType(position, genericNames));
+		ITypeID baseType = scope.getType(position, genericNames);
+		if (baseType == null)
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString());
+		
+		ITypeID result = scope.getTypeRegistry().getModified(modifiers, baseType);
 		if (result == null)
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString());
 		

ScriptingExample/scripts/helloworld.zs

 println(2 + 5);
 println(1 - 2);
 println(1 + 3 as long);
+
+println(<hello world in bracket parser>);

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 
 import org.openzen.zenscript.javabytecode.JavaCompiler;
 import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+import org.openzen.zenscript.parser.expression.ParsedExpressionString;
 
 public class Main {
     /**
 	private static ParsedFile[] parse(ZSPackage pkg, File[] files) throws IOException {
 		ParsedFile[] parsedFiles = new ParsedFile[files.length];
 		for (int i = 0; i < files.length; i++) {
-			parsedFiles[i] = ParsedFile.parse(pkg, files[i]);
+			parsedFiles[i] = ParsedFile.parse(pkg, new TestBracketParser(), files[i]);
 		}
 		return parsedFiles;
 	}
 		}
 		return compiler.finishAndGetModule();
 	}
+	
+	private static class TestBracketParser implements BracketExpressionParser {
+		@Override
+		public ParsedExpression parse(CodePosition position, ZSTokenParser tokens) {
+			StringBuilder result = new StringBuilder();
+			while (tokens.optional(ZSTokenType.T_GREATER) == null) {
+				ZSToken token = tokens.next();
+				result.append(token.content);
+				result.append(tokens.getLastWhitespace());
+			}
+			
+			return new ParsedExpressionString(position.until(tokens.getPosition()), result.toString());
+		}
+	}
 }

Shared/src/main/java/org/openzen/zencode/shared/CompileExceptionCode.java

 	PRECOMPILE_FAILED,
 	UNTYPED_EMPTY_ARRAY,
 	UNTYPED_EMPTY_MAP,
-	VAR_WITHOUT_TYPE_OR_INITIALIZER
+	VAR_WITHOUT_TYPE_OR_INITIALIZER,
+	NO_BRACKET_PARSER,
+	INVALID_BRACKET_EXPRESSION
 }

Shared/src/main/java/org/openzen/zencode/shared/FileSourceFile.java

 package org.openzen.zencode.shared;
 
 import java.io.BufferedInputStream;
-import java.io.BufferedReader;
+import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileReader;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.nio.charset.StandardCharsets;
 
 				new BufferedInputStream(new FileInputStream(file)),
 				StandardCharsets.UTF_8);
 	}
+
+	@Override
+	public void update(String content) throws IOException {
+		try (OutputStreamWriter writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file, false)), StandardCharsets.UTF_8)) {
+			writer.write(content);
+		}
+	}
 }

Shared/src/main/java/org/openzen/zencode/shared/LiteralSourceFile.java

 	public Reader open() throws IOException {
 		return new StringReader(contents);
 	}
+
+	@Override
+	public void update(String content) throws IOException {
+		throw new UnsupportedOperationException("Cannot update literal source files");
+	}
 }

Shared/src/main/java/org/openzen/zencode/shared/SourceFile.java

 	String getFilename();
 	
 	Reader open() throws IOException;
+	
+	void update(String content) throws IOException;
 }

Shared/src/main/java/org/openzen/zencode/shared/VirtualSourceFile.java

 	public Reader open() throws IOException {
 		throw new UnsupportedOperationException("Cannot open virtual source files");
 	}
+
+	@Override
+	public void update(String content) throws IOException {
+		throw new UnsupportedOperationException("Cannot write to virtual source files");
+	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ValidationUtils.java

 	private static final Pattern IDENTIFIER_PATTERN = Pattern.compile("^[a-zA-Z_][a-zA-Z_0-9]*$");
 
 	public static void validateValidOverride(Validator target, CodePosition position, TypeScope scope, FunctionHeader header, FunctionHeader overridden) {
-		if (!header.canCastTo(scope, overridden))
+		if (!header.canOverride(scope, overridden))
 			target.logError(INVALID_OVERRIDE, position, "Invalid override: incompatible parameters or return type");
 	}