Performed major drawing optimizations, introducing a new drawing system

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 	private final LiveBool disabled;
 	private final Runnable action;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DIRectangle bounds;
 	
 	private DButtonStyle style;
 		this.disabled = disabled;
 		this.action = action;
 	}
-
+	
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		
 		DStylePath path = parent.getChild("Button", styleClass);
-		this.style = new DButtonStyle(context.getStylesheets().get(context, path));
-		fontMetrics = context.getFontMetrics(style.font);
+		this.style = new DButtonStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.font);
 		
 		sizing.setValue(new DSizing(
 				style.paddingLeft + style.paddingRight + fontMetrics.getWidth(label.getValue()),
 			shadow = style.shadowDisabled;
 		}
 		
-		DPath shape = DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 2 * context.getScale());
+		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());
 	}
 	}
 	
 	private void repaint() {
-		if (context == null || bounds == null)
+		if (surface == null || bounds == null)
 			return;
 		
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 }

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

 package org.openzen.drawablegui;
 
 import java.io.Closeable;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.style.DStylePath;
 
  * @author Hoofdgebruiker
  */
 public interface DComponent extends Closeable {
-	void setContext(DStylePath parent, DUIContext context);
+	void setSurface(DStylePath parent, int z, DDrawSurface surface);
 	
 	LiveObject<DSizing> getSizing();
 	

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

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

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

 				&& y >= this.y && y < (this.y + this.height);
 	}
 	
+	public boolean overlaps(DIRectangle other) {
+		if (x + width < other.x)
+			return false;
+		if (y + width < other.y)
+			return false;
+		if (other.x + other.width < x)
+			return false;
+		if (other.y + other.height < y)
+			return false;
+		
+		return true;
+	}
+	
 	@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.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 	private DIRectangle bounds = DIRectangle.EMPTY;
 	private final DDimension preferredWidth;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DInputFieldStyle style;
 	private DFontMetrics fontMetrics;
 	private int cursorFrom = -1;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		
 		DStylePath path = parent.getChild("input", styleClass);
-		style = new DInputFieldStyle(context.getStylesheets().get(context, path));
-		fontMetrics = context.getFontMetrics(style.font);
+		style = new DInputFieldStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.font);
 		sizing.setValue(new DSizing(
-				preferredWidth.evalInt(context) + style.paddingLeft + style.paddingRight + 2 * style.borderWidth,
+				preferredWidth.evalInt(surface.getContext()) + style.paddingLeft + style.paddingRight + 2 * style.borderWidth,
 				fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingTop + style.paddingBottom + 2 * style.borderWidth));
 		
 		if (blinkTimer != null)
 			blinkTimer.close();
-		blinkTimer = context.setTimer(300, this::blink);
+		blinkTimer = surface.getContext().setTimer(300, this::blink);
 	}
 	
 	private void blink() {
 		cursorBlink = !cursorBlink;
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 
 	@Override
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
-		context.setCursor(DUIContext.Cursor.TEXT);
+		surface.getContext().setCursor(DUIContext.Cursor.TEXT);
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
-		context.setCursor(DUIContext.Cursor.NORMAL);
+		surface.getContext().setCursor(DUIContext.Cursor.NORMAL);
 	}
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		context.getWindow().focus(this);
+		surface.getContext().getWindow().focus(this);
 	}
 	
 	@Override
 	private void setCursor(int from, int to) {
 		cursorFrom = from;
 		cursorTo = to;
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 	
 	private void handleValueUpdated(String newValue) {
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 	
 	private void backspace() {

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final ListenerHandle<LiveString.Listener> labelListener;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
+	private int z;
 	private DIRectangle bounds;
 	private DLabelStyle style;
 	private DFontMetrics fontMetrics;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		
 		DStylePath path = parent.getChild("label", styleClass);
-		style = new DLabelStyle(context.getStylesheets().get(context, path));
+		style = new DLabelStyle(surface.getStylesheet(path));
 		
-		fontMetrics = context.getFontMetrics(style.font);
+		fontMetrics = surface.getFontMetrics(style.font);
 		calculateDimension();
 	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		style.border.update(surface, z + 1, bounds);
 	}
 
 	@Override
 	public void paint(DCanvas canvas) {
-		style.border.paint(canvas, bounds);
 		canvas.drawText(style.font, style.color, bounds.x + style.border.getPaddingLeft(), bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(), label.getValue());
 	}
 
 	
 	private void onLabelChanged(String oldValue, String newValue) {
 		calculateDimension();
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 	
 	private void calculateDimension() {

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final ListenerHandle<LiveString.Listener> tooltipListener;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
+	private int z;
 	private DIRectangle bounds;
 	private DFontMetrics fontMetrics;
 	private DSimpleTooltipStyle style;
 	
+	private DDrawnRectangle background;
+	private DDrawnText text;
+	
 	public DSimpleTooltipComponent(DStyleClass styleClass, LiveString tooltip) {
 		this.styleClass = styleClass;
 		this.tooltip = tooltip;
 	}
 	
 	private void onTooltipChanged(String oldValue, String newValue) {
-		if (context == null || bounds == null)
+		if (surface == null || bounds == null)
 			return;
 		
 		calculateSize();
 				bounds.y,
 				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
 				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom());
-		context.repaint(bounds);
+		surface.repaint(bounds);
+		
+		if (text != null)
+			text.close();
+		
+		text = surface.drawText(
+				z,
+				style.font,
+				style.textColor,
+				bounds.x + style.border.getPaddingLeft(),
+				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(),
+				newValue);
 	}
 	
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		style.border.update(surface, z + 1, bounds);
+		
+		if (background != null)
+			background.close();
+		background = surface.fillRect(z, bounds, style.backgroundColor);
+		text.setPosition(
+				bounds.x + style.border.getPaddingLeft(),
+				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent());
 	}
 	
 	@Override
 	}
 	
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		
 		DStylePath path = parent.getChild("tooltip", styleClass);
-		style = new DSimpleTooltipStyle(context.getStylesheets().get(context, path));
-		fontMetrics = context.getFontMetrics(style.font);
+		style = new DSimpleTooltipStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.font);
 		calculateSize();
+		
+		text = surface.drawText(z + 1, style.font, style.textColor, 0, 0, tooltip.getValue());
 	}
 	
 	@Override
 	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
-		style.border.paint(canvas, bounds);
-		canvas.drawText(
-				style.font,
-				style.textColor,
-				bounds.x + style.border.getPaddingLeft(),
-				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(),
-				tooltip.getValue());
+		
 	}
 	
 	@Override

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

  */
 package org.openzen.drawablegui.border;
 
