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

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 				annotations);
 	}
 	
-	public boolean validate() {
+	public boolean validate(Consumer<ValidationLogEntry> logger) {
 		if (state != State.NORMALIZED)
 			throw new IllegalStateException("Module is not yet normalized");
 		
 		}
 		
 		for (ValidationLogEntry entry : validator.getLog()) {
-			System.out.println(entry.kind + " " + entry.position.toString() + ": " + entry.message);
+			logger.accept(entry);
 		}
 		state = validator.hasErrors() ? State.INVALID : State.VALIDATED;
 		return !validator.hasErrors();

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

 import java.io.File;
 import org.json.JSONArray;
 import org.json.JSONObject;
-import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 
 /**
 	public final File directory;
 	public final ModuleReference[] modules;
 	
-	public Library(ModuleLoader loader, File directory, String name, JSONObject json) {
+	public Library(File directory, String name, JSONObject json) {
 		this.name = name;
 		this.directory = new File(directory, json.getString("directory"));
 		
 		modules = new ModuleReference[modulesJson.length()];
 		for (int i = 0; i < modulesJson.length(); i++) {
 			String moduleName = modulesJson.getString(i);
-			modules[i] = new DirectoryModuleLoader(loader, moduleName, new File(this.directory, moduleName), false);
+			modules[i] = new DirectoryModuleReference(moduleName, new File(this.directory, moduleName), false);
 		}
 	}
 }

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

 package org.openzen.zenscript.constructor;
 
-import org.openzen.zenscript.compiler.CompilationUnit;
 import java.io.File;
+import org.openzen.zenscript.compiler.CompilationUnit;
 import java.io.IOException;
-import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+import java.util.function.Consumer;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 
 public class Main {
 			return;
 		}
 		
+		Consumer<CompileException> exceptionLogger = exception -> System.err.println(exception.toString());
+		
 		File currentDirectory = new File(arguments.directory);
 		CompilationUnit compilationUnit = new CompilationUnit();
-		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit);
-		moduleLoader.register("stdlib", new DirectoryModuleLoader(moduleLoader, "stdlib", new File("../../StdLibs/stdlib"), true));
 		
-		Project project = new Project(moduleLoader, currentDirectory);
+		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit, exceptionLogger);
+		moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
+		
+		Project project = new Project(currentDirectory);
 		for (Library library : project.libraries) {
 			for (ModuleReference module : library.modules)
 				moduleLoader.register(module.getName(), module);

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

 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Consumer;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.json.JSONTokener;
 	public final File sourceDirectory;
 	public final String packageName;
 	public final String host;
+	private final Consumer<CompileException> exceptionLogger;
 	
-	public Module(String name, File directory, File moduleFile) throws IOException {
+	public Module(String name, File directory, File moduleFile, Consumer<CompileException> exceptionLogger) throws IOException {
 		this.name = name;
 		this.sourceDirectory = new File(directory, "src");
+		this.exceptionLogger = exceptionLogger;
 		
 		BufferedInputStream input = new BufferedInputStream(new FileInputStream(moduleFile));
 		JSONObject json = new JSONObject(new JSONTokener(input));
 				try {
 					files.add(ParsedFile.parse(pkg, file));
 				} catch (CompileException ex) {
-					System.out.println(ex.getMessage());
+					exceptionLogger.accept(ex);
 				}
 			} else if (file.isDirectory()) {
 				parse(files, pkg.getOrCreatePackage(file.getName()), file);
 			String[] dependencies,
 			ZSPackage pkg,
 			ParsedFile[] files,
-			ModuleSpace registry) {
+			ModuleSpace registry,
+			Consumer<CompileException> exceptionLogger) {
 		// We are considering all these files to be in the same package, so make
 		// a single PackageDefinition instance. If these files were in multiple
 		// packages, we'd need an instance for every package.
 			try {
 				file.compileTypes(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals, registry.getAnnotations());
 			} catch (CompileException ex) {
-				System.out.println(ex.getMessage());
+				exceptionLogger.accept(ex);
 				failed = true;
 			}
 		}
 			try {
 				file.compileMembers(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals, registry.getAnnotations());
 			} catch (CompileException ex) {
-				System.out.println(ex.getMessage());
+				exceptionLogger.accept(ex);
 				failed = true;
 			}
 		}
 			try {
 				file.compileCode(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, scripts, globals, registry.getAnnotations());
 			} catch (CompileException ex) {
-				System.out.println(ex.getMessage());
+				exceptionLogger.accept(ex);
 				failed = true;
 			}
 		}

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

 import java.util.HashSet;
 import java.util.Map;
 import java.util.Stack;
+import java.util.function.Consumer;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.compiler.SemanticModule;
 
 	private final Stack<String> compilingModulesStack = new Stack<>();
 	
 	private final CompilationUnit compilationUnit;
+	private final Consumer<CompileException> exceptionLogger;
 	
-	public ModuleLoader(CompilationUnit compilationUnit) {
+	public ModuleLoader(CompilationUnit compilationUnit, Consumer<CompileException> exceptionLogger) {
 		this.compilationUnit = compilationUnit;
+		this.exceptionLogger = exceptionLogger;
 	}
 	
 	public SemanticModule getModule(String name) {
 		compilingModulesSet.add(name);
 		compilingModulesStack.add(name);
 		
-		SemanticModule module = modules.get(name).load(compilationUnit);
+		SemanticModule module = modules.get(name).load(this, compilationUnit, exceptionLogger);
 		moduleCache.put(name, module);
 		
 		compilingModulesSet.remove(name);

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

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 import org.json.JSONArray;
 import org.json.JSONObject;
-import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.TargetType;
 	public final Library[] libraries;
 	public final Target[] targets;
 	
-	public Project(ModuleLoader loader, File directory) throws IOException {
+	public Project(File directory) throws IOException {
 		this.directory = directory;
 		name = directory.getName();
 		
 		libraries = new Library[jsonLibraries.length()];
 		int k = 0;
 		for (String key : jsonLibraries.keySet()) {
-			libraries[k] = new Library(loader, directory, key, jsonLibraries.getJSONObject(key));
+			libraries[k] = new Library(directory, key, jsonLibraries.getJSONObject(key));
 			k++;
 		}
 		
 		for (int i = 0; i < jsonModules.length(); i++) {
 			Object module = jsonModules.get(i);
 			if (module instanceof String) {
-				modules[i] = new DirectoryModuleLoader(loader, module.toString(), new File(directory, module.toString()), false);
+				modules[i] = new DirectoryModuleReference(module.toString(), new File(directory, module.toString()), false);
 			} else if (module instanceof JSONObject) {
 				JSONObject jsonModule = (JSONObject) module;
 				String name = jsonModule.getString("name");
 				switch (jsonModule.getString("type")) {
 					case "directory":
-						modules[i] = new DirectoryModuleLoader(loader, name, new File(directory, jsonModule.getString("directory")), false);
+						modules[i] = new DirectoryModuleReference(name, new File(directory, jsonModule.getString("directory")), false);
 						break;
 					default:
 						throw new ConstructorException("Invalid module type: " + jsonModule.getString("type"));

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

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 import org.json.JSONArray;
 import org.json.JSONObject;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ConstructorException;
  *
  * @author Hoofdgebruiker
  */
-public class DirectoryModuleLoader implements ModuleReference {
-	private final ModuleLoader loader;
+public class DirectoryModuleReference implements ModuleReference {
 	private final String moduleName;
 	private final File directory;
 	private final boolean isStdlib;
 	private SourcePackage rootPackage = null;
 	
-	public DirectoryModuleLoader(ModuleLoader loader, String moduleName, File directory, boolean isStdlib) {
-		this.loader = loader;
+	public DirectoryModuleReference(String moduleName, File directory, boolean isStdlib) {
 		this.moduleName = moduleName;
 		this.directory = directory;
 		this.isStdlib = isStdlib;
 	}
 
 	@Override
-	public SemanticModule load(CompilationUnit unit) {
+	public SemanticModule load(ModuleLoader loader, CompilationUnit unit, Consumer<CompileException> exceptionLogger) {
 		if (!directory.exists())
 			throw new ConstructorException("Error: module directory not found: " + directory);
 		
 			for (String dependencyName : dependencyNames)
 				space.addModule(dependencyName, loader.getModule(dependencyName));
 
-			Module module = new Module(moduleName, directory, jsonFile);
+			Module module = new Module(moduleName, directory, jsonFile, exceptionLogger);
 			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
 
 			ParsedFile[] parsedFiles = module.parse(pkg);
-			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, pkg, parsedFiles, space);
+			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, pkg, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

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

  */
 package org.openzen.zenscript.constructor.module;
 
+import java.util.function.Consumer;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.constructor.ModuleLoader;
 
 /**
  *
 public interface ModuleReference {
 	public String getName();
 	
-	public SemanticModule load(CompilationUnit unit);
+	public SemanticModule load(ModuleLoader loader, CompilationUnit unit, Consumer<CompileException> exceptionLogger);
 	
 	public SourcePackage getRootPackage();
 }

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

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

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui;
-
-import org.openzen.drawablegui.style.DShadow;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface DCanvas {
-	void pushBounds(DIRectangle bounds);
-	
-	void popBounds();
-	
-	void pushOffset(int x, int y);
-	
-	void popOffset();
-	
-	DIRectangle getBounds();
-	
-	DUIContext getContext();
-	
-	void drawText(DFont font, int color, float x, float y, String text);
-	
-	/**
-	 * Strokes a given path.
-	 * 
-	 * @param path path to be stroked
-	 * @param transform path transform
-	 * @param color path color
-	 * @param lineWidth path line width
-	 */
-	void strokePath(DPath path, DTransform2D transform, int color, float lineWidth);
-	
-	/**
-	 * Fills a given path.
-	 * 
-	 * @param path path to be filled
-	 * @param transform 
-	 * @param color
-	 */
-	void fillPath(DPath path, DTransform2D transform, int color);
-	
-	/**
-	 * Draws the shadow for a given path.
-	 * 
-	 * @param path
-	 * @param transform
-	 * @param shadow
-	 */
-	void shadowPath(DPath path, DTransform2D transform, DShadow shadow);
-	
-	/**
-	 * Fills a rectangle.
-	 * 
-	 * @param x
-	 * @param y
-	 * @param width
-	 * @param height
-	 * @param color 
-	 */
-	void fillRectangle(int x, int y, int width, int height, int color);
-}

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

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

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import java.io.Closeable;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawTarget;
+import org.openzen.drawablegui.draw.DDrawnColorableElement;
+import org.openzen.drawablegui.draw.DDrawnElement;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.style.DShadow;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class DColorableIconInstance implements Closeable {
+	private final List<DDrawnElement> elements = new ArrayList<>();
+	private final List<DDrawnColorableElement> colorables = new ArrayList<>();
+	
+	public DColorableIconInstance(DDrawSurface surface, int z, DColorableIcon icon, DTransform2D transform, int color) {
+		icon.draw(new DrawTarget(surface), z, transform, DDrawTarget.INSTANCE_COLOR);
+		setColor(color);
+	}
+	
+	public void setColor(int color) {
+		for (DDrawnColorableElement colorable : colorables)
+			colorable.setColor(color);
+	}
+	
+	public void setTransform(DTransform2D transform) {
+		for (DDrawnElement element : elements)
+			element.setTransform(transform);
+	}
+	
+	@Override
+	public void close() {
+		for (DDrawnElement element : elements)
+			element.close();
+	}
+	
+	private class DrawTarget implements DDrawTarget {
+		private final DDrawSurface surface;
+		
+		public DrawTarget(DDrawSurface surface) {
+			this.surface = surface;
+		}
+
+		@Override
+		public DFontMetrics getFontMetrics(DFont font) {
+			return surface.getFontMetrics(font);
+		}
+
+		@Override
+		public float getScale() {
+			return surface.getScale();
+		}
+
+		@Override
+		public float getTextScale() {
+			return surface.getTextScale();
+		}
+
+		@Override
+		public DDrawnText drawText(int z, DFont font, int color, float x, float y, String text) {
+			return addColorable(surface.drawText(z, font, color, x, y, text), color);
+		}
+
+		@Override
+		public DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color) {
+			return addColorable(surface.fillRect(z, rectangle, color), color);
+		}
+
+		@Override
+		public DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth) {
+			return addColorable(surface.strokePath(z, path, transform, color, lineWidth), color);
+		}
+
+		@Override
+		public DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color) {
+			return addColorable(surface.fillPath(z, path, transform, color), color);
+		}
+
+		@Override
+		public DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow) {
+			return addColorable(surface.shadowPath(z, path, transform, color, shadow), color);
+		}
+		
+		private <T extends DDrawnColorableElement> T addColorable(T colorable, int color) {
+			if (color == DDrawTarget.INSTANCE_COLOR)
+				colorables.add(colorable);
+			
+			elements.add(colorable);
+			return colorable;
+		}
+	}
+}

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

  */
 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);
