- renamed setSurface to mount, and added unmount method

- Continued drawing optimizations, refactoring paint methods to mount methods.
- Removed the paint methods

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.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 	private final Runnable action;
 	
 	private DDrawSurface surface;
+	private int z;
 	private DIRectangle bounds;
 	
 	private DButtonStyle style;
 	private boolean hovering = false;
 	private boolean pressing = false;
 	
+	private DDrawnShape shape;
+	private DDrawnText text;
+	private DShadow currentShadow;
+	
 	public DButton(DStyleClass styleClass, LiveString label, LiveBool disabled, Runnable action) {
 		this.styleClass = styleClass;
 		this.label = label;
 	}
 	
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	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));
 		sizing.setValue(new DSizing(
 				style.paddingLeft + style.paddingRight + fontMetrics.getWidth(label.getValue()),
 				style.paddingTop + style.paddingBottom + fontMetrics.getAscent() + fontMetrics.getDescent()));
+		currentShadow = getShadow();
+	}
+	
+	@Override
+	public void unmount() {
+		surface = null;
+		
+		if (shape != null)
+			shape.close();
+		if (text != null)
+			text.close();
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		int backgroundColor = style.backgroundColorNormal;
-		DShadow shadow = style.shadowNormal;
-		if (hovering) {
-			backgroundColor = style.backgroundColorHover;
-			shadow = style.shadowNormal;
-		}
-		if (pressing) {
-			backgroundColor = style.backgroundColorPress;
-			shadow = style.shadowPress;
-		}
-		if (disabled.getValue()) {
-			backgroundColor = style.backgroundColorDisabled;
-			shadow = style.shadowDisabled;
-		}
 		
-		DPath shape = DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * surface.getScale());
-		canvas.shadowPath(shape, DTransform2D.IDENTITY, backgroundColor, shadow);
-		canvas.drawText(style.font, style.textColor, bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent(), label.getValue());
+		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()),
+				DTransform2D.IDENTITY,
+				getBackgroundColor(),
+				currentShadow);
+		text = surface.drawText(
+				z +  1, 
+				style.font,
+				style.textColor,
+				bounds.x + style.paddingLeft,
+				bounds.y + style.paddingTop + fontMetrics.getAscent(),
+				label.getValue());
 	}
 
 	@Override
 	public void close() {
-		
+		unmount();
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hovering = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
 		hovering = false;
 		pressing = false;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseDown(DMouseEvent e) {
 		pressing = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 			action.run();
 		}
 		
-		repaint();
+		update();
+	}
+	
+	private void update() {
+		DShadow newShadow = getShadow();
+		if (newShadow != currentShadow) {
+			currentShadow = newShadow;
+			
+			if (shape != null)
+				shape.close();
+			
+			shape = surface.shadowPath(
+				z,
+				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * surface.getScale()),
+				DTransform2D.IDENTITY,
+				getBackgroundColor(),
+				currentShadow);
+		} else {
+			shape.setColor(getBackgroundColor());
+		}
+	}
+	
+	private DShadow getShadow() {
+		if (disabled.getValue())
+			return style.shadowDisabled;
+		if (pressing)
+			return style.shadowPress;
+		if (hovering)
+			return style.shadowHover;
+		
+		return style.shadowNormal;
 	}
 	
-	private void repaint() {
-		if (surface == null || bounds == null)
-			return;
+	private int getBackgroundColor() {
+		if (disabled.getValue())
+			return style.backgroundColorDisabled;
+		if (pressing)
+			return style.backgroundColorPress;
+		if (hovering)
+			return style.backgroundColorHover;
 		
-		surface.repaint(bounds);
+		return style.backgroundColorNormal;
 	}
 }

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.draw.DDrawTarget;
+
 /**
  *
  * @author Hoofdgebruiker
 public interface DColorableIcon {
 	void draw(DCanvas canvas, DTransform2D transform, int color);
 	
+	void draw(DDrawTarget target, int z, DTransform2D transform, int color);
+	
 	float getNominalWidth();
 	
 	float getNominalHeight();

DrawableGui/src/main/java/org/openzen/drawablegui/DColorableIconInstance.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.io.Closeable;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawTarget;
+import org.openzen.drawablegui.draw.DDrawnColorableElement;
+import org.openzen.drawablegui.draw.DDrawnElement;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.style.DShadow;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class DColorableIconInstance implements Closeable {
+	private final List<DDrawnElement> elements = new ArrayList<>();
+	private final List<DDrawnColorableElement> colorables = new ArrayList<>();
+	
+	public DColorableIconInstance(DDrawSurface surface, int z, DColorableIcon icon, DTransform2D transform, int color) {
+		icon.draw(new DrawTarget(surface), z, transform, DDrawTarget.INSTANCE_COLOR);
+		setColor(color);
+	}
+	
+	public void setColor(int color) {
+		for (DDrawnColorableElement colorable : colorables)
+			colorable.setColor(color);
+	}
+	
+	public void setTransform(DTransform2D transform) {
+		for (DDrawnElement element : elements)
+			element.setTransform(transform);
+	}
+	
+	@Override
+	public void close() {
+		for (DDrawnElement element : elements)
+			element.close();
+	}
+	
+	private class DrawTarget implements DDrawTarget {
+		private final DDrawSurface surface;
+		
+		public DrawTarget(DDrawSurface surface) {
+			this.surface = surface;
+		}
+
+		@Override
+		public DFontMetrics getFontMetrics(DFont font) {
+			return surface.getFontMetrics(font);
+		}
+
+		@Override
+		public float getScale() {
+			return surface.getScale();
+		}
+
+		@Override
+		public float getTextScale() {
+			return surface.getTextScale();
+		}
+
+		@Override
+		public DDrawnText drawText(int z, DFont font, int color, float x, float y, String text) {
+			return addColorable(surface.drawText(z, font, color, x, y, text), color);
+		}
+
+		@Override
+		public DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color) {
+			return addColorable(surface.fillRect(z, rectangle, color), color);
+		}
+
+		@Override
+		public DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth) {
+			return addColorable(surface.strokePath(z, path, transform, color, lineWidth), color);
+		}
+
+		@Override
+		public DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color) {
+			return addColorable(surface.fillPath(z, path, transform, color), color);
+		}
+
+		@Override
+		public DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow) {
+			return addColorable(surface.shadowPath(z, path, transform, color, shadow), color);
+		}
+		
+		private <T extends DDrawnColorableElement> T addColorable(T colorable, int color) {
+			if (color == DDrawTarget.INSTANCE_COLOR)
+				colorables.add(colorable);
+			
+			elements.add(colorable);
+			return colorable;
+		}
+	}
+}

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

  * @author Hoofdgebruiker
  */
 public interface DComponent extends Closeable {
-	void setSurface(DStylePath parent, int z, DDrawSurface surface);
+	void mount(DStylePath parent, int z, DDrawSurface surface);
+	
+	void unmount();
 	
 	LiveObject<DSizing> getSizing();
 	
 	
 	void setBounds(DIRectangle bounds);
 	
-	void paint(DCanvas canvas);
-	
 	default void onMounted() {}
 	
 	default void onUnmounted() {}

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.draw.DDrawTarget;
+
 /**
  *
  * @author Hoofdgebruiker
 		base.draw(canvas, transform, color);
 		addition.draw(canvas, transform.mul(additionTransform), color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		base.draw(target, z, transform, color);
+		addition.draw(target, z + 1, transform.mul(additionTransform), color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.draw.DDrawTarget;
+
 /**
  *
  * @author Hoofdgebruiker
 public interface DDrawable {
 	void draw(DCanvas canvas, DTransform2D transform);
 	
+	void draw(DDrawTarget target, int z, DTransform2D transform);
+	
 	float getNominalWidth();
 	
 	float getNominalHeight();

DrawableGui/src/main/java/org/openzen/drawablegui/DDrawableInstance.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.io.Closeable;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawTarget;
+import org.openzen.drawablegui.draw.DDrawnColorableElement;
+import org.openzen.drawablegui.draw.DDrawnElement;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.style.DShadow;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DDrawableInstance implements Closeable {
+	private final List<DDrawnElement> elements = new ArrayList<>();
+	
+	public DDrawableInstance(DDrawSurface surface, int z, DDrawable icon, DTransform2D transform) {
+		icon.draw(new DrawTarget(surface), z, transform);
+	}
+	
+	public void setTransform(DTransform2D transform) {
+		for (DDrawnElement element : elements)
+			element.setTransform(transform);
+	}
+	
+	@Override
+	public void close() {
+		for (DDrawnElement element : elements)
+			element.close();
+	}
+	
+	private class DrawTarget implements DDrawTarget {
+		private final DDrawSurface surface;
+		
+		public DrawTarget(DDrawSurface surface) {
+			this.surface = surface;
+		}
+
+		@Override
+		public DFontMetrics getFontMetrics(DFont font) {
+			return surface.getFontMetrics(font);
+		}
+
+		@Override
+		public float getScale() {
+			return surface.getScale();
+		}
+
+		@Override
+		public float getTextScale() {
+			return surface.getTextScale();
+		}
+
+		@Override
+		public DDrawnText drawText(int z, DFont font, int color, float x, float y, String text) {
+			return addElement(surface.drawText(z, font, color, x, y, text));
+		}
+
+		@Override
+		public DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color) {
+			return addElement(surface.fillRect(z, rectangle, color));
+		}
+
+		@Override
+		public DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth) {
+			return addElement(surface.strokePath(z, path, transform, color, lineWidth));
+		}
+
+		@Override
+		public DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color) {
+			return addElement(surface.fillPath(z, path, transform, color));
+		}
+
+		@Override
+		public DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow) {
+			return addElement(surface.shadowPath(z, path, transform, color, shadow));
+		}
+		
+		private <T extends DDrawnColorableElement> T addElement(T colorable) {
+			elements.add(colorable);
+			return colorable;
+		}
+	}
+}

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

 	private DEmptyView() {}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+		
+	}
+	
+	@Override
+	public void unmount() {
 		
 	}
 	
 		
 	}
 
-	@Override
-	public void paint(DCanvas canvas) {
-		
-	}
-
 	@Override
 	public void close() {
 		// nothing to clean up

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

 	public boolean overlaps(DIRectangle other) {
 		if (x + width < other.x)
 			return false;
-		if (y + width < other.y)
+		if (y + height < other.y)
 			return false;
 		if (other.x + other.width < x)
 			return false;
 		return true;
 	}
 	
+	public DIRectangle offset(int x, int y) {
+		return new DIRectangle(this.x + x, this.y + y, width, height);
+	}
+	
+	public DIRectangle expand(int edge) {
+		return new DIRectangle(x - edge, y - edge, width + 2 * edge, height + 2 * edge);
+	}
+	
+	public DIRectangle union(DIRectangle other) {
+		int left = Math.min(x, other.x);
+		int top = Math.min(y, other.y);
+		int right = Math.max(x + width, other.x + other.width);
+		int bottom = Math.max(y + height, other.y + other.height);
+		return new DIRectangle(left, top, right - left, bottom - top);
+	}
+	
+	public DIRectangle intersect(DIRectangle other) {
+		int left = Math.max(x, other.x);
+		int top = Math.max(y, other.y);
+		int right = Math.min(x + width, other.x + other.width);
+		int bottom = Math.min(y + height, other.y + other.height);
+		if (right < left || bottom < top)
+			return EMPTY;
+		
+		return new DIRectangle(left, top, right - left, bottom - top);
+	}
+	
 	@Override
 	public String toString() {
 		return "(x = " + x + ", y = " + y + ", width = " + width + ", height = " + height + ")";

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.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 	private final DDimension preferredWidth;
 	
 	private DDrawSurface surface;
+	private int z;
 	private DInputFieldStyle style;
 	private DFontMetrics fontMetrics;
 	private int cursorFrom = -1;
 	private boolean cursorBlink = true;
 	private DTimerHandle blinkTimer;
 	
+	private DDrawnShape shape;
+	private DDrawnText text;
+	private DDrawnRectangle cursor;
+	private DDrawnRectangle selection;
+	
 	public DInputField(DStyleClass styleClass, MutableLiveString value, DDimension preferredWidth) {
 		this.styleClass = styleClass;
 		this.value = value;
 	@Override
 	public void close() {
 		valueListener.close();
-		blinkTimer.close();
+		unmount();
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	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);
+		
 		sizing.setValue(new DSizing(
-				preferredWidth.evalInt(surface.getContext()) + style.paddingLeft + style.paddingRight + 2 * style.borderWidth,
-				fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingTop + style.paddingBottom + 2 * style.borderWidth));
+				preferredWidth.evalInt(surface.getContext()) + 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);
+		
+		if (text != null)
+			text.close();
+		text = surface.drawText(
+				z + 2,
+				style.font,
+				style.color,
+				bounds.x + style.margin.left + style.border.getPaddingLeft(),
+				bounds.y + style.margin.top + style.border.getPaddingTop() + fontMetrics.getAscent(),
+				value.getValue());
+		
+		if (cursor != null)
+			cursor.close();
+		cursor = surface.fillRect(z + 2, DIRectangle.EMPTY, cursorBlink ? style.cursorColor : 0);
+		
+		if (selection != null)
+			selection.close();
+		selection = surface.fillRect(z + 1, DIRectangle.EMPTY, 0);
+		
+		setCursor(cursorFrom, cursorTo);
+	}
+	
+	@Override
+	public void unmount() {
+		blinkTimer.close();
+		
+		if (style != null)
+			style.border.close();
+		if (shape != null)
+			shape.close();
+		if (text != null)
+			text.close();
+		if (cursor != null)
+			cursor.close();
+		if (selection != null)
+			selection.close();
 	}
 	
 	private void blink() {
 		cursorBlink = !cursorBlink;
-		surface.repaint(bounds);
+		cursor.setColor(cursorBlink ? style.cursorColor : 0);
 	}
 
 	@Override
 	
 	@Override
 	public int getBaselineY() {
-		return style.borderWidth + style.paddingTop + fontMetrics.getAscent();
+		return style.margin.top + style.border.getPaddingTop() + fontMetrics.getAscent();
 	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
-		if (style.borderWidth > 0) {
-			canvas.strokePath(
-					DPath.rectangle(bounds.x, bounds.y, bounds.width - style.borderWidth, bounds.height - style.borderWidth),
-					DTransform2D.IDENTITY,
-					style.borderColor,
-					style.borderWidth);
-		}
+		setCursor(cursorFrom, cursorTo);
 		
-		int cursorXFrom = fontMetrics.getWidth(value.getValue(), 0, Math.min(cursorFrom, cursorTo));
-		int cursorXTo = fontMetrics.getWidth(value.getValue(), 0, Math.max(cursorFrom, cursorTo));
-		if (cursorFrom != cursorTo) {
-			canvas.fillRectangle(
-					bounds.x + style.paddingLeft + cursorXFrom,
-					bounds.y + style.paddingTop,
-					cursorXTo - cursorXFrom,
-					fontMetrics.getAscent() + fontMetrics.getDescent(),
-					style.selectionColor);
-		}
-		
-		canvas.drawText(style.font, style.color, bounds.x + style.paddingLeft + style.borderWidth, bounds.y + style.paddingBottom + style.borderWidth + fontMetrics.getAscent(), value.getValue());
-		
-		if (cursorBlink) {
-			canvas.fillRectangle(
-					bounds.x + style.paddingLeft + cursorXTo,
-					bounds.y + style.paddingTop,
-					style.cursorWidth,
-					fontMetrics.getAscent() + fontMetrics.getDescent(),
-					style.cursorColor);
-		}
+		if (shape != null)
+			shape.close();
+		shape = surface.fillPath(z, 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);
 	}
 	
 	@Override
 	private void setCursor(int from, int to) {
 		cursorFrom = from;
 		cursorTo = to;
-		surface.repaint(bounds);
+		
+		int cursorXFrom = fontMetrics.getWidth(value.getValue(), 0, Math.min(cursorFrom, cursorTo));
+		int cursorXTo = fontMetrics.getWidth(value.getValue(), 0, Math.max(cursorFrom, cursorTo));
+		if (cursorFrom != cursorTo) {
+			selection.setRectangle(new DIRectangle(
+					bounds.x + style.margin.left + style.border.getPaddingLeft() + cursorXFrom,
+					bounds.y + style.margin.top + style.border.getPaddingTop(),
+					cursorXTo - cursorXFrom,
+					fontMetrics.getAscent() + fontMetrics.getDescent()));
+			selection.setColor(style.selectionColor);
+		} else {
+			selection.setColor(0);
+		}
+		
+		cursor.setRectangle(new DIRectangle(
+				bounds.x + style.margin.left + style.border.getPaddingLeft() + cursorXTo,
+				bounds.y + style.margin.top + style.border.getPaddingTop(),
+				style.cursorWidth,
+				fontMetrics.getAscent() + fontMetrics.getDescent()));
 	}
 	
 	private void handleValueUpdated(String newValue) {
-		surface.repaint(bounds);
+		if (text != null)
+			text.close();
+		text = surface.drawText(
+				z + 2,
+				style.font,
+				style.color,
+				bounds.x + style.margin.left + style.border.getPaddingLeft(),
+				bounds.y + style.margin.top + style.border.getPaddingTop() + fontMetrics.getAscent(),
+				value.getValue());
 	}
 	
 	private void backspace() {

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

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

DrawableGui/src/main/java/org/openzen/drawablegui/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;
 	private DLabelStyle style;
 	private DFontMetrics fontMetrics;
 	
+	private DDrawnText text;
+	
 	public DLabel(DStyleClass styleClass, LiveString label) {
 		this.styleClass = styleClass;
 		this.label = label;
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
 		this.z = z;
 		
 		
 		fontMetrics = surface.getFontMetrics(style.font);
 		calculateDimension();
+		
+		if (text != null)
+			text.close();
+		text = surface.drawText(z, style.font, style.color, 0, 0, label.getValue());
+	}
+	
+	@Override
+	public void unmount() {
+		if (style != null)
+			style.border.close();
+		if (text != null)
+			text.close();
 	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		style.border.update(surface, z + 1, bounds);
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		canvas.drawText(style.font, style.color, bounds.x + style.border.getPaddingLeft(), bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(), label.getValue());
+		text.setPosition(
+				bounds.x + style.border.getPaddingLeft(),
+				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent());
 	}
 
 	@Override
 	public void close() {
 		labelListener.close();
+		unmount();
 	}
 	
 	private void onLabelChanged(String oldValue, String newValue) {
 		calculateDimension();
-		surface.repaint(bounds);
+		
+		if (text != null)
+			text.close();
+		text = surface.drawText(
+				z,
+				style.font,
+				style.color,
+				bounds.x + style.border.getPaddingLeft(),
+				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(),
+				newValue);
 	}
 	
 	private void calculateDimension() {

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

 				bounds.y,
 				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
 				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom());
-		surface.repaint(bounds);
 		
 		if (text != null)
 			text.close();
 	}
 	
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
 		this.z = z;
 		
 	}
 	
 	@Override
-	public void paint(DCanvas canvas) {
-		
+	public void unmount() {
+		if (background != null)
+			background.close();
+		if (text != null)
+			text.close();
 	}
 	
 	@Override
 	public void close() {
 		tooltipListener.close();
+		unmount();
 	}
 	
 	private void calculateSize() {

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

  */
 package org.openzen.drawablegui.border;
 
+import java.io.Closeable;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.draw.DDrawSurface;
 
  *
  * @author Hoofdgebruiker
  */
-public interface DBorder {
+public interface DBorder extends Closeable {
 	public void update(DDrawSurface surface, int z, DIRectangle bounds);
 	
 	public int getPaddingLeft();
 	default int getPaddingVertical() {
 		return getPaddingTop() + getPaddingBottom();
 	}
+	
+	@Override
+	void close();
 }

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

 			total += border.getPaddingBottom();
 		return total;
 	}
+	
+	@Override
+	public void close() {
+		for (DBorder border : borders)
+			border.close();
+	}
 }

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

 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.ImmutableLiveObject;
 import org.openzen.drawablegui.live.LiveBool;
 	private final LiveObject<DSizing> sizing = new ImmutableLiveObject<>(DSizing.EMPTY);
 	
 	private DDrawSurface surface;