-import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawSurface;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface DBorder {
-	public void paint(DCanvas canvas, DIRectangle bounds);
+	public void update(DDrawSurface surface, int z, DIRectangle bounds);
 	
 	public int getPaddingLeft();
 	

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

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

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

 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.ImmutableLiveObject;
 import org.openzen.drawablegui.live.LiveBool;
 	private final DComponent content;
 	private final LiveObject<DSizing> sizing = new ImmutableLiveObject<>(DSizing.EMPTY);
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DCustomWindowBorderStyle style;
 	private DIRectangle bounds;
 	private DPath border;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
-		content.setContext(parent, context);
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		content.setSurface(parent, z + 1, surface);
 		
-		state = context.getWindow().getWindowState();
-		active = context.getWindow().getActive();
+		state = surface.getContext().getWindow().getWindowState();
+		active = surface.getContext().getWindow().getActive();
 		stateListener = state.addListener(this::onStateChanged);
 		activeListener = active.addListener(this::onActiveChanged);
 		
 		DStylePath path = parent.getChild("customwindowborder", styleClass);
-		style = new DCustomWindowBorderStyle(context.getStylesheets().get(context, path));
+		style = new DCustomWindowBorderStyle(surface.getStylesheet(path));
 		
 		if (bounds != null)
 			layout();
 		} else {
 			content.setBounds(bounds);
 		}
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 
 	@Override
 	}
 	
 	private void onActiveChanged(boolean oldValue, boolean newValue) {
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 }

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

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

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

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

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

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

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

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

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawSurface.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.DUIContext;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DStyleDefinition;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawSurface {
+	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);
+	
+	default void repaint(DIRectangle rectangle) {
+		repaint(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawnRectangle.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnRectangle extends Closeable {
+	void setRectangle(DIRectangle rectangle);
+	
+	void setColor(int color);
+	
+	@Override
+	void close();
+}

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

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DDrawnText.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnText extends Closeable {
+	void setPosition(float x, float y);
+	
+	void setColor(int color);
+	
+	@Override
+	void close();
+}

DrawableGui/src/main/java/org/openzen/drawablegui/draw/DSubSurface.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.DIRectangle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DSubSurface extends DDrawSurface {
+	void setOffset(int x, int y);
+	
+	void setClip(DIRectangle bounds);
+}

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

 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.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DIRectangle bounds;
-	private DUIContext context;
+	private DDrawSurface context;
 	private DFormStyle style;
 	private DFontMetrics fontMetrics;
 	private int maxFieldWidth;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.context = surface;
 		
 		DStylePath path = parent.getChild("form", styleClass);
-		style = new DFormStyle(context.getStylesheets().get(context, path));
-		fontMetrics = context.getFontMetrics(style.labelFont);
+		style = new DFormStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.labelFont);
+		
 		for (DFormComponent component : components)
-			component.component.setContext(path, context);
+			component.component.setSurface(path, z + 1, surface);
 		
 		int height = style.paddingBottom + style.paddingTop;
 		int maxLabelWidth = style.minimumLabelSize;

DrawableGui/src/main/java/org/openzen/drawablegui/layout/DLinearLayout.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.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
-	private DUIContext context;
+	private DDrawSurface surface;
+	private int z;
 	private DLinearLayoutStyle style;
 	private DIRectangle bounds;
 	private float totalGrow;
 	private float totalShrink;
-	private DPath shape;
+	private DDrawnShape shape;
 	
 	public DLinearLayout(DStyleClass styleClass, Orientation orientation, Alignment alignment, Element... components) {
 		this.styleClass = styleClass;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		
-		DStylePath path = parent.getChild("verticalLayout", styleClass);
-		style = new DLinearLayoutStyle(context.getStylesheets().get(context, path));
+		DStylePath path = parent.getChild("linearlayout", styleClass);
+		style = new DLinearLayoutStyle(surface.getStylesheet(path));
 		
 		for (Element element : components)
-			element.component.setContext(parent, context);
+			element.component.setSurface(parent, z + 1, surface);
 	}
 
 	@Override
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
+		if (bounds.equals(this.bounds))
+			return;
+		
 		this.bounds = bounds;
-		shape = style.shape.instance(style.margin.apply(bounds));
+		style.border.update(surface, z + 1, bounds);
+		
+		if (shape != null)
+			shape.close();
+		shape = surface.shadowPath(z, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		
 		layout();
 	}
 
 	@Override
 	public void paint(DCanvas canvas) {
-		canvas.shadowPath(shape, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
-		style.border.paint(canvas, bounds);
 		for (Element element : components) {
 			element.component.paint(canvas);
 		}
 	}
 	
 	private void layoutHorizontal() {
-		if (bounds == null || context == null)
+		if (bounds == null || surface == null)
 			return;
 		
 		DSizing myPreferences = sizing.getValue();
 	}
 	
 	private void layoutVertical() {
-		if (bounds == null || context == null)
+		if (bounds == null || surface == null)
 			return;
 		
 		DSizing myPreferences = sizing.getValue();

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

 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DIRectangle;
 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.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DStylePath path;
-	private DUIContext context;
+	private DDrawSurface surface;
+	private int z;
 	private DSideLayoutStyle style;
 	private DIRectangle bounds;
 	
+	private DDrawnRectangle background;
+	
 	public DSideLayout(DStyleClass styleClass, DComponent main) {
 		this.styleClass = styleClass;
 		this.main = main;
 	}
 	
 	public void add(Side side, DComponent component) {
-		if (context != null)
-			component.setContext(path, context);
+		if (surface != null)
+			component.setSurface(path, z + 1, surface);
 		
 		sides.add(new SideComponent(side, component));
 	}
 		
 		this.main = component;
 		
-		if (context != null && bounds != null) {
-			main.setContext(path, context);
+		if (surface != null && bounds != null) {
+			main.setSurface(path, z + 1, surface);
 			setBounds(bounds);
-			context.repaint(bounds);
+			surface.repaint(bounds);
 		}
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		this.path = parent.getChild("sidelayout", styleClass);
-		style = new DSideLayoutStyle(context.getStylesheets().get(context, path));
+		style = new DSideLayoutStyle(surface.getStylesheet(path));
 		
-		main.setContext(path, context);
+		main.setSurface(path, z + 1, surface);
 		for (SideComponent side : sides)
-			side.component.setContext(path, context);
+			side.component.setSurface(path, z + 1, surface);
+		
+		background = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
 	}
 	
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
+		background.setRectangle(bounds);
+		
 		int left = bounds.x;
 		int right = bounds.x + bounds.width;
 		int top = bounds.y;
 
 	@Override
 	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		//canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
 		main.paint(canvas);
 		
 		for (SideComponent component : sides)
 		main.close();
 		for (SideComponent side : sides)
 			side.close();
+		
+		background.close();
 	}
 	
 	public class SideComponent implements Closeable, LiveObject.Listener<DSizing> {

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

 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveInt;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private final ListenerHandle<LiveInt.Listener> targetHeightListener;
 	private final ListenerHandle<LiveInt.Listener> offsetListener;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DScrollBarStyle style;
 	private DIRectangle bounds;
 	
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
-		this.style = new DScrollBarStyle(context.getStylesheets().get(context, parent.getChild("scrollbar", styleClass)));
+	public void setSurface(DStylePath parent, int z, DDrawSurface context) {
+		this.surface = context;
+		this.style = new DScrollBarStyle(context.getStylesheet(parent.getChild("scrollbar", styleClass)));
 		sizing.setValue(new DSizing(style.width, 0));
 	}
 
 			return;
 		
 		this.hovering = hovering;
-		context.repaint(bounds.x, fromY, bounds.width, toY - fromY);
+		surface.repaint(bounds.x, fromY, bounds.width, toY - fromY);
 	}
 	
 	private void setDragging(boolean dragging) {
 			return;
 		
 		this.dragging = dragging;
-		context.repaint(bounds.x, fromY, bounds.width, toY - fromY);
+		surface.repaint(bounds.x, fromY, bounds.width, toY - fromY);
 	}
 	
 	private void recalculate() {

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

 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
-import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTimerHandle;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.SimpleLiveInt;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DSubSurface;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private final DStyleClass styleClass;
 	private final DComponent contents;
 	private final DScrollBar scrollBar;
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DIRectangle bounds;
 	
 	private DScrollPaneStyle style;
-	private DPath shape;
+	private int z;
+	private DDrawnShape shape;
 	private final LiveInt contentsHeight;
 	private final LiveInt offsetX;
 	private final LiveInt offsetY;
 	
 	private DComponent hovering = null;
 	
+	private DSubSurface subSurface;
+	
 	public DScrollPane(DStyleClass styleClass, DComponent contents, LiveInt preferredHeight) {
 		this.styleClass = styleClass;
 		this.contents = contents;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		
 		DStylePath path = parent.getChild("scrollpane", styleClass);
-		contents.setContext(path, new TranslatedContext());
-		scrollBar.setContext(path, context);
-		style = new DScrollPaneStyle(context.getStylesheets().get(context, path));
+		subSurface = surface.createSubSurface(z + 1);
+		contents.setSurface(path, 0, subSurface);
+		scrollBar.setSurface(path, z + 2, surface);
+		style = new DScrollPaneStyle(surface.getStylesheet(path));
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		shape = style.shape.instance(style.margin.apply(bounds));
+		
+		if (shape != null)
+			shape.close();
+		shape = surface.shadowPath(z, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		style.border.update(surface, z + 1, style.margin.apply(bounds));
 		
 		int height = Math.max(bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom(),
 				contents.getSizing().getValue().preferredHeight);
 				bounds.height - style.border.getPaddingVertical() - style.margin.getVertical()));
 		contents.setBounds(new DIRectangle(0, 0, bounds.width - scrollBar.getBounds().width, height));
 		contentsHeight.setValue(height);
+		
+		subSurface.setOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
+		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) {
-		canvas.shadowPath(shape, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
-		style.border.paint(canvas, style.margin.apply(bounds));
 		scrollBar.paint(canvas);
 		
 		canvas.pushBounds(new DIRectangle(
 	}
 	
 	private class TranslatedContext implements DUIContext {
+		private final DUIContext context;
+		
+		public TranslatedContext(DUIContext context) {
+			this.context = context;
+		}
 		
 		@Override
 		public DStyleSheets getStylesheets(){
 			
 			if (value != offsetY.getValue())
 				offsetY.setValue(value);
-			if (context != null && bounds != null)
-				context.repaint(bounds);
+			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/swing/SwingCanvas.java

 	
 	public SwingCanvas(Graphics2D g, SwingGraphicsContext context, DIRectangle bounds) {
 		this.g = g;
-		g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-		g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
 		
 		this.context = context;
 		
 		font.cached = Font.decode(baseFontName).deriveFont(style, font.size);
 	}
 	
-	private AffineTransform getTransform(DTransform2D transform) {
+	public static AffineTransform getTransform(DTransform2D transform) {
 		return new AffineTransform(transform.xx, transform.xy, transform.yx, transform.yy, transform.dx, transform.dy);
 	}
     

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.Graphics2D;
+import java.util.ArrayList;
+import java.util.List;
+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.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.draw.DSubSurface;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DStyleDefinition;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingDrawSurface implements DDrawSurface {
+	private final List<SwingDrawnElement> elements = new ArrayList<>();
+	private final SwingGraphicsContext context;
+	
+	public SwingDrawSurface(SwingGraphicsContext context) {
+		this.context = context;
+	}
+	
+	public void paint(Graphics2D g) {
+		for (SwingDrawnElement element : elements)
+			element.paint(g);
+	}
+
+	@Override
+	public SwingGraphicsContext getContext() {
+		return context;
+	}
+
+	@Override
+	public DStyleDefinition getStylesheet(DStylePath path) {
+		return context.getStylesheets().get(context, path);
+	}
+	
+	@Override
+	public DFontMetrics getFontMetrics(DFont font) {
+		return context.getFontMetrics(font);
+	}
+	
+	@Override
+	public float getScale() {
+		return context.getScale();
+	}
+	
+	@Override
+	public float getTextScale() {
+		return context.getTextScale();
+	}
+
+	@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));
+	}
+
+	@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));
+	}
+	
+	@Override
+	public DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color) {
+		return addElement(new SwingDrawnRectangle(this, z, rectangle, color));
+	}
+
+	@Override
+	public DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color) {
+		return addElement(new SwingFilledPath(this, z, transform, context.getPath(path), color));
+	}
+
+	@Override
+	public DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow) {
+		if (shadow.color == 0 || shadow.radius == 0) {
+			return fillPath(z, path, transform, color);
+		}
+		
+		return addElement(new SwingShadowedPath(this, z, transform, path, context.getPath(path), color, shadow));
+	}
+	
+	@Override
+	public DSubSurface createSubSurface(int z) {
+		return addElement(new SwingSubSurface(this, z));
+	}
+	
+	public void remove(SwingDrawnElement element) {
+		elements.remove(element);
+	}
+
+	@Override
+	public void repaint(int x, int y, int width, int height) {
+		context.repaint(x, y, width, height);
+	}
+	
+	private <T extends SwingDrawnElement> T addElement(T element) {
+		int index = elements.size();
+		while (index > 0 && element.z < elements.get(index - 1).z)
+			index--;
+		
+		elements.add(index, element);
+		return element;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.Graphics2D;
+import java.io.Closeable;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class SwingDrawnElement implements Closeable {
+	public final SwingDrawSurface target;
+	public final int z;
+	
+	public SwingDrawnElement(SwingDrawSurface target, int z) {
+		this.target = target;
+		this.z = z;
+	}
+	
+	abstract void paint(Graphics2D g);
+	
+	@Override
+	public void close() {
+		target.remove(this);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingDrawnRectangle extends SwingDrawnElement implements DDrawnRectangle {
+	private DIRectangle rectangle;
+	private Color color;
+	
+	public SwingDrawnRectangle(SwingDrawSurface target, int z, DIRectangle rectangle, int color) {
+		super(target, z);
+		
+		this.rectangle = rectangle;
+		this.color = new Color(color, true);
+	}
+
+	@Override
+	public void setRectangle(DIRectangle rectangle) {
+		this.rectangle = rectangle;
+	}
+
+	@Override
+	public void setColor(int color) {
+		this.color = new Color(color, true);
+	}
+
+	@Override
+	public void paint(Graphics2D g) {
+		g.setColor(color);
+		g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.draw.DDrawnText;
+import static org.openzen.drawablegui.swing.SwingCanvas.prepare;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingDrawnText extends SwingDrawnElement implements DDrawnText {
+	private float x;
+	private float y;
+	private int color;
+	private final DFont font;
+	private final String text;
+	
+	public SwingDrawnText(SwingDrawSurface target, int z, float x, float y, int color, DFont font, String text) {
+		super(target, z);
+		
+		this.x = x;
+		this.y = y;
+		this.color = color;
+		this.font = font;
+		this.text = text;
+	}
+
+	@Override
+	public void setPosition(float x, float y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	@Override
+	public void setColor(int color) {
+		this.color = color;
+	}
+
+	@Override
+	public void paint(Graphics2D g) {
+		prepare(font);
+		g.setColor(new Color(color, true));
+		g.setFont((Font) font.cached);
+		g.drawString(text, x, y);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+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 final GeneralPath path;
+	
+	public SwingFilledPath(
+			SwingDrawSurface target,
+			int z,
+			DTransform2D transform,
+			GeneralPath path,
+			int color) {
+		super(target, z);
+		
+		this.path = path;
+		
+		this.color = color;
+		this.transform = transform;
+	}
+
+	@Override
+	public void setTransform(DTransform2D transform) {
+		this.transform = transform;
+	}
+
+	@Override
+	public void setColor(int color) {
+		this.color = color;
+	}
+
+	@Override
+	public void paint(Graphics2D g) {
+		if (color == 0)
+			return;
+		
+		AffineTransform old = g.getTransform();
+		g.setColor(new Color(color, true));
+		g.transform(getTransform(transform));
+		g.fill(path);
+		g.setTransform(old);
+	}
+}

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

 import org.openzen.drawablegui.DTimerHandle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.style.DStylePathRoot;
 import org.openzen.drawablegui.style.DStyleSheets;
 
 	private final JavaClipboard clipboard = new JavaClipboard();
 	private Graphics graphics;
 	private DUIWindow window;
+	private DDrawSurface surface;
 	
 	public SwingGraphicsContext(DStyleSheets stylesheets, float scale, float textScale, SwingRoot root) {
 		this.stylesheets = stylesheets;
 		this.root = root;
 	}
 	
+	public void setSurface(DDrawSurface surface) {
+		this.surface = surface;
+	}
+	
 	public GeneralPath getPath(DPath path) {
 		GeneralPath generalPath = preparedPaths.get(path);
 		if (generalPath == null) {
 	public DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root) {
 		SwingWindow swingWindow = (SwingWindow)this.window;
 		SwingDialog window = new SwingDialog(swingWindow, title, root, false);
-		SwingGraphicsContext windowContext = new SwingGraphicsContext(stylesheets, scale, textScale, window.swingComponent);
+		SwingGraphicsContext windowContext = window.swingComponent.context;
 		windowContext.setWindow(window);
 		windowContext.graphics = this.graphics; // help a little...
+		windowContext.setSurface(window.swingComponent.surface);
 		
 		Point rootLocation = swingWindow.swingComponent.getLocationOnScreen();
 		
-		root.setContext(DStylePathRoot.INSTANCE, windowContext);
+		root.setSurface(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);
 	public DUIWindow openView(int x, int y, DAnchor anchor, DComponent root) {
 		SwingWindow swingWindow = (SwingWindow)this.window;
 		SwingInlineWindow window = new SwingInlineWindow(swingWindow, "", root);
-		SwingGraphicsContext windowContext = new SwingGraphicsContext(stylesheets, scale, textScale, window.swingComponent);
+		SwingGraphicsContext windowContext = window.swingComponent.context;
 		windowContext.setWindow(window);
 		windowContext.graphics = this.graphics; // help a little...
+		windowContext.setSurface(window.swingComponent.surface);
 		
-		root.setContext(DStylePathRoot.INSTANCE, windowContext);
+		root.setSurface(DStylePathRoot.INSTANCE, 0, windowContext.surface);
 		DSizing dimension = root.getSizing().getValue();
 		
 		Point rootLocation = swingWindow.swingComponent.getLocationOnScreen();

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

 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Rectangle;
+import java.awt.RenderingHints;
 import java.awt.Toolkit;
 import java.awt.event.ComponentEvent;
 import java.awt.event.ComponentListener;
  */
 public final class SwingRoot extends Component implements ComponentListener, MouseListener, MouseMotionListener, MouseWheelListener, KeyListener {
 	public final SwingGraphicsContext context;
+	public final SwingDrawSurface surface;
 	public final DComponent component;
 	private DComponent focus = null;
 	private boolean firstPaint = true;
 				Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f,
 				Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f,
 				this);
+		surface = new SwingDrawSurface(context);
+		context.setSurface(surface);
 		
 		addComponentListener(this);
 		addMouseListener(this);
 	public void paint(Graphics g) {
 		if (firstPaint) {
 			firstPaint = false;
-			component.setContext(DStylePathRoot.INSTANCE, context);
+			component.setSurface(DStylePathRoot.INSTANCE, 0, surface);
 			component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
 		}
 		
 		long start = System.currentTimeMillis();
 		Rectangle clipBounds = g.getClipBounds();
 		DIRectangle clipBounds2 = clipBounds == null ? null : new DIRectangle(clipBounds.x, clipBounds.y, clipBounds.width, clipBounds.height);
-		SwingCanvas canvas = new SwingCanvas((Graphics2D) g, context, clipBounds2);
+		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);
+		SwingCanvas canvas = new SwingCanvas(g2d, context, clipBounds2);
 		component.paint(canvas);
 		
 		System.out.println("Paint in " + (System.currentTimeMillis() - start) + " ms");

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.image.BufferedImage;
+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 org.openzen.drawablegui.style.DShadow;
+import static org.openzen.drawablegui.swing.SwingCanvas.getGaussianBlurFilter;
+import static org.openzen.drawablegui.swing.SwingCanvas.getTransform;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingShadowedPath extends SwingDrawnElement implements DDrawnShape {
+	private final GeneralPath path;
+	private final BufferedImage shadowImage;
+	private final DIRectangle shadowBounds;
+	private final int shadowOffset;
+	
+	private int color;
+	private DTransform2D transform;
+	
+	public SwingShadowedPath(
+			SwingDrawSurface target,
+			int z,
+			DTransform2D transform,
+			DPath originalPath,
+			GeneralPath path,
+			int color,
+			DShadow shadow) {
+		super(target, z);
+		
+		this.transform = transform;
+		this.path = path;
+		this.color = color;
+		
+		shadowBounds = DPathBoundsCalculator.getBounds(originalPath, transform.offset(shadow.offsetX, shadow.offsetY));
+		shadowOffset = 2 * (int)Math.ceil(shadow.radius);
+		
+		BufferedImage image = new BufferedImage(shadowBounds.width + 2 * shadowOffset, shadowBounds.height + 2 * shadowOffset, BufferedImage.TYPE_INT_ARGB_PRE);
+		Graphics2D imageG = (Graphics2D) image.getGraphics();
+		
+		imageG.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		imageG.setColor(new Color(shadow.color, true));
+		imageG.setTransform(getTransform(transform.offset(shadowOffset + shadow.offsetX - shadowBounds.x, shadowOffset + shadow.offsetY - shadowBounds.y)));
+		imageG.fill(path);
+		
+		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), true).filter(image, null);
+		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), false).filter(image, null);
+		shadowImage = image;
+	}
+
+	@Override
+	public void setTransform(DTransform2D transform) {
+		this.transform = transform;
+	}
+
+	@Override
+	public void setColor(int color) {
+		this.color = color;
+	}
+
+	@Override
+	public void paint(Graphics2D g) {
+		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.fill(path);
+		g.setTransform(old);
+	}
+
+	@Override
+	public void close() {
+		target.remove(this);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import org.openzen.drawablegui.DPath;
+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 final GeneralPath path;
+	private final float lineWidth;
+	
+	public SwingStrokedPath(
+			SwingDrawSurface target,
+			int z,
+			DTransform2D transform,
+			int color,
+			GeneralPath path,
+			float lineWidth) {
+		super(target, z);
+		
+		this.transform = transform;
+		this.color = color;
+		this.path = path;
+		this.lineWidth = lineWidth;
+	}
+
+	@Override
+	public void setTransform(DTransform2D transform) {
+		this.transform = transform;
+	}
+
+	@Override
+	public void setColor(int color) {
+		this.color = color;
+	}
+
+	@Override
+	public void close() {
+		target.remove(this);
+	}
+
+	@Override
+	public void paint(Graphics2D g) {
+		if (color == 0)
+			return;
+		
+		AffineTransform old = g.getTransform();
+		g.setColor(new Color(color, true));
+		g.setStroke(new BasicStroke(lineWidth));
+		g.transform(SwingCanvas.getTransform(transform));
+		g.draw(path);
+		g.setTransform(old);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.geom.AffineTransform;
+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.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.draw.DSubSurface;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DStyleDefinition;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+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());
+	}
+	
+	@Override
+	public void paint(Graphics2D g) {
+		Rectangle clipBounds = g.getClipBounds();
+		if (clip != null) {
+			g.setClip(clip.x, clip.y, clip.width, clip.height);
+		}
+		
+		AffineTransform oldTransform = g.getTransform();
+		g.transform(AffineTransform.getTranslateInstance(offsetX, offsetY));
+		surface.paint(g);
+		g.setTransform(oldTransform);
+		g.setClip(clipBounds.x, clipBounds.y, clipBounds.width, clipBounds.height);
+	}
+
+	@Override
+	public void setOffset(int x, int y) {
+		offsetX = x;
+		offsetY = y;
+	}
+
+	@Override
+	public void setClip(DIRectangle bounds) {
+		clip = bounds;
+	}
+
+	@Override
+	public DUIContext getContext() {
+		return surface.getContext();
+	}
+
+	@Override
+	public DStyleDefinition getStylesheet(DStylePath path) {
+		return surface.getStylesheet(path);
+	}
+
+	@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 surface.drawText(z, font, color, x, y, text);
+	}
+
+	@Override
+	public DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth) {
+		return surface.strokePath(z, path, transform, color, lineWidth);
+	}
+	
+	@Override
+	public DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color) {
+		return surface.fillRect(z, rectangle, color);
+	}
+
+	@Override
+	public DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color) {
+		return surface.fillPath(z, path, transform, color);
+	}
+
+	@Override
+	public DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow) {
+		return surface.shadowPath(z, path, transform, color, shadow);
+	}
+
+	@Override
+	public DSubSurface createSubSurface(int z) {
+		return surface.createSubSurface(z);
+	}
+
+	@Override
+	public void repaint(int x, int y, int width, int height) {
+		int left = toGlobalX(x);
+		int top = toGlobalY(y);
+		int right = left + width;
+		int bottom = top + height;
+
+		if (clip != null) {
+			left = Math.max(clip.x, left);
+			top = Math.max(clip.y, top);
+			right = Math.min(clip.x + clip.width, right);
+			bottom = Math.min(clip.y + clip.height, bottom);
+		}
+
+		if (left >= right || top >= bottom)
+			return;
+
+		target.repaint(left, top, right - left, bottom - top);
+	}
+
+	private int toGlobalX(int x) {
+		return x + offsetX;
+	}
+
+	private int toGlobalY(int y) {
+		return y + offsetY;
+	}
+
+	private int toLocalX(int x) {
+		return x - offsetX;
+	}
+
+	private int toLocalY(int y) {
+		return y - offsetY;
+	}
+}

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

 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
-import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 /**
  * @author Hoofdgebruiker
  */
 public class DTreeView<N extends DTreeNode<N>> implements DComponent {
+	private final DStyleClass styleClass;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private DIRectangle bounds;
 	
 	private int selectedRow = -1;
 	private N selectedNode = null;
 	
-	private final DTreeViewStyle styleDefinition;
-	private DTreeViewStyle.Calculated style;
+	private DTreeViewStyle style;
 	private DFontMetrics fontMetrics;
 	
-	private DUIContext context;
+	private final DDrawable nodeOpenedIcon;
+	private final DDrawable nodeClosedIcon;
+	
+	private DDrawSurface surface;
 	private final N root;
 	private final boolean showRoot;
 	private final List<Row> rows = new ArrayList<>();
 	
-	public DTreeView(DTreeViewStyle style, N root, boolean showRoot) {
-		this.styleDefinition = style;
+	public DTreeView(
+			DStyleClass styleClass,
+			DDrawable nodeOpenedIcon,
+			DDrawable nodeClosedIcon,
+			N root,
+			boolean showRoot)
+	{
+		this.styleClass = styleClass;
 		this.root = root;
 		this.showRoot = showRoot;
+		
+		this.nodeOpenedIcon = nodeOpenedIcon;
+		this.nodeClosedIcon = nodeClosedIcon;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
-		style = styleDefinition.forContext(context);
-		fontMetrics = context.getFontMetrics(style.font);
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		style = new DTreeViewStyle(surface.getStylesheet(parent.getChild("tree", styleClass)));
+		fontMetrics = surface.getFontMetrics(style.font);
 		
 		updateLayout();
 	}
 
 	@Override
 	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, styleDefinition.backgroundColor);
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
 		
 		int drawX = bounds.x + style.padding;
 		int drawY = bounds.y + style.padding;
 		int row = yToRow(e.y);
 		if (row >= 0 && row < rows.size()) {
 			Row rowEntry = rows.get(row);
-			if (e.x >= rowEntry.x && e.x < (rowEntry.x + styleDefinition.nodeOpenedIcon.getNominalWidth())) {
+			if (e.x >= rowEntry.x && e.x < (rowEntry.x + nodeOpenedIcon.getNominalWidth())) {
 				if (!rowEntry.node.isLeaf())
 					rowEntry.node.isCollapsed().toggle();
 				return;
 				selectedNode = rows.get(row).node;
 
 				if (oldRow >= 0)
-					context.repaint(
+					surface.repaint(
 							bounds.x,
 							rowToY(oldRow) - style.selectedPaddingTop,
 							bounds.width,
 							fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom);
-				context.repaint(
+				surface.repaint(
 						bounds.x,
 						rowToY(row) - style.selectedPaddingTop,
 						bounds.width,
 	}
 	
 	private int paintNode(DCanvas canvas, N node, int drawX, int drawY) {
-		int textColor = styleDefinition.nodeTextColor;
+		int textColor = style.nodeTextColor;
 		if (node == selectedNode) {
-			textColor = styleDefinition.selectedNodeTextColor;
+			textColor = style.selectedNodeTextColor;
 			canvas.fillRectangle(
 					bounds.x,
 					drawY - style.selectedPaddingTop,
 					bounds.width,
 					fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom,
-					styleDefinition.selectedBackgroundColor);
+					style.selectedBackgroundColor);
 		}
 		
 		int drawingX = drawX;
 		if (!node.isLeaf()) {
-			DDrawable icon = node.isCollapsed().getValue() ? style.nodeClosedIcon : style.nodeOpenedIcon;
+			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 + style.nodeClosedIcon.getNominalWidth();
+			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();
 		@Override
 		public void onChanged(boolean oldValue, boolean newValue) {
 			updateLayout();
-			context.repaint(bounds);
+			surface.repaint(bounds);
 		}
 
 		@Override
 		public void onInserted(int index, N value) {
 			updateLayout();
-			context.repaint(bounds);
+			surface.repaint(bounds);
 		}
 
 		@Override
 		public void onChanged(int index, N oldValue, N newValue) {
 			updateLayout();
-			context.repaint(bounds);
+			surface.repaint(bounds);
 		}
 
 		@Override
 		public void onRemoved(int index, N oldValue) {
 			updateLayout();
-			context.repaint(bounds);
+			surface.repaint(bounds);
 		}
 		
 		@Override

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

 import org.openzen.drawablegui.style.DDimension;
 import org.openzen.drawablegui.style.DDpDimension;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class DTreeViewStyle {
-	public static DTreeViewStyle DEFAULT = new DTreeViewStyle();
-	
-	public final DDrawable nodeOpenedIcon;
-	public final DDrawable nodeClosedIcon;
 	public final int backgroundColor;
 	public final int borderColor;
-	public final DDimension padding;
-	public final DDimension rowSpacing;
-	public final DDimension fontSize;
-	public final DDimension indent;
-	public final DDimension iconTextSpacing;
+	public final int padding;
+	public final int rowSpacing;
+	public final DFont font;
+	public final int indent;
+	public final int iconTextSpacing;
 	public final int nodeTextColor;
 	public final int selectedNodeTextColor;
 	public final int selectedBackgroundColor;
-	public final DDimension selectedPaddingTop;
-	public final DDimension selectedPaddingBottom;
-	
-	private DTreeViewStyle() {
-		nodeOpenedIcon = ExpandedArrow.INSTANCE;
-		nodeClosedIcon = CollapsedArrow.INSTANCE;
-		backgroundColor = 0;
-		borderColor = 0xFF888888;
-		padding = new DDpDimension(3);
-		rowSpacing = new DDpDimension(2);
-		fontSize = new DDpDimension(12.5f);  
-		indent = new DDpDimension(12);
-		iconTextSpacing = new DDpDimension(2);
-		nodeTextColor = 0xFF000000;
-		selectedNodeTextColor = 0xFFFFFFFF;
-		selectedBackgroundColor = 0xFF007ACC;
-		selectedPaddingTop = new DDpDimension(1);
-		selectedPaddingBottom = new DDpDimension(1);
-	}
-	
-	public Calculated forContext(DUIContext context) {
-		return new Calculated(this, context);
-	}
-	
-	public static class Calculated {
-		public final DDrawable nodeOpenedIcon;
-		public final DDrawable nodeClosedIcon;
-		public final int backgroundColor;
-		public final int borderColor;
-		public final int padding;
-		public final int rowSpacing;
-		public final DFont font;
-		public final int indent;
-		public final int iconTextSpacing;
-		public final int nodeTextColor;
-		public final int selectedNodeTextColor;
-		public final int selectedBackgroundColor;
-		public final int selectedPaddingTop;
-		public final int selectedPaddingBottom;
-		
-		private Calculated(DTreeViewStyle style, DUIContext context) {
-			nodeOpenedIcon = style.nodeOpenedIcon;
-			nodeClosedIcon = style.nodeClosedIcon;
-			backgroundColor = style.backgroundColor;
-			borderColor = style.borderColor;
-			padding = style.padding.evalInt(context);
-			rowSpacing = style.rowSpacing.evalInt(context);
-			font = new DFont(DFontFamily.UI, false, false, false, style.fontSize.evalInt(context));
-			indent = style.indent.evalInt(context);
-			iconTextSpacing = style.iconTextSpacing.evalInt(context);
-			nodeTextColor = style.nodeTextColor;
-			selectedNodeTextColor = style.selectedNodeTextColor;
-			selectedBackgroundColor = style.selectedBackgroundColor;
-			selectedPaddingTop = style.selectedPaddingTop.evalInt(context);
-			selectedPaddingBottom = style.selectedPaddingBottom.evalInt(context);
-		}
+	public final int selectedPaddingTop;
+	public final int selectedPaddingBottom;
+
+	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)));
+		indent = style.getDimension("indent", new DDpDimension(12));
+		iconTextSpacing = style.getDimension("iconTextSpacing", new DDpDimension(2));
+		nodeTextColor = style.getColor("nodeTextColor", 0xFF000000);
+		selectedNodeTextColor = style.getColor("selectedNodeTextColor", 0xFFFFFFFF);
+		selectedBackgroundColor = style.getColor("selectedBackgroundColor", 0xFF007ACC);
+		selectedPaddingTop = style.getDimension("selectedPaddingTop", new DDpDimension(1));
+		selectedPaddingBottom = style.getDimension("selectedPaddingBottom", new DDpDimension(1));
 	}
 }

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

 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.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 import org.openzen.drawablegui.live.LiveBool;
 	private final ListenerHandle<LiveBool.Listener> disabledListener;
 	private final DSimpleTooltip tooltip;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private IconButtonControlStyle style;
 	private DIRectangle bounds;
 	private final MutableLiveObject<DSizing> preferences = DSizing.create();
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
-		tooltip.setContext(context);
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		tooltip.setContext(surface.getContext());
 		
 		DStylePath path = parent.getChild("iconbutton", styleClass);
-		style = new IconButtonControlStyle(context.getStylesheets().get(context, path));
+		style = new IconButtonControlStyle(surface.getStylesheet(path));
 		
-		int iconWidth = (int)(icon.getNominalWidth() * context.getScale() + 0.5f);
-		int iconHeight = (int)(icon.getNominalWidth() * context.getScale() + 0.5f);
+		int iconWidth = (int)(icon.getNominalWidth() * surface.getScale() + 0.5f);
+		int iconHeight = (int)(icon.getNominalWidth() * surface.getScale() + 0.5f);
 		int width = iconWidth + 2 * style.padding + 2 * style.margin;
 		int height = iconHeight + 2 * style.padding + 2 * style.margin;
 		preferences.setValue(new DSizing(width, height));
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
-		if (context != null)
+		if (surface != null)
 			shape = DPath.roundedRectangle(
 					bounds.x + style.margin,
 					bounds.y + style.margin,
 		
 		DDrawable icon = disabled.getValue() ? iconDisabled : this.icon;
 		icon.draw(canvas, DTransform2D.scaleAndTranslate(
-				bounds.x + (bounds.width - icon.getNominalWidth() * context.getScale()) / 2,
-				bounds.y + (bounds.height - icon.getNominalHeight() * context.getScale()) / 2,
-				context.getScale()));
+				bounds.x + (bounds.width - icon.getNominalWidth() * surface.getScale()) / 2,
+				bounds.y + (bounds.height - icon.getNominalHeight() * surface.getScale()) / 2,
+				surface.getScale()));
 	}
 
 	@Override
 	}
 	
 	private void repaint() {
-		if (context == null || bounds == null)
+		if (surface == null || bounds == null)
 			return;
 		
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 }

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

 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
-import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private final DStyleClass styleClass;
 	private final LiveString content;
 	private DIRectangle bounds;
-	private DUIContext context;
+	private DDrawSurface surface;
+	private int z;
 	private StatusBarStyle style;
 	private DFontMetrics fontMetrics;
 
+	private DDrawnShape shape;
+	
 	public StatusBarView(DStyleClass styleClass, LiveString content) {
 		this.styleClass = styleClass;
 		this.content = content;
 	}
 	
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		
 		DStylePath path = parent.getChild("StatusBar", styleClass);
-		style = new StatusBarStyle(context.getStylesheets().get(context, path));
-		fontMetrics = context.getFontMetrics(style.font);
+		style = new StatusBarStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.font);
 		
 		dimensionPreferences.setValue(new DSizing(0, style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingBottom));
 	}
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		
+		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.shadowPath(DPath.rectangle(bounds.x, bounds.y, bounds.width, bounds.height), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
-		canvas.drawText(style.font, style.textColor, style.paddingLeft, style.paddingTop + fontMetrics.getAscent(), content.getValue());
+		canvas.drawText(
+				style.font,
+				style.textColor,
+				bounds.x + style.paddingLeft,
+				bounds.y + style.paddingTop + fontMetrics.getAscent(), content.getValue());
 	}
 
 	@Override

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

 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;
 import org.openzen.drawablegui.live.LiveList;
 	
 	private final Map<TabbedViewTab, ListenerHandle<LiveObject.Listener<DSizing>>> tabSizeListeners = new HashMap<>();
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DStylePath path;
 	private DIRectangle bounds;
 	private TabbedViewStyle style;
 	private int totalTabHeight;
 	private DFontMetrics fontMetrics;