+public interface DComponent extends Destructible {
+	void mount(DStylePath parent, int z, DDrawSurface surface);
+	
+	void unmount();
 	
 	LiveObject<DSizing> getSizing();
 	
 	
 	void setBounds(DIRectangle bounds);
 	
-	void paint(DCanvas canvas);
-	
 	default void onMounted() {}
 	
 	default void onUnmounted() {}
 	default void onKeyPressed(DKeyEvent e) {}
 	
 	default void onKeyReleased(DKeyEvent e) {}
-	
-	@Override
-	void close();
 }

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

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

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

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

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import java.io.Closeable;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawTarget;
+import org.openzen.drawablegui.draw.DDrawnColorableElement;
+import org.openzen.drawablegui.draw.DDrawnElement;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.style.DShadow;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DDrawableInstance implements Closeable {
+	private final List<DDrawnElement> elements = new ArrayList<>();
+	
+	public DDrawableInstance(DDrawSurface surface, int z, DDrawable icon, DTransform2D transform) {
+		icon.draw(new DrawTarget(surface), z, transform);
+	}
+	
+	public void setTransform(DTransform2D transform) {
+		for (DDrawnElement element : elements)
+			element.setTransform(transform);
+	}
+	
+	@Override
+	public void close() {
+		for (DDrawnElement element : elements)
+			element.close();
+	}
+	
+	private class DrawTarget implements DDrawTarget {
+		private final DDrawSurface surface;
+		
+		public DrawTarget(DDrawSurface surface) {
+			this.surface = surface;
+		}
+
+		@Override
+		public DFontMetrics getFontMetrics(DFont font) {
+			return surface.getFontMetrics(font);
+		}
+
+		@Override
+		public float getScale() {
+			return surface.getScale();
+		}
+
+		@Override
+		public float getTextScale() {
+			return surface.getTextScale();
+		}
+
+		@Override
+		public DDrawnText drawText(int z, DFont font, int color, float x, float y, String text) {
+			return addElement(surface.drawText(z, font, color, x, y, text));
+		}
+
+		@Override
+		public DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color) {
+			return addElement(surface.fillRect(z, rectangle, color));
+		}
+
+		@Override
+		public DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth) {
+			return addElement(surface.strokePath(z, path, transform, color, lineWidth));
+		}
+
+		@Override
+		public DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color) {
+			return addElement(surface.fillPath(z, path, transform, color));
+		}
+
+		@Override
+		public DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow) {
+			return addElement(surface.shadowPath(z, path, transform, color, shadow));
+		}
+		
+		private <T extends DDrawnColorableElement> T addElement(T colorable) {
+			elements.add(colorable);
+			return colorable;
+		}
+	}
+}

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

  */
 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 mount(DStylePath parent, int z, DDrawSurface surface) {
+		
+	}
+	
+	@Override
+	public void unmount() {
 		
 	}
 	
 		
 	}
 
-	@Override
-	public void paint(DCanvas canvas) {
-		
-	}
-
 	@Override
 	public void close() {
 		// nothing to clean up

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

 	int getWidth(String str);
 	
 	int getWidth(String str, int offset, int length);
+	
+	default int getLineHeight() {
+		return getAscent() + getDescent();
+	}
 }

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

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

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui;
-
-import org.openzen.drawablegui.style.DDpDimension;
-import org.openzen.drawablegui.style.DStyleDefinition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class DHorizontalLayoutStyle {
-	public final int spacing;
-	
-	public final int paddingTop;
-	public final int paddingLeft;
-	public final int paddingRight;
-	public final int paddingBottom;
-	
-	public DHorizontalLayoutStyle(DStyleDefinition style) {
-		spacing = style.getDimension("spacing", new DDpDimension(8));
-		
-		paddingTop = style.getDimension("paddingTop", new DDpDimension(8));
-		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(8));
-		paddingRight = style.getDimension("paddingRight", new DDpDimension(8));
-		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(8));
-	}
-}

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

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

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

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

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

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

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
 	private 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;
 	
+	private DDrawnText text;
+	
 	public DLabel(DStyleClass styleClass, LiveString label) {
 		this.styleClass = styleClass;
 		this.label = label;
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void mount(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();
+		
+		if (text != null)
+			text.close();
+		text = surface.drawText(z, style.font, style.color, 0, 0, label.getValue());
+	}
+	
+	@Override
+	public void unmount() {
+		if (style != null)
+			style.border.close();
+		if (text != null)
+			text.close();
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		style.border.paint(canvas, bounds);
-		canvas.drawText(style.font, style.color, bounds.x + style.border.getPaddingLeft(), bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(), label.getValue());
+		style.border.update(surface, z + 1, bounds);
+		text.setPosition(
+				bounds.x + style.border.getPaddingLeft(),
+				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent());
 	}
 
 	@Override
 	public void close() {
 		labelListener.close();
+		unmount();
 	}
 	
 	private void onLabelChanged(String oldValue, String newValue) {
 		calculateDimension();
-		context.repaint(bounds);
+		
+		if (text != null)
+			text.close();
+		text = surface.drawText(
+				z,
+				style.font,
+				style.color,
+				bounds.x + style.border.getPaddingLeft(),
+				bounds.y + style.border.getPaddingTop() + fontMetrics.getAscent(),
+				newValue);
 	}
 	
 	private void calculateDimension() {

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

  * @author Hoofdgebruiker
  */
 public interface DPath {
+	public static DPath line(float x1, float y1, float x2, float y2) {
+		return tracer -> {
+			tracer.moveTo(x1, y1);
+			tracer.lineTo(x2, y2);
+		};
+	}
+	
 	public static DPath circle(float x, float y, float radius) {
 		// see http://spencermortensen.com/articles/bezier-circle/
 		return tracer -> {
 	}
 	
 	public static DPath roundedRectangle(float x, float y, float width, float height, float radius) {
+		if (radius < 0.01f)
+			return rectangle(x, y, width, height);
+		
 		return tracer -> {
 			float c = radius - radius * 0.551915024494f;
 			tracer.moveTo(x + width - radius, y + height);
 		};
 	}
 	
+	public static DPath roundedRectangle(float x, float y, float width, float height, float radiusTopLeft, float radiusTopRight, float radiusBottomLeft, float radiusBottomRight) {
+		return tracer -> {
+			float cTopLeft = radiusTopLeft - radiusTopLeft * 0.551915024494f;
+			float cTopRight = radiusTopRight - radiusTopRight * 0.551915024494f;
+			float cBottomLeft = radiusBottomLeft - radiusBottomLeft * 0.551915024494f;
+			float cBottomRight = radiusBottomRight - radiusBottomRight * 0.551915024494f;
+			
+			tracer.moveTo(x + width - radiusBottomRight, y + height);
+			if (radiusBottomRight > 0.01f) {
+				tracer.bezierCubic(
+						x + width - cBottomRight, y + height,
+						x + width, y + height - cBottomRight,
+						x + width, y + height - radiusBottomRight);
+			}
+			tracer.lineTo(x + width, y + radiusTopRight);
+			if (radiusTopRight > 0.01f) {
+				tracer.bezierCubic(
+						x + width, y + cTopRight,
+						x + width - cTopRight, y,
+						x + width - radiusTopRight, y);
+			}
+			tracer.lineTo(x + radiusTopLeft, y);
+			if (radiusTopLeft > 0.01f) {
+				tracer.bezierCubic(
+						x + cTopLeft, y,
+						x, y + cTopLeft,
+						x, y + radiusTopLeft);
+			}
+			tracer.lineTo(x, y + height - radiusBottomLeft);
+			if (radiusBottomLeft > 0.01f) {
+				tracer.bezierCubic(
+						x, y + height - cBottomLeft,
+						x + cBottomLeft, y + height,
+						x + radiusBottomLeft, y + height);
+			}
+			tracer.close();
+		};
+	}
+	
 	void trace(DPathTracer tracer);
 }

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

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

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import org.openzen.drawablegui.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;
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSimpleTooltipComponent implements DComponent {
+	private final DStyleClass styleClass;
+	private final LiveString tooltip;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	private final ListenerHandle<LiveString.Listener> tooltipListener;
+	
+	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;
+		tooltipListener = tooltip.addListener(this::onTooltipChanged);
+	}
+	
+	private void onTooltipChanged(String oldValue, String newValue) {
+		if (surface == null || bounds == null)
+			return;
+		
+		calculateSize();
+		bounds = new DIRectangle(
+				bounds.x,
+				bounds.y,
+				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
+				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom());
+		
+		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
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+	
+	@Override
+	public int getBaselineY() {
+		return style.border.getPaddingTop() + fontMetrics.getAscent();
+	}
+	
+	@Override
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
+	}
+	
+	@Override
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
+		
+		DStylePath path = parent.getChild("tooltip", styleClass);
+		style = new DSimpleTooltipStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.font);
+		calculateSize();
+		
+		if (text != null)
+			text.close();
+		text = surface.drawText(z + 1, style.font, style.textColor, 0, 0, tooltip.getValue());
+	}
+	
+	@Override
+	public void unmount() {
+		if (background != null)
+			background.close();
+		if (text != null)
+			text.close();
+	}
+	
+	@Override
+	public void close() {
+		tooltipListener.close();
+		unmount();
+	}
+	
+	private void calculateSize() {
+		sizing.setValue(new DSizing(
+				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
+				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom()));
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/DTooltipStyle.java → DrawableGui/src/main/java/org/openzen/drawablegui/DSimpleTooltipStyle.java

  *
  * @author Hoofdgebruiker
  */
-public class DTooltipStyle {
+public class DSimpleTooltipStyle {
 	public final DBorder border;
 	public final DFont font;
 	public final int backgroundColor;
 	public final int textColor;
 	
-	public DTooltipStyle(DStyleDefinition style) {
+	public DSimpleTooltipStyle(DStyleDefinition style) {
 		border = style.getBorder("border", context -> new DCompositeBorder(
-				new DLineBorder(0xFF, 1),
+				new DLineBorder(0xFF000000, 1),
 				new DPaddedBorder(context.dp(4), context.dp(4), context.dp(4), context.dp(4))));
 		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, context.sp(12)));
 		backgroundColor = style.getColor("backgroundColor", 0xFFFFFFE1);

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui;
-
-import org.openzen.drawablegui.style.DStylePath;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface DTooltip {
-	void setContext(DUIContext context, DStylePath parent);
-	
-	int getWidth();
-	
-	int getHeight();
-	
-	void setBounds(DIRectangle bounds);
-	
-	DIRectangle getBounds();
-	
-	void paint(DCanvas canvas);
-}

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

 	
 	DUIWindow openView(int x, int y, DAnchor anchor, DComponent root);
 	
-	DTooltipHandle openTooltip(int x, int y, DTooltip tooltip);
-	
 	default int dp(float dp) {
 		return (int)(dp * getScale());
 	}

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

  * @author Hoofdgebruiker
  */
 public interface DUIWindow {
-	DIRectangle getWindowBounds();
+	LiveObject<DIRectangle> getWindowBounds();
 	
 	DUIContext getContext();
 	

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui;
-
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import org.openzen.drawablegui.listeners.ListenerHandle;
-import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
-import org.openzen.drawablegui.style.DStyleClass;
-import org.openzen.drawablegui.style.DStylePath;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class DVerticalLayout extends BaseComponentGroup {
-	private final DStyleClass styleClass;
-	private final Alignment alignment;
-	private final Element[] components;
-	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
-	private final MutableLiveObject<DSizing> sizing = DSizing.create();
-	
-	private DUIContext context;
-	private DHorizontalLayoutStyle style;
-	private DIRectangle bounds;
-	private float totalGrow;
-	private float totalShrink;
-	
-	public DVerticalLayout(DStyleClass styleClass, Alignment alignment, Element... components) {
-		this.styleClass = styleClass;
-		this.alignment = alignment;
-		this.components = components;
-		
-		componentSizeListeners = new ListenerHandle[components.length];
-		totalGrow = 0;
-		totalShrink = 0;
-		
-		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateDimensionPreferences());
-			
-			totalGrow += components[i].grow;
-			totalShrink += components[i].shrink;
-		}
-	}
-
-	@Override
-	protected void forEachChild(Consumer<DComponent> children) {
-		for (Element element : components)
-			children.accept(element.component);
-	}
-
-	@Override
-	protected DComponent findChild(Predicate<DComponent> predicate) {
-		for (Element element : components)
-			if (predicate.test(element.component))
-				return element.component;
-		
-		return null;
-	}
-
-	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
-		
-		DStylePath path = parent.getChild("verticalLayout", styleClass);
-		style = new DHorizontalLayoutStyle(context.getStylesheets().get(context, path));
-		
-		for (Element element : components)
-			element.component.setContext(parent, context);
-		
-		layout();
-	}
-
-	@Override
-	public LiveObject<DSizing> getSizing() {
-		return sizing;
-	}
-
-	@Override
-	public DIRectangle getBounds() {
-		return bounds;
-	}
-
-	@Override
-	public int getBaselineY() {
-		return components[0].component.getBaselineY();
-	}
-
-	@Override
-	public void setBounds(DIRectangle bounds) {
-		this.bounds = bounds;
-		layout();
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		for (Element element : components) {
-			element.component.paint(canvas);
-		}
-	}
-
-	@Override
-	public void close() {
-		for (ListenerHandle<LiveObject.Listener<DSizing>> listener : componentSizeListeners) {
-			listener.close();
-		}
-	}
-	
-	public static enum Alignment {
-		TOP(0),
-		MIDDLE(0.5f),
-		BOTTOM(1);
-		
-		public final float align;
-		
-		Alignment(float align) {
-			this.align = align;
-		}
-	}
-	
-	public static enum ElementAlignment {
-		LEFT,
-		CENTER,
-		RIGHT,
-		STRETCH
-	}
-	
-	public static class Element {
-		public final DComponent component;
-		public final float grow;
-		public final float shrink;
-		public final ElementAlignment alignment;
-		
-		public Element(DComponent component, float grow, float shrink, ElementAlignment alignment) {
-			this.component = component;
-			this.grow = grow;
-			this.shrink = shrink;
-			this.alignment = alignment;
-		}
-	}
-	
-	private void layout() {
-		if (bounds == null || context == null)
-			return;
-		
-		DSizing myPreferences = sizing.getValue();
-		if (bounds.height < myPreferences.preferredHeight) {
-			layoutShrinked();
-		} else {
-			layoutGrown();
-		}
-	}
-	
-	private void layoutShrinked() {
-		DSizing myPreferences = sizing.getValue();
-		if (totalShrink == 0) {
-			// now what?
-			// shrink proportionally, we have to shrink...
-			float scale = (float)(bounds.height - (components.length - 1) * style.spacing) / (myPreferences.preferredHeight - (components.length - 1) * style.spacing);
-			int y = 0;
-			
-			for (int i = 0; i < components.length; i++) {
-				Element element = components[i];
-				DSizing preferences = element.component.getSizing().getValue();
-				int newY = y + preferences.preferredHeight;
-				float idealUnspacedY = newY * scale;
-				int idealY = (int)(idealUnspacedY + 0.5f + i * style.spacing);
-				layout(element, bounds.y + y, idealY - y);
-				y = idealY;
-			}
-		} else {
-			int delta = bounds.height - myPreferences.preferredHeight;
-			float deltaScaled = delta / totalShrink;
-			int y = bounds.y;
-			for (Element element : components) {
-				DSizing preferences = element.component.getSizing().getValue();
-				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
-				float idealUnspacedY = y + scaledSize;
-				int newY = (int)(idealUnspacedY + 0.5f);
-				layout(element, y, newY - y);
-				y = newY + style.spacing;
-			}
-		}
-	}
-	
-	private void layoutGrown() {
-		// resize according to grow values
-		DSizing myPreferences = sizing.getValue();
-		
-		if (totalGrow == 0) {
-			int deltaY = (int)(myPreferences.preferredHeight - bounds.height);
-			int y = bounds.y + (int)(deltaY * alignment.align);
-			for (Element element : components) {
-				DSizing preferences = element.component.getSizing().getValue();
-				int newY = y + preferences.preferredHeight;
-				layout(element, y, newY - y);
-				y = newY;
-			}
-		} else {
-			int delta = bounds.width - myPreferences.preferredWidth;
-			float deltaScaled = delta / totalGrow;
-			int y = bounds.y;
-			for (Element element : components) {
-				DSizing preferences = element.component.getSizing().getValue();
-				float scaledSize = preferences.preferredHeight + deltaScaled * element.grow;
-				float idealUnspacedY = y + scaledSize;
-				int newY = (int)(idealUnspacedY + 0.5f);
-				layout(element, y, newY - y);
-				y = newY + style.spacing;
-			}
-		}
-	}
-	
-	private void layout(Element element, int y, int height) {
-		DSizing preferences = element.component.getSizing().getValue();
-		int x;
-		int width;
-		switch (element.alignment) {
-			case LEFT:
-				width = Math.min(preferences.preferredWidth, bounds.width - style.paddingLeft - style.paddingRight);
-				x = bounds.x + style.paddingLeft;
-				break;
-			case CENTER:
-				width = Math.min(preferences.preferredWidth, bounds.width - style.paddingLeft - style.paddingRight);
-				x = bounds.x + style.paddingLeft + (bounds.width - style.paddingLeft - style.paddingRight - width) / 2;
-				break;
-			case RIGHT:
-				width = Math.min(preferences.preferredWidth, bounds.width - style.paddingLeft - style.paddingRight);
-				x = bounds.x + bounds.width - style.paddingLeft - width;
-				break;
-			case STRETCH:
-			default:
-				width = bounds.width - style.paddingLeft - style.paddingRight;
-				x = bounds.x + style.paddingLeft;
-				break;
-		}
-		element.component.setBounds(new DIRectangle(x, y, width, height));
-	}
-	
-	private void updateDimensionPreferences() {
-		int preferredWidth = 0;
-		int preferredHeight = -style.spacing;
-		int minimumWidth = 0;
-		int minimumHeight = -style.spacing;
-		int maximumWidth = Integer.MAX_VALUE;
-		int maximumHeight = -style.spacing;
-		
-		for (Element element : components) {
-			DSizing preferences = element.component.getSizing().getValue();
-			preferredWidth = Math.max(preferredWidth, preferences.preferredWidth);
-			preferredHeight += preferences.preferredHeight + style.spacing;
-			
-			minimumWidth = Math.max(minimumWidth, preferences.minimumWidth);
-			minimumHeight += preferences.minimumHeight + style.spacing;
-			
-			maximumWidth = Math.min(maximumWidth, preferences.maximumWidth);
-			maximumHeight += preferences.maximumHeight + style.spacing;
-		}
-		
-		DSizing preferences = new DSizing(
-				minimumWidth + style.paddingLeft + style.paddingRight,
-				minimumHeight + style.paddingTop + style.paddingBottom,
-				preferredWidth + style.paddingLeft + style.paddingRight,
-				preferredHeight + style.paddingTop + style.paddingBottom,
-				maximumWidth + style.paddingLeft + style.paddingRight,
-				maximumHeight + style.paddingTop + style.paddingBottom);
-		sizing.setValue(preferences);
-	}
-}

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui;
-
-import org.openzen.drawablegui.style.DDpDimension;
-import org.openzen.drawablegui.style.DStyleDefinition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class DVerticalLayoutStyle {
-	public final int spacing;
-	
-	public final int paddingTop;
-	public final int paddingLeft;
-	public final int paddingRight;
-	public final int paddingBottom;
-	
-	public DVerticalLayoutStyle(DStyleDefinition style) {
-		spacing = style.getDimension("spacing", new DDpDimension(8));
-		
-		paddingTop = style.getDimension("paddingTop", new DDpDimension(8));
-		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(8));
-		paddingRight = style.getDimension("paddingRight", new DDpDimension(8));
-		paddingBottom = style.getDimension("paddingBottom", new DDpDimension(8));
-	}
-}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import java.util.List;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface Destructible extends AutoCloseable {
+	public static <T extends Destructible> void close(List<T> list) {
+		for (T item : list)
+			item.close();
+	}
+	
+	@Override
+	public void close();
+}

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

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

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(),
 			total += border.getPaddingBottom();
 		return total;
 	}