+	private int z;
 	private DCustomWindowBorderStyle style;
 	private DIRectangle bounds;
-	private DPath border;
 	
 	private LiveBool active;
 	private LiveObject<DUIWindow.State> state;
 	private ListenerHandle<LiveObject.Listener<DUIWindow.State>> stateListener;
 	private ListenerHandle<LiveBool.Listener> activeListener;
 	
+	private DDrawnRectangle background;
+	private DDrawnShape shadowedBackground;
+	private DDrawnShape border;
+	
 	public DCustomWindowBorder(DStyleClass styleClass, DComponent content) {
 		this.styleClass = styleClass;
 		this.content = content;
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
-		content.setSurface(parent, z + 1, surface);
+		this.z = z;
+		content.mount(parent, z + 1, surface);
 		
 		state = surface.getContext().getWindow().getWindowState();
 		active = surface.getContext().getWindow().getActive();
 		if (bounds != null)
 			layout();
 	}
+	
+	@Override
+	public void unmount() {
+		if (background != null)
+			background.close();
+		if (shadowedBackground != null)
+			shadowedBackground.close();
+		if (border != null)
+			border.close();
+	}
 
 	@Override
 	public LiveObject<DSizing> getSizing() {
 			return;
 		
 		if (state.getValue() != DUIWindow.State.MAXIMIZED) {
-			border = DPath.rectangle(
-				bounds.x + style.padding,
-				bounds.y + style.padding,
-				bounds.width - 2 * style.padding - style.borderWidth,
-				bounds.height - 2 * style.padding - style.borderWidth);
+			DPath path = DPath.rectangle(
+					bounds.x + style.padding,
+					bounds.y + style.padding,
+					bounds.width - 2 * style.padding - style.borderWidth,
+					bounds.height - 2 * style.padding - style.borderWidth);
+			if (border != null)
+				border.close();
+			border = surface.strokePath(
+					z + 1,
+					path,
+					DTransform2D.IDENTITY,
+					active.getValue() ? style.focusedBorderColor : style.inactiveBorderColor,
+					style.borderWidth);
 			
 			int spacing = style.borderWidth + style.padding;
 			DIRectangle inner = new DIRectangle(
 					bounds.height - 2 * spacing);
 
 			content.setBounds(inner);
+			
+			if (shadowedBackground != null)
+				shadowedBackground.close();
+			if (background != null) {
+				background.close();
+				background = null;
+			}
+			shadowedBackground = surface.shadowPath(z, path, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		} else {
 			content.setBounds(bounds);
-		}
-		surface.repaint(bounds);
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		if (state.getValue() != DUIWindow.State.MAXIMIZED) {
-			int spacing = style.borderWidth + style.padding;
-			DIRectangle canvasBounds = canvas.getBounds();
-			if (canvasBounds == null
-					|| canvasBounds.x < bounds.x + spacing
-					|| canvasBounds.y < bounds.y + spacing
-					|| canvasBounds.x + canvasBounds.width > bounds.x + bounds.width - spacing
-					|| canvasBounds.y + canvasBounds.height > bounds.y + bounds.height - spacing) {
-				canvas.shadowPath(border, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
-				canvas.strokePath(
-						border,
-						DTransform2D.IDENTITY,
-						active.getValue() ? style.focusedBorderColor : style.inactiveBorderColor,
-						style.borderWidth);
+			
+			if (shadowedBackground != null) {
+				shadowedBackground.close();
+				shadowedBackground = null;
+			}
+			if (border != null) {
+				border.close();
+				border = null;
+			}
+			if (background == null) {
+				background = surface.fillRect(z, bounds, style.backgroundColor);
+			} else {
+				background.setRectangle(bounds);
 			}
-		} else {
-			canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
 		}
-		
-		content.paint(canvas);
+		surface.repaint(bounds);
 	}
 
 	@Override
 	
 	@Override
 	public void close() {
-		
+		unmount();
 	}
 	
 	private void onStateChanged(DUIWindow.State oldValue, DUIWindow.State newValue) {
 	}
 	
 	private void onActiveChanged(boolean oldValue, boolean newValue) {
-		surface.repaint(bounds);
+		if (border != null)
+			border.setColor(newValue ? style.focusedBorderColor : style.inactiveBorderColor);
 	}
 }

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

 	public int getPaddingBottom() {
 		return 0;
 	}
+
+	@Override
+	public void close() {
+		
+	}
 }

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

 	public int getPaddingBottom() {
 		return borderWidth;
 	}
+
+	@Override
+	public void close() {
+		if (shape != null)
+			shape.close();
+	}
 }

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

 	public int getPaddingBottom() {
 		return bottom;
 	}
+
+	@Override
+	public void close() {
+		
+	}
 }

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

  */
 package org.openzen.drawablegui.border;
 
-import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 	public int getPaddingBottom() {
 		return bottomWidth;
 	}
+
+	@Override
+	public void close() {
+		if (left != null)
+			left.close();
+		if (top != null)
+			top.close();
+		if (right != null)
+			right.close();
+		if (bottom != null)
+			bottom.close();
+	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawSurface.java

  */
 package org.openzen.drawablegui.draw;
 
-import org.openzen.drawablegui.DFont;
-import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DPath;
-import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
-import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleDefinition;
 import org.openzen.drawablegui.style.DStylePath;
 
  *
  * @author Hoofdgebruiker
  */
-public interface DDrawSurface {
+public interface DDrawSurface extends DDrawTarget {
 	DUIContext getContext();
 	
 	DStyleDefinition getStylesheet(DStylePath path);
 	
-	DFontMetrics getFontMetrics(DFont font);
-	
-	float getScale();
-	
-	float getTextScale();
-	
-	DDrawnText drawText(int z, DFont font, int color, float x, float y, String text);
-	
-	DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color);
-	
-	DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth);
-	
-	DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color);
-	
-	DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow);
-	
 	DSubSurface createSubSurface(int z);
 	
 	void repaint(int x, int y, int width, int height);

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawTarget.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.draw;
+
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.style.DShadow;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawTarget {
+	public static final int INSTANCE_COLOR = 1;
+	
+	DFontMetrics getFontMetrics(DFont font);
+	
+	float getScale();
+	
+	float getTextScale();
+	
+	DDrawnText drawText(int z, DFont font, int color, float x, float y, String text);
+	
+	DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color);
+	
+	DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth);
+	
+	DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color);
+	
+	DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow);
+}

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawnColorableElement.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.draw;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnColorableElement extends DDrawnElement {
+	void setColor(int color);
+}

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawnElement.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.draw;
+
+import java.io.Closeable;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnElement extends Closeable {
+	void setTransform(DTransform2D transform);
+	
+	DIRectangle getBounds();
+	
+	@Override
+	public void close();
+}

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawnRectangle.java

  */
 package org.openzen.drawablegui.draw;
 
-import java.io.Closeable;
 import org.openzen.drawablegui.DIRectangle;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public interface DDrawnRectangle extends Closeable {
+public interface DDrawnRectangle extends DDrawnColorableElement {
 	void setRectangle(DIRectangle rectangle);
-	
-	void setColor(int color);
-	
-	@Override
-	void close();
 }

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawnShape.java

  */
 package org.openzen.drawablegui.draw;
 
-import java.io.Closeable;
-import org.openzen.drawablegui.DTransform2D;
-
 /**
  *
  * @author Hoofdgebruiker
  */
-public interface DDrawnShape extends Closeable {
-	public void setTransform(DTransform2D transform);
-	
-	public void setColor(int color);
+public interface DDrawnShape extends DDrawnColorableElement {
 	
-	@Override
-	public void close();
 }

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawnText.java

  */
 package org.openzen.drawablegui.draw;
 
-import java.io.Closeable;
+import org.openzen.drawablegui.DTransform2D;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public interface DDrawnText extends Closeable {
-	void setPosition(float x, float y);
-	
-	void setColor(int color);
-	
+public interface DDrawnText extends DDrawnColorableElement {
 	@Override
-	void close();
+	default void setTransform(DTransform2D transform) { // only uses position, not scaling or rotation
+		setPosition(transform.xx, transform.yy);
+	}
+	
+	void setPosition(float x, float y);
 }

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DSubSurface.java

 package org.openzen.drawablegui.draw;
 
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DTransform2D;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public interface DSubSurface extends DDrawSurface {
+public interface DSubSurface extends DDrawnElement, DDrawSurface {
+	@Override
+	default void setTransform(DTransform2D transform) {
+		setOffset((int)transform.xx, (int)transform.yy);
+	}
+	
 	void setOffset(int x, int y);
 	
 	void setClip(DIRectangle bounds);
+	
+	void repaint();
 }

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

 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DUIContext;
 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;
 	private int maxFieldWidth;
 	private int maxLabelWidth;
 	
+	private final DDrawnText[] labels;
+	
 	public DForm(DStyleClass styleClass, DFormComponent... components) {
 		this.styleClass = styleClass;
 		this.components = components;
+		
+		labels = new DDrawnText[components.length];
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.context = surface;
 		
 		DStylePath path = parent.getChild("form", styleClass);
 		fontMetrics = surface.getFontMetrics(style.labelFont);
 		
 		for (DFormComponent component : components)
-			component.component.setSurface(path, z + 1, surface);
+			component.component.mount(path, z + 1, surface);
 		
 		int height = style.paddingBottom + style.paddingTop;
 		int maxLabelWidth = style.minimumLabelSize;
 		
 		if (bounds != null)
 			layout();
+		
+		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);
+		}
+	}
+	
+	@Override
+	public void unmount() {
+		for (int i = 0; i < labels.length; i++) {
+			if (labels[i] == null)
+				continue;
+			
+			labels[i].close();
+			labels[i] = null;
+		}
+		
+		for (DFormComponent component : components)
+			component.component.unmount();
 	}
 
 	@Override
 			layout();
 	}
 
-	@Override
-	public void paint(DCanvas canvas) {
-		int x = style.paddingLeft;
-		int y = style.paddingTop;
-		for (DFormComponent component : components) {
-			int baseline = component.component.getBaselineY();
-			if (baseline == -1)
-				baseline = fontMetrics.getAscent();
-			canvas.drawText(style.labelFont, style.labelColor, x, y + baseline, component.label);
-			component.component.paint(canvas);
-			
-			y += component.component.getSizing().getValue().preferredHeight + style.spacing;
-		}
-	}
-
 	@Override
 	public void close() {
-		
+		unmount();
 	}
 	
 	private void layout() {
 		int x = bounds.x + style.paddingLeft;
 		int y = bounds.y + style.paddingBottom;
 		
-		for (DFormComponent component : components) {
+		for (int i = 0; i < components.length; i++) {
+			DFormComponent component = components[i];
+			
 			int preferredHeight = component.component.getSizing().getValue().preferredHeight;
 			DIRectangle componentBounds = new DIRectangle(x + maxLabelWidth, y, bounds.width - maxLabelWidth - style.paddingLeft - style.paddingRight - style.spacing, preferredHeight);
 			component.component.setBounds(componentBounds);
 			
+			int baseline = component.component.getBaselineY();
+			if (baseline == -1)
+				baseline = fontMetrics.getAscent();
+			labels[i].setPosition(x, y + baseline);
+			
 			y += preferredHeight + style.spacing;
 		}
 	}

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

 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
 		this.z = z;
 		
 		style = new DLinearLayoutStyle(surface.getStylesheet(path));
 		
 		for (Element element : components)
-			element.component.setSurface(parent, z + 1, surface);
+			element.component.mount(parent, z + 1, surface);
+	}
+	
+	@Override
+	public void unmount() {
+		for (Element element : components)
+			element.component.unmount();
 	}
 
 	@Override
 		layout();
 	}
 