+	private int z;
 
 	private final LiveList<TabbedViewTab> tabComponents = new LiveMappedList<>(tabs, tab -> {
 		TabbedViewTab result = new TabbedViewTab(this, currentTab, tab);
-		if (context != null)
-			result.setContext(path, context);
+		if (surface != null)
+			result.setSurface(path, z + 2, surface);
 		
 		tabSizeListeners.put(result, result.getSizing().addListener((oldSize, newSize) -> layoutTabs()));
 		return result;
 					bounds.width, bounds.height - totalTabHeight);
 				newValue.content.setBounds(contentBounds);
 			}
-			if (newValue == null && context != null && bounds != null)
-				context.repaint(bounds);
+			if (newValue == null && surface != null && bounds != null)
+				surface.repaint(bounds);
 		});
 	}
 	
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
+		
 		path = parent.getChild("tabbedView", styleClass);
-		style = new TabbedViewStyle(context.getStylesheets().get(context, path));
-		fontMetrics = context.getFontMetrics(style.tabFont);
+		style = new TabbedViewStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.tabFont);
 		totalTabHeight = style.tabBorder.getPaddingVertical() + fontMetrics.getAscent() + fontMetrics.getDescent();
 		
 		for (TabbedViewComponent tab : tabs)
 	}
 	
 	private void repaintTabs() {
-		context.repaint(bounds.x, bounds.y, bounds.width, totalTabHeight);
+		surface.repaint(bounds.x, bounds.y, bounds.width, totalTabHeight);
 	}
 	
 	private void prepare(TabbedViewComponent tab) {
-		tab.content.setContext(path, context);
+		tab.content.setSurface(path, z + 1, surface);
 	}
 	
 	private void layoutTabs() {

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

 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 	private final TabbedView parent;
 	public final TabbedViewTabClose closeButton;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private TabbedViewTabStyle style;
 	private DFontMetrics fontMetrics;
 	private int textWidth;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		DStylePath path = parent.getChild("tab", DStyleClass.EMPTY);
-		style = new TabbedViewTabStyle(context.getStylesheets().get(context, path));
-		fontMetrics = context.getFontMetrics(style.tabFont);
-		closeButton.setContext(path, context);
+		style = new TabbedViewTabStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.tabFont);
+		closeButton.setSurface(path, z + 1, surface);
 		
 		calculateSizing();
 	}
 	}
 	
 	private void repaint() {
-		if (context != null && bounds != null)
-			context.repaint(bounds);
+		if (surface != null && bounds != null)
+			surface.repaint(bounds);
 	}
 }

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

 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 	private final TabbedViewTab tab;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DIRectangle bounds;
 	private TabbedViewTabCloseStyle style;
 	private DColorableIcon icon;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		
 		DStylePath path = parent.getChild("tabClose", DStyleClass.EMPTY);