+	
+	@Override
+	public void close() {
+		for (DBorder border : borders)
+			border.close();
+	}
 }

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

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

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;
 
 /**
  *
  */
 public class DEmptyBorder implements DBorder {
 	public static final DEmptyBorder INSTANCE = new DEmptyBorder();
+	public static final DBorderElement ELEMENT = context -> INSTANCE;
 	
 	private DEmptyBorder() {}
 	
 	@Override
-	public void paint(DCanvas canvas, DIRectangle bounds) {
+	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
 		
 	}
 
 	public int getPaddingBottom() {
 		return 0;
 	}
+
+	@Override
+	public void close() {
+		
+	}
 }

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);
 	public int getPaddingBottom() {
 		return borderWidth;
 	}
+
+	@Override
+	public void close() {
+		if (shape != null)
+			shape.close();
+	}
 }

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

  */
 package org.openzen.drawablegui.border;
 
-import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawSurface;
 
 /**
  *
 		this.right = right;
 		this.bottom = bottom;
 	}
+	
+	public DPaddedBorder(int size) {
+		this(size, size, size, size);
+	}
 
 	@Override
-	public void paint(DCanvas canvas, DIRectangle bounds) {
+	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
 		// nothing to paint
 	}
 
 	public int getPaddingBottom() {
 		return bottom;
 	}
+
+	@Override
+	public void close() {
+		
+	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.border;
+
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnShape;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSideBorder implements DBorder {
+	public final int leftWidth;
+	public final int leftColor;
+	public final int topWidth;
+	public final int topColor;
+	public final int rightWidth;
+	public final int rightColor;
+	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,
+			int rightWidth, int rightColor,
+			int bottomWidth, int bottomColor) {
+		this.leftWidth = leftWidth;
+		this.leftColor = leftColor;
+		this.topWidth = topWidth;
+		this.topColor = topColor;
+		this.rightWidth = rightWidth;
+		this.rightColor = rightColor;
+		this.bottomWidth = bottomWidth;
+		this.bottomColor = bottomColor;
+	}
+
+	@Override
+	public void update(DDrawSurface surface, int z, DIRectangle bounds) {
+		if (leftWidth > 0) {
+			int x = bounds.x;
+			if (left != null)
+				left.close();
+			left = surface.strokePath(z, DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+		if (topWidth > 0) {
+			int y = bounds.y;
+			if (top != null)
+				top.close();
+			top = surface.strokePath(z, DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+		if (rightWidth > 0) {
+			int x = bounds.x + bounds.width - rightWidth;
+			if (right != null)
+				right.close();
+			right = surface.strokePath(z, DPath.line(x, bounds.y, x, bounds.y + bounds.height), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+		if (bottomWidth > 0) {
+			int y = bounds.y + bounds.height - bottomWidth;
+			if (bottom != null)
+				bottom.close();
+			bottom = surface.strokePath(z, DPath.line(bounds.x, y, bounds.x + bounds.width, y), DTransform2D.IDENTITY, topColor, topWidth);
+		}
+	}
+
+	@Override
+	public int getPaddingLeft() {
+		return leftWidth;
+	}
+
+	@Override
+	public int getPaddingRight() {
+		return rightWidth;
+	}
+
+	@Override
+	public int getPaddingTop() {
+		return topWidth;
+	}
+
+	@Override
+	public int getPaddingBottom() {
+		return bottomWidth;
+	}
+
+	@Override
+	public void close() {
+		if (left != null)
+			left.close();
+		if (top != null)
+			top.close();
+		if (right != null)
+			right.close();
+		if (bottom != null)
+			bottom.close();
+	}
+}

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

+/*
+ * 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.DUIContext;
+import org.openzen.drawablegui.style.DStyleDefinition;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawSurface extends DDrawTarget {
+	DUIContext getContext();
+	
+	DStyleDefinition getStylesheet(DStylePath path);
+	
+	DSubSurface createSubSurface(int z);
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.draw;
+
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.style.DShadow;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawTarget {
+	public static final int INSTANCE_COLOR = 1;
+	
+	DFontMetrics getFontMetrics(DFont font);
+	
+	float getScale();
+	
+	float getTextScale();
+	
+	DDrawnText drawText(int z, DFont font, int color, float x, float y, String text);
+	
+	DDrawnRectangle fillRect(int z, DIRectangle rectangle, int color);
+	
+	DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth);
+	
+	DDrawnShape fillPath(int z, DPath path, DTransform2D transform, int color);
+	
+	DDrawnShape shadowPath(int z, DPath path, DTransform2D transform, int color, DShadow shadow);
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.draw;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnColorableElement extends DDrawnElement {
+	void setColor(int color);
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.draw;
+
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.Destructible;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnElement extends Destructible {
+	void setTransform(DTransform2D transform);
+	
+	DIRectangle getBounds();
+}

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 org.openzen.drawablegui.DIRectangle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnRectangle extends DDrawnColorableElement {
+	void setRectangle(DIRectangle rectangle);
+}

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

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.drawablegui;
+package org.openzen.drawablegui.draw;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public interface DTooltipHandle {
-	void close();
+public interface DDrawnShape extends DDrawnColorableElement {
+	
 }

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 org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawnText extends DDrawnColorableElement {
+	@Override
+	default void setTransform(DTransform2D transform) { // only uses position, not scaling or rotation
+		setPosition(transform.xx, transform.yy);
+	}
+	
+	void setPosition(float x, float y);
+}

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

+/*
+ * 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;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DSubSurface extends DDrawnElement, DDrawSurface {
+	@Override
+	default void setTransform(DTransform2D transform) {
+		setOffset((int)transform.xx, (int)transform.yy);
+	}
+	
+	void setOffset(int x, int y);
+	
+	void setClip(DIRectangle bounds);
+}

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

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

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

+/*
+ * 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.layout;
+
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import org.openzen.drawablegui.BaseComponentGroup;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DSizing;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DLinearLayout extends BaseComponentGroup {
+	private final DStyleClass styleClass;
+	private final Orientation orientation;
+	private final Alignment alignment;
+	private final Element[] components;
+	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	
+	private DDrawSurface surface;
+	private int z;
+	private DLinearLayoutStyle style;
+	private DIRectangle bounds;
+	private float totalGrow;
+	private float totalShrink;
+	private DDrawnShape shape;
+	
+	public DLinearLayout(DStyleClass styleClass, Orientation orientation, Alignment alignment, Element... components) {
+		this.styleClass = styleClass;
+		this.orientation = orientation;
+		this.alignment = alignment;
+		this.components = components;
+		
+		componentSizeListeners = new ListenerHandle[components.length];
+		totalGrow = 0;
+		totalShrink = 0;
+		
+		for (int i = 0; i < componentSizeListeners.length; i++) {
+			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateSizing());
+			
+			totalGrow += components[i].grow;
+			totalShrink += components[i].shrink;
+		}
+	}
+
+	@Override
+	protected void forEachChild(Consumer<DComponent> children) {
+		for (Element element : components)
+			children.accept(element.component);
+	}
+
+	@Override
+	protected DComponent findChild(Predicate<DComponent> predicate) {
+		for (Element element : components)
+			if (predicate.test(element.component))
+				return element.component;
+		
+		return null;
+	}
+
+	@Override
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
+		
+		DStylePath path = parent.getChild("linearlayout", styleClass);
+		style = new DLinearLayoutStyle(surface.getStylesheet(path));
+		
+		for (Element element : components)
+			element.component.mount(parent, z + 1, surface);
+	}
+	
+	@Override
+	public void unmount() {
+		for (Element element : components)
+			element.component.unmount();
+	}
+
+	@Override
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public int getBaselineY() {
+		return components[0].component.getBaselineY();
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		if (bounds.equals(this.bounds))
+			return;
+		
+		this.bounds = 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 close() {
+		for (ListenerHandle<LiveObject.Listener<DSizing>> listener : componentSizeListeners) {
+			listener.close();
+		}
+		for (Element element : components)
+			element.component.close();
+	}
+	
+	private int getInnerWidth() {
+		return bounds.width - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
+	}
+	
+	private int getInnerHeight() {
+		return bounds.height - style.margin.getVertical() - style.border.getPaddingVertical();
+	}
+	
+	private int getPreferredInnerWidth() {
+		DSizing myPreferences = sizing.getValue();
+		return myPreferences.preferredWidth - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
+	}
+	
+	private int getPreferredInnerHeight() {
+		DSizing myPreferences = sizing.getValue();
+		return myPreferences.preferredHeight - style.margin.getVertical() - style.border.getPaddingVertical();
+	}
+	
+	private void layout() {
+		if (orientation == Orientation.HORIZONTAL) {
+			layoutHorizontal();
+		} else {
+			layoutVertical();
+		}
+	}
+	
+	private void layoutHorizontal() {
+		if (bounds == null || surface == null)
+			return;
+		
+		DSizing myPreferences = sizing.getValue();
+		if (bounds.width < myPreferences.preferredWidth) {
+			layoutHorizontalShrinked();
+		} else {
+			layoutHorizontalGrown();
+		}
+	}
+	
+	private void layoutVertical() {
+		if (bounds == null || surface == null)
+			return;
+		
+		DSizing myPreferences = sizing.getValue();
+		if (bounds.height < myPreferences.preferredHeight) {
+			layoutVerticalShrinked();
+		} else {
+			layoutVerticalGrown();
+		}
+	}
+	
+	private void layoutHorizontalShrinked() {
+		float availableWidth = getInnerWidth() - (components.length - 1) * style.spacing;
+		float preferredInnerWidth = getPreferredInnerWidth() - (components.length - 1) * style.spacing;
+		
+		if (totalShrink == 0) {
+			// now what?
+			// shrink proportionally, we have to shrink...
+			float scale = availableWidth / preferredInnerWidth;
+			int x = bounds.x + style.margin.left + style.border.getPaddingLeft();
+			
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				int newX = (int)(x + preferences.preferredWidth * scale + 0.5f);
+				layoutHorizontal(element, bounds.x + x, newX - x);
+				x = newX + style.spacing;
+			}
+		} else {
+			int delta = getInnerHeight() - getPreferredInnerHeight();
+			float deltaScaled = delta / totalShrink;
+			int y = bounds.y;
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
+				float idealUnspacedY = y + scaledSize;
+				int newX = (int)(idealUnspacedY + 0.5f);
+				layoutHorizontal(element, y, newX - y);
+				y = newX + style.spacing;
+			}
+		}
+	}
+	
+	private void layoutVerticalShrinked() {
+		float availableHeight = getInnerHeight() - (components.length - 1) * style.spacing;
+		float preferredInnerHeight = getPreferredInnerHeight() - (components.length - 1) * style.spacing;
+		
+		if (totalShrink == 0) {
+			// now what?
+			// shrink proportionally, we have to shrink...
+			float scale = availableHeight / preferredInnerHeight;
+			int y = bounds.y + style.margin.top + style.border.getPaddingTop();
+			
+			for (int i = 0; i < components.length; i++) {
+				Element element = components[i];
+				DSizing preferences = element.component.getSizing().getValue();
+				int newY = (int)(y + preferences.preferredHeight * scale + 0.5f);
+				layoutVertical(element, bounds.y + y, newY - y);
+				y = newY + style.spacing;
+			}
+		} else {
+			int delta = getInnerHeight() - getPreferredInnerHeight();
+			float deltaScaled = delta / totalShrink;
+			int y = bounds.y;
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
+				float idealUnspacedY = y + scaledSize;
+				int newY = (int)(idealUnspacedY + 0.5f);
+				layoutVertical(element, y, newY - y);
+				y = newY + style.spacing;
+			}
+		}
+	}
+	
+	private void layoutHorizontalGrown() {
+		// resize according to grow values
+		int delta = getPreferredInnerWidth() - getInnerWidth();
+		if (totalGrow == 0) {
+			int x = bounds.x + style.margin.left + style.border.getPaddingLeft() + (int)(delta * alignment.align);
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				int newX = x + preferences.preferredWidth;
+				layoutHorizontal(element, x, newX - x);
+				x = newX;
+			}
+		} else {
+			float deltaScaled = delta / totalGrow;
+			int x = bounds.x + style.margin.left + style.border.getPaddingLeft();
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				float scaledSize = preferences.preferredWidth - deltaScaled * element.grow;
+				float idealUnspacedX = x + scaledSize;
+				int newX = (int)(idealUnspacedX + 0.5f);
+				layoutHorizontal(element, x, newX - x);
+				x = newX + style.spacing;
+			}
+		}
+	}
+	
+	private void layoutVerticalGrown() {
+		// resize according to grow values
+		int delta = getPreferredInnerHeight() - getInnerHeight();
+		if (totalGrow == 0) {
+			int y = bounds.y + style.margin.top + style.border.getPaddingTop() + (int)(delta * alignment.align);
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				int newY = y + preferences.preferredHeight;
+				layoutVertical(element, y, newY - y);
+				y = newY;
+			}
+		} else {
+			float deltaScaled = delta / totalGrow;
+			int y = bounds.y + style.margin.top + style.border.getPaddingTop();
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				float scaledSize = preferences.preferredHeight - deltaScaled * element.grow;
+				float idealUnspacedY = y + scaledSize;
+				int newY = (int)(idealUnspacedY + 0.5f);
+				layoutVertical(element, y, newY - y);
+				y = newY + style.spacing;
+			}
+		}
+	}
+	
+	private void layoutHorizontal(Element element, int x, int width) {
+		DSizing preferences = element.component.getSizing().getValue();
+		int height;
+		int y;
+		switch (element.alignment) {
+			case BOTTOM:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.border.getPaddingVertical());
+				y = bounds.y + style.border.getPaddingTop();
+				break;
+			case MIDDLE:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.border.getPaddingVertical());
+				y = bounds.y + style.border.getPaddingTop() + (bounds.height - style.border.getPaddingVertical() - height) / 2;
+				break;
+			case TOP:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.border.getPaddingVertical());
+				y = bounds.y + bounds.height - style.border.getPaddingBottom() - height;
+				break;
+			case STRETCH:
+			default:
+				height = bounds.height - style.border.getPaddingVertical();
+				y = bounds.y + style.border.getPaddingTop();
+				break;
+		}
+		element.component.setBounds(new DIRectangle(x, y, width, height));
+	}
+	
+	private void layoutVertical(Element element, int y, int height) {
+		DSizing preferences = element.component.getSizing().getValue();
+		int x;
+		int width;
+		switch (element.alignment) {
+			case LEFT:
+				width = Math.min(preferences.preferredWidth, bounds.width - style.border.getPaddingHorizontal() - style.margin.getHorizontal());
+				x = bounds.x + style.margin.left + style.border.getPaddingLeft();
+				break;
+			case CENTER:
+				width = Math.min(preferences.preferredWidth, bounds.width - style.border.getPaddingHorizontal());
+				x = bounds.x + style.margin.left + style.border.getPaddingLeft() + (bounds.width - style.border.getPaddingHorizontal() - width) / 2;
+				break;
+			case RIGHT:
+				width = Math.min(preferences.preferredWidth, bounds.width - style.border.getPaddingHorizontal());
+				x = bounds.x + bounds.width - style.margin.right - style.border.getPaddingRight() - width;
+				break;
+			case STRETCH:
+			default:
+				width = bounds.width - style.border.getPaddingHorizontal() - style.margin.getHorizontal();
+				x = bounds.x + style.margin.left + style.border.getPaddingLeft();
+				break;
+		}
+		element.component.setBounds(new DIRectangle(x, y, width, height));
+	}
+	
+	private void updateSizing() {
+		if (orientation == Orientation.HORIZONTAL) {
+			updateSizingHorizontal();
+		} else {
+			updateSizingVertical();
+		}
+	}
+	
+	private void updateSizingHorizontal() {
+		int preferredWidth = -style.spacing;
+		int preferredHeight = 0;
+		int minimumWidth = -style.spacing;
+		int minimumHeight = Integer.MAX_VALUE;
+		int maximumWidth = -style.spacing;
+		int maximumHeight = 0;
+		
+		for (Element element : components) {
+			DSizing preferences = element.component.getSizing().getValue();
+			preferredWidth += preferences.preferredWidth + style.spacing;
+			preferredHeight = Math.max(preferredHeight, preferences.preferredHeight);
+			
+			minimumWidth += preferences.minimumWidth + style.spacing;
+			minimumHeight = Math.max(minimumHeight, preferences.minimumHeight);
+			
+			maximumHeight += preferences.maximumWidth + style.spacing;
+			maximumWidth = Math.min(maximumHeight, preferences.maximumHeight);
+		}
+		
+		int paddingHorizontal = style.border.getPaddingHorizontal() + style.margin.getHorizontal();
+		int paddingVertical = style.border.getPaddingVertical() + style.margin.getVertical();
+		DSizing preferences = new DSizing(
+				minimumWidth + paddingHorizontal,
+				minimumHeight + paddingVertical,
+				preferredWidth + paddingHorizontal,
+				preferredHeight + paddingVertical,
+				maximumWidth + paddingHorizontal,
+				maximumHeight + paddingVertical);
+		sizing.setValue(preferences);
+	}
+	
+	private void updateSizingVertical() {
+		int preferredWidth = 0;
+		int preferredHeight = -style.spacing;
+		int minimumWidth = 0;
+		int minimumHeight = -style.spacing;
+		int maximumWidth = Integer.MAX_VALUE;
+		int maximumHeight = -style.spacing;
+		
+		for (Element element : components) {
+			DSizing preferences = element.component.getSizing().getValue();
+			preferredWidth = Math.max(preferredWidth, preferences.preferredWidth);
+			preferredHeight += preferences.preferredHeight + style.spacing;
+			
+			minimumWidth = Math.max(minimumWidth, preferences.minimumWidth);
+			minimumHeight += preferences.minimumHeight + style.spacing;
+			
+			maximumWidth = Math.min(maximumWidth, preferences.maximumWidth);
+			maximumHeight += preferences.maximumHeight + style.spacing;
+		}
+		
+		int paddingHorizontal = style.border.getPaddingHorizontal() + style.margin.getHorizontal();
+		int paddingVertical = style.border.getPaddingVertical() + style.margin.getVertical();
+		DSizing preferences = new DSizing(
+				minimumWidth + paddingHorizontal,
+				minimumHeight + paddingVertical,
+				preferredWidth + paddingHorizontal,
+				preferredHeight + paddingVertical,
+				maximumWidth + paddingHorizontal,
+				maximumHeight + paddingVertical);
+		sizing.setValue(preferences);
+	}
+	
+	public static enum Orientation {
+		HORIZONTAL,
+		VERTICAL
+	}
+	
+	public static enum Alignment {
+		TOP(0),
+		LEFT(0),
+		MIDDLE(0.5f),
+		CENTER(0.5f),
+		BOTTOM(1),
+		RIGHT(1);
+		
+		public final float align;
+		
+		Alignment(float align) {
+			this.align = align;
+		}
+	}
+	
+	public static enum ElementAlignment {
+		LEFT,
+		CENTER,
+		RIGHT,
+		TOP,
+		MIDDLE,
+		BOTTOM,
+		STRETCH
+	}
+	
+	public static class Element {
+		public final DComponent component;
+		public final float grow;
+		public final float shrink;
+		public final ElementAlignment alignment;
+		
+		public Element(DComponent component, float grow, float shrink, ElementAlignment alignment) {
+			this.component = component;
+			this.grow = grow;
+			this.shrink = shrink;
+			this.alignment = alignment;
+		}
+	}
+}

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

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

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.drawablegui;
+package org.openzen.drawablegui.layout;
 
 import java.io.Closeable;
 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.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DSizing;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 	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.mount(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.mount(path, z + 1, surface);
 			setBounds(bounds);
-			context.repaint(bounds);
 		}
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		this.path = parent.getChild("sidelayout", styleClass);
+		style = new DSideLayoutStyle(surface.getStylesheet(path));
 		
-		main.setContext(path, context);
+		main.mount(path, z + 1, surface);
 		for (SideComponent side : sides)
-			side.component.setContext(path, context);
+			side.component.mount(path, z + 1, surface);
+		
+		if (background != null)
+			background.close();
+		background = surface.fillRect(z, DIRectangle.EMPTY, style.backgroundColor);
+	}
+	
+	@Override
+	public void unmount() {
+		main.unmount();
+		for (SideComponent side : sides)
+			side.component.unmount();
+		
+		background.close();
+		background = null;
 	}
 	
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
+		background.setRectangle(bounds);
+		
 		int left = bounds.x;
 		int right = bounds.x + bounds.width;
 		int top = bounds.y;
 		
 		main.setBounds(new DIRectangle(left, top, right - left, bottom - top));
 	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		main.paint(canvas);
-		
-		for (SideComponent component : sides)
-			component.component.paint(canvas);
-	}
 	
 	private void recalculateSize() {
 		DSizing mainPreferences = main.getSizing().getValue();
 		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/layout/DSideLayoutStyle.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.layout;
+
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSideLayoutStyle {
+	public final int backgroundColor;
+	
+	public DSideLayoutStyle(DStyleDefinition style) {
+		backgroundColor = style.getColor("backgroundColor", 0);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.live;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InverseLiveBool implements LiveBool {
+	private final LiveBool source;
+	
+	public InverseLiveBool(LiveBool source) {
+		this.source = source;
+	}
+
+	@Override
+	public boolean getValue() {
+		return !source.getValue();
+	}
+
+	@Override
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return source.addListener((oldValue, newValue) -> listener.onChanged(!oldValue, !newValue));
+	}
+}

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

  */
 package org.openzen.drawablegui.live;
 