-	@Override
-	public void paint(DCanvas canvas) {
-		for (Element element : components) {
-			element.component.paint(canvas);
-		}
-	}
-
 	@Override
 	public void close() {
 		for (ListenerHandle<LiveObject.Listener<DSizing>> listener : componentSizeListeners) {
 			listener.close();
 		}
+		for (Element element : components)
+			element.component.close();
 	}
 	
 	private int getInnerWidth() {

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

 	
 	public void add(Side side, DComponent component) {
 		if (surface != null)
-			component.setSurface(path, z + 1, surface);
+			component.mount(path, z + 1, surface);
 		
 		sides.add(new SideComponent(side, component));
 	}
 		this.main = component;
 		
 		if (surface != null && bounds != null) {
-			main.setSurface(path, z + 1, surface);
+			main.mount(path, z + 1, surface);
 			setBounds(bounds);
 			surface.repaint(bounds);
 		}
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	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));
 		
-		main.setSurface(path, z + 1, surface);
+		main.mount(path, z + 1, surface);
 		for (SideComponent side : sides)
-			side.component.setSurface(path, z + 1, surface);
+			side.component.mount(path, z + 1, surface);
 		
+		if (background != null)
+			background.close();
 		background = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
 	}
 	
+	@Override
+	public void unmount() {
+		main.unmount();
+		for (SideComponent side : sides)
+			side.component.unmount();
+		
+		background.close();
+		background = null;
+	}
+	
 	@Override
 	public DIRectangle getBounds() {
 		return bounds;
 		
 		main.setBounds(new DIRectangle(left, top, right - left, bottom - top));
 	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		//canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
-		main.paint(canvas);
-		
-		for (SideComponent component : sides)
-			component.component.paint(canvas);
-	}
 	
 	private void recalculateSize() {
 		DSizing mainPreferences = main.getSizing().getValue();

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

 		@Override
 		public void onRemoved(int index, T oldValue) {
 			U oldMappedValue = mapped.remove(index);
+			if (oldMappedValue instanceof AutoCloseable) {
+				try { ((AutoCloseable) oldMappedValue).close(); } catch (Exception ex) {}
+			}
 			listeners.accept(listener -> listener.onRemoved(index, oldMappedValue));
 		}
 	}

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

 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+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.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 DDrawSurface surface;
 	private DScrollBarStyle style;
+	private int z;
 	private DIRectangle bounds;
 	
 	private int fromY = 0;
 	private int dragStartOffset;
 	private int dragStartY;
 	
+	private DDrawnRectangle background;
+	private DDrawnShape bar;
+	
 	public DScrollBar(DStyleClass styleClass, LiveInt targetHeight, LiveInt offset) {
 		this.styleClass = styleClass;
 		this.targetHeight = targetHeight;
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface context) {
-		this.surface = context;
-		this.style = new DScrollBarStyle(context.getStylesheet(parent.getChild("scrollbar", styleClass)));
+	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)));
 		sizing.setValue(new DSizing(style.width, 0));
+		
+		background = surface.fillRect(z, DIRectangle.EMPTY, style.scrollBarBackgroundColor);
+	}
+	
+	@Override
+	public void unmount() {
+		background.close();
+		background = null;
+		
+		if (bar != null) {
+			bar.close();
+			bar = null;
+		}
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		background.setRectangle(bounds);
 		recalculate();
 	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		if (targetHeight.getValue() <= this.bounds.height)
-			return; // no scrollbar
-		
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.scrollBarBackgroundColor);
-		
-		int color = style.scrollBarNormalColor;
-		if (hovering)
-			color = style.scrollBarHoverColor;
-		if (dragging)
-			color = style.scrollBarPressColor;
-		
-		canvas.fillRectangle(bounds.x, fromY, this.bounds.width, toY - fromY, color);
-	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 	public void close() {
 		targetHeightListener.close();
 		offsetListener.close();
+		
+		unmount();
+	}
+	
+	private void updateBarColor() {
+		int color = style.scrollBarNormalColor;
+		if (hovering)
+			color = style.scrollBarHoverColor;
+		if (dragging)
+			color = style.scrollBarPressColor;		
+		if (targetHeight.getValue() <= this.bounds.height)
+			color = 0;
+		
+		bar.setColor(color);
 	}
 	
 	private void checkHover(DMouseEvent e) {
 			return;
 		
 		this.hovering = hovering;
+		updateBarColor();
 		surface.repaint(bounds.x, fromY, bounds.width, toY - fromY);
 	}
 	
 			return;
 		
 		this.dragging = dragging;
+		updateBarColor();
 		surface.repaint(bounds.x, fromY, bounds.width, toY - fromY);
 	}
 	
 		
 		fromY = bounds.y + this.bounds.height * offset.getValue() / targetHeight.getValue();
 		toY = bounds.y + this.bounds.height * (offset.getValue() + this.bounds.height) / targetHeight.getValue();
+		
+		if (bar != null)
+			bar.close();
+		bar = surface.fillPath(z + 1, DPath.rectangle(bounds.x, fromY, bounds.width, toY - fromY), DTransform2D.IDENTITY, style.scrollBarNormalColor);
+		updateBarColor();
 	}
 	
 	private class ScrollListener implements LiveInt.Listener {

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

 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
 		
 		DStylePath path = parent.getChild("scrollpane", styleClass);
 		subSurface = surface.createSubSurface(z + 1);
-		contents.setSurface(path, 0, subSurface);
-		scrollBar.setSurface(path, z + 2, surface);
+		contents.mount(path, 0, subSurface);
+		scrollBar.mount(path, z + 2, surface);
 		style = new DScrollPaneStyle(surface.getStylesheet(path));
 	}
+	
+	@Override
+	public void unmount() {
+		subSurface.close();
+		
+		contents.unmount();
+		scrollBar.unmount();
+	}
 
 	@Override
 	public LiveObject<DSizing> getSizing() {
 		subSurface.setClip(new DIRectangle(
 				bounds.x + style.border.getPaddingLeft(),
 				bounds.y + style.border.getPaddingTop(),
-				bounds.width - style.border.getPaddingLeft() - style.border.getPaddingTop() - scrollBar.getBounds().width,
-				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom()));
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		scrollBar.paint(canvas);
-		
-		canvas.pushBounds(new DIRectangle(
-				bounds.x + style.border.getPaddingLeft(),
-				bounds.y + style.border.getPaddingTop(),
-				bounds.width - style.border.getPaddingLeft() - style.border.getPaddingTop() - scrollBar.getBounds().width,
+				bounds.width - style.border.getPaddingLeft() - style.border.getPaddingTop(),
 				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom()));
-		canvas.pushOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
-		contents.paint(canvas);
-		canvas.popOffset();
-		canvas.popBounds();
 	}
 	
 	@Override
 	@Override
 	public void close() {
 		contents.close();
+		unmount();
 	}
 	
 	private DMouseEvent forward(DComponent target, DMouseEvent e) {
 			
 			if (value != offsetY.getValue())
 				offsetY.setValue(value);
-			if (surface != null && bounds != null)
-				surface.repaint(bounds);
 			
 			subSurface.setOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
 		}

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

 		shape = style.getShape("shape", DRectangleShape.ELEMENT);
 		shadow = style.getShadow("shadow", DShadow.NONE_ELEMENT);
 	}
+	
+	public DBaseStyle(DStyleDefinition style, DBorderElement defaultBorder, int defaultBackgroundColor) {
+		border = style.getBorder("border", defaultBorder);
+		backgroundColor = style.getColor("backgroundColor", defaultBackgroundColor);
+		margin = style.getMargin("margin", DMargin.EMPTY_ELEMENT);
+		shape = style.getShape("shape", DRectangleShape.ELEMENT);
+		shadow = style.getShadow("shadow", DShadow.NONE_ELEMENT);
+	}
+	
+	public DBaseStyle(DStyleDefinition style, DBorderElement defaultBorder, int defaultBackgroundColor, DShapeElement defaultShape, DShadowElement defaultShadow) {
+		border = style.getBorder("border", defaultBorder);
+		backgroundColor = style.getColor("backgroundColor", defaultBackgroundColor);
+		margin = style.getMargin("margin", DMargin.EMPTY_ELEMENT);
+		shape = style.getShape("shape", defaultShape);
+		shadow = style.getShadow("shadow", defaultShadow);
+	}
 }

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

 package org.openzen.drawablegui.swing;
 
 import java.awt.Graphics2D;
+import java.awt.Rectangle;
 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.drawablegui.DFont;
 public class SwingDrawSurface implements DDrawSurface {
 	private final List<SwingDrawnElement> elements = new ArrayList<>();
 	private final SwingGraphicsContext context;
+	public int offsetX;
+	public int offsetY;
 	
-	public SwingDrawSurface(SwingGraphicsContext context) {
+	public SwingDrawSurface(SwingGraphicsContext context, int offsetX, int offsetY) {
 		this.context = context;
+		this.offsetX = offsetX;
+		this.offsetY = offsetY;
 	}
 	
-	public void paint(Graphics2D g) {
+	public void setOffset(int offsetX, int offsetY) {
+		this.offsetX = offsetX;
+		this.offsetY = offsetY;
+	}
+	
+	public void paint(Graphics2D g, DIRectangle clip) {
 		for (SwingDrawnElement element : elements)
-			element.paint(g);
+			if (clip == null || clip.overlaps(element.getBounds()))
+				element.paint(g, clip);
+	}
+	
+	public DIRectangle calculateBounds() {
+		if (elements.isEmpty())
+			return DIRectangle.EMPTY;
+		
+		DIRectangle result = elements.get(0).getBounds();
+		for (SwingDrawnElement element : elements)
+			result = result.union(element.getBounds());
+		return result;
 	}
 
 	@Override
 
 	@Override
 	public DDrawnText drawText(int z, DFont font, int color, float x, float y, String text) {
-		return addElement(new SwingDrawnText(this, z, x, y, color, font, text));
+		DFontMetrics fontMetrics = context.getFontMetrics(font);
+		return addElement(new SwingDrawnText(this, z, x, y, color, font, text, fontMetrics.getAscent(), fontMetrics.getDescent(), fontMetrics.getWidth(text)));
 	}
 
 	@Override
 	public DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth) {
-		return addElement(new SwingStrokedPath(this, z, transform, color, context.getPath(path), lineWidth));
+		return addElement(new SwingStrokedPath(this, z, transform, color, path, context.getPath(path), lineWidth));
 	}
 	
 	@Override
 
 	@Override
 	public DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color) {
-		return addElement(new SwingFilledPath(this, z, transform, context.getPath(path), color));
+		return addElement(new SwingFilledPath(this, z, transform, path, context.getPath(path), color));
 	}
 
 	@Override
 	
 	public void remove(SwingDrawnElement element) {
 		elements.remove(element);
+		repaint(element.getBounds());
 	}
 
 	@Override
 	public void repaint(int x, int y, int width, int height) {
-		context.repaint(x, y, width, height);
+		context.repaint(x + offsetX, y + offsetY, width, height);
+	}
+	
+	@Override
+	public void repaint(DIRectangle rectangle) {
+		context.repaint(rectangle.offset(offsetX, offsetY));
 	}
 	
 	private <T extends SwingDrawnElement> T addElement(T element) {
 			index--;
 		
 		elements.add(index, element);
+		repaint(element.getBounds());
 		return element;
 	}
 }

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

 package org.openzen.drawablegui.swing;
 
 import java.awt.Graphics2D;