-		style = new TabbedViewTabCloseStyle(context.getStylesheets().get(context, path));
+		style = new TabbedViewTabCloseStyle(surface.getStylesheet(path));
 		sizing.setValue(new DSizing(style.size, style.size));
 		icon = new ScalableCloseIcon(style.size / 24);
 	}
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hover = true;
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
 		hover = false;
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 	
 	@Override

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

 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.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.ImmutableLiveString;
 import org.openzen.drawablegui.live.LiveBool;
 	private final DDrawable icon;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final Consumer<DMouseEvent> onClick;
-	private DUIContext context;
+	private DDrawSurface surface;
 	private AspectBarSelectorButtonStyle style;
 	private DIRectangle bounds = DIRectangle.EMPTY;
 	private DPath shape;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		DStylePath path = parent.getChild("selectorbutton", styleClass);
-		style = new AspectBarSelectorButtonStyle(context.getStylesheets().get(context, path));
+		style = new AspectBarSelectorButtonStyle(surface.getStylesheet(path));
 		sizing.setValue(new DSizing(style.width, style.height));
 		shape = DPath.roundedRectangle(
 				0,
 				style.height,
 				style.roundingRadius);
 		
-		tooltip.setContext(context);
+		tooltip.setContext(surface.getContext());
 	}
 
 	@Override
 					color,
 					shadow);
 		icon.draw(canvas, DTransform2D.scaleAndTranslate(
-				bounds.x + (style.width - icon.getNominalWidth() * context.getScale()) / 2,
-				bounds.y + (style.height - icon.getNominalHeight() * context.getScale()) / 2,
-				context.getScale()));
+				bounds.x + (style.width - icon.getNominalWidth() * surface.getScale()) / 2,
+				bounds.y + (style.height - icon.getNominalHeight() * surface.getScale()) / 2,
+				surface.getScale()));
 	}
 	
 	@Override
 	}
 	
 	private void repaint() {
-		if (context != null && bounds != null)
-			context.repaint(bounds);
+		if (surface != null && bounds != null)
+			surface.repaint(bounds);
 	}
 }

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

  */
 package org.openzen.zenscript.ide.ui.view.aspectbar;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.zenscript.ide.ui.IDEAspectBar;
 import org.openzen.zenscript.ide.ui.IDEAspectToolbar;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.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 final IDEAspectBar aspectBar;
 	
 	private DIRectangle bounds;