-import java.io.Closeable;
 import java.util.Iterator;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.listeners.ListenerList;
 
  *
  * @author Hoofdgebruiker
  */
-public class LiveConcatList<T> implements Closeable, LiveList<T> {
+public class LiveConcatList<T> implements Destructible, LiveList<T> {
 	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
 	private final LiveList<T> a;
 	private final LiveList<T> b;

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

  */
 package org.openzen.drawablegui.live;
 
-import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.listeners.ListenerList;
 
  *
  * @author Hoofdgebruiker
  */
-public class LiveMappedList<T, U> implements Closeable, LiveList<U> {
+public class LiveMappedList<T, U> implements Destructible, LiveList<U> {
 	private final ListenerList<Listener<U>> listeners = new ListenerList<>();
 	private final Function<T, U> projection;
 	private final List<U> mapped;
 		@Override
 		public void onRemoved(int index, T oldValue) {
 			U oldMappedValue = mapped.remove(index);
+			if (oldMappedValue instanceof AutoCloseable) {
+				try { ((AutoCloseable) oldMappedValue).close(); } catch (Exception ex) {}
+			}
 			listeners.accept(listener -> listener.onRemoved(index, oldMappedValue));
 		}
 	}

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

  */
 package org.openzen.drawablegui.live;
 
-import java.io.Closeable;
 import java.util.function.Predicate;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.listeners.ListenerList;
 
  *
  * @author Hoofdgebruiker
  */
-public class LivePredicateBool<T> implements LiveBool, Closeable, LiveObject.Listener<T> {
+public class LivePredicateBool<T> implements LiveBool, Destructible, LiveObject.Listener<T> {
 	private final ListenerList<LiveBool.Listener> listeners = new ListenerList<>();
 	private final LiveObject<T> source;
 	private final Predicate<T> predicate;

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

  */
 public class SimpleLiveInt implements LiveInt {
 	private final ListenerList<Listener> listeners = new ListenerList<>();
-	private int value = 0;
+	private int value;
 
+	public SimpleLiveInt(int value) {
+		this.value = value;
+	}
+	
 	@Override
 	public int getValue() {
 		return value;
 
 	@Override
 	public void setValue(int value) {
+		if (value == this.value)
+			return;
+		
 		int oldValue = this.value;
 		this.value = value;
 		listeners.accept(listener -> listener.onChanged(oldValue, value));

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

 	
 	@Override
 	public void setValue(T value) {
+		if (value == this.value)
+			return;
+		
 		T oldValue = this.value;
 		this.value = value;
 		listeners.accept(listener -> listener.onUpdated(oldValue, value));

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

 
 	@Override
 	public void setValue(String value) {
+		if (value.equals(this.value))
+			return;
+		
 		String oldValue = this.value;
 		this.value = value;
 		listeners.accept(listener -> listener.onChanged(oldValue, value));

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

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

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

 package org.openzen.drawablegui.scroll;
 
 import org.openzen.drawablegui.DAnchor;
-import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTimerHandle;
-import org.openzen.drawablegui.DTooltip;
-import org.openzen.drawablegui.DTooltipHandle;
+import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveInt;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.SimpleLiveInt;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.draw.DDrawSurface;
+import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DSubSurface;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.drawablegui.style.DStyleSheets;
 	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 int z;
+	private DDrawnShape shape;
 	private final LiveInt contentsHeight;
 	private final LiveInt offsetX;
 	private final LiveInt offsetY;
 	
+	private final LiveObject<DSizing> sizing;
+	
 	private final ListenerHandle<LiveInt.Listener> contentsHeightListener;
 	private final ListenerHandle<LiveInt.Listener> offsetXListener;
 	private final ListenerHandle<LiveInt.Listener> offsetYListener;
+	private final ListenerHandle<LiveObject.Listener<DSizing>> contentsSizingListener;
 	
 	private DComponent hovering = null;
 	
-	public DScrollPane(DStyleClass styleClass, DComponent contents) {
+	private DSubSurface subSurface;
+	
+	public DScrollPane(DStyleClass styleClass, DComponent contents, LiveObject<DSizing> sizing) {
+		this.sizing = sizing;
 		this.styleClass = styleClass;
 		this.contents = contents;
 		
-		contentsHeight = new SimpleLiveInt();
-		offsetX = new SimpleLiveInt();
-		offsetY = new SimpleLiveInt();
+		contentsHeight = new SimpleLiveInt(0);
+		offsetX = new SimpleLiveInt(0);
+		offsetY = new SimpleLiveInt(0);
 		
 		scrollBar = new DScrollBar(DStyleClass.EMPTY, contentsHeight, offsetY);
 		
 		offsetXListener = offsetX.addListener(new ScrollListener());
 		offsetYListener = offsetY.addListener(new ScrollListener());
 		
-		contents.getSizing().addListener((oldPreferences, newPreferences) -> {
+		contentsSizingListener = contents.getSizing().addListener((oldPreferences, newPreferences) -> {
 			if (bounds == null)
 				return;
 			
 	}
 
 	@Override
-	public void setContext(DStylePath parent, DUIContext context) {
-		this.context = context;
+	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+		this.surface = surface;
+		this.z = z;
 		
 		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.mount(path, 1, subSurface);
+		scrollBar.mount(path, z + 2, surface);
+		style = new DScrollPaneStyle(surface.getStylesheet(path));
+	}
+	
+	@Override
+	public void unmount() {
+		subSurface.close();
 		
-		if (bounds != null)
-			setBounds(bounds);
+		contents.unmount();
+		scrollBar.unmount();
 	}
 
 	@Override
 	public LiveObject<DSizing> getSizing() {
-		return contents.getSizing(); // TODO: derived preferences
+		return sizing;
 	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
-		if (this.context == null)
-			return;
+		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(),
+		int height = Math.max(
+				bounds.height - style.border.getPaddingHorizontal(),
 				contents.getSizing().getValue().preferredHeight);
 		int scrollBarWidth = scrollBar.getSizing().getValue().preferredWidth;
 		scrollBar.setBounds(new DIRectangle(
-				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight(),
-				bounds.y + style.border.getPaddingTop(),
+				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight() - style.margin.right,
+				bounds.y + style.border.getPaddingTop() + style.margin.top,
 				scrollBarWidth,
-				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom()));
+				bounds.height - style.border.getPaddingVertical() - style.margin.getVertical()));
 		contents.setBounds(new DIRectangle(0, 0, bounds.width - scrollBar.getBounds().width, height));
 		contentsHeight.setValue(height);
-	}
-
-	@Override
-	public void paint(DCanvas canvas) {
-		if (bounds == null)
-			return;
 		
-		style.border.paint(canvas, bounds);
-		scrollBar.paint(canvas);
-		
-		canvas.pushBounds(new DIRectangle(
-				bounds.x + style.border.getPaddingLeft(),
-				bounds.y + style.border.getPaddingTop(),
-				bounds.width - style.border.getPaddingLeft() - style.border.getPaddingTop() - scrollBar.getBounds().width,
-				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom()));
-		canvas.pushOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
-		contents.paint(canvas);
-		canvas.popOffset();
-		canvas.popBounds();
+		subSurface.setOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
+		subSurface.setClip(new DIRectangle(
+				bounds.x + style.margin.left + style.border.getPaddingLeft(),
+				bounds.y + style.margin.top + style.border.getPaddingTop(),
+				bounds.width - style.margin.getHorizontal() - style.border.getPaddingHorizontal(),
+				bounds.height - style.margin.getVertical() - style.border.getPaddingVertical()));
 	}
 	
 	@Override
 	@Override
 	public void close() {
 		contents.close();
+		unmount();
+		
+		contentsSizingListener.close();
+		contentsHeightListener.close();
+		offsetXListener.close();
+		offsetYListener.close();
 	}
 	
 	private DMouseEvent forward(DComponent target, DMouseEvent e) {
 		return y - bounds.y + offsetY.getValue();
 	}
 	
-	private class TranslatedContext implements DUIContext {
-		
-		@Override
-		public DStyleSheets getStylesheets(){
-			return context.getStylesheets();
-		}
-
-		@Override
-		public float getScale() {
-			return context.getScale();
-		}
-		
-		@Override
-		public float getTextScale() {
-			return context.getTextScale();
-		}
-
-		@Override
-		public void repaint(int x, int y, int width, int height) {
-			int left = toGlobalX(x);
-			int top = toGlobalY(y);
-			int right = left + width;
-			int bottom = top + height;
-			
-			left = Math.max(bounds.x, left);
-			top = Math.max(bounds.y, top);
-			right = Math.min(bounds.x + bounds.width, right);
-			bottom = Math.min(bounds.y + bounds.height, bottom);
-			
-			if (left >= right || top >= bottom)
-				return;
-			
-			context.repaint(left, top, right - left, bottom - top);
-		}
-
-		@Override
-		public void setCursor(Cursor cursor) {
-			context.setCursor(cursor);
-		}
-
-		@Override
-		public DFontMetrics getFontMetrics(DFont font) {
-			return context.getFontMetrics(font);
-		}
-
-		@Override
-		public void scrollInView(int x, int y, int width, int height) {
-			if (y < offsetY.getValue())
-				offsetY.setValue(y);
-			if (y + height > offsetY.getValue() + bounds.height)
-				offsetY.setValue(y + height - bounds.height);
-		}
-
-		@Override
-		public DTimerHandle setTimer(int millis, Runnable target) {
-			return context.setTimer(millis, target);
-		}
-
-		@Override
-		public DClipboard getClipboard() {
-			return context.getClipboard();
-		}
-
-		@Override
-		public DUIWindow getWindow() {
-			return context.getWindow();
-		}
-
-		@Override
-		public DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root) {
-			return context.openDialog(toGlobalX(x), toGlobalY(y), anchor, title, root);
-		}
-
-		@Override
-		public DUIWindow openView(int x, int y, DAnchor anchor, DComponent root) {
-			return context.openView(toGlobalX(x), toGlobalY(y), anchor, root);
-		}
-		
-		@Override
-		public DTooltipHandle openTooltip(int x, int y, DTooltip tooltip) {
-			return context.openTooltip(toGlobalX(x), toGlobalY(y), tooltip);
-		}
-	}
-	
 	private class ScrollListener implements LiveInt.Listener {
 
 		@Override
 			
 			if (value != offsetY.getValue())
 				offsetY.setValue(value);
-			if (context != null && bounds != null)
-				context.repaint(bounds);
+			
+			subSurface.setOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
 		}
 	}
 }

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

  */
 package org.openzen.drawablegui.scroll;
 
-import org.openzen.drawablegui.border.DBorder;
-import org.openzen.drawablegui.border.DLineBorder;
+import org.openzen.drawablegui.style.DBaseStyle;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class DScrollPaneStyle {
-	public final DBorder border;
-	
+public class DScrollPaneStyle extends DBaseStyle {
 	public DScrollPaneStyle(DStyleDefinition style) {
-		this.border = style.getBorder("border", context -> new DLineBorder(0xFF888888, 1));
+		super(style);
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.border.DBorder;
+import org.openzen.drawablegui.border.DEmptyBorder;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DBaseStyle {
+	public final DMargin margin;
+	public final DBorder border;
+	public final DShadow shadow;
+	public final DShape shape;
+	public final int backgroundColor;
+	
+	public DBaseStyle(DStyleDefinition style) {
+		border = style.getBorder("border", DEmptyBorder.ELEMENT);
+		backgroundColor = style.getColor("backgroundColor", 0);
+		margin = style.getMargin("margin", DMargin.EMPTY_ELEMENT);
+		shape = style.getShape("shape", DRectangleShape.ELEMENT);
+		shadow = style.getShadow("shadow", DShadow.NONE_ELEMENT);
+	}
+	
+	public DBaseStyle(DStyleDefinition style, DBorderElement defaultBorder, int defaultBackgroundColor) {
+		border = style.getBorder("border", defaultBorder);
+		backgroundColor = style.getColor("backgroundColor", defaultBackgroundColor);
+		margin = style.getMargin("margin", DMargin.EMPTY_ELEMENT);
+		shape = style.getShape("shape", DRectangleShape.ELEMENT);
+		shadow = style.getShadow("shadow", DShadow.NONE_ELEMENT);
+	}
+	
+	public DBaseStyle(DStyleDefinition style, DBorderElement defaultBorder, int defaultBackgroundColor, DShapeElement defaultShape, DShadowElement defaultShadow) {
+		border = style.getBorder("border", defaultBorder);
+		backgroundColor = style.getColor("backgroundColor", defaultBackgroundColor);
+		margin = style.getMargin("margin", DMargin.EMPTY_ELEMENT);
+		shape = style.getShape("shape", defaultShape);
+		shadow = style.getShadow("shadow", defaultShadow);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.border.DBorder;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DBorderElement extends DStyleElement {
+	DBorder eval(DUIContext context);
+	
+	@Override
+	default DBorderElement asBorder() {
+		return this;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DColorElement implements DStyleElement {
+	private final int color;
+	
+	public DColorElement(int color) {
+		this.color = color;
+	}
+	
+	@Override
+	public int asColor() {
+		return color;
+	}
+}

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

  *
  * @author Hoofdgebruiker
  */
-public interface DDimension {
+public interface DDimension extends DStyleElement {
 	float eval(DUIContext context);
 	
 	default int evalInt(DUIContext context) {
 		return (int)(eval(context) + 0.5f);
 	}
+	
+	@Override
+	default DDimension asDimension() {
+		return this;
+	}
 }

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

  */
 package org.openzen.drawablegui.style;
 
-import java.util.function.Function;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.border.DBorder;
 	}
 
 	@Override
-	public DShadow getShadow(String name, Function<DUIContext, DShadow> defaultValue) {
-		return defaultValue.apply(context);
+	public DShadow getShadow(String name, DShadowElement defaultValue) {
+		return defaultValue.eval(context);
 	}
 
 	@Override
-	public DFont getFont(String name, Function<DUIContext, DFont> defaultValue) {
-		return defaultValue.apply(context);
+	public DFont getFont(String name, DFontElement defaultValue) {
+		return defaultValue.eval(context);
 	}
 
 	@Override
-	public DBorder getBorder(String name, Function<DUIContext, DBorder> defaultValue) {
-		return defaultValue.apply(context);
+	public DBorder getBorder(String name, DBorderElement defaultValue) {
+		return defaultValue.eval(context);
+	}
+	
+	@Override
+	public DMargin getMargin(String name, DMarginElement defaultValue) {
+		return defaultValue.eval(context);
+	}
+	
+	@Override
+	public DShape getShape(String name, DShapeElement defaultValue) {
+		return defaultValue.eval(context);
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DEmptyStylesheet implements DStylesheet {
+	public static final DEmptyStylesheet INSTANCE = new DEmptyStylesheet();
+	
+	private DEmptyStylesheet() {}
+
+	@Override
+	public DStyleDefinition getInstance(DUIContext context) {
+		return new DEmptyStyleDefinition(context);
+	}
+}

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

 
 	@Override
 	public DStyleDefinition get(DUIContext context, DStylePath path) {
-		return new DEmptyStyleDefinition(context);
+		return path.getInline(context);
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+@FunctionalInterface
+public interface DFontElement extends DStyleElement {
+	DFont eval(DUIContext context);
+	
+	@Override
+	default DFontElement asFont() {
+		return this;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DIRectangle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DMargin {
+	public static final DMargin EMPTY = new DMargin(0);
+	public static final DMarginElement EMPTY_ELEMENT = context -> EMPTY;
+	
+	public final int left;
+	public final int right;
+	public final int top;
+	public final int bottom;
+	
+	public DMargin(int left, int right, int top, int bottom) {
+		this.left = left;
+		this.right = right;
+		this.top = top;
+		this.bottom = bottom;
+	}
+	
+	public DMargin(int amount) {
+		this(amount, amount, amount, amount);
+	}
+	
+	public int getVertical() {
+		return top + bottom;
+	}
+	
+	public int getHorizontal() {
+		return left + right;
+	}
+	
+	public DIRectangle apply(DIRectangle bounds) {
+		return new DIRectangle(
+				bounds.x + left,
+				bounds.y + top,
+				bounds.width - left - right,
+				bounds.height - top - bottom);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DMarginElement extends DStyleElement {
+	DMargin eval(DUIContext context);
+	
+	default DMarginElement asMargin() {
+		return this;
+	}
+}

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

  * @author Hoofdgebruiker
  */
 public class DPxDimension implements DDimension {
+	public static final DPxDimension ZERO = new DPxDimension(0);
+	
 	private final float pixels;
 	
 	public DPxDimension(float pixels) {

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DRectangleShape implements DShape {
+	public static final DRectangleShape INSTANCE = new DRectangleShape();
+	public static final DShapeElement ELEMENT = context -> INSTANCE;
+
+	@Override
+	public DPath instance(DIRectangle bounds) {
+		return DPath.rectangle(bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DRoundedRectangleShape implements DShape {
+	private final float radiusTopLeft;
+	private final float radiusTopRight;
+	private final float radiusBottomLeft;
+	private final float radiusBottomRight;
+	
+	public DRoundedRectangleShape(float radius) {
+		this(radius, radius, radius, radius);
+	}
+	
+	public DRoundedRectangleShape(float radiusTopLeft, float radiusTopRight, float radiusBottomLeft, float radiusBottomRight) {
+		this.radiusTopLeft = radiusTopLeft;
+		this.radiusTopRight = radiusTopRight;
+		this.radiusBottomLeft = radiusBottomLeft;
+		this.radiusBottomRight = radiusBottomRight;
+	}
+
+	@Override
+	public DPath instance(DIRectangle bounds) {
+		return DPath.roundedRectangle(bounds.x, bounds.y, bounds.width, bounds.height, radiusTopLeft, radiusTopRight, radiusBottomLeft, radiusBottomRight);
+	}
+}

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

  */
 public class DShadow {
 	public static final DShadow NONE = new DShadow(0, 0, 0, 0);
+	public static final DShadowElement NONE_ELEMENT = context -> NONE;
 	
 	public final int color;
 	public final float offsetX;

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DShadowElement extends DStyleElement {
+	DShadow eval(DUIContext context);
+	
+	@Override
+	default DShadowElement asShadow() {
+		return this;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DShape {
+	DPath instance(DIRectangle bounds);
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+@FunctionalInterface
+public interface DShapeElement extends DStyleElement {
+	DShape eval(DUIContext context);
+	
+	@Override
+	default DShapeElement asShape() {
+		return this;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import java.util.Map;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.border.DBorder;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSimpleStylesheet implements DStylesheet {
+	private final Map<String, DStyleElement> elements;
+	
+	public DSimpleStylesheet(Map<String, DStyleElement> elements) {
+		this.elements = elements;
+	}
+
+	@Override
+	public DStyleDefinition getInstance(DUIContext context) {
+		return new Instance(context);
+	}
+	
+	private class Instance implements DStyleDefinition {
+		private final DUIContext context;
+		
+		private Instance(DUIContext context) {
+			this.context = context;
+		}
+
+		@Override
+		public int getDimension(String name, DDimension defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.evalInt(context);
+			
+			return elements.get(name).asDimension().evalInt(context);
+		}
+
+		@Override
+		public float getFloatDimension(String name, DDimension defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asDimension().eval(context);
+		}
+
+		@Override
+		public int getColor(String name, int defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue;
+			
+			return elements.get(name).asColor();
+		}
+
+		@Override
+		public DShadow getShadow(String name, DShadowElement defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asShadow().eval(context);
+		}
+
+		@Override
+		public DFont getFont(String name, DFontElement defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asFont().eval(context);
+		}
+
+		@Override
+		public DBorder getBorder(String name, DBorderElement defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asBorder().eval(context);
+		}
+		
+		@Override
+		public DMargin getMargin(String name, DMarginElement defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asMargin().eval(context);
+		}
+		
+		@Override
+		public DShape getShape(String name, DShapeElement defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asShape().eval(context);
+		}
+	}
+}

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

  */
 public class DStyleClass {
 	private static final String[] NO_CLASSES = new String[0];
-	public static final DStyleClass EMPTY = new DStyleClass(null, NO_CLASSES);
+	public static final DStyleClass EMPTY = new DStyleClass(null, NO_CLASSES, DEmptyStylesheet.INSTANCE);
 	
 	public static DStyleClass forId(String id) {
-		return new DStyleClass(id, NO_CLASSES);
+		return new DStyleClass(id, NO_CLASSES, DEmptyStylesheet.INSTANCE);
+	}
+	
+	public static DStyleClass inline(DStylesheet stylesheet) {
+		return new DStyleClass(null, NO_CLASSES, stylesheet);
+	}
+	
+	public static DStyleClass inline(String id, DStylesheet stylesheet) {
+		return new DStyleClass(id, NO_CLASSES, stylesheet);
 	}
 	
 	public final String id;
 	public final String[] classes;
+	public final DStylesheet inline;
 	
-	public DStyleClass(String id, String[] classes) {
+	public DStyleClass(String id, String[] classes, DStylesheet inline) {
 		this.id = id;
 		this.classes = classes;
+		this.inline = inline;
 	}
 }

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

  */
 package org.openzen.drawablegui.style;
 
-import java.util.function.Function;
 import org.openzen.drawablegui.DFont;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.border.DBorder;
 
 /**
 	
 	public int getColor(String name, int defaultValue);
 	
-	public DShadow getShadow(String name, Function<DUIContext, DShadow> defaultValue);
+	public DShadow getShadow(String name, DShadowElement defaultValue);
 	
-	public DFont getFont(String name, Function<DUIContext, DFont> defaultValue);
+	public DFont getFont(String name, DFontElement defaultValue);
 	
-	public DBorder getBorder(String name, Function<DUIContext, DBorder> defaultValue);
+	public DBorder getBorder(String name, DBorderElement defaultValue);
+	
+	public DMargin getMargin(String name, DMarginElement defaultValue);
+	
+	public DShape getShape(String name, DShapeElement defaultValue);
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import java.util.function.Function;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.border.DBorder;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DStyleElement {
+	default DDimension asDimension() {
+		throw new RuntimeException("Not a dimension!");
+	}
+	
+	default int asColor() {
+		throw new RuntimeException("Not a color!");
+	}
+	
+	default DFontElement asFont() {
+		throw new RuntimeException("Not a font!");
+	}
+	
+	default DBorderElement asBorder() {
+		throw new RuntimeException("Not a border!");
+	}
+	
+	default DMarginElement asMargin() {
+		throw new RuntimeException("Not a margin!");
+	}
+	
+	default DShadowElement asShadow() {
+		throw new RuntimeException("Not a shadow!");
+	}
+	
+	default DShapeElement asShape() {
+		throw new RuntimeException("Not a shape!");
+	}
+}

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

  */
 package org.openzen.drawablegui.style;
 
+import org.openzen.drawablegui.DUIContext;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface DStylePath {
 	public DStylePath getChild(String element, DStyleClass styleClass);
+	
+	public DStyleDefinition getInline(DUIContext context);
 }

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

  */
 package org.openzen.drawablegui.style;
 
+import org.openzen.drawablegui.DUIContext;
+
 /**
  *
  * @author Hoofdgebruiker
 		return new DStyleChildElement(this, element, styleClass);
 	}
 	
+	@Override
+	public DStyleDefinition getInline(DUIContext context) {
+		return new DEmptyStyleDefinition(context);
+	}
+	
 	private static class DStyleChildElement implements DStylePath {
 		private final DStylePath parent;
 		private final String element;
 		public DStylePath getChild(String element, DStyleClass styleClass) {
 			return new DStyleChildElement(this, element, styleClass);
 		}
+
+		@Override
+		public DStyleDefinition getInline(DUIContext context) {
+			return styleClass.inline.getInstance(context);
+		}
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DStylesheet {
+	DStyleDefinition getInstance(DUIContext context);
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.style;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DStylesheetBuilder {
+	private final Map<String, DStyleElement> elements = new HashMap<>();
+	
+	public DStylesheetBuilder dimensionDp(String name, float value) {
+		elements.put(name, new DDpDimension(value));
+		return this;
+	}
+	
+	public DStylesheetBuilder dimensionPx(String name, float value) {
+		elements.put(name, new DPxDimension(value));
+		return this;
+	}
+	
+	public DStylesheetBuilder dimensionSp(String name, float value) {
+		elements.put(name, new DSpDimension(value));
+		return this;
+	}
+	
+	public DStylesheetBuilder color(String name, int value) {
+		elements.put(name, new DColorElement(value));
+		return this;
+	}
+	
+	public DStylesheetBuilder font(String name, DFontElement font) {
+		elements.put(name, font);
+		return this;
+	}
+	
+	public DStylesheetBuilder shadow(String name, DShadowElement shadow) {
+		elements.put(name, shadow);
+		return this;
+	}
+	
+	public DStylesheetBuilder border(String name, DBorderElement border) {
+		elements.put(name, border);
+		return this;
+	}
+	
+	public DStylesheetBuilder marginDp(String name, float value) {
+		elements.put(name, (DMarginElement)context -> new DMargin(context.dp(value)));
+		return this;
+	}
+	
+	public DStylesheetBuilder shape(String name, DShapeElement shape) {
+		elements.put(name, shape);
+		return this;
+	}
+	
+	public DStylesheet build() {
+		return new DSimpleStylesheet(elements);
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingCanvas.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.Font;
-import java.awt.Graphics2D;
-import java.awt.Rectangle;
-import java.awt.RenderingHints;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.GeneralPath;
-import java.awt.image.BufferedImage;
-import java.awt.image.ConvolveOp;
-import java.awt.image.Kernel;
-import java.util.Stack;
-import org.openzen.drawablegui.DCanvas;
-import org.openzen.drawablegui.DFont;
-import org.openzen.drawablegui.DFontFamily;
-import org.openzen.drawablegui.DTransform2D;
-import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DPath;
-import org.openzen.drawablegui.DPathBoundsCalculator;
-import org.openzen.drawablegui.DUIContext;
-import org.openzen.drawablegui.style.DShadow;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SwingCanvas implements DCanvas {
-	private final Graphics2D g;
-	private final SwingGraphicsContext context;
-	private final Stack<Rectangle> bounds = new Stack<>();
-	private final Stack<AffineTransform> transformStack = new Stack<>();
-	
-	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;
-		
-		if (bounds != null)
-			pushBounds(new DIRectangle(bounds.x, bounds.y, bounds.width, bounds.height));
-	}
-	
-	@Override
-	public void pushBounds(DIRectangle bounds) {
-		this.bounds.push(g.getClipBounds());
-		g.setClip(bounds.x, bounds.y, bounds.width, bounds.height);
-	}
-	
-	@Override
-	public void popBounds() {
-		Rectangle bounds = this.bounds.pop();
-		g.setClip(bounds.x, bounds.y, bounds.width, bounds.height);
-	}
-	
-	@Override
-	public void pushOffset(int x, int y) {
-		transformStack.push(g.getTransform());
-		g.transform(AffineTransform.getTranslateInstance(x, y));
-	}
-	
-	@Override
-	public void popOffset() {
-		g.setTransform(transformStack.pop());
-	}
-	
-	@Override
-	public DIRectangle getBounds() {
-		Rectangle bounds = g.getClipBounds();
-		return new DIRectangle(bounds.x, bounds.y, bounds.width, bounds.height);
-	}
-
-	@Override
-	public void drawText(DFont font, int color, float x, float y, String text) {
-		prepare(font);
-		g.setColor(new Color(color, true));
-		g.setFont((Font) font.cached);
-		g.drawString(text, x, y);
-	}
-
-	@Override
-	public DUIContext getContext() {
-		return context;
-	}
-
-	@Override
-	public void strokePath(DPath path, DTransform2D transform, int color, float lineWidth) {
-		if (color == 0)
-			return;
-		
-		AffineTransform old = g.getTransform();
-		GeneralPath jPath = context.getPath(path);
-		g.setColor(new Color(color, true));
-		g.setStroke(new BasicStroke(lineWidth));
-		g.transform(getTransform(transform));
-		g.draw(jPath);
-		g.setTransform(old);
-	}
-
-	@Override
-	public void fillPath(DPath path, DTransform2D transform, int color) {
-		if (color == 0)
-			return;
-		
-		AffineTransform old = g.getTransform();
-		GeneralPath jPath = context.getPath(path);
-		g.setColor(new Color(color, true));
-		g.transform(getTransform(transform));
-		g.fill(jPath);
-		g.setTransform(old);
-	}
-
-	@Override
-	public void shadowPath(DPath path, DTransform2D transform, DShadow shadow) {
-		if (shadow.color == 0)
-			return;
-		
-		if (shadow.radius == 0) {
-			fillPath(path, transform, shadow.color);
-			return;
-		}
-		
-		DIRectangle bounds = DPathBoundsCalculator.getBounds(path, transform.offset(shadow.offsetX, shadow.offsetY));
-		int offset = 2 * (int)Math.ceil(shadow.radius);
-		
-		GeneralPath jPath = context.getPath(path);
-		
-		BufferedImage image = new BufferedImage(bounds.width + 2 * offset, bounds.height + 2 * offset, 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(offset + shadow.offsetX - bounds.x, offset + shadow.offsetY - bounds.y)));
-		imageG.fill(jPath);
-		
-		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), true).filter(image, null);
-		image = getGaussianBlurFilter((int)Math.ceil(shadow.radius), false).filter(image, null);
-		g.drawImage(image, bounds.x - offset, bounds.y - offset, null);
-	}
-
-	@Override
-	public void fillRectangle(int x, int y, int width, int height, int color) {
-		if (color == 0)
-			return;
-		
-		g.setColor(new Color(color, true));
-		g.fillRect(x, y, width, height);
-	}
-	
-	public static void prepare(DFont font) {
-		if (font.cached != null && font.cached instanceof Font)
-			return;
-		
-		String baseFontName = font.family == DFontFamily.CODE ? "Consolas" : Font.DIALOG;
-		int style = 0;
-		if (font.bold)
-			style |= Font.BOLD;
-		if (font.italic)
-			style |= Font.ITALIC;
-		
-		font.cached = Font.decode(baseFontName).deriveFont(style, font.size);
-	}
-	
-	private AffineTransform getTransform(DTransform2D transform) {
-		return new AffineTransform(transform.xx, transform.xy, transform.yx, transform.yy, transform.dx, transform.dy);
-	}
-    
-	
-	// taken from http://www.java2s.com/Code/Java/Advanced-Graphics/GaussianBlurDemo.htm
-    public static ConvolveOp getGaussianBlurFilter(int radius, boolean horizontal) {
-        if (radius < 1) {
-            throw new IllegalArgumentException("Radius must be >= 1");
-        }
-        
-        int size = radius * 2 + 1;
-        float[] data = new float[size];
-        
-        float sigma = radius / 3.0f;
-        float twoSigmaSquare = 2.0f * sigma * sigma;
-        float sigmaRoot = (float) Math.sqrt(twoSigmaSquare * Math.PI);
-        float total = 0.0f;
-        
-        for (int i = -radius; i <= radius; i++) {
-            float distance = i * i;
-            int index = i + radius;
-            data[index] = (float) Math.exp(-distance / twoSigmaSquare) / sigmaRoot;
-            total += data[index];
-        }
-        
-        for (int i = 0; i < data.length; i++) {
-            data[i] /= total;
-        }        
-        
-        Kernel kernel = null;
-        if (horizontal) {
-            kernel = new Kernel(size, 1, data);
-        } else {
-            kernel = new Kernel(1, size, data);
-        }
-        return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
-    }
-}

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

 
 import java.awt.BorderLayout;
 import java.awt.Color;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
 import java.awt.event.WindowEvent;
 import java.awt.event.WindowListener;
 import java.awt.event.WindowStateListener;
 import org.openzen.drawablegui.border.DCustomWindowBorder;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 	private final boolean noTitleBar;
 	private final SimpleLiveObject<State> state = new SimpleLiveObject<>(State.NORMAL);
 	private final SimpleLiveBool active = new SimpleLiveBool(true);
+	private final MutableLiveObject<DIRectangle> bounds = new SimpleLiveObject<>(DIRectangle.EMPTY);
 	
 	public SwingDialog(SwingWindow owner, String title, DComponent root, boolean noTitleBar) {
 		super(owner, title);
 		
 		addWindowListener(this);
 		addWindowStateListener(this);
+		addComponentListener(new ComponentAdapter() {
+			@Override
+			public void componentMoved(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+			
+			@Override
+			public void componentResized(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+		});
 		
 		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
 		swingComponent.setWindow(this);
 	}
 
 	@Override
-	public DIRectangle getWindowBounds() {
-		return new DIRectangle(getX(), getY(), getWidth(), getHeight());
+	public LiveObject<DIRectangle> getWindowBounds() {
+		return bounds;
 	}
 
 	@Override
 
 	@Override
 	public void windowOpened(WindowEvent e) {
-		
+		updateBounds();
 	}
 
 	@Override
 		state.setValue(getStateFromWindowState());
 	}
 	
+	private void updateBounds() {
+		bounds.setValue(new DIRectangle(getX(), getY(), getWidth(), getHeight()));
+	}
+	
 	private State getStateFromWindowState() {
 		/*switch (ge()) {
 			case NORMAL:

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.Font;
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
+import java.awt.image.ConvolveOp;
+import java.awt.image.Kernel;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontFamily;
+import org.openzen.drawablegui.DFontMetrics;
+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.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 int offsetX;
+	public int offsetY;
+	
+	public SwingDrawSurface(SwingGraphicsContext context, int offsetX, int offsetY) {
+		this.context = context;
+		this.offsetX = offsetX;
+		this.offsetY = offsetY;
+	}
+	
+	public void setOffset(int offsetX, int offsetY) {
+		this.offsetX = offsetX;
+		this.offsetY = offsetY;
+	}
+	
+	public void paint(Graphics2D g, DIRectangle clip) {
+		for (SwingDrawnElement element : elements)
+			if (clip == null || clip.overlaps(element.getBounds()))
+				element.paint(g, clip);
+	}
+	
+	public DIRectangle calculateBounds() {
+		if (elements.isEmpty())
+			return DIRectangle.EMPTY;
+		
+		DIRectangle result = elements.get(0).getBounds();
+		for (SwingDrawnElement element : elements)
+			result = result.union(element.getBounds());
+		return result;
+	}
+
+	@Override
+	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) {
+		DFontMetrics fontMetrics = context.getFontMetrics(font);
+		return addElement(new SwingDrawnText(this, z, x, y, color, font, text, fontMetrics.getAscent(), fontMetrics.getDescent(), fontMetrics.getWidth(text)));
+	}
+
+	@Override
+	public DDrawnShape strokePath(int z, DPath path, DTransform2D transform, int color, float lineWidth) {
+		return addElement(new SwingStrokedPath(this, z, transform, color, path, 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, path, 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);
+		repaint(element.getBounds());
+	}
+	
+	public void repaint(int x, int y, int width, int height) {
+		context.repaint(x + offsetX, y + offsetY, width, height);
+	}
+	
+	public void repaint(DIRectangle rectangle) {
+		context.repaint(rectangle.offset(offsetX, offsetY));
+	}
+	
+	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);
+		repaint(element.getBounds());
+		return element;
+	}
+	
+	public static void prepare(DFont font) {
+		if (font.cached != null && font.cached instanceof Font)
+			return;
+		
+		String baseFontName = font.family == DFontFamily.CODE ? "Consolas" : Font.DIALOG;
+		int style = 0;
+		if (font.bold)
+			style |= Font.BOLD;
+		if (font.italic)
+			style |= Font.ITALIC;
+		
+		font.cached = Font.decode(baseFontName).deriveFont(style, font.size);
+	}
+	
+	public static AffineTransform getTransform(DTransform2D transform) {
+		return new AffineTransform(transform.xx, transform.xy, transform.yx, transform.yy, transform.dx, transform.dy);
+	}
+    
+	
+	// taken from http://www.java2s.com/Code/Java/Advanced-Graphics/GaussianBlurDemo.htm
+    public static ConvolveOp getGaussianBlurFilter(int radius, boolean horizontal) {
+        if (radius < 1) {
+            throw new IllegalArgumentException("Radius must be >= 1");
+        }
+        
+        int size = radius * 2 + 1;
+        float[] data = new float[size];
+        
+        float sigma = radius / 3.0f;
+        float twoSigmaSquare = 2.0f * sigma * sigma;
+        float sigmaRoot = (float) Math.sqrt(twoSigmaSquare * Math.PI);
+        float total = 0.0f;
+        
+        for (int i = -radius; i <= radius; i++) {
+            float distance = i * i;
+            int index = i + radius;
+            data[index] = (float) Math.exp(-distance / twoSigmaSquare) / sigmaRoot;
+            total += data[index];
+        }
+        
+        for (int i = 0; i < data.length; i++) {
+            data[i] /= total;
+        }        
+        
+        Kernel kernel = null;
+        if (horizontal) {
+            kernel = new Kernel(size, 1, data);
+        } else {
+            kernel = new Kernel(1, size, data);
+        }
+        return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
+    }
+}

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 org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawnElement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class SwingDrawnElement implements DDrawnElement {
+	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, DIRectangle clip);
+	
+	@Override
+	public void close() {
+		target.remove(this);
+	}
+	
+	protected void invalidate() {
+		target.repaint(getBounds());
+	}
+}

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

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

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

+/*
+ * 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.DIRectangle;
+import org.openzen.drawablegui.draw.DDrawnText;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingDrawnText extends SwingDrawnElement implements DDrawnText {
+	private float x;
+	private float y;
+	private final int width;
+	private final int ascent;
+	private final int descent;
+	private Color awtColor;
+	private final Font font;
+	private final String text;
+	
+	public SwingDrawnText(SwingDrawSurface target, int z, float x, float y, int color, DFont font, String text, int ascent, int descent, int width) {
+		super(target, z);
+		SwingDrawSurface.prepare(font);
+		
+		this.x = x;
+		this.y = y;
+		this.awtColor = new Color(color, true);
+		this.font = (Font) font.cached;
+		this.text = text;
+		this.ascent = ascent;
+		this.descent = descent;
+		this.width = width;
+	}
+
+	@Override
+	public void setPosition(float x, float y) {
+		invalidate();
+		this.x = x;
+		this.y = y;
+		invalidate();
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return new DIRectangle((int)x, (int)y - ascent, width, ascent + descent);
+	}
+	
+	@Override
+	public void setColor(int color) {
+		this.awtColor = new Color(color, true);
+		invalidate();
+	}
+
+	@Override
+	public void paint(Graphics2D g, DIRectangle clip) {
+		g.setColor(awtColor);
+		g.setFont(font);
+		g.drawString(text, x, y);
+	}
+}

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

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

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

 import java.awt.Dimension;
 import java.awt.Font;
 import java.awt.Graphics;
+import java.awt.Point;
 import java.awt.geom.GeneralPath;
 import java.util.WeakHashMap;
 import javax.swing.JFrame;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DPathTracer;
 import org.openzen.drawablegui.DTimerHandle;
-import org.openzen.drawablegui.DTooltip;
-import org.openzen.drawablegui.DTooltipHandle;
 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) {
 		if (graphics == null)
 			throw new AssertionError("No graphics available!");
 		
-		SwingCanvas.prepare(font);
+		SwingDrawSurface.prepare(font);
 		return new SwingFontMetrics(graphics.getFontMetrics((Font) font.cached), graphics);
 	}
 
 
 	@Override
 	public DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root) {
-		SwingDialog window = new SwingDialog((SwingWindow)this.window, title, root, false);
-		SwingGraphicsContext windowContext = new SwingGraphicsContext(stylesheets, scale, textScale, window.swingComponent);
+		SwingWindow swingWindow = (SwingWindow)this.window;
+		SwingDialog window = new SwingDialog(swingWindow, title, root, false);
+		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.mount(DStylePathRoot.INSTANCE, 0, windowContext.surface);
 		DSizing dimension = root.getSizing().getValue();
-		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
-		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
+		int tx = (int)(x + rootLocation.x - anchor.alignX * dimension.preferredWidth);
+		int ty = (int)(y + rootLocation.y - anchor.alignY * dimension.preferredHeight);
 		
 		window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
 		window.swingComponent.setPreferredSize(new Dimension(dimension.preferredWidth, dimension.preferredHeight));
 
 	@Override
 	public DUIWindow openView(int x, int y, DAnchor anchor, DComponent root) {
-		SwingDialog window = new SwingDialog((SwingWindow)this.window, "", root, false);
-		SwingGraphicsContext windowContext = new SwingGraphicsContext(stylesheets, scale, textScale, window.swingComponent);
+		SwingWindow swingWindow = (SwingWindow)this.window;
+		SwingInlineWindow window = new SwingInlineWindow(swingWindow, "", root);
+		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.mount(DStylePathRoot.INSTANCE, 0, windowContext.surface);
 		DSizing dimension = root.getSizing().getValue();
-		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
-		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
 		
-		window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+		Point rootLocation = swingWindow.swingComponent.getLocationOnScreen();
+		
+		int tx = (int)(x + rootLocation.x - anchor.alignX * dimension.preferredWidth);
+		int ty = (int)(y + rootLocation.y - anchor.alignY * dimension.preferredHeight);
+		
 		window.swingComponent.setPreferredSize(new Dimension(dimension.preferredWidth, dimension.preferredHeight));
 		window.setLocation(tx, ty);
 		window.pack();
 		window.setVisible(true);
+		window.swingComponent.repaint();
+		
 		return window;
 	}
 	
-	@Override
-	public DTooltipHandle openTooltip(int x, int y, DTooltip tooltip) {
-		return null; // TODO
-	}
-	
 	private class PathTracer implements DPathTracer {
 		private final GeneralPath path;
 		

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.BorderLayout;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.awt.event.WindowStateListener;
+import javax.swing.JWindow;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.live.ImmutableLiveObject;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.live.SimpleLiveBool;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class SwingInlineWindow extends JWindow implements WindowListener, WindowStateListener, DUIWindow {
+	public final SwingRoot swingComponent;
+	private final LiveObject<State> state = new ImmutableLiveObject<>(State.NORMAL);
+	private final SimpleLiveBool active = new SimpleLiveBool(true);
+	private final MutableLiveObject<DIRectangle> bounds = new SimpleLiveObject<>(DIRectangle.EMPTY);
+	
+	public SwingInlineWindow(SwingWindow owner, String title, DComponent root) {
+		super(owner);
+		
+		addWindowListener(this);
+		addWindowStateListener(this);
+		
+		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
+		swingComponent.setWindow(this);
+		swingComponent.requestFocusInWindow();
+		addComponentListener(new ComponentAdapter() {
+			@Override
+			public void componentMoved(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+			
+			@Override
+			public void componentResized(ComponentEvent componentEvent) {
+				updateBounds();
+			}
+		});
+	}
+	
+	@Override
+	public DUIContext getContext() {
+		return swingComponent.context;
+	}
+
+	@Override
+	public LiveObject<DIRectangle> getWindowBounds() {
+		return bounds;
+	}
+
+	@Override
+	public boolean hasTitleBar() {
+		return false;
+	}
+
+	@Override
+	public void close() {
+		dispose();
+	}
+
+	@Override
+	public void maximize() {
+		// cannot maximize
+	}
+
+	@Override
+	public void restore() {
+		// cannot restore
+	}
+
+	@Override
+	public void minimize() {
+		// cannot minimize
+	}
+
+	@Override
+	public LiveObject<State> getWindowState() {
+		return state;
+	}
+	
+	@Override
+	public LiveBool getActive() {
+		return active;
+	}
+	
+	@Override
+	public void focus(DComponent component) {
+		swingComponent.focus(component);
+	}
+	
+	@Override
+	public DUIWindow openModal(String title, DComponent component) {
+		throw new IllegalArgumentException("Cannot open a modal from an inline window!");
+	}
+
+	@Override
+	public void windowOpened(WindowEvent e) {
+		updateBounds();
+	}
+
+	@Override
+	public void windowClosing(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowClosed(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowIconified(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowDeiconified(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowActivated(WindowEvent e) {
+		active.setValue(true);
+	}
+
+	@Override
+	public void windowDeactivated(WindowEvent e) {
+		active.setValue(false);
+	}
+
+	@Override
+	public void windowStateChanged(WindowEvent e) {
+		
+	}
+	
+	private void updateBounds() {
+		bounds.setValue(new DIRectangle(getX(), getY(), getWidth(), getHeight()));
+	}
+}

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, 0, 0);
+		context.setSurface(surface);
 		
 		addComponentListener(this);
 		addMouseListener(this);
 	public void paint(Graphics g) {
 		if (firstPaint) {
 			firstPaint = false;
-			component.setContext(DStylePathRoot.INSTANCE, context);
+			component.mount(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);
-		component.paint(canvas);
+		Graphics2D g2d = (Graphics2D) g;
+		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
+		surface.paint(g2d, clipBounds2);
+		
+		System.out.println("Paint in " + (System.currentTimeMillis() - start) + " ms, bounds: " + clipBounds.toString());
 	}
 
 	@Override
 	public void componentResized(ComponentEvent e) {
+		if (firstPaint)
+			return;
+		
 		component.setBounds(new DIRectangle(0, 0,
 				e.getComponent().getWidth(),
 				e.getComponent().getHeight()));