-import java.io.Closeable;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawnElement;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public abstract class SwingDrawnElement implements Closeable {
+public abstract class SwingDrawnElement implements DDrawnElement {
 	public final SwingDrawSurface target;
 	public final int z;
 	
 		this.z = z;
 	}
 	
-	abstract void paint(Graphics2D g);
+	abstract void paint(Graphics2D g, DIRectangle clip);
 	
 	@Override
 	public void close() {
 		target.remove(this);
 	}
+	
+	protected void invalidate() {
+		target.repaint(getBounds());
+	}
 }

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

 import java.awt.Color;
 import java.awt.Graphics2D;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 
 /**
  */
 public class SwingDrawnRectangle extends SwingDrawnElement implements DDrawnRectangle {
 	private DIRectangle rectangle;
-	private Color color;
+	private Color awtColor;
 	
 	public SwingDrawnRectangle(SwingDrawSurface target, int z, DIRectangle rectangle, int color) {
 		super(target, z);
 		
 		this.rectangle = rectangle;
-		this.color = new Color(color, true);
+		this.awtColor = new Color(color, true);
+	}
+	
+	@Override
+	public void setTransform(DTransform2D transform) {
+		// not supported?
+	}
+	
+	@Override
+	public DIRectangle getBounds() {
+		return rectangle;
 	}
 
 	@Override
 	public void setRectangle(DIRectangle rectangle) {
+		invalidate();
 		this.rectangle = rectangle;
+		invalidate();
 	}
 
 	@Override
 	public void setColor(int color) {
-		this.color = new Color(color, true);
+		this.awtColor = new Color(color, true);
+		invalidate();
 	}
 
 	@Override
-	public void paint(Graphics2D g) {
-		g.setColor(color);
+	public void paint(Graphics2D g, DIRectangle clip) {
+		g.setColor(awtColor);
 		g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
 	}
 }

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

 import java.awt.Font;
 import java.awt.Graphics2D;
 import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.draw.DDrawnText;
 import static org.openzen.drawablegui.swing.SwingCanvas.prepare;
 
 public class SwingDrawnText extends SwingDrawnElement implements DDrawnText {
 	private float x;
 	private float y;
-	private int color;
-	private final DFont font;
+	private final int width;
+	private final int ascent;
+	private final int descent;
+	private Color awtColor;
+	private final Font font;
 	private final String text;
 	
-	public SwingDrawnText(SwingDrawSurface target, int z, float x, float y, int color, DFont font, String text) {
+	public SwingDrawnText(SwingDrawSurface target, int z, float x, float y, int color, DFont font, String text, int ascent, int descent, int width) {
 		super(target, z);
+		prepare(font);
 		
 		this.x = x;
 		this.y = y;
-		this.color = color;
-		this.font = font;
+		this.awtColor = new Color(color, true);
+		this.font = (Font) font.cached;
 		this.text = text;
+		this.ascent = ascent;
+		this.descent = descent;
+		this.width = width;
 	}
 
 	@Override
 	public void setPosition(float x, float y) {
+		invalidate();
 		this.x = x;
 		this.y = y;
+		invalidate();
 	}
 
+	@Override
+	public DIRectangle getBounds() {
+		return new DIRectangle((int)x, (int)y - ascent, width, ascent + descent);
+	}
+	
 	@Override
 	public void setColor(int color) {
-		this.color = color;
+		this.awtColor = new Color(color, true);
+		invalidate();
 	}
 
 	@Override
-	public void paint(Graphics2D g) {
-		prepare(font);
-		g.setColor(new Color(color, true));
-		g.setFont((Font) font.cached);
+	public void paint(Graphics2D g, DIRectangle clip) {
+		g.setColor(awtColor);
+		g.setFont(font);
 		g.drawString(text, x, y);
 	}
 }

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

 import java.awt.Graphics2D;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.GeneralPath;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DPathBoundsCalculator;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import static org.openzen.drawablegui.swing.SwingCanvas.getTransform;
  * @author Hoofdgebruiker
  */
 public class SwingFilledPath extends SwingDrawnElement implements DDrawnShape {
-	private int color;
-	private DTransform2D transform;
+	private Color awtColor;
+	private AffineTransform transform;
 	
+	private final DPath originalPath;
 	private final GeneralPath path;
+	private DIRectangle bounds;
 	
 	public SwingFilledPath(
 			SwingDrawSurface target,
 			int z,
 			DTransform2D transform,
+			DPath originalPath,
 			GeneralPath path,
 			int color) {
 		super(target, z);
 		
+		this.originalPath = originalPath;
 		this.path = path;
 		
-		this.color = color;
-		this.transform = transform;
+		this.awtColor = color == 0 ? null : new Color(color, true);
+		this.transform = getTransform(transform);
+		this.bounds = DPathBoundsCalculator.getBounds(originalPath, transform);
 	}
 
 	@Override
 	public void setTransform(DTransform2D transform) {
-		this.transform = transform;
+		this.transform = getTransform(transform);
+		this.bounds = DPathBoundsCalculator.getBounds(originalPath, transform);
+	}
+	
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
 	}
 
 	@Override
 	public void setColor(int color) {
-		this.color = color;
+		this.awtColor = color == 0 ? null : new Color(color, true);
+		invalidate();
 	}
 
 	@Override
-	public void paint(Graphics2D g) {
-		if (color == 0)
+	public void paint(Graphics2D g, DIRectangle clip) {
+		if (awtColor == null)
 			return;
 		
 		AffineTransform old = g.getTransform();
-		g.setColor(new Color(color, true));
-		g.transform(getTransform(transform));
+		g.setColor(awtColor);
+		g.transform(transform);
 		g.fill(path);
 		g.setTransform(old);
 	}

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

 		
 		Point rootLocation = swingWindow.swingComponent.getLocationOnScreen();
 		
-		root.setSurface(DStylePathRoot.INSTANCE, 0, windowContext.surface);
+		root.mount(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);
 		windowContext.graphics = this.graphics; // help a little...
 		windowContext.setSurface(window.swingComponent.surface);
 		
-		root.setSurface(DStylePathRoot.INSTANCE, 0, windowContext.surface);
+		root.mount(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

 				Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f,
 				Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f,
 				this);
-		surface = new SwingDrawSurface(context);
+		surface = new SwingDrawSurface(context, 0, 0);
 		context.setSurface(surface);
 		
 		addComponentListener(this);
 	public void paint(Graphics g) {
 		if (firstPaint) {
 			firstPaint = false;
-			component.setSurface(DStylePathRoot.INSTANCE, 0, surface);
+			component.mount(DStylePathRoot.INSTANCE, 0, surface);
 			component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
 		}
 		
 		Graphics2D g2d = (Graphics2D) g;
 		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 		g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
+		surface.paint(g2d, clipBounds2);
 		
-		surface.paint(g2d);
-		SwingCanvas canvas = new SwingCanvas(g2d, context, clipBounds2);
-		component.paint(canvas);
-		
-		System.out.println("Paint in " + (System.currentTimeMillis() - start) + " ms");
+		System.out.println("Paint in " + (System.currentTimeMillis() - start) + " ms, bounds: " + clipBounds.toString());
 	}
 
 	@Override

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

  * @author Hoofdgebruiker
  */
 public class SwingShadowedPath extends SwingDrawnElement implements DDrawnShape {
+	private final DPath originalPath;
 	private final GeneralPath path;
 	private final BufferedImage shadowImage;
 	private final DIRectangle shadowBounds;
 	private final int shadowOffset;
 	
-	private int color;
-	private DTransform2D transform;
+	private Color awtColor;
+	private AffineTransform transform;
+	private DIRectangle bounds;
 	
 	public SwingShadowedPath(
 			SwingDrawSurface target,
 			DShadow shadow) {
 		super(target, z);
 		
-		this.transform = transform;
+		this.transform = getTransform(transform);
+		this.originalPath = originalPath;
 		this.path = path;
-		this.color = color;
+		this.awtColor = new Color(color, true);
 		
 		shadowBounds = DPathBoundsCalculator.getBounds(originalPath, transform.offset(shadow.offsetX, shadow.offsetY));
 		shadowOffset = 2 * (int)Math.ceil(shadow.radius);
 		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), true).filter(image, null);
 		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), false).filter(image, null);
 		shadowImage = image;
+		
+		bounds = new DIRectangle(
+				shadowBounds.x - shadowOffset,
+				shadowBounds.y - shadowOffset,
+				shadowBounds.width + 2 * shadowOffset,
+				shadowBounds.height + 2 * shadowOffset);
 	}
 
 	@Override
 	public void setTransform(DTransform2D transform) {
-		this.transform = transform;
+		this.transform = getTransform(transform);
+	}
+	
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
 	}
 
 	@Override
 	public void setColor(int color) {
-		this.color = color;
+		this.awtColor = new Color(color, true);
+		invalidate();
 	}
 
 	@Override