-	private DUIContext context;
+	private DDrawSurface surface;
+	private int z;
+	
 	private DStylePath path;
 	private AspectBarStyle style;
 	private DFontMetrics activeToolbarTitleFontMetrics;
 	private LiveMappedList<IDEAspectBarControl, DComponent> activeToolbarComponents;
 	
 	private final ListenerHandle<LiveList.Listener<IDEAspectToolbar>> listener;
-	private DPath aspectBarShape;
 	private DPath windowControlsShape;
 	private int aspectSelectorEndX = 0;
 	
 	private final ListenerHandle<LiveObject.Listener<DSizing>> maximizeRestoreRelayout;
 	private final ListenerHandle<LiveObject.Listener<DSizing>> closeRelayout;
 	
+	private DDrawnRectangle topBackground;
+	private DDrawnRectangle bottomBackground;
+	private DDrawnShape aspectBarShape;
+	
 	public AspectBarView(DStyleClass styleClass, IDEAspectBar aspectBar) {
 		this.styleClass = styleClass;
 		this.aspectBar = aspectBar;
 		aspectBar.active.addListener(this::onActiveChanged);
 		listener = aspectBar.toolbars.addListener(new ToolbarListListener());
 		
-		minimize = new WindowActionButton(scale -> new ScalableMinimizeIcon(scale), e -> context.getWindow().minimize());
+		minimize = new WindowActionButton(scale -> new ScalableMinimizeIcon(scale), e -> surface.getContext().getWindow().minimize());
 		minimizeRelayout = minimize.getSizing().addListener((a, b) -> layout());
 		maximizeRestore = new WindowActionButton(ScalableMaximizeIcon::new, e -> {
-			if (context.getWindow().getWindowState().getValue() == DUIWindow.State.MAXIMIZED)
-				context.getWindow().restore();
+			if (surface.getContext().getWindow().getWindowState().getValue() == DUIWindow.State.MAXIMIZED)
+				surface.getContext().getWindow().restore();
 			else
-				context.getWindow().maximize();
+				surface.getContext().getWindow().maximize();
 		});
 		maximizeRestoreRelayout = maximizeRestore.getSizing().addListener((a, b) -> layout());
-		close = new WindowActionButton(scale -> new ScalableCloseIcon(scale), e -> context.getWindow().close());
+		close = new WindowActionButton(scale -> new ScalableCloseIcon(scale), e -> surface.getContext().getWindow().close());
 		closeRelayout = close.getSizing().addListener((a, b) -> layout());
 		
 		selectorButtons = new LiveMappedList<>(
 				bar -> {
 					LiveBool buttonActive = new LivePredicateBool<>(aspectBar.active, activeBar -> activeBar == bar);
 					AspectBarSelectorButton button = new AspectBarSelectorButton(DStyleClass.EMPTY, bar.icon, buttonActive, bar.description, e -> aspectBar.active.setValue(bar));
-					if (context != null)
-						button.setContext(path, context);
+					if (surface != null)
+						button.setSurface(path, z + 1, surface);
 					
 					return button;
 				});
 	}
 	
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		this.path = parent.getChild("aspectbar", styleClass);
-		this.style = new AspectBarStyle(context.getStylesheets().get(context, path));
-		activeToolbarTitleFontMetrics = context.getFontMetrics(style.activeToolbarTitleFont);
-		showWindowControls = !context.getWindow().hasTitleBar();
+		this.style = new AspectBarStyle(surface.getStylesheet(path));
+		
+		activeToolbarTitleFontMetrics = surface.getFontMetrics(style.activeToolbarTitleFont);
+		showWindowControls = !surface.getContext().getWindow().hasTitleBar();
 		
 		sizing.setValue(new DSizing(0, style.height));
 		
 		for (DComponent selectorButton : selectorButtons)