-	public void paint(Graphics2D g) {
+	public void paint(Graphics2D g, DIRectangle clip) {
 		g.drawImage(shadowImage, shadowBounds.x - shadowOffset, shadowBounds.y - shadowOffset, null);
 		
 		AffineTransform old = g.getTransform();
-		g.setColor(new Color(color, true));
-		g.transform(getTransform(transform));
+		g.setColor(awtColor);
+		g.transform(transform);
 		g.fill(path);
 		g.setTransform(old);
 	}

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

 import java.awt.Graphics2D;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.GeneralPath;
+import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DPathBoundsCalculator;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.draw.DDrawnShape;
 
  * @author Hoofdgebruiker
  */
 public class SwingStrokedPath extends SwingDrawnElement implements DDrawnShape {
-	private DTransform2D transform;
-	private int color;
+	private AffineTransform transform;
+	private Color awtColor;
 	
+	private final DPath originalPath;
 	private final GeneralPath path;
-	private final float lineWidth;
+	private final BasicStroke stroke;
+	private DIRectangle bounds;
 	
 	public SwingStrokedPath(
 			SwingDrawSurface target,
 			int z,
 			DTransform2D transform,
 			int color,
+			DPath originalPath,
 			GeneralPath path,
 			float lineWidth) {
 		super(target, z);
 		
-		this.transform = transform;
-		this.color = color;
+		this.transform = SwingCanvas.getTransform(transform);
+		this.awtColor = color == 0 ? null : new Color(color, true);
+		this.originalPath = originalPath;
 		this.path = path;
-		this.lineWidth = lineWidth;
+		this.stroke = new BasicStroke(lineWidth);
+		this.bounds = DPathBoundsCalculator.getBounds(originalPath, transform).expand((int)(lineWidth + 0.5f));
 	}
 
 	@Override
 	public void setTransform(DTransform2D transform) {
-		this.transform = transform;
+		invalidate();
+		this.transform = SwingCanvas.getTransform(transform);
+		this.bounds = DPathBoundsCalculator.getBounds(originalPath, transform);
+		invalidate();
 	}
 
 	@Override
-	public void setColor(int color) {
-		this.color = color;
+	public DIRectangle getBounds() {
+		return bounds;
 	}
-
+	
 	@Override
-	public void close() {
-		target.remove(this);
+	public void setColor(int color) {
+		awtColor = color == 0 ? null : new Color(color, true);
+		invalidate();
 	}
 
 	@Override
-	public void paint(Graphics2D g) {
-		if (color == 0)
+	public void paint(Graphics2D g, DIRectangle clip) {
+		if (awtColor == null)
 			return;
 		
 		AffineTransform old = g.getTransform();
-		g.setColor(new Color(color, true));
-		g.setStroke(new BasicStroke(lineWidth));
-		g.transform(SwingCanvas.getTransform(transform));
+		g.setColor(awtColor);
+		g.setStroke(stroke);
+		g.transform(transform);
 		g.draw(path);
 		g.setTransform(old);
 	}

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

 public class SwingSubSurface extends SwingDrawnElement implements DSubSurface {
 	private final SwingDrawSurface surface;
 	
-	private int offsetX = 0;
-	private int offsetY = 0;
 	private DIRectangle clip = null;
 	
 	public SwingSubSurface(SwingDrawSurface parent, int z) {
 		super(parent, z);
 		
-		this.surface = new SwingDrawSurface(parent.getContext());
+		this.surface = new SwingDrawSurface(parent.getContext(), 0, 0);
 	}
 	
 	@Override
-	public void paint(Graphics2D g) {
+	public void paint(Graphics2D g, DIRectangle clip) {
 		Rectangle clipBounds = g.getClipBounds();
-		if (clip != null) {
-			g.setClip(clip.x, clip.y, clip.width, clip.height);
+		if (this.clip != null) {
+			g.setClip(this.clip.x, this.clip.y, this.clip.width, this.clip.height);
 		}
 		
 		AffineTransform oldTransform = g.getTransform();
-		g.transform(AffineTransform.getTranslateInstance(offsetX, offsetY));
-		surface.paint(g);
+		g.transform(AffineTransform.getTranslateInstance(surface.offsetX, surface.offsetY));
+		DIRectangle newClip = this.clip == null ? clip : clip.offset(-surface.offsetX, -surface.offsetY).intersect(this.clip.offset(-surface.offsetX, -surface.offsetY));
+		surface.paint(g, newClip);
 		g.setTransform(oldTransform);
 		g.setClip(clipBounds.x, clipBounds.y, clipBounds.width, clipBounds.height);
 	}
+	
+	@Override
+	public void setTransform(DTransform2D transform) {
+		setOffset((int)transform.xx, (int)transform.yy);
+	}
 
 	@Override
 	public void setOffset(int x, int y) {
-		offsetX = x;
-		offsetY = y;
+		surface.setOffset(x, y);
+		repaint();
 	}
 
 	@Override
 	public DUIContext getContext() {
 		return surface.getContext();
 	}
+	
+	@Override
+	public DIRectangle getBounds() {
+		return surface.calculateBounds();
+	}
 
 	@Override
 	public DStyleDefinition getStylesheet(DStylePath path) {
 
 		target.repaint(left, top, right - left, bottom - top);
 	}
+	
+	@Override
+	public void repaint() {
+		DIRectangle bounds = surface.calculateBounds().offset(surface.offsetX, surface.offsetY);
+		if (clip != null)
+			bounds = bounds.intersect(clip);
+		
+		target.repaint(bounds);
+	}
 
 	private int toGlobalX(int x) {
-		return x + offsetX;
+		return x + surface.offsetX;
 	}
 
 	private int toGlobalY(int y) {
-		return y + offsetY;
+		return y + surface.offsetY;
 	}
 
 	private int toLocalX(int x) {
-		return x - offsetX;
+		return x - surface.offsetX;
 	}
 
 	private int toLocalY(int y) {
-		return y - offsetY;
+		return y - surface.offsetY;
 	}
 }

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

 	private void updateBounds() {
 		state.setValue(getStateFromWindowState());
 		bounds.setValue(new DIRectangle(getX(), getY(), getWidth(), getHeight()));
+		swingComponent.repaint();
 	}
 	
 	private State getStateFromWindowState() {

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 /**
  *
 	public void draw(DCanvas canvas, DTransform2D transform) {
 		ColoredCollapsedArrow.INSTANCE.draw(canvas, transform, 0xFF000000);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform) {
+		ColoredCollapsedArrow.INSTANCE.draw(target, z, transform, 0xFF000000);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ColoredCollapsedArrow implements DColorableIcon {
 	public static final ColoredCollapsedArrow INSTANCE = new ColoredCollapsedArrow();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH_0, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH_0, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.List;
-import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DColorableIconInstance;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DDrawableInstance;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 public class DTreeView<N extends DTreeNode<N>> implements DComponent {
 	private final DStyleClass styleClass;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
-	private DIRectangle bounds;
+	private DIRectangle bounds = DIRectangle.EMPTY;
+	private int z;
 	
 	private int selectedRow = -1;
 	private N selectedNode = null;
 	private final boolean showRoot;
 	private final List<Row> rows = new ArrayList<>();
 	
+	private DDrawnRectangle background;
+	private DDrawnRectangle selectedBackground;
+	
 	public DTreeView(
 			DStyleClass styleClass,
 			DDrawable nodeOpenedIcon,
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	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);
 		
+		background = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
+		selectedBackground = surface.fillRect(z + 1, DIRectangle.EMPTY, 0);
+		
 		updateLayout();
 	}
+	
+	@Override
+	public void unmount() {
+		background.close();
+		background = null;
+		selectedBackground.close();
+		selectedBackground = null;
+		
+		for (Row row : rows)
+			row.close();
+	}
 
 	@Override
 	public MutableLiveObject<DSizing> getSizing() {
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		background.setRectangle(bounds);
 		
-		int drawX = bounds.x + style.padding;
-		int drawY = bounds.y + style.padding;
-		if (showRoot) {
-			paintNode(canvas, root, drawX, drawY);
-		} else {
-			for (N child : root.getChildren()) {
-				drawY = paintNode(canvas, child, drawX, drawY);
-				drawY += style.rowSpacing;
-			}
-		}
+		for (Row row : rows)
+			row.setBounds(bounds);
 	}
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		int row = yToRow(e.y);
-		if (row >= 0 && row < rows.size()) {
-			Row rowEntry = rows.get(row);
+		int rowIndex = yToRow(e.y);
+		if (rowIndex >= 0 && rowIndex < rows.size()) {
+			Row rowEntry = rows.get(rowIndex);
 			if (e.x >= rowEntry.x && e.x < (rowEntry.x + nodeOpenedIcon.getNominalWidth())) {
 				if (!rowEntry.node.isLeaf())
 					rowEntry.node.isCollapsed().toggle();
 			
 			rowEntry.node.onMouseClick(e);
 			
-			if (e.isSingleClick()) {
-				int oldRow = selectedRow;
-				selectedRow = row;
-				selectedNode = rows.get(row).node;
-
-				if (oldRow >= 0)
+			if (e.isSingleClick() && rowIndex != selectedRow) {
+				int oldRowIndex = selectedRow;
+				
+				selectedRow = rowIndex;
+				Row row = rows.get(rowIndex);
+				selectedNode = row.node;
+				
+				int selectionX = bounds.x + style.padding + row.x - style.selectedPaddingLeft;
+				int selectionY = bounds.y + style.padding + rowIndex * (style.rowSpacing + fontMetrics.getAscent() + fontMetrics.getDescent()) - style.selectedPaddingTop;
+				int selectionWidth = (int)(fontMetrics.getWidth(row.node.getTitle())
+						+ style.iconTextSpacing
+						+ row.icon.getNominalWidth()
+						+ style.iconTextSpacing
+						+ row.node.getIcon().getNominalWidth()
+						+ style.selectedPaddingLeft
+						+ style.selectedPaddingRight);
+				int selectionHeight = fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom;
+				
+				if (row.node.isLeaf()) {
+					int delta = (int)(row.icon.getNominalWidth() + style.iconTextSpacing);
+					selectionX += delta;
+					selectionWidth -= delta;
+				}
+				
+				selectedBackground.setRectangle(new DIRectangle(
+						selectionX,
+						selectionY,
+						selectionWidth,
+						selectionHeight));
+				selectedBackground.setColor(style.selectedBackgroundColor);
+				row.text.setColor(style.selectedNodeTextColor);
+				row.nodeIcon.setColor(style.selectedNodeTextColor);
+				
+				if (oldRowIndex >= 0) {
 					surface.repaint(
 							bounds.x,
-							rowToY(oldRow) - style.selectedPaddingTop,
+							rowToY(oldRowIndex) - style.selectedPaddingTop,
 							bounds.width,
 							fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom);
+					Row oldRow = rows.get(oldRowIndex);
+					oldRow.text.setColor(style.nodeTextColor);
+					oldRow.nodeIcon.setColor(style.nodeTextColor);
+				}
 				surface.repaint(
 						bounds.x,
-						rowToY(row) - style.selectedPaddingTop,
+						rowToY(rowIndex) - style.selectedPaddingTop,
 						bounds.width,
 						fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom);
 			}
 		return (y - bounds.y - style.padding) / (style.rowSpacing + fontMetrics.getAscent() + fontMetrics.getDescent());
 	}
 	
-	private int paintNode(DCanvas canvas, N node, int drawX, int drawY) {
-		int textColor = style.nodeTextColor;
-		if (node == selectedNode) {
-			textColor = style.selectedNodeTextColor;
-			canvas.fillRectangle(
-					bounds.x,
-					drawY - style.selectedPaddingTop,
-					bounds.width,
-					fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom,
-					style.selectedBackgroundColor);
-		}
-		
-		int drawingX = drawX;
-		if (!node.isLeaf()) {
-			DDrawable icon = node.isCollapsed().getValue() ? nodeClosedIcon : nodeOpenedIcon;
-			icon.draw(canvas, DTransform2D.translate(drawingX, drawY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()));
-			drawingX += style.iconTextSpacing + icon.getNominalWidth();
-		} else {
-			drawingX += style.iconTextSpacing + nodeClosedIcon.getNominalWidth();
-		}
-		node.getIcon().draw(canvas, DTransform2D.translate(drawingX, drawY + fontMetrics.getAscent() + fontMetrics.getDescent() - node.getIcon().getNominalHeight()), textColor);
-		drawingX += style.iconTextSpacing + node.getIcon().getNominalWidth();
-		canvas.drawText(style.font, textColor, drawingX, drawY + fontMetrics.getAscent(), node.getTitle());
-		drawY += fontMetrics.getAscent() + fontMetrics.getDescent();
-		
-		if (!node.isCollapsed().getValue()) {
-			for (N child : node.getChildren()) {
-				drawY += style.rowSpacing;
-				drawY = paintNode(canvas, child, drawX + style.indent, drawY);
-			}
-		}
-		
-		return drawY;
-	}
-	
 	private void updateLayout() {
 		int oldRowCount = rows.size();
 		
 	}
 	
 	private void updateLayout(N node, int x) {
-		rows.add(new Row(x, node));
+		rows.add(new Row(x, rows.size(), node));
 		
 		if (!node.isCollapsed().getValue()) {
 			for (N child : node.getChildren()) {
 	
 	private class Row implements Closeable, LiveBool.Listener, LiveList.Listener<N> {
 		private final int x;
+		private final int index;
 		private final N node;
+		private final DDrawable icon;
 		private final ListenerHandle<LiveBool.Listener> collapseListener;
 		private final ListenerHandle<LiveList.Listener<N>> childListener;
 		
-		public Row(int x, N node) {
+		private DDrawnText text;
+		private DDrawableInstance collapseIcon = null;
+		private DColorableIconInstance nodeIcon;
+		
+		public Row(int x, int index, N node) {
 			this.x = x;
+			this.index = index;
 			this.node = node;
 			this.collapseListener = node.isCollapsed().addListener(this);
 			this.childListener = node.getChildren().addListener(this);
+			
+			int baseX = bounds.x + style.padding + x;
+			int baseY = (int)(bounds.y + style.padding + index * (fontMetrics.getAscent() + fontMetrics.getDescent() + style.rowSpacing));
+			
+			icon = node.isCollapsed().getValue() ? nodeClosedIcon : nodeOpenedIcon;
+			nodeIcon = new DColorableIconInstance(
+					surface,
+					z + 2,
+					node.getIcon(),
+					DTransform2D.translate(baseX + icon.getNominalWidth() + style.iconTextSpacing, baseY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()),
+					style.nodeTextColor);
+			
+			if (!node.isLeaf())
+				collapseIcon = new DDrawableInstance(
+						surface, 
+						z + 2,
+						icon,
+						DTransform2D.translate(baseX, baseY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()));
+			
+			text = surface.drawText(
+					z + 2,
+					style.font,
+					style.nodeTextColor,
+					baseX + style.iconTextSpacing + icon.getNominalWidth() + style.iconTextSpacing + node.getIcon().getNominalWidth(),
+					baseY + fontMetrics.getAscent(),
+					node.getTitle());
+		}
+		
+		public void setBounds(DIRectangle bounds) {
+			int baseX = bounds.x + style.padding + x;
+			int baseY = (int)(bounds.y + style.padding + index * (fontMetrics.getAscent() + fontMetrics.getDescent() + style.rowSpacing));
+			
+			if (collapseIcon != null) {
+				collapseIcon.setTransform(DTransform2D.translate(
+						baseX,
+						baseY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()));
+			}
+			nodeIcon.setTransform(DTransform2D.translate(
+					baseX + icon.getNominalWidth() + style.iconTextSpacing,
+					baseY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()));
+			text.setPosition(
+					baseX + style.iconTextSpacing + icon.getNominalWidth() + style.iconTextSpacing + node.getIcon().getNominalWidth(),
+					baseY + fontMetrics.getAscent());
 		}
 
 		@Override
 		public void onChanged(boolean oldValue, boolean newValue) {
 			updateLayout();
-			surface.repaint(bounds);
 		}
 
 		@Override
 		public void onInserted(int index, N value) {
 			updateLayout();
-			surface.repaint(bounds);
 		}
 
 		@Override
 		public void onChanged(int index, N oldValue, N newValue) {
 			updateLayout();
-			surface.repaint(bounds);
 		}
 
 		@Override
 		public void onRemoved(int index, N oldValue) {
 			updateLayout();
-			surface.repaint(bounds);
 		}
 		
 		@Override
 		public void close() {
 			collapseListener.close();
 			childListener.close();
+			
+			text.close();
+			nodeIcon.close();
+			
+			if (collapseIcon != null)
+				collapseIcon.close();
 		}
 	}
 }

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

 	public final int selectedBackgroundColor;
 	public final int selectedPaddingTop;
 	public final int selectedPaddingBottom;
+	public final int selectedPaddingLeft;
+	public final int selectedPaddingRight;
 
 	public DTreeViewStyle(DStyleDefinition style) {
 		backgroundColor = style.getColor("backgroundColor", 0);
 		borderColor = style.getColor("borderColor", 0xFF888888);
 		padding = style.getDimension("padding", new DDpDimension(3));
 		rowSpacing = style.getDimension("rowSpacing", new DDpDimension(2));
-		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, context.sp(12.5f)));
+		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, context.sp(13)));
 		indent = style.getDimension("indent", new DDpDimension(12));
 		iconTextSpacing = style.getDimension("iconTextSpacing", new DDpDimension(2));
 		nodeTextColor = style.getColor("nodeTextColor", 0xFF000000);
 		selectedBackgroundColor = style.getColor("selectedBackgroundColor", 0xFF007ACC);
 		selectedPaddingTop = style.getDimension("selectedPaddingTop", new DDpDimension(1));
 		selectedPaddingBottom = style.getDimension("selectedPaddingBottom", new DDpDimension(1));
+		selectedPaddingLeft = style.getDimension("selectedPaddingLeft", new DDpDimension(2));
+		selectedPaddingRight = style.getDimension("selectedPaddingRight", new DDpDimension(2));
 	}
 }

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 /**
  *
 		ExpandedColoredArrow.INSTANCE.draw(canvas, transform, 0xFF000000);
 	}
 
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform) {
+		ExpandedColoredArrow.INSTANCE.draw(target, z, transform, 0xFF000000);
+	}
+
 	@Override
 	public float getNominalWidth() {
 		return 24;

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ExpandedColoredArrow implements DColorableIcon {
 	public static final ExpandedColoredArrow INSTANCE = new ExpandedColoredArrow();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH_0, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH_0, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

DrawableGuiIconConverter/src/main/java/org/openzen/drawablegui/iconconverter/Main.java

 		output.append("import org.openzen.drawablegui.DPath;\n");
 		output.append("import org.openzen.drawablegui.DTransform2D;\n");
 		output.append("import org.openzen.drawablegui.DColorableIcon;\n");
+		output.append("import org.openzen.drawablegui.draw.DDrawTarget;\n");
 		output.append("\n");
 		output.append("public class ").append(className).append(" implements DColorableIcon {\n");
 		output.append("\tpublic static final ").append(className).append(" INSTANCE = new ").append(className).append("();\n");
 		output.append("\t}\n");
 		output.append("\n");
 		output.append("\t@Override\n");
+		output.append("\tpublic void draw(DDrawTarget target, int z, DTransform2D transform) {\n");
+		for (String pathName : pathNames) {
+			output.append("\t\target.fillPath(z, ").append(pathName).append(", transform, DDrawTarget.INSTANCE_COLOR);\n");
+		}
+		output.append("\t}\n");
+		output.append("\n");
+		output.append("\t@Override\n");
 		output.append("\tpublic float getNominalWidth() {\n");
 		output.append("\t\treturn ").append(width).append(";\n");
 		output.append("\t}\n");

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 import org.openzen.drawablegui.style.DShadow;
 
 public class AddBoxIcon implements DColorableIcon {
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.shadowPath(PATH, transform, color, new DShadow(0xFF999999, 0, 1, 6));
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 import org.openzen.drawablegui.style.DShadow;
 
 public class BuildIcon implements DColorableIcon {
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.shadowPath(PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.shadowPath(z, PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ChevronRight implements DColorableIcon {
 	public static final ChevronRight INSTANCE = new ChevronRight();
 	
 	private ChevronRight() {}
 	
-	private static final DPath PATH_0 = tracer -> {
+	private static final DPath PATH = tracer -> {
 		tracer.moveTo(10f, 6f);
 		tracer.lineTo(8.59f, 7.41f);
 		tracer.lineTo(13.17f, 12f);
 	
 	@Override
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
-		canvas.fillPath(PATH_0, transform, color);
+		canvas.fillPath(PATH, transform, color);
+	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
 	}
 
 	@Override

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class CloseIcon implements DColorableIcon {
 	public static final CloseIcon INSTANCE = new CloseIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class CodeIcon implements DColorableIcon {
 	public static final CodeIcon INSTANCE = new CodeIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 /**
  *
 		icon.draw(canvas, transform, color);
 	}
 
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform) {
+		icon.draw(target, z, transform, color);
+	}
+
 	@Override
 	public float getNominalWidth() {
 		return icon.getNominalWidth();

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class FolderIcon implements DColorableIcon {
 	public static final FolderIcon INSTANCE = new FolderIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class LibraryIcon implements DColorableIcon {
 	public static final LibraryIcon INSTANCE = new LibraryIcon();
 	
 	private LibraryIcon() {}
 	
-	private static final DPath PATH_0 = tracer -> {
+	private static final DPath PATH = tracer -> {
 		tracer.moveTo(20.54f, 5.23f);
 		tracer.lineTo(19.15f, 3.55f);
 		tracer.bezierCubic(18.88f, 3.21f, 18.47f, 3.0f, 18.0f, 3.0f);
 	
 	@Override
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
-		canvas.fillPath(PATH_0, transform, color);
+		canvas.fillPath(PATH, transform, color);
+	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
 	}
 
 	@Override

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ModuleIcon implements DColorableIcon {
 	public static final ModuleIcon INSTANCE = new ModuleIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 import org.openzen.drawablegui.style.DShadow;
 
 public class PlayIcon implements DColorableIcon {
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.shadowPath(PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.shadowPath(z, PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ProjectIcon implements DColorableIcon {
 	public static final ProjectIcon INSTANCE = new ProjectIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class SaveIcon implements DColorableIcon {
 	public static final SaveIcon INSTANCE = new SaveIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ScalableCloseIcon implements DColorableIcon {
 	private final DPath path;
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.strokePath(path, transform, color, 1);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.strokePath(z, path, transform, color, 1);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ScalableMaximizeIcon implements DColorableIcon {
 	private final DPath path;
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.strokePath(path, transform, color, 1);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.strokePath(z, path, transform, color, 1);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 /**
  *
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.strokePath(path, transform, color, 1);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.strokePath(z, path, transform, color, 1);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 import org.openzen.drawablegui.style.DShadow;
 
 public class SettingsIcon implements DColorableIcon {
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.shadowPath(PATH, transform, color, new DShadow(0xFF888888, 0, 1, 4));
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ShadedCodeIcon implements DColorableIcon {
 	public static final ShadedCodeIcon INSTANCE = new ShadedCodeIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 
 public class ShadedProjectIcon implements DColorableIcon {
 	public static final ShadedProjectIcon INSTANCE = new ShadedProjectIcon();
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.fillPath(PATH, transform, color);
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.draw.DDrawTarget;
 import org.openzen.drawablegui.style.DShadow;
 
 public class ShadedSaveIcon implements DColorableIcon {
 	public void draw(DCanvas canvas, DTransform2D transform, int color) {
 		canvas.shadowPath(PATH, transform, color, new DShadow(0xFFCCCCCC, 0, 1, 4));
 	}
+	
+	@Override
+	public void draw(DDrawTarget target, int z, DTransform2D transform, int color) {
+		target.fillPath(z, PATH, transform, color);
+	}
 
 	@Override
 	public float getNominalWidth() {

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

 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DDrawableInstance;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DSimpleTooltip;
 import org.openzen.drawablegui.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.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 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 DSimpleTooltip tooltip;
 	
 	private DDrawSurface surface;
+	private int z;
 	private IconButtonControlStyle style;
 	private DIRectangle bounds;
 	private final MutableLiveObject<DSizing> preferences = DSizing.create();
 	private boolean hover;
 	private boolean press;
-	private DPath shape;
+	
+	private DShadow shadow;
+	private DDrawnShape shape;
+	private DDrawableInstance drawnIcon;
 	
 	public IconButtonControl(DStyleClass styleClass, DDrawable icon, DDrawable iconDisabled, LiveBool disabled, LiveString tooltip, Consumer<DMouseEvent> onClick) {
 		this.styleClass = styleClass;
 		this.onClick = onClick;
 		this.disabled = disabled;
 		this.tooltip = new DSimpleTooltip(DStyleClass.EMPTY, tooltip);
-		disabledListener = disabled.addListener((oldValue, newValue) -> repaint());
+		disabledListener = disabled.addListener((oldValue, newValue) -> onDisabledChanged(newValue));
 	}
 	
 	public IconButtonControl(DStyleClass styleClass, DDrawable icon, LiveString tooltip, Consumer<DMouseEvent> onClick) {
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
+		this.z = z;
+		
 		tooltip.setContext(surface.getContext());
 		
 		DStylePath path = parent.getChild("iconbutton", styleClass);
 		if (bounds != null)
 			setBounds(bounds);
 	}
+	
+	@Override
+	public void unmount() {
+		if (shape != null)
+			shape.close();
+		if (drawnIcon != null)
+			drawnIcon.close();
+	}
 
 	@Override
 	public LiveObject<DSizing> getSizing() {
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
-		if (surface != null)
-			shape = DPath.roundedRectangle(
-					bounds.x + style.margin,
-					bounds.y + style.margin,
-					bounds.width - 2 * style.margin,
-					bounds.height - 2 * style.margin,
-					style.roundingRadius);
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		if (disabled.getValue()) {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorDisabled, style.shadowDisabled);
-		} else if (press) {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorPress, style.shadowPress);
-		} else if (hover) {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorHover, style.shadowHover);
-		} else {
-			canvas.shadowPath(shape, DTransform2D.IDENTITY, style.colorNormal, style.shadowNormal);
-		}
+		if (shape != null)
+			shape.close();
 		
-		DDrawable icon = disabled.getValue() ? iconDisabled : this.icon;
-		icon.draw(canvas, DTransform2D.scaleAndTranslate(
-				bounds.x + (bounds.width - icon.getNominalWidth() * surface.getScale()) / 2,
-				bounds.y + (bounds.height - icon.getNominalHeight() * surface.getScale()) / 2,
-				surface.getScale()));
+		shadow = getShadow();
+		shape = surface.shadowPath(z, DPath.roundedRectangle(
+				bounds.x + style.margin,
+				bounds.y + style.margin,
+				bounds.width - 2 * style.margin,
+				bounds.height - 2 * style.margin,
+				style.roundingRadius), DTransform2D.IDENTITY, getColor(), shadow);
+		
+		onDisabledChanged(disabled.getValue());
 	}
 
 	@Override
 	public void close() {
 		disabledListener.close();
+		unmount();
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hover = true;
-		repaint();
+		update();
 		tooltip.onTargetMouseEnter(e);
 	}
 	
 	public void onMouseExit(DMouseEvent e) {
 		hover = false;
 		press = false;
-		repaint();
+		update();
 		tooltip.onTargetMouseExit(e);
 	}
 	
 	@Override
 	public void onMouseDown(DMouseEvent e) {
 		press = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseRelease(DMouseEvent e) {
 		press = false;
-		repaint();
+		update();
 	}
 	
 	@Override
 		onClick.accept(e);
 	}
 	
-	private void repaint() {
-		if (surface == null || bounds == null)
-			return;
+	private void onDisabledChanged(boolean disabled) {
+		DDrawable icon = disabled ? iconDisabled : this.icon;
+		
+		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()));
+	}
+	
+	private void update() {
+		DShadow newShadow = getShadow();
+		if (newShadow != shadow) {
+			if (shape != null)
+				shape.close();
+			
+			shadow = newShadow;
+			shape = surface.shadowPath(z, DPath.roundedRectangle(
+					bounds.x + style.margin,
+					bounds.y + style.margin,
+					bounds.width - 2 * style.margin,
+					bounds.height - 2 * style.margin,
+					style.roundingRadius), DTransform2D.IDENTITY, getColor(), shadow);
+		} else {
+			shape.setColor(getColor());
+		}
+	}
+	
+	private int getColor() {
+		if (disabled.getValue())
+			return style.colorDisabled;
+		if (press)
+			return style.colorPress;
+		if (hover)
+			return style.colorHover;
+		
+		return style.colorNormal;
+	}
+	
+	private DShadow getShadow() {
+		if (disabled.getValue())
+			return style.shadowDisabled;
+		if (press)
+			return style.shadowPress;
+		if (hover)
+			return style.shadowHover;
 		
-		surface.repaint(bounds);
+		return style.shadowNormal;
 	}
 }

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

 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 DFontMetrics fontMetrics;
 
 	private DDrawnShape shape;
+	private DDrawnText text;
 	
 	public StatusBarView(DStyleClass styleClass, LiveString content) {
 		this.styleClass = styleClass;
 	}
 	
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
 		this.z = z;
 		
 		fontMetrics = surface.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());
+	}
+	
+	@Override
+	public void unmount() {
+		if (shape != null)
+			shape.close();
+		if (text != null)
+			text.close();
 	}
 	
 	@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);
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		canvas.drawText(
-				style.font,
-				style.textColor,
-				bounds.x + style.paddingLeft,
-				bounds.y + style.paddingTop + fontMetrics.getAscent(), content.getValue());
+		text.setPosition(bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent());
 	}
 
 	@Override
 	public void close() {
-		// nothing to clean up
+		unmount();
 	}
 }

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

 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveArrayList;
 	private final LiveList<TabbedViewTab> tabComponents = new LiveMappedList<>(tabs, tab -> {
 		TabbedViewTab result = new TabbedViewTab(this, currentTab, tab);
 		if (surface != null)
-			result.setSurface(path, z + 2, surface);
+			result.mount(path, z + 2, surface);
 		
 		tabSizeListeners.put(result, result.getSizing().addListener((oldSize, newSize) -> layoutTabs()));
 		return result;
 		tabs.addListener(new TabListListener());
 		
 		currentTab.addListener((oldValue, newValue) -> {
-			if (oldValue != null)
+			if (oldValue != null) {
 				oldValue.content.onUnmounted();
-			if (newValue != null)
+				oldValue.content.unmount();
+			}
+			if (newValue != null) {
 				newValue.content.onMounted();
+				newValue.content.mount(path, z + 1, surface);
+			}
 			
 			if (newValue != null && bounds != null) {
 				DIRectangle contentBounds = new DIRectangle(
 	}
 	
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
 		this.z = z;
 		
 		for (TabbedViewComponent tab : tabs)
 			prepare(tab);
 	}
+	
+	@Override
+	public void unmount() {
+		for (TabbedViewComponent tab : tabs)
+			tab.content.unmount();
+		for (TabbedViewTab tab : tabComponents)
+			tab.unmount();
+	}
 
 	@Override
 	public LiveObject<DSizing> getSizing() {
 		layoutTabs();
 	}
 
-	@Override
-	public void paint(DCanvas canvas) {
-		for (DComponent component : tabComponents)
-			component.paint(canvas);
-		
-		if (currentTab.getValue() != null)
-			currentTab.getValue().content.paint(canvas);
-	}
-
 	@Override
 	public void close() {
 		for (Map.Entry<TabbedViewTab, ListenerHandle<LiveObject.Listener<DSizing>>> entry : tabSizeListeners.entrySet()) {
 			entry.getValue().close();
 		}
+		
+		for (TabbedViewComponent tab : tabs)
+			tab.content.close();
+		for (TabbedViewTab tab : tabComponents)
+			tab.close();
 	}
 	
 	private void repaintTabs() {
 	}
 	
 	private void prepare(TabbedViewComponent tab) {
-		tab.content.setSurface(path, z + 1, surface);
+		tab.content.mount(path, z + 1, surface);
 	}
 	
 	private void layoutTabs() {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.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.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 	public final TabbedViewTabClose closeButton;
 	
 	private DDrawSurface surface;
+	private int z;
 	private TabbedViewTabStyle style;
 	private DFontMetrics fontMetrics;
 	private int textWidth;
 	
 	private final ListenerHandle<LiveString.Listener> titleListener;
 	private final ListenerHandle<LiveBool.Listener> updatedListener;
+	private final ListenerHandle<LiveObject.Listener<TabbedViewComponent>> currentTabListener;
 	
 	private boolean hover;
 	private boolean press;
 	
+	private DDrawnShape shape;
+	private DDrawnShape updated;
+	private DDrawnText text;
+	
 	public TabbedViewTab(TabbedView parent, MutableLiveObject<TabbedViewComponent> currentTab, TabbedViewComponent tab) {
 		this.parent = parent;
 		this.currentTab = currentTab;
 		
 		titleListener = tab.title.addListener((oldValue, newValue) -> calculateSizing());
 		updatedListener = tab.updated.addListener((oldValue, newValue) -> calculateSizing());
+		currentTabListener = currentTab.addListener((oldTab, newTab) -> update());
 	}
 	
 	public void closeTab() {
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
+		this.z = z;
+		
 		DStylePath path = parent.getChild("tab", DStyleClass.EMPTY);
 		style = new TabbedViewTabStyle(surface.getStylesheet(path));
 		fontMetrics = surface.getFontMetrics(style.tabFont);
-		closeButton.setSurface(path, z + 1, surface);
+		closeButton.mount(path, z + 1, surface);
 		
+		text = surface.drawText(z + 1, style.tabFont, style.tabFontColor, 0, 0, tab.title.getValue());
 		calculateSizing();
 	}
 	
+	@Override
+	public void unmount() {
+		if (shape != null)
+			shape.close();
+		if (updated != null)
+			updated.close();
+		if (text != null)
+			text.close();
+		
+		closeButton.close();
+		style.border.close();
+	}
+	
 	private void calculateSizing() {
 		textWidth = fontMetrics.getWidth(tab.title.getValue());
 		
-		int width = style.paddingLeft + textWidth + style.paddingRight
+		int width = style.border.getPaddingHorizontal() + textWidth
 						+ style.closeIconPadding
 						+ closeButton.getSizing().getValue().preferredWidth;
-		
 		if (tab.updated.getValue()) {
 			width += style.updatedDiameter + style.updatedPadding;
 		}
 		
 		sizing.setValue(new DSizing(
 				width,
-				style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent()
-						+ style.paddingBottom));
+				style.border.getPaddingHorizontal() + fontMetrics.getAscent() + fontMetrics.getDescent()));
 	}
 
 	@Override
 		this.bounds = bounds;
 		
 		DSizing close = closeButton.getSizing().getValue();
+		style.border.update(surface, z + 1, style.margin.apply(bounds));
+		
 		closeButton.setBounds(new DIRectangle(
-				bounds.x + bounds.width - close.preferredWidth - style.paddingRight,
+				bounds.x + bounds.width - close.preferredWidth - style.border.getPaddingRight(),
 				bounds.y + (bounds.height - close.preferredHeight) / 2,
 				close.preferredWidth,
 				close.preferredHeight));
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		int width = style.paddingLeft + textWidth + style.paddingRight
-				+ closeButton.getSizing().getValue().preferredWidth + style.closeIconPadding;
-		
-		if (tab.updated.getValue())
-			width += style.updatedDiameter + style.updatedPadding;
-
-		int color = style.tabColorNormal;
-		if (currentTab.getValue() == tab)
-			color = style.tabColorActive;
-		else if (press)
-			color = style.tabColorPress;
-		else if (hover)
-			color = style.tabColorHover;
-
-		canvas.fillRectangle(bounds.x, bounds.y, width, bounds.height, color);
-		canvas.strokePath(DPath.rectangle(bounds.x, bounds.y, width, bounds.height), DTransform2D.IDENTITY, style.borderColor, style.borderWidth);
 		
-		canvas.drawText(style.tabFont, style.tabFontColor, bounds.x + style.paddingLeft, bounds.y + style.paddingTop + fontMetrics.getAscent(), tab.title.getValue());
+		if (shape != null)
+			shape.close();
+		shape = surface.shadowPath(z, 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()) {
-			canvas.fillPath(
+			if (updated != null)
+				updated.close();
+			updated = surface.fillPath(
+					z + 1,
 					DPath.circle(
-						bounds.x + bounds.width - style.paddingRight - closeButton.getBounds().width - style.closeIconPadding - style.updatedDiameter / 2,
-						bounds.y + style.paddingTop + ((bounds.height - style.paddingTop - style.paddingBottom) / 2), style.updatedDiameter / 2),
+						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),
 					DTransform2D.IDENTITY,
 					style.updatedColor);
+		} else {
+			if (updated != null) {
+				updated.close();
+				updated = null;
+			}
 		}
-		
-		closeButton.paint(canvas);
 	}
 
 	@Override
 	public void close() {
 		titleListener.close();
 		updatedListener.close();
+		
+		unmount();
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hover = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
 		hover = false;
 		press = false;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseDown(DMouseEvent e) {
 		press = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseRelease(DMouseEvent e) {
 		press = false;
-		repaint();
+		update();
 	}
 	
 	@Override
 		currentTab.setValue(tab);
 	}
 	
-	private void repaint() {
-		if (surface != null && bounds != null)
-			surface.repaint(bounds);
+	private void update() {
+		if (style == null || shape == null)
+			return;
+		
+		int color = style.tabColorNormal;
+		if (currentTab.getValue() == tab)
+			color = style.tabColorActive;
+		else if (press)
+			color = style.tabColorPress;
+		else if (hover)
+			color = style.tabColorHover;
+		shape.setColor(color);
 	}
 }

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

  */
 package org.openzen.zenscript.ide.ui.view;
 
-import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.DColorableIconInstance;
 import org.openzen.drawablegui.DComponent;
 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;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DDrawSurface surface;
+	private int z;
 	private DIRectangle bounds;
 	private TabbedViewTabCloseStyle style;
 	private DColorableIcon icon;
 	private boolean hover;
 	private boolean press;
 	
+	private DDrawnRectangle background;
+	private DColorableIconInstance drawnIcon;
+	
 	public TabbedViewTabClose(TabbedViewTab tab) {
 		this.tab = tab;
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	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));
 		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);
+		if (drawnIcon != null)
+			drawnIcon.close();
+		drawnIcon = new DColorableIconInstance(surface, z + 1, icon, DTransform2D.IDENTITY, 0xFF000000);
+	}
+	
+	@Override
+	public void unmount() {
+		if (background != null)
+			background.close();
+		if (drawnIcon != null)
+			drawnIcon.close();
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		if (hover) {
-			canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 0xFFE81123);
-		}
 		
-		icon.draw(canvas, DTransform2D.translate(
+		background.setRectangle(bounds);
+		
+		if (drawnIcon != null)
+			drawnIcon.close();
+		drawnIcon = new DColorableIconInstance(surface, z + 1, icon, DTransform2D.translate(
 				bounds.x + (bounds.width - icon.getNominalWidth()) / 2,
-				bounds.y + (bounds.height - icon.getNominalHeight()) / 2),
-				hover ? 0xFFFFFFFF : 0xFF000000);
+				bounds.y + (bounds.height - icon.getNominalHeight()) / 2), 0xFF000000);
+		/*drawnIcon.setTransform(DTransform2D.translate(
+				bounds.x + (bounds.width - icon.getNominalWidth()) / 2,
+				bounds.y + (bounds.height - icon.getNominalHeight()) / 2));*/
 	}
 
 	@Override
 	public void close() {
-		
+		unmount();
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hover = true;
-		surface.repaint(bounds);
+		background.setColor(0xFFE81123);
+		drawnIcon.setColor(0xFFFFFFFF);
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
 		hover = false;
-		surface.repaint(bounds);
+		background.setColor(0);
+		drawnIcon.setColor(0xFF000000);
 	}
 	
 	@Override

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

 
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
+import org.openzen.drawablegui.border.DCompositeBorder;
+import org.openzen.drawablegui.border.DLineBorder;
+import org.openzen.drawablegui.border.DPaddedBorder;
+import org.openzen.drawablegui.style.DBaseStyle;
 import org.openzen.drawablegui.style.DDpDimension;
 import org.openzen.drawablegui.style.DPxDimension;
 import org.openzen.drawablegui.style.DStyleDefinition;
  *
  * @author Hoofdgebruiker
  */
-public class TabbedViewTabStyle {
+public class TabbedViewTabStyle extends DBaseStyle {
 	public final DFont tabFont;
 	public final int tabFontColor;
 	
 	public final int tabColorPress;
 	public final int tabColorActive;
 	
-	public final int paddingTop;
-	public final int paddingBottom;
-	public final int paddingLeft;
-	public final int paddingRight;
-	
-	public final int borderColor;
-	public final int borderWidth;
-	
 	public final int closeIconSize;
 	public final int closeIconPadding;
 	
 	public final int updatedColor;
 	
 	public TabbedViewTabStyle(DStyleDefinition style) {
+		super(style, context -> new DCompositeBorder(new DLineBorder(0xFF888888, 1), new DPaddedBorder(context.dp(4))), 0);
 		tabFont = style.getFont("tabFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(12 * context.getScale())));
 		tabFontColor = style.getColor("tabFontColor", 0xFF000000);
 		
 		tabColorPress = style.getColor("tabColorPress", 0xFFF0F0F0);
 		tabColorActive = style.getColor("tabColorActive", 0xFFFFFFFF);
 		
-		paddingTop = style.getDimension("paddingTop", new DDpDimension(4));
-		paddingBottom = style.getDimension("paddingTop", new DDpDimension(4));
-		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(4));
-		paddingRight = style.getDimension("paddingRight", new DDpDimension(4));
-		
-		borderColor = style.getColor("borderColor", 0xFF888888);
-		borderWidth = style.getDimension("borderWidth", new DPxDimension(1));
-		
 		closeIconSize = style.getDimension("closeIconSize", new DDpDimension(16));
 		closeIconPadding = style.getDimension("closeIconPadding", new DDpDimension(6));
 		

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

 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DDrawableInstance;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 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.LiveBool;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final Consumer<DMouseEvent> onClick;
 	private DDrawSurface surface;
+	private int z;
 	private AspectBarSelectorButtonStyle style;
 	private DIRectangle bounds = DIRectangle.EMPTY;
-	private DPath shape;
+	private DDrawnShape shape;
+	private DShadow shadow;
+	private DDrawableInstance iconInstance;
+	
 	private boolean hovering;
 	private boolean pressing;
 	private final DSimpleTooltip tooltip;
 		this.onClick = onClick;
 		this.tooltip = new DSimpleTooltip(DStyleClass.EMPTY, new ImmutableLiveString(tooltip));
 		
-		activeListener = active.addListener((oldValue, newValue) -> repaint());
+		activeListener = active.addListener((oldValue, newValue) -> update());
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	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));
 		sizing.setValue(new DSizing(style.width, style.height));
-		shape = DPath.roundedRectangle(
-				0,
-				0,
-				style.width,
-				style.height,
-				style.roundingRadius);
 		
 		tooltip.setContext(surface.getContext());
 	}
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		int color = style.colorNormal;
-		DShadow shadow = style.shadowNormal;
-		if (active.getValue()) {
-			color = style.colorActive;
-			shadow = style.shadowActive;
-		} else if (pressing) {
-			color = style.colorPress;
-			shadow = style.shadowPress;
-		} else if (hovering) {
-			color = style.colorHover;
-			shadow = style.shadowHover;
-		}
 		
-		canvas.shadowPath(
-					shape,
-					DTransform2D.translate(bounds.x, bounds.y),
-					color,
-					shadow);
-		icon.draw(canvas, DTransform2D.scaleAndTranslate(
+		if (shape != null)
+			shape.close();
+		
+		shadow = getShadow();
+		shape = surface.shadowPath(
+				z,
+				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.roundingRadius),
+				DTransform2D.IDENTITY,
+				getColor(),
+				shadow);
+		
+		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()));
 	}
 	
+	@Override
+	public void unmount() {
+		if (shape != null)
+			shape.close();
+		if (iconInstance != null)
+			iconInstance.close();
+		
+		tooltip.close();
+	}
+	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hovering = true;
 		tooltip.onTargetMouseEnter(e);
-		repaint();
+		update();
 	}
 	
 	@Override
 		hovering = false;
 		pressing = false;
 		tooltip.onTargetMouseExit(e);
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseDown(DMouseEvent e) {
 		pressing = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 			onClick.accept(e);
 		
 		pressing = false;
-		repaint();
+		update();
 	}
 
 	@Override
 	public void close() {
 		activeListener.close();
 		tooltip.close();
+		
+		unmount();
+	}
+	
+	private void update() {
+		if (surface == null)
+			return;
+		
+		DShadow newShadow = getShadow();
+		if (newShadow != shadow) {
+			shadow = newShadow;
+			
+			if (shape != null)
+				shape.close();
+			
+			shape = surface.shadowPath(
+				z,
+				DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.roundingRadius),
+				DTransform2D.IDENTITY,
+				getColor(),
+				shadow);
+		} else {
+			shape.setColor(getColor());
+		}
 	}
 	