-			selectorButton.setContext(path, context);
+			selectorButton.setSurface(path, z + 2, surface);
 		
 		if (activeToolbarComponents != null)
 			for (DComponent component : activeToolbarComponents)
-				component.setContext(path, context);
+				component.setSurface(path, z + 2, surface);
+		
+		minimize.setSurface(path, z + 2, surface);
+		maximizeRestore.setSurface(path, z + 2, surface);
+		close.setSurface(path, z + 2, surface);
 		
-		minimize.setContext(path, context);
-		maximizeRestore.setContext(path, context);
-		close.setContext(path, context);
+		if (topBackground != null)
+			topBackground.close();
+		if (bottomBackground != null)
+			bottomBackground.close();
+		
+		topBackground = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
+		bottomBackground = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColorBottom);
 	}
 	
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
-		if (context != null) {
+		if (surface != null) {
 			layout();
-			context.repaint(bounds);
+			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);
+		//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)
 			button.paint(canvas);
 		}
 		
-		canvas.shadowPath(
+		/*canvas.shadowPath(
 				aspectBarShape,
 				DTransform2D.IDENTITY,
 				style.foregroundColor,
-				style.aspectBarShadow);
+				style.aspectBarShadow);*/
 		
 		if (aspectBar.active.getValue() != null) {
 			int y = bounds.y
 	@Override
 	public void close() {
 		listener.close();
+		
+		topBackground.close();
+		bottomBackground.close();
 	}
 	
 	private void onActiveChanged(IDEAspectToolbar previous, IDEAspectToolbar aspectBar) {
 		
 		activeToolbarComponents = new LiveMappedList<>(aspectBar.controls, control -> {
 			DComponent result = control.instantiate();
-			if (context != null)
-				result.setContext(path, context);
+			if (surface != null)
+				result.setSurface(path, z + 2, surface);
 			return result;
 		});
 		
 		if (bounds == null)
 			return;
 		
+		topBackground.setRectangle(new DIRectangle(bounds.x, bounds.y, bounds.width, bounds.height - style.marginBottom));
+		bottomBackground.setRectangle(new DIRectangle(bounds.x, bounds.y + bounds.height - style.marginBottom, bounds.width, style.marginBottom));
+		
 		layoutAspectSelectorButtons();
 		layoutActiveToolbarComponents();
 		
 		minimize.setBounds(new DIRectangle(x, bounds.y, minimizeSize.preferredWidth, minimizeSize.preferredHeight));
 		
 		calculateAspectBarShape();
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 	
 	private void layoutAspectSelectorButtons() {
 			x += width;
 		}
 		
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 
 	@Override
 	private void calculateAspectBarShape() {
 		int toX = aspectSelectorEndX;
 		
-		aspectBarShape = tracer -> {
+		if (aspectBarShape != null)
+			aspectBarShape.close();
+		
+		aspectBarShape = surface.shadowPath(z + 1, tracer -> {
 			int height = bounds.height - style.marginBottom;
 			int baseY = bounds.y + height - style.aspectSelectorBottomSize;
 			int barBaseX = toX + style.aspectSelectorToToolbarSpacing;
 			int barBaseY = bounds.y + style.aspectBarPaddingTop;
 			
 			tracer.moveTo(bounds.x, baseY);
-			tracer.lineTo(toX - 3 * context.getScale(), baseY);
+			tracer.lineTo(toX - 3 * surface.getScale(), baseY);
 			tracer.bezierCubic(
-					toX + 0 * context.getScale(), baseY,
-					toX + 2 * context.getScale(), baseY,
-					toX + 3.5f * context.getScale(), baseY - 4 * context.getScale());
-			tracer.lineTo(barBaseX - 3.5f * context.getScale(), barBaseY + 4 * context.getScale());
+					toX + 0 * surface.getScale(), baseY,
+					toX + 2 * surface.getScale(), baseY,
+					toX + 3.5f * surface.getScale(), baseY - 4 * surface.getScale());
+			tracer.lineTo(barBaseX - 3.5f * surface.getScale(), barBaseY + 4 * surface.getScale());
 			tracer.bezierCubic(
-					barBaseX - 2 * context.getScale(), barBaseY,
-					barBaseX - 0 * context.getScale(), barBaseY,
-					barBaseX + 3 * context.getScale(), barBaseY);
+					barBaseX - 2 * surface.getScale(), barBaseY,
+					barBaseX - 0 * surface.getScale(), barBaseY,
+					barBaseX + 3 * surface.getScale(), barBaseY);
 			
 			if (showWindowControls) {
 				int spacingLeft = style.windowControlSpacingLeft;
 			tracer.lineTo(bounds.x + bounds.width, bounds.y + height);
 			tracer.lineTo(bounds.x, bounds.y + height);
 			tracer.close();
-		};
+		}, DTransform2D.IDENTITY, style.foregroundColor, style.aspectBarShadow);
 		
 		if (showWindowControls) {
 			DIRectangle minimizeBounds = minimize.getBounds();

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

 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 	private DIRectangle bounds;
 	private boolean hover;
 	private boolean press;
-	private DUIContext context;
+	private DDrawSurface surface;
 	
 	public WindowActionButton(Function<Float, DColorableIcon> icon, Consumer<DMouseEvent> action) {
 		this.scalableIcon = icon;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		
-		windowFocused = context.getWindow().getActive();
+		windowFocused = surface.getContext().getWindow().getActive();
 		windowFocusedListener = windowFocused.addListener((a, b) -> repaint());
 		
-		icon = scalableIcon == null ? null : scalableIcon.apply(context.getScale());
+		icon = scalableIcon == null ? null : scalableIcon.apply(surface.getScale());
 		sizing.setValue(new DSizing(
-				(int)(48 * context.getScale()),
-				(int)(24 * context.getScale())));
+				(int)(48 * surface.getScale()),
+				(int)(24 * surface.getScale())));
 	}
 
 	@Override
 	}
 	
 	private void repaint() {
-		if (context == null)
+		if (surface == null)
 			return;
 		
-		context.repaint(bounds);
+		surface.repaint(bounds);
 	}
 }

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

 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.live.ImmutableLiveString;
 import org.openzen.drawablegui.live.InverseLiveBool;
 import org.openzen.drawablegui.live.LiveBool;
 	private final SimpleLiveBool unchanged = new SimpleLiveBool(true);
 	
 	private DIRectangle bounds;