-	private void repaint() {
-		if (surface != null && bounds != null)
-			surface.repaint(bounds);
+	private DShadow getShadow() {
+		if (active.getValue())
+			return style.shadowActive;
+		if (pressing)
+			return style.shadowPress;
+		if (hovering)
+			return style.shadowHover;
+		
+		return style.shadowNormal;
+	}
+	
+	private int getColor() {
+		if (active.getValue())
+			return style.colorActive;
+		if (pressing)
+			return style.colorPress;
+		if (hovering)
+			return style.colorHover;
+		
+		return style.colorNormal;
 	}
 }

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

 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.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.drawablegui.live.LivePredicateBool;
 import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.zenscript.ide.ui.IDEAspectBarControl;
 	private DDrawnRectangle topBackground;
 	private DDrawnRectangle bottomBackground;
 	private DDrawnShape aspectBarShape;
+	private DDrawnText activeBarText;
+	private DDrawnRectangle activeBarSeparator;
+	
+	private DDrawnShape windowControlsBackground;
 	
 	public AspectBarView(DStyleClass styleClass, IDEAspectBar aspectBar) {
 		this.styleClass = styleClass;
 					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.setSurface(path, z + 1, surface);
+						button.mount(path, z + 1, surface);
 					
 					return button;
 				});
 	}
 	
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
 		this.z = z;
 		this.path = parent.getChild("aspectbar", styleClass);
 		sizing.setValue(new DSizing(0, style.height));
 		
 		for (DComponent selectorButton : selectorButtons)
-			selectorButton.setSurface(path, z + 2, surface);
+			selectorButton.mount(path, z + 2, surface);
 		
 		if (activeToolbarComponents != null)
 			for (DComponent component : activeToolbarComponents)
-				component.setSurface(path, z + 2, surface);
+				component.mount(path, z + 2, surface);
 		
-		minimize.setSurface(path, z + 2, surface);
-		maximizeRestore.setSurface(path, z + 2, surface);
-		close.setSurface(path, z + 2, surface);
+		minimize.mount(path, z + 2, surface);
+		maximizeRestore.mount(path, z + 2, surface);
+		close.mount(path, z + 2, surface);
 		
 		if (topBackground != null)
 			topBackground.close();
 		bottomBackground = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColorBottom);
 	}
 	
+	@Override
+	public void unmount() {
+		topBackground.close();
+		topBackground = null;
+		bottomBackground.close();
+		bottomBackground = null;
+		
+		aspectBarShape.close();
+		aspectBarShape = null;
+		activeBarText.close();
+		activeBarText = null;
+		activeBarSeparator.close();
+		activeBarSeparator = null;
+		
+		if (windowControlsBackground != null) {
+			windowControlsBackground.close();
+			windowControlsBackground = null;
+		}
+	}
+	
 	@Override
 	public LiveObject<DSizing> getSizing() {
 		return sizing;
 		
 		if (surface != null) {
 			layout();
+			setupActiveBarText();
 			surface.repaint(bounds);
 		}
 	}
 
-	@Override
-	public void paint(DCanvas canvas) {
-		canvas.pushBounds(bounds);
-		//canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
-		//canvas.fillRectangle(bounds.x, bounds.y + bounds.height - style.marginBottom, bounds.width, style.marginBottom, style.backgroundColorBottom);
-		
-		for (DComponent button : selectorButtons) {
-			if (button.getBounds() == null)
-				continue;
-			
-			button.paint(canvas);
-		}
-		
-		/*canvas.shadowPath(
-				aspectBarShape,
-				DTransform2D.IDENTITY,
-				style.foregroundColor,
-				style.aspectBarShadow);*/
-		
-		if (aspectBar.active.getValue() != null) {
-			int y = bounds.y
-					+ style.aspectBarPaddingTop
-					+ (int)(activeToolbarTitleFontMetrics.getAscent() * 0.35f)
-					+ (bounds.height - style.aspectBarPaddingTop) / 2;
-			int x = aspectSelectorEndX + style.aspectSelectorToToolbarSpacing;
-			canvas.drawText(style.activeToolbarTitleFont, style.activeToolbarTitleColor, x, y, aspectBar.active.getValue().title);
-			canvas.fillRectangle(
-					x + activeToolbarTitleFontMetrics.getWidth(aspectBar.active.getValue().title) + 8,
-					bounds.y + style.aspectBarPaddingTop + 8,
-					2,
-					bounds.height - style.aspectBarPaddingTop - 16,
-					0xFFCCCCCC);
-		}
-		
-		if (activeToolbarComponents != null) {
-			for (DComponent component : activeToolbarComponents)
-				component.paint(canvas);
-		}
-		
-		if (showWindowControls) {
-			canvas.shadowPath(windowControlsShape, DTransform2D.IDENTITY, style.backgroundColor, style.windowControlShadow);
-			minimize.paint(canvas);
-			maximizeRestore.paint(canvas);
-			close.paint(canvas);
-		}
-		
-		canvas.popBounds();
-	}
-
 	@Override
 	public void close() {
 		listener.close();
 		
-		topBackground.close();
-		bottomBackground.close();
+		minimizeRelayout.close();
+		maximizeRestoreRelayout.close();
+		closeRelayout.close();
+		unmount();
 	}
 	
 	private void onActiveChanged(IDEAspectToolbar previous, IDEAspectToolbar aspectBar) {
-		if (activeToolbarComponents != null)
+		if (activeToolbarComponents != null) {
+			for (DComponent component : activeToolbarComponents)
+				component.close();
+			
 			activeToolbarComponents.close();
+		}
 		
 		activeToolbarComponents = new LiveMappedList<>(aspectBar.controls, control -> {
 			DComponent result = control.instantiate();
 			if (surface != null)
-				result.setSurface(path, z + 2, surface);
+				result.mount(path, z + 2, surface);
 			return result;
 		});
 		
+		setupActiveBarText();
 		layoutActiveToolbarComponents();
 	}
 	
+	private void setupActiveBarText() {
+		if (bounds == null)
+			return;
+		
+		if (activeBarText != null) {
+			activeBarText.close();
+			activeBarText = null;
+		}
+		if (activeBarSeparator != null) {
+			activeBarSeparator.close();
+			activeBarSeparator = null;
+		}
+		if (aspectBar.active.getValue() == null)
+			return;
+		
+		int y = bounds.y
+				+ style.aspectBarPaddingTop
+				+ (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,
+				new DIRectangle(
+					x + activeBarText.getBounds().width + 8,
+					bounds.y + style.aspectBarPaddingTop + 8,
+					2,
+					bounds.height - style.aspectBarPaddingTop - 16),
+				0xFFCCCCCC);
+	}
+	
 	private void layout() {
 		if (bounds == null)
 			return;
 		layoutAspectSelectorButtons();
 		layoutActiveToolbarComponents();
 		
-		int x = bounds.x + bounds.width;
-		DSizing closeSize = close.getSizing().getValue();
-		DSizing maximizeRestoreSize = maximizeRestore.getSizing().getValue();
-		DSizing minimizeSize = minimize.getSizing().getValue();
+		if (showWindowControls) {
+			int x = bounds.x + bounds.width;
+			
+			DSizing closeSize = close.getSizing().getValue();
+			DSizing maximizeRestoreSize = maximizeRestore.getSizing().getValue();
+			DSizing minimizeSize = minimize.getSizing().getValue();
+			
+			x -= closeSize.preferredWidth;
+			close.setBounds(new DIRectangle(x, bounds.y, closeSize.preferredWidth, closeSize.preferredHeight));
+			x -= maximizeRestoreSize.preferredWidth;
+			maximizeRestore.setBounds(new DIRectangle(x, bounds.y, maximizeRestoreSize.preferredWidth, maximizeRestoreSize.preferredHeight));
+			x -= minimizeSize.preferredWidth;
+			minimize.setBounds(new DIRectangle(x, bounds.y, minimizeSize.preferredWidth, minimizeSize.preferredHeight));
+		}
 		
-		x -= closeSize.preferredWidth;
-		close.setBounds(new DIRectangle(x, bounds.y, closeSize.preferredWidth, closeSize.preferredHeight));
-		x -= maximizeRestoreSize.preferredWidth;
-		maximizeRestore.setBounds(new DIRectangle(x, bounds.y, maximizeRestoreSize.preferredWidth, maximizeRestoreSize.preferredHeight));
-		x -= minimizeSize.preferredWidth;
-		minimize.setBounds(new DIRectangle(x, bounds.y, minimizeSize.preferredWidth, minimizeSize.preferredHeight));
+		if (activeBarText != null) {
+			int activeBarY = bounds.y
+				+ style.aspectBarPaddingTop
+				+ (int)(activeToolbarTitleFontMetrics.getAscent() * 0.35f)
+				+ (bounds.height - style.aspectBarPaddingTop) / 2;
+			int activeBarX = aspectSelectorEndX + style.aspectSelectorToToolbarSpacing;
+			activeBarText.setPosition(activeBarX, activeBarY);
+			
+			activeBarSeparator.close();
+			activeBarSeparator = surface.fillRect(
+				z + 3,
+				new DIRectangle(
+					activeBarX + activeBarText.getBounds().width + 8,
+					bounds.y + style.aspectBarPaddingTop + 8,
+					2,
+					bounds.height - style.aspectBarPaddingTop - 16),
+				0xFFCCCCCC);
+		}
 		
 		calculateAspectBarShape();
+		
+		if (showWindowControls) {
+			if (windowControlsBackground != null)
+				windowControlsBackground.close();
+			
+			windowControlsBackground = surface.shadowPath(
+					z + 1,
+					windowControlsShape,
+					DTransform2D.IDENTITY,
+					style.backgroundColor,
+					style.windowControlShadow);
+		}
+		
 		surface.repaint(bounds);
 	}
 	

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

 import java.util.function.Function;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.DColorableIconInstance;
 import org.openzen.drawablegui.DComponent;
 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;
 	private boolean hover;
 	private boolean press;
 	private DDrawSurface surface;
+	private int z;
+	
+	private DDrawnRectangle background;
+	private DColorableIconInstance drawnIcon;
 	
 	public WindowActionButton(Function<Float, DColorableIcon> icon, Consumer<DMouseEvent> action) {
 		this.scalableIcon = icon;
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
+		this.z = z;
 		
 		windowFocused = surface.getContext().getWindow().getActive();
-		windowFocusedListener = windowFocused.addListener((a, b) -> repaint());
+		windowFocusedListener = windowFocused.addListener((a, b) -> update());
 		
 		icon = scalableIcon == null ? null : scalableIcon.apply(surface.getScale());
 		sizing.setValue(new DSizing(
 				(int)(48 * surface.getScale()),
 				(int)(24 * surface.getScale())));
+		
+		background = surface.fillRect(z, DIRectangle.EMPTY, getBackgroundColor());
+	}
+	
+	@Override
+	public void unmount() {
+		if (drawnIcon != null) {
+			drawnIcon.close();
+			drawnIcon = null;
+		}
+		if (background != null) {
+			background.close();
+			background = null;
+		}
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		int color = 0xFFFFFFFF;
-		int iconColor = windowFocused.getValue() ? 0xFF000000 : 0xFF999999;
-		
-		if (hover) {
-			if (icon instanceof ScalableCloseIcon) {
-				color = 0xFFE81123;
-				iconColor = 0xFFFFFFFF;
-			} else {
-				color = 0xFFE0E0E0;
-			}
-		}
-		if (press)
-			color = 0xFFCCCCCC;
-		
-		
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, color);
+		background.setRectangle(bounds);
 		