-	private DUIContext context;
+	private int z;
+	private DDrawSurface surface;
 	private SourceEditorStyle style;
 	private DTimerHandle blinkTimer;
 	
 	
 	private final LiveBool updated;
 	
+	private DDrawnRectangle background;
+	private DDrawnRectangle lineBarBackground;
+	
 	public SourceEditor(DStyleClass styleClass, IDEWindow window, IDESourceFile sourceFile) {
 		this.styleClass = styleClass;
 		this.window = window;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
-		this.style = new SourceEditorStyle(context.getStylesheets().get(context, parent.getChild("sourceeditor", styleClass)));
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
+		this.style = new SourceEditorStyle(surface.getStylesheet(parent.getChild("sourceeditor", styleClass)));
 		
-		fontMetrics = context.getFontMetrics(font);
+		fontMetrics = surface.getFontMetrics(font);
 		textLineHeight = fontMetrics.getAscent() + fontMetrics.getDescent();
 		fullLineHeight = textLineHeight + fontMetrics.getLeading() + style.extraLineSpacing;
 		selectionLineHeight = textLineHeight + style.selectionPaddingTop + style.selectionPaddingBottom;
 		
 		if (blinkTimer != null)
 			blinkTimer.close();
-		blinkTimer = context.setTimer(300, this::blink);
+		blinkTimer = surface.getContext().setTimer(300, this::blink);
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
+		
+		lineBarWidth = Math.max(style.lineBarMinWidth, fontMetrics.getWidth(Integer.toString(tokens.getLineCount())))
+				+ style.lineBarSpacingLeft
+				+ style.lineBarSpacingRight;
+		
+		if (background != null)
+			background.close();
+		if (lineBarBackground != null)
+			lineBarBackground.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();
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
 		
-		lineBarWidth = Math.max(style.lineBarMinWidth, fontMetrics.getWidth(Integer.toString(tokens.getLineCount())))
-				+ style.lineBarSpacingLeft
-				+ style.lineBarSpacingRight;
-		canvas.fillRectangle(bounds.x, bounds.y, lineBarWidth, bounds.height, style.lineBarBackgroundColor);
 		if (style.lineBarStrokeWidth > 0) {
 			canvas.strokePath(tracer -> {
 				tracer.moveTo(bounds.x + lineBarWidth, bounds.y);
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
-		context.setCursor(DUIContext.Cursor.TEXT);
+		surface.getContext().setCursor(DUIContext.Cursor.TEXT);
 	}
 	
 	@Override
 	public void onMouseExit(DMouseEvent e) {
-		context.setCursor(DUIContext.Cursor.NORMAL);
+		surface.getContext().setCursor(DUIContext.Cursor.NORMAL);
 	}
 	
 	@Override
 	public void onMouseClick(DMouseEvent e) {
-		context.getWindow().focus(this);
+		surface.getContext().getWindow().focus(this);
 		
 		SourcePosition position = getPositionAt(e.x, e.y);
 		if (e.isDoubleClick()) {
 		String extract = tokens.extract(
 				SourcePosition.min(cursorStart, cursorEnd),
 				SourcePosition.max(cursorStart, cursorEnd));
-		context.getClipboard().copyAsString(extract);
+		surface.getContext().getClipboard().copyAsString(extract);
 	}
 	
 	private void cut() {
 	}
 	
 	private void paste() {
-		String text = context.getClipboard().getAsString();
+		String text = surface.getContext().getClipboard().getAsString();
 		if (text == null)
 			return;
 		
 			int x2 = getX(to);
 			int fromX = Math.min(x1, x2);
 			int toX = Math.max(x1, x2) + 2;
-			context.repaint(fromX, y, toX - fromX, selectionLineHeight);
+			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);
-			context.repaint(bounds.x, fromY, bounds.width, toY - fromY);
+			surface.repaint(bounds.x, fromY, bounds.width, toY - fromY);
 		}
 	}
 	
 		if (bounds == null)
 			return;
 		
-		context.repaint(bounds.x, lineToY(line), bounds.width, selectionLineHeight);
+		surface.repaint(bounds.x, lineToY(line), bounds.width, selectionLineHeight);
 	}
 	
 	public void scrollTo(SourcePosition position) {
-		context.scrollInView(getX(position), getY(position), 2, selectionLineHeight);
+		surface.getContext().scrollInView(getX(position), getY(position), 2, selectionLineHeight);
 	}
 	
 	private void blink() {
 		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
 		
 		if (bounds != null)
-			context.repaint(bounds);
+			surface.repaint(bounds);
 	}
 	
 	private class TokenListener implements TokenModel.Listener {

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

 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.LiveList;
-import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private final DStyleClass styleClass;
 	private final LiveList<OutputLine> lines;
 	
-	private DUIContext context;
+	private DDrawSurface surface;
 	private DIRectangle bounds;
 	private DPath shape;
 	private OutputViewStyle style;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void setSurface(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
 		
 		DStylePath path = parent.getChild("outputview", styleClass);
-		style = new OutputViewStyle(context.getStylesheets().get(context, path));
+		style = new OutputViewStyle(surface.getStylesheet(path));
 	}
 
 	@Override

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

 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylesheetBuilder;
+import org.openzen.drawablegui.tree.CollapsedArrow;
 import org.openzen.drawablegui.tree.DTreeView;
 import org.openzen.drawablegui.tree.DTreeViewStyle;
+import org.openzen.drawablegui.tree.ExpandedArrow;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEPackage;
 				new Element(addPackageButton, 0, 0, ElementAlignment.TOP),
 				new Element(addFileButton, 0, 0, ElementAlignment.TOP));
 		DTreeView projectTree = new DTreeView(
-				DTreeViewStyle.DEFAULT,
+				DStyleClass.EMPTY,
+				ExpandedArrow.INSTANCE,
+				CollapsedArrow.INSTANCE,
 				new RootTreeNode(this, host), false);
 		projectTree.getSizing().setValue(new DSizing(500, 500));
 		DScrollPane treeScrollPane = new DScrollPane(