-		if (scalableIcon != null) {
+		if (icon != null) {
+			if (drawnIcon != null)
+				drawnIcon.close();
+			
 			int iconX = bounds.x + (int)(bounds.width - icon.getNominalWidth()) / 2;
 			int iconY = bounds.y + (int)(bounds.height - icon.getNominalHeight()) / 2;
-			icon.draw(canvas, DTransform2D.translate(iconX, iconY), iconColor);
+			drawnIcon = new DColorableIconInstance(surface, z + 1, icon, DTransform2D.translate(iconX, iconY), getIconColor());
 		}
 	}
 
 	@Override
 	public void close() {
 		windowFocusedListener.close();
+		unmount();
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hover = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
 		hover = false;
 		press = false;
-		repaint();
+		update();
 	}
 	
 	@Override
 	public void onMouseDown(DMouseEvent e) {
 		press = true;
-		repaint();
+		update();
 	}
 	
 	@Override
 			action.accept(e);
 		
 		press = false;
-		repaint();
+		update();
 	}
 	
-	private void repaint() {
-		if (surface == null)
-			return;
+	private void update() {
+		background.setColor(getBackgroundColor());
+		if (drawnIcon != null)
+			drawnIcon.setColor(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;
+			}
+		}
+		if (press)
+			color = 0xFFCCCCCC;
+		
+		return color;
+	}
+	
+	private int getIconColor() {
+		int iconColor = windowFocused.getValue() ? 0xFF000000 : 0xFF999999;
+		
+		if (hover) {
+			if (icon instanceof ScalableCloseIcon) {
+				iconColor = 0xFFFFFFFF;
+			}
+		}
 		
-		surface.repaint(bounds);
+		return iconColor;
 	}
 }

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

 package org.openzen.zenscript.ide.ui.view.editor;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DUIContext;
 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.ImmutableLiveString;
 import org.openzen.drawablegui.live.InverseLiveBool;
 import org.openzen.drawablegui.live.LiveBool;
 	
 	private DDrawnRectangle background;
 	private DDrawnRectangle lineBarBackground;
+	private DDrawnShape lineBarLine;
+	private DDrawnRectangle selection;
+	private DDrawnRectangle cursor;
+	private DDrawnRectangle currentLineHighlight;
+	private final List<DDrawnRectangle> multiLineSelection = new ArrayList<>();
+	private final List<DDrawnText> lineNumbers = new ArrayList<>();
+	private final List<List<DDrawnText>> drawnTokens = new ArrayList<>();
 	
 	public SourceEditor(DStyleClass styleClass, IDEWindow window, IDESourceFile sourceFile) {
 		this.styleClass = styleClass;
 		return updated;
 	}
 	
-	@Override
-	public void onMounted() {
-		window.aspectBar.toolbars.add(editToolbar);
-		window.aspectBar.active.setValue(editToolbar);
-	}
-	
-	@Override
-	public void onUnmounted() {
-		window.aspectBar.toolbars.remove(editToolbar);
-	}
-	
 	@Override
 	public void close() {
 		if (blinkTimer != null)
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+		if (surface != null)
+			unmount();
+		
 		this.surface = surface;
 		this.z = z;
 		this.style = new SourceEditorStyle(surface.getStylesheet(parent.getChild("sourceeditor", styleClass)));
 		
 		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
 		
+		blinkTimer = surface.getContext().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);
+		
+		for (int i = 0; i < tokens.getLineCount(); i++)
+			lineNumbers.add(surface.drawText(z + 3, font, style.lineBarTextColor, 0, 0, Integer.toString(i + 1)));
+		
+		for (TokenLine line : tokens.getLines())
+			drawnTokens.add(lineToTokens(line));
+		
+		window.aspectBar.toolbars.add(editToolbar);
+		window.aspectBar.active.setValue(editToolbar);
+	}
+	
+	@Override
+	public void unmount() {
+		window.aspectBar.toolbars.remove(editToolbar);
+		
+		surface = null;
+		
+		if (background != null) {
+			background.close();
+			background = null;
+		}
+		if (lineBarBackground != null) {
+			lineBarBackground.close();
+			lineBarBackground = null;
+		}
+		if (lineBarLine != null) {
+			lineBarLine.close();
+			lineBarLine = null;
+		}
+		if (selection != null) {
+			selection.close();
+			selection = null;
+		}
+		if (cursor != null) {
+			cursor.close();
+			cursor = null;
+		}
+		
 		if (blinkTimer != null)
 			blinkTimer.close();
-		blinkTimer = surface.getContext().setTimer(300, this::blink);
+		
+		for (DDrawnText lineNumber : lineNumbers)
+			lineNumber.close();
+		lineNumbers.clear();
+		
+		for (List<DDrawnText> line : drawnTokens)
+			for (DDrawnText token : line)
+				token.close();
+		drawnTokens.clear();
+		
+		clearMultilineSelection();
+	}
+	
+	private void clearMultilineSelection() {
+		for (DDrawnRectangle item : multiLineSelection)
+			item.close();
+		multiLineSelection.clear();
 	}
 
 	@Override
 			background.close();
 		if (lineBarBackground != null)
 			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);
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		DIRectangle canvasBounds = canvas.getBounds();
-		
-		if (style.lineBarStrokeWidth > 0) {
-			canvas.strokePath(tracer -> {
+		lineBarLine = surface.strokePath(z + 1, tracer -> {
 				tracer.moveTo(bounds.x + lineBarWidth, bounds.y);
 				tracer.lineTo(bounds.x + lineBarWidth, bounds.y + bounds.height);
 			}, DTransform2D.IDENTITY, style.lineBarStrokeColor, style.lineBarStrokeWidth);
-		}
 		
-		int x = bounds.x + lineBarWidth + style.lineBarMargin;
-		if (cursorEnd != null)
-			canvas.fillRectangle(x, lineToY(cursorEnd.line), bounds.width - x, selectionLineHeight, style.currentLineHighlight);
-		
-		if (cursorStart != null && !cursorStart.equals(cursorEnd)) {
-			if (cursorStart.line == cursorEnd.line) {
-				int y = getY(cursorStart);
-				int x1 = getX(cursorStart);
-				int x2 = getX(cursorEnd);
-				int fromX = Math.min(x1, x2);
-				int toX = Math.max(x1, x2);
-				canvas.fillRectangle(fromX, y, toX - fromX, selectionLineHeight, style.selectionColor);
-			} else {
-				SourcePosition from = SourcePosition.min(cursorStart, cursorEnd);
-				SourcePosition to = SourcePosition.max(cursorStart, cursorEnd);
-				
-				int fromX = getX(from);
-				canvas.fillRectangle(fromX, getY(from), bounds.width - fromX, selectionLineHeight, style.selectionColor);
-				
-				for (int i = from.line + 1; i < to.line; i++) {
-					canvas.fillRectangle(x, lineToY(i), bounds.width - x, selectionLineHeight, style.selectionColor);
-				}
-				
-				int toX = getX(to);
-				canvas.fillRectangle(x, getY(to), toX - x, selectionLineHeight, style.selectionColor);
-			}
-		}
-		
-		int y = bounds.y + style.selectionPaddingTop;
-		int lineIndex = 1;
-		for (TokenLine line : tokens.getLines()) {
-			if (y + textLineHeight  >= canvasBounds.y && y < canvasBounds.y + canvasBounds.height) {
-				String lineNumber = Integer.toString(lineIndex);
-				int lineNumberX = x - style.lineBarSpacingRight - style.lineBarMargin - fontMetrics.getWidth(lineNumber);
-				canvas.drawText(font, style.lineBarTextColor, lineNumberX, y + fontMetrics.getAscent(), lineNumber);
-
-				int lineX = x;
-				for (ZSToken token : line.getTokens()) {
-					String content = getDisplayContent(token);
-					canvas.drawText(font, TokenClass.get(token.type).color, lineX, y + fontMetrics.getAscent(), content);
-					lineX += fontMetrics.getWidth(content);
-				}
-			}
-			
-			y += fullLineHeight;
-			lineIndex++;
+		for (int i = 0; i < lineNumbers.size(); i++) {
+			lineNumbers.get(i).setPosition(
+					bounds.x + lineBarWidth - style.lineBarSpacingRight - style.lineBarMargin - lineNumbers.get(i).getBounds().width,
+					bounds.y + style.selectionPaddingTop + i * fullLineHeight + fontMetrics.getAscent());
 		}
 		
-		if (cursorEnd != null && cursorBlink) {
-			int cursorX = getX(cursorEnd);
-			int cursorY = getY(cursorEnd);
-			canvas.fillRectangle(cursorX, cursorY, style.cursorWidth, selectionLineHeight, style.cursorColor);
-		}
+		layoutLines(0);
 	}
 	
 	@Override
 	}
 	
 	private void setCursor(SourcePosition start, SourcePosition end) {
-		if (cursorStart != null)
-			repaint(cursorStart, cursorEnd);
-		
 		int previousLine = cursorEnd == null ? -1 : cursorEnd.line;
 		
 		cursorStart = start;
 				repaintLine(previousLine);
 			repaintLine(cursorEnd.line);
 		}
-		repaint(cursorStart, cursorEnd);
+		
+		clearMultilineSelection();
+		
+		int x = bounds.x + lineBarWidth + style.lineBarMargin;
+		currentLineHighlight.setRectangle(new DIRectangle(x, lineToY(cursorEnd.line), bounds.width - x, selectionLineHeight));
+		int cursorX = getX(cursorEnd);
+		int cursorY = getY(cursorEnd);
+		cursor.setRectangle(new DIRectangle(cursorX, cursorY, style.cursorWidth, selectionLineHeight));
+		
+		if (cursorStart != null && !cursorStart.equals(cursorEnd)) {
+			if (cursorStart.line == cursorEnd.line) {
+				int y = getY(cursorStart);
+				int x1 = getX(cursorStart);
+				int x2 = getX(cursorEnd);
+				int fromX = Math.min(x1, x2);
+				int toX = Math.max(x1, x2);
+				selection.setRectangle(new DIRectangle(fromX, y, toX - fromX, selectionLineHeight));
+			} else {
+				SourcePosition from = SourcePosition.min(cursorStart, cursorEnd);
+				SourcePosition to = SourcePosition.max(cursorStart, cursorEnd);
+				
+				int fromX = getX(from);
+				multiLineSelection.add(surface.fillRect(
+						z + 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));
+				}
+				
+				int toX = getX(to);
+				multiLineSelection.add(surface.fillRect(z + 2, new DIRectangle(x, getY(to), toX - x, selectionLineHeight), style.selectionColor));
+				selection.setRectangle(DIRectangle.EMPTY);
+			}
+		} else {
+			if (cursorEnd != null)
+				
+			selection.setRectangle(DIRectangle.EMPTY);
+		}
+		
 		scrollTo(cursorEnd);
 	}
 	
 		unchanged.setValue(false);
 	}
 	
-	private void repaint(SourcePosition from, SourcePosition to) {
-		if (from.line == to.line) {
-			int y = lineToY(from.line);
-			int x1 = getX(from);
-			int x2 = getX(to);
-			int fromX = Math.min(x1, x2);
-			int toX = Math.max(x1, x2) + 2;
-			surface.repaint(fromX, y, toX - fromX, selectionLineHeight);
-		} else {
-			int fromY = lineToY(Math.min(from.line, to.line));
-			int toY = lineToY(Math.max(from.line, to.line) + 1);
-			surface.repaint(bounds.x, fromY, bounds.width, toY - fromY);
-		}
-	}
-	
 	private void repaintLine(int line) {
 		if (bounds == null)
 			return;
 	private void blink() {
 		if (cursorEnd != null) {
 			cursorBlink = !cursorBlink;
-			repaint(cursorEnd, cursorEnd);
+			cursor.setColor(cursorBlink ? style.cursorColor : 0);
 		}
 	}
 	
 			surface.repaint(bounds);
 	}
 	
+	private void layoutLines(int fromIndex) {
+		for (int i = fromIndex; i < drawnTokens.size(); i++) {
+			layoutLine(i);
+		}
+	}
+	
+	private void layoutLine(int index) {
+		List<DDrawnText> tokenLine = drawnTokens.get(index);
+		int x = bounds.x + lineBarWidth + style.lineBarMargin;
+		int y = bounds.y + style.selectionPaddingTop + index * fullLineHeight + fontMetrics.getAscent();
+
+		for (DDrawnText token : tokenLine) {
+			token.setPosition(x, y);
+			x += token.getBounds().width;
+		};
+	}
+	
+	private List<DDrawnText> lineToTokens(TokenLine line) {
+		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));
+		}
+		return tokenLine;
+	}
+	
 	private class TokenListener implements TokenModel.Listener {
 
 		@Override
 		public void onLineInserted(int index) {
 			onLinesUpdated();
+			
+			if (bounds != null) {
+				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));
+				
+				drawnTokens.add(index, lineToTokens(tokens.getLine(index)));
+				layoutLines(index);
+			}
 		}
 
 		@Override
 		public void onLineChanged(int index) {
 			repaintLine(index);
+			
+			if (bounds != null) {
+				removeLineTokens(drawnTokens.get(index));
+				drawnTokens.get(index).clear();
+				drawnTokens.get(index).addAll(lineToTokens(tokens.getLine(index)));
+				layoutLine(index);
+			}
 		}
 
 		@Override
 		public void onLineDeleted(int index) {
 			onLinesUpdated();
+			
+			if (bounds != null) {
+				lineNumbers.remove(lineNumbers.size() - 1).close();
+				removeLineTokens(drawnTokens.remove(index));
+				layoutLines(index);
+			}
+		}
+		
+		private void removeLineTokens(List<DDrawnText> tokens) {
+			for (DDrawnText token : tokens)
+				token.close();
 		}
 	}
 	

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 	private final LiveList<OutputLine> lines;
 	
 	private DDrawSurface surface;
+	private int z;
 	private DIRectangle bounds;
-	private DPath shape;
 	private OutputViewStyle style;
 	
+	private DDrawnShape shape;
+	
 	public OutputView(DStyleClass styleClass, LiveList<OutputLine> lines) {
 		this.styleClass = styleClass;
 		this.lines = lines;
 	}
 
 	@Override
-	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
+		this.z = z;
 		
 		DStylePath path = parent.getChild("outputview", styleClass);
 		style = new OutputViewStyle(surface.getStylesheet(path));
 	}
+	
+	@Override
+	public void unmount() {
+		if (shape != null) {
+			shape.close();
+			shape = null;
+		}
+	}
 
 	@Override
 	public MutableLiveObject<DSizing> getSizing() {
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		shape = style.shape.instance(bounds);
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		canvas.shadowPath(
-				shape,
-				DTransform2D.IDENTITY,
-				style.backgroundColor,
-				style.shadow);
+		shape = surface.shadowPath(z, style.shape.instance(bounds), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 	}
 
 	@Override
 	public void close() {
-		
+		unmount();
 	}
 }