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

Constructor/libraries/stdlib/src/Arrays.zs

@@ -19,6 +19,7 @@ export expand <T> T[] {
 	
 	public get first as T?;
 	public get last as T?;
+	public get reversed as T[];
 	
 	public map<U>(projection as function(value as T) as U) as U[] {
 		val result as U[] = new U[](this.length);
@@ -79,6 +80,38 @@ export expand <T> T[] {
 		return true;
 	}
 	
+	public first(predicate as function(value as T) as bool) as T? {
+		for value in this
+			if predicate(value)
+				return value;
+		
+		return null;
+	}
+	
+	public first(predicate as function(i as int, value as T) as bool) as T? {
+		for i, value in this
+			if predicate(i, value)
+				return value;
+		
+		return null;
+	}
+	
+	public last(predicate as function(value as T) as bool) as T? {
+		for i, value in this.reversed
+			if predicate(value)
+				return value;
+		
+		return null;
+	}
+	
+	public last(predicate as function(value as T) as bool) as T? {
+		for i, value in this.reversed
+			if predicate(value)
+				return value
+		
+		return null;
+	}
+	
 	public count(predicate as function(value as T) as bool) as int {
 		var result = 0;
 		for value in this

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

@@ -0,0 +1,34 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.constructor;
+
+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.ModuleReference;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Library {
+	public final String name;
+	public final File directory;
+	public final ModuleReference[] modules;
+	
+	public Library(ModuleLoader loader, File directory, String name, JSONObject json) {
+		this.name = name;
+		this.directory = new File(directory, json.getString("directory"));
+		
+		JSONArray modulesJson = json.getJSONArray("modules");
+		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);
+		}
+	}
+}

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

@@ -22,6 +22,10 @@ public class Main {
 		moduleLoader.register("stdlib", new DirectoryModuleLoader(moduleLoader, "stdlib", new File("libraries/stdlib"), true));
 		
 		Project project = new Project(moduleLoader, currentDirectory);
+		for (Library library : project.libraries) {
+			for (ModuleReference module : library.modules)
+				moduleLoader.register(module.getName(), module);
+		}
 		for (ModuleReference module : project.modules) {
 			moduleLoader.register(module.getName(), module);
 		}

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

@@ -17,9 +17,13 @@ import org.openzen.zenscript.constructor.module.ModuleReference;
  * @author Hoofdgebruiker
  */
 public class Project {
+	public final String name;
 	public final ModuleReference[] modules;
+	public final Library[] libraries;
 	
 	public Project(ModuleLoader loader, File directory) throws IOException {
+		name = directory.getName();
+		
 		if (!directory.exists())
 			throw new ConstructorException("Project directory doesn't exist");
 		if (!directory.isDirectory())
@@ -31,6 +35,14 @@ public class Project {
 		
 		JSONObject json = JSONUtils.load(projectFile);
 		
+		JSONObject jsonLibraries = json.getJSONObject("libraries");
+		libraries = new Library[jsonLibraries.length()];
+		int k = 0;
+		for (String key : jsonLibraries.keySet()) {
+			libraries[k] = new Library(loader, directory, key, jsonLibraries.getJSONObject(key));
+			k++;
+		}
+		
 		JSONArray jsonModules = json.getJSONArray("modules");
 		modules = new ModuleReference[jsonModules.length()];
 		for (int i = 0; i < jsonModules.length(); i++) {

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

@@ -28,6 +28,7 @@ public class DirectoryModuleLoader 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;
@@ -93,4 +94,26 @@ public class DirectoryModuleLoader implements ModuleReference {
 			throw new ConstructorException("Loading module files failed: " + ex.getMessage(), ex);
 		}
 	}
+	
+	@Override
+	public SourcePackage getRootPackage() {
+		if (rootPackage == null)
+			rootPackage = loadPackage("", new File(directory, "src"));
+		
+		return rootPackage;
+	}
+	
+	private SourcePackage loadPackage(String name, File directory) {
+		SourcePackage pkg = new SourcePackage(name);
+		
+		for (File file : directory.listFiles()) {
+			if (file.isDirectory()) {
+				pkg.addPackage(loadPackage(file.getName(), file));
+			} else if (file.isFile() && file.getName().toLowerCase().endsWith(".zs")) {
+				pkg.addFile(new SourceFile(file.getName(), file));
+			}
+		}
+		
+		return pkg;
+	}
 }

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

@@ -13,4 +13,6 @@ public interface ModuleReference {
 	public String getName();
 	
 	public SemanticModule load();
+	
+	public SourcePackage getRootPackage();
 }

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

@@ -0,0 +1,22 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.constructor.module;
+
+import java.io.File;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SourceFile {
+	public final String name;
+	public final File file;
+	
+	public SourceFile(String name, File file) {
+		this.name = name;
+		this.file = file;
+	}
+}

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

@@ -0,0 +1,31 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.constructor.module;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SourcePackage {
+	public final String name;
+	public final Map<String, SourcePackage> subPackages = new HashMap<>();
+	public final Map<String, SourceFile> sourceFiles = new HashMap<>();
+	
+	public SourcePackage(String name) {
+		this.name = name;
+	}
+	
+	public void addPackage(SourcePackage pkg) {
+		subPackages.put(pkg.name, pkg);
+	}
+	
+	public void addFile(SourceFile file) {
+		sourceFiles.put(file.name, file);
+	}
+}

DrawableGui/build.gradle

@@ -0,0 +1,24 @@
+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = ''
+}
+
+dependencies {
+    // TODO: Add dependencies here
+    //   but note that JUnit should have already been added in parent.gradle.
+    //   By default, only the Maven Central Repository is specified in
+    //   parent.gradle.
+    //
+    // You can read more about how to add dependency here:
+    //   http://www.gradle.org/docs/current/userguide/dependency_management.html#sec:how_to_declare_your_dependencies
+}

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

@@ -0,0 +1,89 @@
+/*
+ * 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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class BaseComponentGroup implements DComponent {
+	private DComponent hovering = null;
+	
+	protected abstract void forEachChild(Consumer<DComponent> children);
+	
+	protected abstract DComponent findChild(Predicate<DComponent> predicate);
+	
+	@Override
+	public void onMouseEnter(DMouseEvent e) {
+		DComponent target = getComponent(e.x, e.y);
+		setHovering(target, e);
+	}
+	
+	@Override
+	public void onMouseExit(DMouseEvent e) {
+		setHovering(null, e);
+	}
+	
+	@Override
+	public void onMouseMove(DMouseEvent e) {
+		DComponent target = getComponent(e.x, e.y);
+		if (target == hovering) {
+			if (target != null)
+				target.onMouseMove(e);
+		} else {
+			setHovering(target, e);
+		}
+	}
+	
+	@Override
+	public void onMouseDrag(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseDrag(e);
+	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseClick(e);
+	}
+	
+	@Override
+	public void onMouseDown(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseDown(e);
+	}
+	
+	@Override
+	public void onMouseRelease(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseRelease(e);
+		onMouseMove(e);
+	}
+	
+	@Override
+	public void onMouseScroll(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseScroll(e);
+	}
+	
+	private void setHovering(DComponent component, DMouseEvent e) {
+		if (component == hovering)
+			return;
+		
+		if (hovering != null)
+			hovering.onMouseExit(e);
+		hovering = component;
+		if (hovering != null)
+			hovering.onMouseEnter(e);
+	}
+	
+	private DComponent getComponent(int x, int y) {
+		return findChild(child -> child.getBounds().contains(x, y));
+	}
+}

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

@@ -0,0 +1,67 @@
+/*
+ * 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/DClipboard.java

@@ -0,0 +1,16 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DClipboard {
+	void copyAsString(String value);
+	
+	String getAsString();
+}

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

@@ -0,0 +1,21 @@
+/*
+ * 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.DCanvas;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DColorableIcon {
+	void draw(DCanvas canvas, DTransform2D transform, int color);
+	
+	float getNominalWidth();
+	
+	float getNominalHeight();
+}

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

@@ -0,0 +1,59 @@
+/*
+ * 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 org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DComponent extends Closeable {
+	void setContext(DStylePath parent, DUIContext context);
+	
+	LiveObject<DDimensionPreferences> getDimensionPreferences();
+	
+	DIRectangle getBounds();
+	
+	void setBounds(DIRectangle bounds);
+	
+	void paint(DCanvas canvas);
+	
+	default void onMounted() {}
+	
+	default void onUnmounted() {}
+	
+	default void onMouseEnter(DMouseEvent e) {}
+	
+	default void onMouseExit(DMouseEvent e) {}
+	
+	default void onMouseMove(DMouseEvent e) {}
+	
+	default void onMouseDrag(DMouseEvent e) {}
+	
+	default void onMouseClick(DMouseEvent e) {}
+	
+	default void onMouseDown(DMouseEvent e) {}
+	
+	default void onMouseRelease(DMouseEvent e) {}
+	
+	default void onMouseScroll(DMouseEvent e) {}
+	
+	default void onFocusLost() {}
+	
+	default void onFocusGained() {}
+	
+	default void onKeyTyped(DKeyEvent e) {}
+	
+	default void onKeyPressed(DKeyEvent e) {}
+	
+	default void onKeyReleased(DKeyEvent e) {}
+	
+	@Override
+	void close();
+}

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

@@ -0,0 +1,39 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DDimensionPreferences {
+	public static final DDimensionPreferences EMPTY = new DDimensionPreferences(0, 0);
+	
+	public final int minimumWidth;
+	public final int minimumHeight;
+	public final int preferredWidth;
+	public final int preferredHeight;
+	public final int maximumWidth;
+	public final int maximumHeight;
+	
+	public DDimensionPreferences(int preferredWidth, int preferredHeight) {
+		this.minimumWidth = 0;
+		this.minimumHeight = 0;
+		this.preferredWidth = preferredWidth;
+		this.preferredHeight = preferredHeight;
+		this.maximumWidth = 1000000;
+		this.maximumHeight = 1000000;
+	}
+	
+	public DDimensionPreferences(int minimumWidth, int minimumHeight, int preferredWidth, int preferredHeight, int maximumWidth, int maximumHeight) {
+		this.minimumWidth = minimumWidth;
+		this.minimumHeight = minimumHeight;
+		this.preferredWidth = preferredWidth;
+		this.preferredHeight = preferredHeight;
+		this.maximumWidth = maximumWidth;
+		this.maximumHeight = maximumHeight;
+	}
+}

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

@@ -0,0 +1,18 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawable {
+	void draw(DCanvas canvas, DTransform2D transform);
+	
+	float getNominalWidth();
+	
+	float getNominalHeight();
+}

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

@@ -0,0 +1,53 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import org.openzen.drawablegui.live.ImmutableLiveObject;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DEmptyView implements DComponent {
+	public static final DEmptyView INSTANCE = new DEmptyView();
+	
+	private static final LiveObject<DDimensionPreferences> DIMENSION = new ImmutableLiveObject(new DDimensionPreferences(0, 0));
+	private static final DIRectangle NO_BOUNDS = new DIRectangle(0, 0, 0, 0);
+	
+	private DEmptyView() {}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		
+	}
+	
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return DIMENSION;
+	}
+	
+	@Override
+	public DIRectangle getBounds() {
+		return NO_BOUNDS;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		
+	}
+
+	@Override
+	public void close() {
+		// nothing to clean up
+	}
+}

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

@@ -0,0 +1,70 @@
+/*
+ * 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.Objects;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DFont {
+	public final DFontFamily family;
+	public final boolean bold;
+	public final boolean italic;
+	public final boolean underline;
+	public final int size;
+	
+	public Object cached;
+	
+	public DFont(DFontFamily family, boolean bold, boolean italic, boolean underline, int size) {
+		this.family = family;
+		this.bold = bold;
+		this.italic = italic;
+		this.underline = underline;
+		this.size = size;
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = 3;
+		hash = 29 * hash + Objects.hashCode(this.family);
+		hash = 29 * hash + (this.bold ? 1 : 0);
+		hash = 29 * hash + (this.italic ? 1 : 0);
+		hash = 29 * hash + (this.underline ? 1 : 0);
+		hash = 29 * hash + Float.floatToIntBits(this.size);
+		return hash;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (obj == null) {
+			return false;
+		}
+		if (getClass() != obj.getClass()) {
+			return false;
+		}
+		final DFont other = (DFont) obj;
+		if (this.bold != other.bold) {
+			return false;
+		}
+		if (this.italic != other.italic) {
+			return false;
+		}
+		if (this.underline != other.underline) {
+			return false;
+		}
+		if (this.size != other.size)
+			return false;
+		if (this.family != other.family) {
+			return false;
+		}
+		return true;
+	}
+}

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

@@ -0,0 +1,15 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public enum DFontFamily {
+	UI,
+	CODE
+}

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

@@ -0,0 +1,22 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DFontMetrics {
+	int getAscent();
+	
+	int getDescent();
+	
+	int getLeading();
+	
+	int getWidth(String str);
+	
+	int getWidth(String str, int offset, int length);
+}

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

@@ -0,0 +1,31 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DIRectangle {
+	public static final DIRectangle EMPTY = new DIRectangle(0, 0, 0, 0);
+	
+	public final int x;
+	public final int y;
+	public final int width;
+	public final int height;
+	
+	public DIRectangle(int x, int y, int width, int height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+	}
+	
+	public boolean contains(int x, int y) {
+		return x >= this.x && x < (this.x + this.width)
+				&& y >= this.y && y < (this.y + this.height);
+	}
+}

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

@@ -0,0 +1,211 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DKeyEvent {
+	public static final char CHAR_UNDEFINED = 65535;
+	
+	public static final int BUTTON1 = 1;
+	public static final int BUTTON2 = 2;
+	public static final int BUTTON3 = 4;
+	public static final int ALT = 256;
+	public static final int CTRL = 512;
+	public static final int SHIFT = 1024;
+	public static final int META = 2048;
+	public static final int ALT_GRAPH = 4096;
+	
+	public final char character;
+	public final KeyCode keyCode;
+	public final int modifiers;
+	
+	public DKeyEvent(char character, KeyCode keyCode, int modifiers) {
+		this.character = character;
+		this.keyCode = keyCode;
+		this.modifiers = modifiers;
+	}
+	
+	public boolean has(int modifiers) {
+		return (this.modifiers & modifiers) == modifiers;
+	}
+	
+	public enum KeyCode {
+		ENTER,
+		BACKSPACE,
+		TAB,
+		CANCEL,
+		CLEAR,
+		SHIFT,
+		CONTROL,
+		ALT,
+		PAUSE,
+		CAPS_LOCK,
+		ESCAPE,
+		SPACE,
+		PAGE_UP,
+		PAGE_DOWN,
+		END,
+		HOME,
+		LEFT,
+		UP,
+		RIGHT,
+		DOWN,
+		COMMA,
+		MINUS,
+		PERIOD,
+		SLASH,
+		NUM0,
+		NUM1,
+		NUM2,
+		NUM3,
+		NUM4,
+		NUM5,
+		NUM6,
+		NUM7,
+		NUM8,
+		NUM9,
+		SEMICOLON,
+		EQUALS,
+		A,
+		B,
+		C,
+		D,
+		E,
+		F,
+		G,
+		H,
+		I,
+		J,
+		K,
+		L,
+		M,
+		N,
+		O,
+		P,
+		Q,
+		R,
+		S,
+		T,
+		U,
+		V,
+		W,
+		X,
+		Y,
+		Z,
+		OPEN_BRACKET,
+		BACKSLASH,
+		CLOSE_BRACKET,
+		NUMPAD0,
+		NUMPAD1,
+		NUMPAD2,
+		NUMPAD3,
+		NUMPAD4,
+		NUMPAD5,
+		NUMPAD6,
+		NUMPAD7,
+		NUMPAD8,
+		NUMPAD9,
+		MULTIPLY,
+		ADD,
+		SEPARATOR,
+		SUBTRACT,
+		DECIMAL,
+		DIVIDE,
+		DELETE,
+		NUM_LOCK,
+		SCROLL_LOCK,
+		F1,
+		F2,
+		F3,
+		F4,
+		F5,
+		F6,
+		F7,
+		F8,
+		F9,
+		F10,
+		F11,
+		F12,
+		F13,
+		F14,
+		F15,
+		F16,
+		F17,
+		F18,
+		F19,
+		F20,
+		F21,
+		F22,
+		F23,
+		F24,
+		PRINTSCREEN,
+		INSERT,
+		HELP,
+		META,
+		BACKQUOTE,
+		QUOTE,
+		KEYPAD_UP,
+		KEYPAD_DOWN,
+		KEYPAD_LEFT,
+		KEYPAD_RIGHT,
+		AMPERSAND,
+		ASTERISK,
+		QUOTEDBL,
+		LESS,
+		GREATER,
+		BRACELEFT,
+		BRACERIGHT,
+		AT,
+		COLON,
+		CIRCUMFLEX,
+		DOLLAR,
+		EURO_SIGN,
+		EXCLAMATION_MARK,
+		INVERTED_EXCLAMATION_MARK,
+		LEFT_PARENTHESIS,
+		NUMBER_SIGN,
+		PLUS,
+		RIGHT_PARENTHESIS,
+		UNDERSCORE,
+		WINDOWS,
+		CONTEXT_MENU,
+		FINAL,
+		CONVERT,
+		NONCONVERT,
+		ACCEPT,
+		KANA,
+		KANJI,
+		ALPHANUMERIC,
+		KATAKANA,
+		HIRAGANA,
+		FULL_WIDTH,
+		HALF_WIDTH,
+		ROMAN_CHARACTERS,
+		ALL_CANDIDATES,
+		PREVIOUS_CANDIDATE,
+		CODE_INPUT,
+		JAPANESE_KATAKANA,
+		JAPANESE_HIRAGANA,
+		JAPANESE_ROMAN,
+		KANA_LOCK,
+		INPUT_METHOD_ON_OFF,
+		CUT,
+		COPY,
+		PASTE,
+		UNDO,
+		AGAIN,
+		FIND,
+		PROPS,
+		STOP,
+		COMPOSE,
+		ALT_GRAPH,
+		BEGIN,
+		UNKNOWN
+	}
+}

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

@@ -0,0 +1,51 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DMouseEvent {
+	public static final int BUTTON1 = 1;
+	public static final int BUTTON2 = 2;
+	public static final int BUTTON3 = 4;
+	public static final int ALT = 256;
+	public static final int CTRL = 512;
+	public static final int SHIFT = 1024;
+	public static final int META = 2048;
+	public static final int ALT_GRAPH = 4096;
+	
+	public final int x;
+	public final int y;
+	public final int modifiers;
+	public final int deltaZ;
+	public final int clickCount;
+	
+	public DMouseEvent(int x, int y, int modifiers, int deltaZ, int clickCount) {
+		this.x = x;
+		this.y = y;
+		this.modifiers = modifiers;
+		this.deltaZ = deltaZ;
+		this.clickCount = clickCount;
+	}
+	
+	public boolean isSingleClick() {
+		return clickCount == 1;
+	}
+	
+	public boolean isDoubleClick() {
+		return clickCount == 2;
+	}
+	
+	public boolean isTripleClick() {
+		return clickCount == 3;
+	}
+	
+	public boolean has(int modifiers) {
+		return (this.modifiers & modifiers) == modifiers;
+	}
+}

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

@@ -0,0 +1,75 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DPath {
+	public static DPath circle(float x, float y, float radius) {
+		// see http://spencermortensen.com/articles/bezier-circle/
+		return tracer -> {
+			float c = radius * 0.551915024494f;
+			tracer.moveTo(x, y + radius);
+			tracer.bezierCubic(
+					x + c, y + radius,
+					x + radius, y + c,
+					x + radius, y);
+			tracer.bezierCubic(
+					x + radius, y - c,
+					x + c, y - radius,
+					x, y - radius);
+			tracer.bezierCubic(
+					x - c, y - radius,
+					x - radius, y - c,
+					x - radius, y);
+			tracer.bezierCubic(
+					x - radius, y + c,
+					x - c, y + radius,
+					x, y + radius);
+		};
+	}
+	
+	public static DPath rectangle(float x, float y, float width, float height) {
+		return tracer -> {
+			tracer.moveTo(x, y);
+			tracer.lineTo(x + width, y);
+			tracer.lineTo(x + width, y + height);
+			tracer.lineTo(x, y + height);
+			tracer.close();
+		};
+	}
+	
+	public static DPath roundedRectangle(float x, float y, float width, float height, float radius) {
+		return tracer -> {
+			float c = radius - radius * 0.551915024494f;
+			tracer.moveTo(x + width - radius, y + height);
+			tracer.bezierCubic(
+					x + width - c, y + height,
+					x + width, y + height - c,
+					x + width, y + height - radius);
+			tracer.lineTo(x + width, y + radius);
+			tracer.bezierCubic(
+					x + width, y + c,
+					x + width - c, y,
+					x + width - radius, y);
+			tracer.lineTo(x + radius, y);
+			tracer.bezierCubic(
+					x + c, y,
+					x, y + c,
+					x, y + radius);
+			tracer.lineTo(x, y + height - radius);
+			tracer.bezierCubic(
+					x, y + height - c,
+					x + c, y + height,
+					x + radius, y + height);
+			tracer.close();
+		};
+	}
+	
+	void trace(DPathTracer tracer);
+}

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

@@ -0,0 +1,70 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DPathBoundsCalculator implements DPathTracer {
+	public static DIRectangle getBounds(DPath path, DTransform2D transform) {
+		DPathBoundsCalculator calculator = new DPathBoundsCalculator(transform);
+		path.trace(calculator);
+		return new DIRectangle(
+				(int)calculator.minX,
+				(int)calculator.minY,
+				(int)Math.ceil(calculator.maxX - calculator.minX),
+				(int)Math.ceil(calculator.maxY - calculator.minY));
+	}
+	
+	private final DTransform2D transform;
+	private float minX = Float.MAX_VALUE;
+	private float minY = Float.MAX_VALUE;
+	private float maxX = Float.MIN_VALUE;
+	private float maxY = Float.MIN_VALUE;
+	
+	private DPathBoundsCalculator(DTransform2D transform) {
+		this.transform = transform;
+	}
+	
+	private void add(float x, float y) {
+		float tx = transform.getX(x, y);
+		float ty = transform.getY(x, y);
+		
+		minX = Math.min(minX, tx);
+		minY = Math.min(minY, ty);
+		maxX = Math.max(maxX, tx);
+		maxY = Math.max(maxY, ty);
+	}
+
+	@Override
+	public void moveTo(float x, float y) {
+		add(x, y);
+	}
+
+	@Override
+	public void lineTo(float x, float y) {
+		add(x, y);
+	}
+
+	@Override
+	public void bezierCubic(float x1, float y1, float x2, float y2, float x3, float y3) {
+		add(x1, y1);
+		add(x2, y2);
+		add(x3, y3);
+	}
+
+	@Override
+	public void bezierQuadratic(float x1, float y1, float x2, float y2) {
+		add(x1, y1);
+		add(x2, y2);
+	}
+
+	@Override
+	public void close() {
+		
+	}
+}

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

@@ -0,0 +1,14 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DPathCommand {
+	public void accept(DPathTracer tracer);
+}

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

@@ -0,0 +1,22 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DPathTracer {
+	public void moveTo(float x, float y);
+	
+	public void lineTo(float x, float y);
+	
+	public void bezierCubic(float x1, float y1, float x2, float y2, float x3, float y3);
+	
+	public void bezierQuadratic(float x1, float y1, float x2, float y2);
+	
+	public void close();
+}

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

@@ -0,0 +1,14 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DPreparedPath {
+	
+}

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

@@ -0,0 +1,261 @@
+/*
+ * 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 java.util.function.Consumer;
+import java.util.function.Predicate;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSideLayout extends BaseComponentGroup {
+	private final DStyleClass styleClass;
+	
+	private DComponent main;
+	private final List<SideComponent> sides = new ArrayList<>();
+	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	
+	private DStylePath path;
+	private DUIContext context;
+	private DIRectangle bounds;
+	
+	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);
+		
+		sides.add(new SideComponent(side, component));
+	}
+	
+	public void setMain(DComponent component) {
+		if (this.main != null)
+			this.main.close();
+		
+		this.main = component;
+		
+		if (context != null && bounds != null) {
+			main.setContext(path, context);
+			setBounds(bounds);
+			context.repaint(bounds);
+		}
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		this.path = parent.getChild("sidelayout", styleClass);
+		
+		main.setContext(path, context);
+		for (SideComponent side : sides)
+			side.component.setContext(path, context);
+	}
+	
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+		
+		int left = bounds.x;
+		int right = bounds.x + bounds.width;
+		int top = bounds.y;
+		int bottom = bounds.y + bounds.height;
+		for (int i = sides.size() - 1; i >= 0; i--) {
+			SideComponent side = sides.get(i);
+			DDimensionPreferences preferences = side.component.getDimensionPreferences().getValue();
+			
+			switch (side.side) {
+				case TOP: {
+					int componentWidth = right - left;
+					int componentHeight = preferences.preferredHeight;
+					int componentX = left;
+					int componentY = top;
+					
+					if (componentWidth > preferences.maximumWidth) {
+						componentX += (componentWidth - preferences.maximumWidth) / 2;
+						componentWidth = preferences.maximumWidth;
+					}
+					
+					side.component.setBounds(new DIRectangle(componentX, componentY, componentWidth, componentHeight));
+					top += componentHeight;
+					break;
+				}
+				case BOTTOM: {
+					int componentWidth = right - left;
+					int componentHeight = preferences.preferredHeight;
+					bottom -= componentHeight;
+					int componentX = left;
+					int componentY = bottom;
+					
+					if (componentWidth > preferences.maximumWidth) {
+						componentX += (componentWidth - preferences.maximumWidth) / 2;
+						componentWidth = preferences.maximumWidth;
+					}
+					
+					side.component.setBounds(new DIRectangle(componentX, componentY, componentWidth, componentHeight));
+					break;
+				}
+				case LEFT: {
+					int componentWidth = preferences.preferredWidth;
+					int componentHeight = bottom - top;
+					int componentX = left;
+					int componentY = top;
+					
+					if (componentHeight > preferences.maximumHeight) {
+						componentY += (componentHeight - preferences.maximumHeight) / 2;
+						componentHeight = preferences.maximumHeight;
+					}
+					
+					side.component.setBounds(new DIRectangle(componentX, componentY, componentWidth, componentHeight));
+					left += componentWidth;
+					break;
+				}
+				case RIGHT: {
+					int componentWidth = preferences.preferredWidth;
+					int componentHeight = bottom - top;
+					right -= componentWidth;
+					int componentX = right;
+					int componentY = top;
+					
+					if (componentHeight > preferences.maximumHeight) {
+						componentY += (componentHeight - preferences.maximumHeight) / 2;
+						componentHeight = preferences.maximumHeight;
+					}
+					
+					side.component.setBounds(new DIRectangle(componentX, componentY, componentWidth, componentHeight));
+					break;
+				}
+			}
+		}
+		
+		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() {
+		DDimensionPreferences mainPreferences = main.getDimensionPreferences().getValue();
+		int minimumWidth = mainPreferences.minimumWidth;
+		int minimumHeight = mainPreferences.minimumHeight;
+		int preferredWidth = mainPreferences.preferredWidth;
+		int preferredHeight = mainPreferences.preferredHeight;
+		int maximumWidth = mainPreferences.maximumWidth;
+		int maximumHeight = mainPreferences.maximumHeight;
+		
+		for (SideComponent side : sides) {
+			DDimensionPreferences sidePreferences = side.component.getDimensionPreferences().getValue();
+			switch (side.side) {
+				case LEFT:
+				case RIGHT:
+					minimumWidth += sidePreferences.preferredWidth;
+					preferredWidth += sidePreferences.preferredWidth;
+					maximumWidth += sidePreferences.preferredWidth;
+					
+					minimumHeight = Math.max(minimumHeight, sidePreferences.minimumHeight);
+					preferredHeight = Math.max(maximumHeight, sidePreferences.preferredHeight);
+					break;
+				case BOTTOM:
+				case TOP:
+					minimumHeight += sidePreferences.preferredHeight;
+					preferredHeight += sidePreferences.preferredHeight;
+					maximumHeight += sidePreferences.preferredHeight;
+					
+					minimumWidth = Math.max(minimumWidth, sidePreferences.minimumWidth);
+					preferredWidth = Math.max(preferredWidth, sidePreferences.preferredWidth);
+					break;
+			}
+		}
+		
+		dimensionPreferences.setValue(new DDimensionPreferences(
+				minimumWidth,
+				minimumHeight,
+				preferredWidth,
+				preferredHeight,
+				maximumWidth,
+				maximumHeight));
+	}
+
+	@Override
+	protected void forEachChild(Consumer<DComponent> children) {
+		children.accept(main);
+		for (SideComponent side : sides)
+			children.accept(side.component);
+	}
+	
+	@Override
+	public DComponent findChild(Predicate<DComponent> predicate) {
+		if (predicate.test(main))
+			return main;
+		for (SideComponent side : sides)
+			if (predicate.test(side.component))
+				return side.component;
+		
+		return null;
+	}
+
+	@Override
+	public void close() {
+		main.close();
+		for (SideComponent side : sides)
+			side.close();
+	}
+	
+	public class SideComponent implements Closeable, LiveObject.Listener<DDimensionPreferences> {
+		public final Side side;
+		public final DComponent component;
+		public final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> listenerHandle;
+
+		public SideComponent(Side side, DComponent component) {
+			this.side = side;
+			this.component = component;
+			listenerHandle = component.getDimensionPreferences().addListener(this);
+		}
+		
+		@Override
+		public void close() {
+			listenerHandle.close();
+		}
+
+		@Override
+		public void onUpdated(DDimensionPreferences oldValue, DDimensionPreferences newValue) {
+			recalculateSize();
+		}
+	}
+	
+	public enum Side {
+		LEFT,
+		RIGHT,
+		TOP,
+		BOTTOM
+	}
+}

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

@@ -0,0 +1,17 @@
+/*
+ * 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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DTimerHandle extends Closeable {
+	@Override
+	public void close();
+}

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

@@ -0,0 +1,70 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class DTransform2D {
+	public static final DTransform2D IDENTITY = new DTransform2D(1, 0, 0, 1, 0, 0);
+	
+	public static DTransform2D translate(float x, float y) {
+		return new DTransform2D(1, 0, 0, 1, x, y);
+	}
+	
+	public static DTransform2D scaleAndTranslate(float x, float y, float scale) {
+		return new DTransform2D(scale, 0, 0, scale, x, y);
+	}
+	
+	public static DTransform2D scale(float scale) {
+		return new DTransform2D(scale, 0, 0, scale, 0, 0);
+	}
+	
+	public final float xx;
+	public final float xy;
+	public final float yx;
+	public final float yy;
+	public final float dx;
+	public final float dy;
+	
+	public DTransform2D(float xx, float xy, float yx, float yy, float dx, float dy) {
+		this.xx = xx;
+		this.xy = xy;
+		this.yx = yx;
+		this.yy = yy;
+		this.dx = dx;
+		this.dy = dy;
+	}
+	
+	public DTransform2D offset(float x, float y) {
+		return new DTransform2D(xx, xy, yx, yy, dx + x, dy + y);
+	}
+	
+	public float getX(float x, float y) {
+		return x * xx + y * xy + dx;
+	}
+	
+	public float getY(float x, float y) {
+		return x * yx + y * yy + dy;
+	}
+	
+	public DTransform2D mul(DTransform2D other) {
+		// [xx xy dx]   [xx xy dx]   [xx*xx+xy*yx xx*xy+xy*yy xx*dx+xy*dy+dx]
+		// [yx yy dy] x [yx yy dy] = [yx*xx+yy*yx yx*xy+yy*yy yx*dx+yy*dy+dy]
+		// [0  0  1 ]   [0  0  1 ]   [0           0           1             ]
+		DTransform2D a = this;
+		DTransform2D b = other;
+		return new DTransform2D(
+				a.xx * b.xx + a.xy * b.yx,
+				a.xx * b.xy + a.xy * b.yy,
+				a.yx * b.xx + a.yy * b.yx,
+				a.yx * b.xy + a.yx + b.xy,
+				a.xx * b.dx + a.xy * b.dy + dx,
+				a.yx * b.dx + a.yy * b.dy + dy
+		);
+	}
+}

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

@@ -0,0 +1,50 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.style.DStyleSheets;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DUIContext {
+	DStyleSheets getStylesheets();
+	
+	float getScale();
+	
+	void repaint(int x, int y, int width, int height);
+	
+	default void repaint(DIRectangle rectangle) {
+		repaint(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
+	}
+	
+	void setCursor(Cursor cursor);
+	
+	void focus(DComponent component);
+	
+	void scrollInView(int x, int y, int width, int height);
+	
+	DTimerHandle setTimer(int millis, Runnable target);
+	
+	DClipboard getClipboard();
+	
+	DFontMetrics getFontMetrics(DFont font);
+	
+	DUIWindow getWindow();
+		
+	enum Cursor {
+		NORMAL,
+		HAND,
+		MOVE,
+		TEXT,
+		E_RESIZE,
+		S_RESIZE,
+		NE_RESIZE,
+		NW_RESIZE,
+	}
+}

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

@@ -0,0 +1,35 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DUIWindow {
+	public boolean hasTitleBar();
+	
+	public void close();
+	
+	public void maximize();
+	
+	public void restore();
+	
+	public void minimize();
+	
+	LiveObject<State> getWindowState();
+	
+	LiveBool getActive();
+	
+	enum State {
+		NORMAL,
+		MAXIMIZED,
+		MINIMIZED
+	};
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.DCanvas;
+import org.openzen.drawablegui.DIRectangle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DBorder {
+	public void paint(DCanvas canvas, DIRectangle bounds);
+	
+	public int getPaddingLeft();
+	
+	public int getPaddingRight();
+	
+	public int getPaddingTop();
+	
+	public int getPaddingBottom();
+}

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

@@ -0,0 +1,184 @@
+/*
+ * 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.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+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.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.ImmutableLiveObject;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DCustomWindowBorder implements DComponent {
+	private final DStyleClass styleClass;
+	private final DComponent content;
+	private final LiveObject<DDimensionPreferences> preferences = new ImmutableLiveObject<>(DDimensionPreferences.EMPTY);
+	
+	private DUIContext context;
+	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;
+	
+	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);
+		
+		state = context.getWindow().getWindowState();
+		active = context.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));
+		
+		if (bounds != null)
+			layout();
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return preferences;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+		layout();
+	}
+	
+	private void layout() {	
+		if (style == null)
+			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);
+			
+			int spacing = style.borderWidth + style.padding;
+			DIRectangle inner = new DIRectangle(
+					bounds.x + spacing,
+					bounds.y + spacing,
+					bounds.width - 2 * spacing,
+					bounds.height - 2 * spacing);
+
+			content.setBounds(inner);
+		} 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);
+			}
+		} else {
+			canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		}
+		
+		content.paint(canvas);
+	}
+
+	@Override
+	public void onMouseEnter(DMouseEvent e) {
+		content.onMouseEnter(e);
+	}
+	
+	@Override
+	public void onMouseExit(DMouseEvent e) {
+		content.onMouseExit(e);
+	}
+	
+	@Override
+	public void onMouseMove(DMouseEvent e) {
+		content.onMouseMove(e);
+	}
+	
+	@Override
+	public void onMouseDrag(DMouseEvent e) {
+		content.onMouseDrag(e);
+	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		content.onMouseClick(e);
+	}
+	
+	@Override
+	public void onMouseDown(DMouseEvent e) {
+		content.onMouseDown(e);
+	}
+	
+	@Override
+	public void onMouseRelease(DMouseEvent e) {
+		content.onMouseRelease(e);
+	}
+	
+	@Override
+	public void onMouseScroll(DMouseEvent e) {
+		content.onMouseScroll(e);
+	}
+	
+	@Override
+	public void close() {
+		
+	}
+	
+	private void onStateChanged(DUIWindow.State oldValue, DUIWindow.State newValue) {
+		layout();
+	}
+	
+	private void onActiveChanged(boolean oldValue, boolean newValue) {
+		context.repaint(bounds);
+	}
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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.style.DDpDimension;
+import org.openzen.drawablegui.style.DPxDimension;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DCustomWindowBorderStyle {
+	public final int padding;
+	public final DShadow shadow;
+	public final int borderWidth;
+	public final int backgroundColor;
+	
+	public final int focusedBorderColor;
+	public final int inactiveBorderColor;
+	
+	public DCustomWindowBorderStyle(DStyleDefinition style) {
+		padding = style.getDimension("padding", new DDpDimension(8));
+		shadow = style.getShadow("shadow", context -> new DShadow(0x80888888, 0, 0, 6 * context.getScale()));
+		borderWidth = style.getDimension("borderWidth", new DPxDimension(1));
+		backgroundColor = style.getColor("backgroundColor", 0xFFEEEEEE);
+		
+		focusedBorderColor = style.getColor("focusedBorderColor", 0xFF18B0FB);
+		inactiveBorderColor = style.getColor("inactiveBorderColor", 0xFF515252);
+	}
+}

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

@@ -0,0 +1,43 @@
+/*
+ * 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.DCanvas;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DEmptyBorder implements DBorder {
+	public static final DEmptyBorder INSTANCE = new DEmptyBorder();
+	
+	@Override
+	public void paint(DCanvas canvas, DIRectangle bounds) {
+		
+	}
+
+	@Override
+	public int getPaddingLeft() {
+		return 0;
+	}
+
+	@Override
+	public int getPaddingRight() {
+		return 0;
+	}
+
+	@Override
+	public int getPaddingTop() {
+		return 0;
+	}
+
+	@Override
+	public int getPaddingBottom() {
+		return 0;
+	}
+}

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

@@ -0,0 +1,56 @@
+/*
+ * 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.DCanvas;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DUIContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DLineBorder implements DBorder {
+	private final int color;
+	private final int borderWidth;
+	
+	public DLineBorder(int color, int borderWidth) {
+		this.color = color;
+		this.borderWidth = borderWidth;
+	}
+
+	@Override
+	public void paint(DCanvas canvas, DIRectangle bounds) {
+		canvas.strokePath(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);
+				tracer.lineTo(bounds.x, bounds.y + bounds.height - borderWidth);
+				tracer.close();
+			}, DTransform2D.IDENTITY, color, borderWidth);
+	}
+
+	@Override
+	public int getPaddingLeft() {
+		return borderWidth;
+	}
+
+	@Override
+	public int getPaddingRight() {
+		return borderWidth;
+	}
+
+	@Override
+	public int getPaddingTop() {
+		return borderWidth;
+	}
+
+	@Override
+	public int getPaddingBottom() {
+		return borderWidth;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/listeners/DummyListenerHandle.java

@@ -0,0 +1,28 @@
+/*
+ * 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.listeners;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DummyListenerHandle<T> implements ListenerHandle<T> {
+	private final T listener;
+
+	public DummyListenerHandle(T listener) {
+		this.listener = listener;
+	}
+
+	@Override
+	public T getListener() {
+		return listener;
+	}
+
+	@Override
+	public void close() {
+
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/listeners/ListenerHandle.java

@@ -0,0 +1,27 @@
+/* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
+package org.openzen.drawablegui.listeners;
+
+import java.io.Closeable;
+
+/**
+ * An EvenListenerHandle is returned when an EventListener is registered in an
+ * EventListenerList, which can then be used to unregister the event listener.
+ *
+ * @param <T> Event type
+ * @author Stan Hebben
+ */
+public interface ListenerHandle<T> extends Closeable
+{
+	/**
+	 * Gets this handle's listener.
+	 *
+	 * @return listener
+	 */
+	public T getListener();
+
+	/**
+	 * Closes (unregisters) the event listener from the list it was registered to.
+	 */
+	@Override
+	public void close();
+}

DrawableGui/src/main/java/org/openzen/drawablegui/listeners/ListenerList.java

@@ -0,0 +1,165 @@
+/* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
+package org.openzen.drawablegui.listeners;
+
+import java.util.function.Consumer;
+
+/**
+ * Implements a list of event listeners. This class is thread-safe and listeners
+ * can be added or removed concurrently, no external locking is ever needed.
+ * Also, it's very lightweight.
+ *
+ * @param <T> event type
+ * @author Stan Hebben
+ */
+public class ListenerList<T>
+{
+    public static final int PRIORITY_HIGH = 100;
+    public static final int PRIORITY_DEFAULT = 0;
+    public static final int PRIORITY_LOW = -100;
+	
+	// implements a linked list of nodes
+	protected volatile EventListenerNode first = null;
+	protected EventListenerNode last = null;
+
+	/**
+	 * Adds an IEventListener to the list.
+	 *
+	 * @param listener event listener
+	 * @return event listener's handle
+	 */
+	public ListenerHandle<T> add(T listener)
+	{
+        return add(listener, PRIORITY_DEFAULT);
+    }
+
+    public ListenerHandle<T> add(T listener, int priority)
+	{
+		EventListenerNode node = new EventListenerNode(listener, priority);
+
+		synchronized (this) {
+			if (first == null) {
+				first = last = node;
+			} else {
+                // prioritized list: where to insert?
+                EventListenerNode previousNode = last;
+                while (previousNode != null && priority > previousNode.priority) {
+                    previousNode = previousNode.prev;
+                }
+
+                if (previousNode == null) {
+                    node.next = first;
+                    first.prev = previousNode;
+                    first = node;
+                } else {
+                    if (previousNode.next == null) {
+                        last = node;
+                    } else {
+                        previousNode.next.prev = node;
+                    }
+
+                    previousNode.next = node;
+                    node.prev = previousNode;
+                }
+            }
+		}
+
+		return node;
+	}
+
+	/**
+	 * Removes an IEventListener from the list.
+	 *
+	 * @param listener listener to be removed
+	 * @return true if the listener was removed, false it it wasn't there
+	 */
+	public synchronized boolean remove(T listener)
+	{
+		EventListenerNode current = first;
+
+		while (current != null) {
+			if (current.listener == listener) {
+				current.close();
+				return true;
+			}
+
+            current = current.next;
+		}
+
+		return false;
+	}
+	
+	/**
+	 * Clears this listener list.
+	 */
+	public synchronized void clear()
+	{
+		first = last = null;
+	}
+	
+	/**
+	 * Invokes the given consumer for every listener in the list.
+	 * 
+	 * @param consumer consumer to be called for each listener
+	 */
+	public void accept(Consumer<T> consumer)
+	{
+		EventListenerNode current = first;
+		
+		while (current != null) {
+			consumer.accept(current.listener);
+			current = current.next;
+		}
+	}
+
+	/**
+	 * Checks if there are any listeners in this list.
+	 *
+	 * @return true if empty
+	 */
+	public boolean isEmpty()
+	{
+		return first == null;
+	}
+
+	// #######################
+	// ### Private classes ###
+	// #######################
+
+	protected class EventListenerNode implements ListenerHandle<T>
+	{
+		protected final T listener;
+        protected final int priority;
+		protected EventListenerNode next = null;
+		protected EventListenerNode prev = null;
+
+		public EventListenerNode(T handler, int priority)
+		{
+			this.listener = handler;
+            this.priority = priority;
+		}
+
+		@Override
+		public T getListener()
+		{
+			return listener;
+		}
+
+		@Override
+		public void close()
+		{
+			synchronized (ListenerList.this) {
+				if (prev == null) {
+					first = next;
+				} else {
+					prev.next = next;
+				}
+
+				if (next == null) {
+					last = prev;
+				} else {
+					next.prev = prev;
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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.DummyListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ImmutableLiveBool implements LiveBool {
+	public static final ImmutableLiveBool TRUE = new ImmutableLiveBool(true);
+	public static final ImmutableLiveBool FALSE = new ImmutableLiveBool(false);
+	
+	private final boolean value;
+	
+	private ImmutableLiveBool(boolean value) {
+		this.value = value;
+	}
+
+	@Override
+	public boolean getValue() {
+		return value;
+	}
+
+	@Override
+	public void setValue(boolean value) {
+		throw new UnsupportedOperationException("Cannot modify an immutable value");
+	}
+
+	@Override
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return new DummyListenerHandle<>(listener);
+	}
+}

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

@@ -0,0 +1,36 @@
+/*
+ * 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.DummyListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ImmutableLiveObject<T> implements LiveObject<T> {
+	private final T value;
+	
+	public ImmutableLiveObject(T value) {
+		this.value = value;
+	}
+	
+	@Override
+	public T getValue() {
+		return value;
+	}
+
+	@Override
+	public void setValue(T value) {
+		throw new UnsupportedOperationException("Immutable value");
+	}
+
+	@Override
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
+		return new DummyListenerHandle<>(listener);
+	}
+}

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

@@ -0,0 +1,80 @@
+/*
+ * 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 java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LiveArrayList<T> implements LiveList<T> {
+	private final List<T> values = new ArrayList<>();
+	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
+
+	@Override
+	public void add(T value) {
+		int index = values.size();
+		values.add(value);
+		listeners.accept(listener -> listener.onInserted(index, value));
+	}
+
+	@Override
+	public void add(int index, T value) {
+		values.add(index, value);
+		listeners.accept(listener -> listener.onInserted(index, value));
+	}
+
+	@Override
+	public void set(int index, T value) {
+		T oldValue = values.set(index, value);
+		listeners.accept(listener -> listener.onChanged(index, oldValue, value));
+	}
+
+	@Override
+	public void remove(int index) {
+		T oldValue = values.remove(index);
+		listeners.accept(listener -> listener.onRemoved(index, oldValue));
+	}
+
+	@Override
+	public void remove(T value) {
+		int index = indexOf(value);
+		if (index < 0)
+			return;
+		
+		remove(index);
+	}
+
+	@Override
+	public int indexOf(T value) {
+		return values.indexOf(value);
+	}
+	
+	@Override
+	public int size() {
+		return values.size();
+	}
+
+	@Override
+	public T get(int index) {
+		return values.get(index);
+	}
+
+	@Override
+	public Iterator<T> iterator() {
+		return values.iterator();
+	}
+
+	@Override
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
+		return listeners.add(listener);
+	}
+}

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

@@ -0,0 +1,28 @@
+/*
+ * 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 interface LiveBool {
+	public boolean getValue();
+	
+	public void setValue(boolean value);
+	
+	default void toggle() {
+		setValue(!getValue());
+	}
+	
+	public ListenerHandle<Listener> addListener(Listener listener);
+	
+	public interface Listener {
+		void onChanged(boolean oldValue, boolean newValue);
+	}
+}

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

@@ -0,0 +1,155 @@
+/*
+ * 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 java.io.Closeable;
+import java.util.Iterator;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LiveConcatList<T> implements Closeable, LiveList<T> {
+	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
+	private final LiveList<T> a;
+	private final LiveList<T> b;
+	
+	private final ListenerHandle<Listener<T>> aListener;
+	private final ListenerHandle<Listener<T>> bListener;
+	
+	public LiveConcatList(LiveList<T> a, LiveList<T> b) {
+		this.a = a;
+		this.b = b;
+		
+		aListener = a.addListener(new FirstListListener());
+		bListener = b.addListener(new SecondListListener());
+	}
+	
+	@Override
+	public void close() {
+		aListener.close();
+		bListener.close();
+	}
+
+	@Override
+	public void add(T value) {
+		throw new UnsupportedOperationException("Cannot modify a concat list");
+	}
+
+	@Override
+	public void add(int index, T value) {
+		throw new UnsupportedOperationException("Cannot modify a concat list");
+	}
+
+	@Override
+	public void set(int index, T value) {
+		throw new UnsupportedOperationException("Cannot modify a concat list");
+	}
+
+	@Override
+	public void remove(int index) {
+		throw new UnsupportedOperationException("Cannot modify a concat list");
+	}
+
+	@Override
+	public void remove(T value) {
+		throw new UnsupportedOperationException("Cannot modify a concat list");
+	}
+
+	@Override
+	public int indexOf(T value) {
+		int result = a.indexOf(value);
+		if (result >= 0)
+			return result;
+		
+		result = b.indexOf(value);
+		return result < 0 ? -1 : result + a.size();
+	}
+
+	@Override
+	public int size() {
+		return a.size() + b.size();
+	}
+
+	@Override
+	public T get(int index) {
+		return index < a.size() ? a.get(index) : b.get(index - a.size());
+	}
+
+	@Override
+	public Iterator<T> iterator() {
+		return new ConcatIterator();
+	}
+
+	@Override
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
+		return listeners.add(listener);
+	}
+	
+	private class ConcatIterator implements Iterator<T> {
+		private boolean firstList = true;
+		private Iterator<T> iterator;
+
+		public ConcatIterator() {
+			iterator = a.iterator();
+			if (!iterator.hasNext()) {
+				firstList = false;
+				iterator = b.iterator();
+			}
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return iterator.hasNext();
+		}
+
+		@Override
+		public T next() {
+			T result = iterator.next();
+			if (firstList && !iterator.hasNext()) {
+				firstList = false;
+				iterator = b.iterator();
+			}
+			return result;
+		}
+	}
+	
+	private class FirstListListener implements Listener<T> {
+		@Override
+		public void onInserted(int index, T value) {
+			listeners.accept(listener -> listener.onInserted(index, value));
+		}
+
+		@Override
+		public void onChanged(int index, T oldValue, T newValue) {
+			listeners.accept(listener -> listener.onChanged(index, oldValue, newValue));
+		}
+
+		@Override
+		public void onRemoved(int index, T oldValue) {
+			listeners.accept(listener -> listener.onRemoved(index, oldValue));
+		}
+	}
+	
+	private class SecondListListener implements Listener<T> {
+		@Override
+		public void onInserted(int index, T value) {
+			listeners.accept(listener -> listener.onInserted(a.size() + index, value));
+		}
+
+		@Override
+		public void onChanged(int index, T oldValue, T newValue) {
+			listeners.accept(listener -> listener.onChanged(a.size() + index, oldValue, newValue));
+		}
+
+		@Override
+		public void onRemoved(int index, T oldValue) {
+			listeners.accept(listener -> listener.onRemoved(a.size() + index, oldValue));
+		}
+	}
+}

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

@@ -0,0 +1,73 @@
+/*
+ * 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 java.util.Collections;
+import java.util.Iterator;
+import org.openzen.drawablegui.listeners.DummyListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LiveEmptyList<T> implements LiveList<T> {
+	private static final LiveEmptyList INSTANCE = new LiveEmptyList();
+	
+	public static <T> LiveEmptyList<T> get() {
+		return INSTANCE;
+	}
+
+	@Override
+	public void add(T value) {
+		throw new UnsupportedOperationException("Immutable list");
+	}
+
+	@Override
+	public void add(int index, T value) {
+		throw new UnsupportedOperationException("Immutable list");
+	}
+
+	@Override
+	public void set(int index, T value) {
+		throw new UnsupportedOperationException("Immutable list");
+	}
+
+	@Override
+	public void remove(int index) {
+		throw new UnsupportedOperationException("Immutable list");
+	}
+
+	@Override
+	public void remove(T value) {
+		throw new UnsupportedOperationException("Immutable list");
+	}
+
+	@Override
+	public int indexOf(T value) {
+		return -1;
+	}
+	
+	@Override
+	public int size() {
+		return 0;
+	}
+	
+	@Override
+	public T get(int index) {
+		throw new ArrayIndexOutOfBoundsException(index);
+	}
+
+	@Override
+	public Iterator<T> iterator() {
+		return Collections.emptyIterator();
+	}
+
+	@Override
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
+		return new DummyListenerHandle<>(listener);
+	}
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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 interface LiveInt {
+	int getValue();
+	
+	void setValue(int value);
+	
+	ListenerHandle<Listener> addListener(Listener listener);
+	
+	interface Listener {
+		void onChanged(int oldValue, int newValue);
+	}
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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 java.util.Iterator;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface LiveList<T> extends Iterable<T> {
+	void add(T value);
+	
+	void add(int index, T value);
+	
+	void set(int index, T value);
+	
+	void remove(int index);
+	
+	void remove(T value);
+	
+	int indexOf(T value);
+	
+	int size();
+	
+	T get(int index);
+	
+	@Override
+	Iterator<T> iterator();
+	
+	ListenerHandle<Listener<T>> addListener(Listener<T> listener);
+	
+	interface Listener<T> {
+		void onInserted(int index, T value);
+		
+		void onChanged(int index, T oldValue, T newValue);
+		
+		void onRemoved(int index, T oldValue);
+	}
+}

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

@@ -0,0 +1,111 @@
+/*
+ * 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 java.io.Closeable;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LiveMappedList<T, U> implements Closeable, LiveList<U> {
+	private final ListenerList<Listener<U>> listeners = new ListenerList<>();
+	private final Function<T, U> projection;
+	private final List<U> mapped;
+	private final ListenerHandle<Listener<T>> mappingListenerHandle;
+	
+	public LiveMappedList(LiveList<T> original, Function<T, U> projection) {
+		this.projection = projection;
+		mappingListenerHandle = original.addListener(new MappingListener());
+		
+		mapped = new ArrayList<>();
+		for (T originalItem : original)
+			mapped.add(projection.apply(originalItem));
+	}
+	
+	@Override
+	public void close() {
+		mappingListenerHandle.close();
+	}
+
+	@Override
+	public void add(U value) {
+		throw new UnsupportedOperationException("Cannot modify a mapped list");
+	}
+
+	@Override
+	public void add(int index, U value) {
+		throw new UnsupportedOperationException("Cannot modify a mapped list");
+	}
+
+	@Override
+	public void set(int index, U value) {
+		throw new UnsupportedOperationException("Cannot modify a mapped list");
+	}
+
+	@Override
+	public void remove(int index) {
+		throw new UnsupportedOperationException("Cannot modify a mapped list");
+	}
+
+	@Override
+	public void remove(U value) {
+		throw new UnsupportedOperationException("Cannot modify a mapped list");
+	}
+
+	@Override
+	public int indexOf(U value) {
+		return mapped.indexOf(value);
+	}
+	
+	@Override
+	public int size() {
+		return mapped.size();
+	}
+
+	@Override
+	public U get(int index) {
+		return mapped.get(index);
+	}
+
+	@Override
+	public Iterator<U> iterator() {
+		return mapped.iterator();
+	}
+
+	@Override
+	public ListenerHandle<Listener<U>> addListener(Listener<U> listener) {
+		return listeners.add(listener);
+	}
+	
+	private class MappingListener implements Listener<T> {
+		@Override
+		public void onInserted(int index, T value) {
+			U mappedValue = projection.apply(value);
+			mapped.add(index, mappedValue);
+			listeners.accept(listener -> listener.onInserted(index, mappedValue));
+		}
+
+		@Override
+		public void onChanged(int index, T oldValue, T newValue) {
+			U mappedNewValue = projection.apply(newValue);
+			U mappedOldValue = mapped.set(index, mappedNewValue);
+			listeners.accept(listener -> listener.onChanged(index, mappedOldValue, mappedNewValue));
+		}
+
+		@Override
+		public void onRemoved(int index, T oldValue) {
+			U oldMappedValue = mapped.remove(index);
+			listeners.accept(listener -> listener.onRemoved(index, oldMappedValue));
+		}
+	}
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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 interface LiveObject<T> {
+	public T getValue();
+	
+	public void setValue(T value);
+	
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener);
+	
+	public interface Listener<T> {
+		void onUpdated(T oldValue, T newValue);
+	}
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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 java.io.Closeable;
+import java.util.function.Predicate;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LivePredicateBool<T> implements LiveBool, Closeable, LiveObject.Listener<T> {
+	private final ListenerList<LiveBool.Listener> listeners = new ListenerList<>();
+	private final LiveObject<T> source;
+	private final Predicate<T> predicate;
+	private final ListenerHandle<LiveObject.Listener<T>> sourceListener;
+	private boolean value;
+	
+	public LivePredicateBool(LiveObject<T> source, Predicate<T> predicate) {
+		this.source = source;
+		this.predicate = predicate;
+		this.sourceListener = source.addListener(this);
+		setValueInternal(predicate.test(source.getValue()));
+	}
+	
+	@Override
+	public void close() {
+		sourceListener.close();
+	}
+	
+	@Override
+	public void setValue(boolean value) {
+		throw new UnsupportedOperationException("Cannot modify a calculated value");
+	}
+
+	@Override
+	public boolean getValue() {
+		return value;
+	}
+
+	@Override
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return listeners.add(listener);
+	}
+	
+	private void setValueInternal(boolean value) {
+		if (value == this.value)
+			return;
+		
+		boolean oldValue = this.value;
+		this.value = value;
+		listeners.accept(listener -> listener.onChanged(oldValue, value));
+	}
+
+	@Override
+	public void onUpdated(T oldValue, T newValue) {
+		setValueInternal(predicate.test(newValue));
+	}
+}

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

@@ -0,0 +1,124 @@
+/*
+ * 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 java.util.Iterator;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LivePrefixedList<T> implements LiveList<T> {
+	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
+	private final T prefix;
+	private final LiveList<T> values;
+	
+	public LivePrefixedList(T prefix, LiveList<T> values) {
+		this.prefix = prefix;
+		this.values = values;
+	}
+
+	@Override
+	public void add(T value) {
+		values.add(value);
+	}
+
+	@Override
+	public void add(int index, T value) {
+		if (index == 0)
+			throw new UnsupportedOperationException("Cannot add an item at the beginning of a prefixed list");
+		values.add(index - 1, value);
+	}
+
+	@Override
+	public void set(int index, T value) {
+		if (index == 0)
+			throw new UnsupportedOperationException("Cannot change the item at the beginning of a prefixed list");
+		
+		values.set(index - 1, value);
+	}
+
+	@Override
+	public void remove(int index) {
+		if (index == 0)
+			throw new UnsupportedOperationException("Cannot remote the item at the beginning of a prefixed list");
+		
+		values.remove(index - 1);
+	}
+
+	@Override
+	public void remove(T value) {
+		values.remove(value);
+	}
+
+	@Override
+	public int indexOf(T value) {
+		if (value.equals(prefix))
+			return 0;
+		
+		int base = values.indexOf(value);
+		return base < 0 ? base : base - 1;
+	}
+
+	@Override
+	public int size() {
+		return values.size() + 1;
+	}
+	
+	@Override
+	public T get(int index) {
+		return index == 0 ? prefix : values.get(index);
+	}
+
+	@Override
+	public Iterator<T> iterator() {
+		return new PrefixIterator();
+	}
+
+	@Override
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
+		return listeners.add(listener);
+	}
+	
+	private class PrefixIterator implements Iterator<T> {
+		private boolean first = true;
+		private Iterator<T> others = values.iterator();
+
+		@Override
+		public boolean hasNext() {
+			return first || others.hasNext();
+		}
+
+		@Override
+		public T next() {
+			if (first) {
+				first = false;
+				return prefix;
+			} else {
+				return others.next();
+			}
+		}
+	}
+	
+	private class BaseListener implements Listener<T> {
+		@Override
+		public void onInserted(int index, T value) {
+			listeners.accept(listener -> listener.onInserted(index + 1, value));
+		}
+
+		@Override
+		public void onChanged(int index, T oldValue, T newValue) {
+			listeners.accept(listener -> listener.onChanged(index + 1, oldValue, newValue));
+		}
+
+		@Override
+		public void onRemoved(int index, T oldValue) {
+			listeners.accept(listener -> listener.onRemoved(index + 1, oldValue));
+		}
+	}
+}

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

@@ -0,0 +1,46 @@
+/*
+ * 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;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SimpleLiveBool implements LiveBool {
+	private final ListenerList<LiveBool.Listener> listeners = new ListenerList<>();
+	private boolean value;
+	
+	public SimpleLiveBool() {
+		this(false);
+	}
+	
+	public SimpleLiveBool(boolean value) {
+		this.value = value;
+	}
+	
+	@Override
+	public boolean getValue() {
+		return value;
+	}
+	
+	@Override
+	public void setValue(boolean value) {
+		if (value == this.value)
+			return;
+		
+		boolean oldValue = this.value;
+		this.value = value;
+		listeners.accept(listener -> listener.onChanged(oldValue, value));
+	}
+	
+	@Override
+	public ListenerHandle<LiveBool.Listener> addListener(LiveBool.Listener listener) {
+		return listeners.add(listener);
+	}
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SimpleLiveInt implements LiveInt {
+	private final ListenerList<Listener> listeners = new ListenerList<>();
+	private int value = 0;
+
+	@Override
+	public int getValue() {
+		return value;
+	}
+
+	@Override
+	public void setValue(int value) {
+		int oldValue = this.value;
+		this.value = value;
+		listeners.accept(listener -> listener.onChanged(oldValue, value));
+	}
+
+	@Override
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return listeners.add(listener);
+	}
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SimpleLiveObject<T> implements LiveObject<T> {
+	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
+	private T value;
+	
+	public SimpleLiveObject(T value) {
+		this.value = value;
+	}
+	
+	@Override
+	public T getValue() {
+		return value;
+	}
+	
+	@Override
+	public void setValue(T value) {
+		T oldValue = this.value;
+		this.value = value;
+		listeners.accept(listener -> listener.onUpdated(oldValue, value));
+	}
+	
+	@Override
+	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
+		return listeners.add(listener);
+	}
+}

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

@@ -0,0 +1,173 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.scroll;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveInt;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollBar implements DComponent {
+	private final LiveObject<DDimensionPreferences> preferences;
+	
+	private final DStyleClass styleClass;
+	private final LiveInt targetHeight;
+	private final LiveInt offset;
+	
+	private final ListenerHandle<LiveInt.Listener> targetHeightListener;
+	private final ListenerHandle<LiveInt.Listener> offsetListener;
+	
+	private DUIContext context;
+	private DScrollBarStyle style;
+	private DIRectangle bounds;
+	
+	private int fromY = 0;
+	private int toY = 0;
+	private boolean hovering = false;
+	private boolean dragging = false;
+	private int dragStartOffset;
+	private int dragStartY;
+	
+	public DScrollBar(DStyleClass styleClass, LiveInt targetHeight, LiveInt offset) {
+		this.styleClass = styleClass;
+		this.targetHeight = targetHeight;
+		this.offset = offset;
+		this.preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+		
+		targetHeightListener = targetHeight.addListener(new ScrollListener());
+		offsetListener = offset.addListener(new ScrollListener());
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		this.style = new DScrollBarStyle(context.getStylesheets().get(context, parent.getChild("scrollbar", styleClass)));
+		preferences.setValue(new DDimensionPreferences(style.width, 0));
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return preferences;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = 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) {
+		checkHover(e);
+	}
+	
+	@Override
+	public void onMouseExit(DMouseEvent e) {
+		setHovering(false);
+		setDragging(false);
+	}
+	
+	@Override
+	public void onMouseMove(DMouseEvent e) {
+		checkHover(e);
+	}
+	
+	@Override
+	public void onMouseDrag(DMouseEvent e) {
+		if (dragging) {
+			int deltaY = e.y - dragStartY;
+			int offsetForDelta = deltaY * targetHeight.getValue() / this.bounds.height;
+			offset.setValue(dragStartOffset + offsetForDelta);
+		}
+	}
+	
+	@Override
+	public void onMouseDown(DMouseEvent e) {
+		if (e.y >= fromY && e.y < toY) {
+			dragStartOffset = offset.getValue();
+			dragStartY = e.y;
+			setDragging(true);
+		}
+	}
+	
+	@Override
+	public void onMouseRelease(DMouseEvent e) {
+		setDragging(false);
+	}
+
+	@Override
+	public void close() {
+		// nothing to clean up
+	}
+	
+	private void checkHover(DMouseEvent e) {
+		setHovering(e.y >= fromY && e.y < toY);
+	}
+	
+	private void setHovering(boolean hovering) {
+		if (hovering == this.hovering)
+			return;
+		
+		this.hovering = hovering;
+		context.repaint(bounds.x, fromY, bounds.width, toY - fromY);
+	}
+	
+	private void setDragging(boolean dragging) {
+		if (dragging == this.dragging)
+			return;
+		
+		this.dragging = dragging;
+		context.repaint(bounds.x, fromY, bounds.width, toY - fromY);
+	}
+	
+	private void recalculate() {
+		if (targetHeight.getValue() == 0 || bounds == null)
+			return;
+		
+		fromY = bounds.y + this.bounds.height * offset.getValue() / targetHeight.getValue();
+		toY = bounds.y + this.bounds.height * (offset.getValue() + this.bounds.height) / targetHeight.getValue();
+	}
+	
+	private class ScrollListener implements LiveInt.Listener {
+		@Override
+		public void onChanged(int oldValue, int newValue) {
+			recalculate();
+		}
+	}
+}

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

@@ -0,0 +1,31 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.scroll;
+
+import org.openzen.drawablegui.style.DDimension;
+import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollBarStyle {
+	public final int scrollBarBackgroundColor;
+	public final int scrollBarNormalColor;
+	public final int scrollBarHoverColor;
+	public final int scrollBarPressColor;
+	public final int width;
+	
+	public DScrollBarStyle(DStyleDefinition style) {
+		this.scrollBarBackgroundColor = style.getColor("scrollbar.background.color", 0xFFF0F0F0);
+		this.scrollBarNormalColor = style.getColor("scrollbar.color.normal", 0xFFCDCDCD);
+		this.scrollBarHoverColor = style.getColor("scrollbar.color.hover", 0xFF888888);
+		this.scrollBarPressColor = style.getColor("scrollbar.color.press", 0xFF666666);
+		this.width = style.getDimension("width", new DDpDimension(12));
+	}
+}

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

@@ -0,0 +1,320 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.scroll;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DClipboard;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.DTimerHandle;
+import org.openzen.drawablegui.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.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+import org.openzen.drawablegui.style.DStyleSheets;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollPane implements DComponent {
+	private final DStyleClass styleClass;
+	private final DComponent contents;
+	private final DScrollBar scrollBar;
+	private DUIContext context;
+	private DIRectangle bounds;
+	
+	private DScrollPaneStyle style;
+	private final LiveInt contentsHeight;
+	private final LiveInt offsetX;
+	private final LiveInt offsetY;
+	
+	private final ListenerHandle<LiveInt.Listener> contentsHeightListener;
+	private final ListenerHandle<LiveInt.Listener> offsetXListener;
+	private final ListenerHandle<LiveInt.Listener> offsetYListener;
+	
+	private DComponent hovering = null;
+	
+	public DScrollPane(DStyleClass styleClass, DComponent contents) {
+		this.styleClass = styleClass;
+		this.contents = contents;
+		
+		contentsHeight = new SimpleLiveInt();
+		offsetX = new SimpleLiveInt();
+		offsetY = new SimpleLiveInt();
+		
+		scrollBar = new DScrollBar(DStyleClass.EMPTY, contentsHeight, offsetY);
+		
+		contentsHeightListener = contentsHeight.addListener(new ScrollListener());
+		offsetXListener = offsetX.addListener(new ScrollListener());
+		offsetYListener = offsetY.addListener(new ScrollListener());
+		
+		contents.getDimensionPreferences().addListener((oldPreferences, newPreferences) -> {
+			if (bounds == null)
+				return;
+			
+			contents.setBounds(new DIRectangle(0, 0, bounds.width, Math.max(bounds.height, newPreferences.preferredHeight)));
+			contentsHeight.setValue(newPreferences.preferredHeight);
+		});
+	}
+	
+	@Override
+	public void onMounted() {
+		contents.onMounted();
+	}
+	
+	@Override
+	public void onUnmounted() {
+		contents.onUnmounted();
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("scrollpane", styleClass);
+		contents.setContext(path, new TranslatedContext());
+		scrollBar.setContext(path, context);
+		style = new DScrollPaneStyle(context.getStylesheets().get(context, path));
+		
+		if (bounds != null)
+			setBounds(bounds);
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return contents.getDimensionPreferences(); // TODO: derived preferences
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+		
+		if (this.context == null)
+			return;
+		
+		int height = Math.max(
+				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom(),
+				contents.getDimensionPreferences().getValue().preferredHeight);
+		int scrollBarWidth = scrollBar.getDimensionPreferences().getValue().preferredWidth;
+		scrollBar.setBounds(new DIRectangle(
+				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight(),
+				bounds.y + style.border.getPaddingTop(),
+				scrollBarWidth,
+				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom()));
+		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();
+	}
+	
+	@Override
+	public void onMouseScroll(DMouseEvent e) {
+		offsetY.setValue(offsetY.getValue() + e.deltaZ * 50);
+	}
+	
+	@Override
+	public void onMouseEnter(DMouseEvent e) {
+		if (e.x >= scrollBar.getBounds().x) {
+			setHovering(scrollBar, e);
+		} else {
+			setHovering(contents, e);
+		}
+	}
+	
+	@Override
+	public void onMouseExit(DMouseEvent e) {
+		setHovering(null, e);
+	}
+	
+	@Override
+	public void onMouseMove(DMouseEvent e) {
+		if (e.x >= scrollBar.getBounds().x) {
+			if (hovering != scrollBar) {
+				setHovering(scrollBar, e);
+			} else {
+				scrollBar.onMouseMove(e);
+			}
+		} else {
+			if (hovering != contents) {
+				setHovering(contents, e);
+			} else {
+				contents.onMouseMove(translateMouseEvent(e));
+			}
+		}
+	}
+	
+	@Override
+	public void onMouseDrag(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseDrag(forward(hovering, e));
+	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseClick(forward(hovering, e));
+	}
+	
+	@Override
+	public void onMouseDown(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseDown(forward(hovering, e));
+	}
+	
+	@Override
+	public void onMouseRelease(DMouseEvent e) {
+		if (hovering != null)
+			hovering.onMouseRelease(forward(hovering, e));
+		
+		onMouseMove(e);
+	}
+
+	@Override
+	public void close() {
+		contents.close();
+	}
+	
+	private DMouseEvent forward(DComponent target, DMouseEvent e) {
+		return target == contents ? translateMouseEvent(e) : e;
+	}
+	
+	private void setHovering(DComponent target, DMouseEvent e) {
+		if (target == hovering)
+			return;
+		
+		if (hovering != null)
+			hovering.onMouseExit(forward(hovering, e));
+		this.hovering = target;
+		if (hovering != null)
+			hovering.onMouseEnter(forward(hovering, e));
+	}
+	
+	private DMouseEvent translateMouseEvent(DMouseEvent e) {
+		return new DMouseEvent(
+				e.x - bounds.x + offsetX.getValue(),
+				e.y - bounds.y + offsetY.getValue(),
+				e.modifiers,
+				e.deltaZ,
+				e.clickCount);
+	}
+	
+	private class TranslatedContext implements DUIContext {
+		
+		@Override
+		public DStyleSheets getStylesheets(){
+			return context.getStylesheets();
+		}
+
+		@Override
+		public float getScale() {
+			return context.getScale();
+		}
+
+		@Override
+		public void repaint(int x, int y, int width, int height) {
+			int left = x + bounds.x - offsetX.getValue();
+			int top = y + bounds.y - offsetY.getValue();
+			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 focus(DComponent component) {
+			context.focus(component);
+		}
+
+		@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();
+		}
+	}
+	
+	private class ScrollListener implements LiveInt.Listener {
+
+		@Override
+		public void onChanged(int oldValue, int newValue) {
+			int value = offsetY.getValue();
+			if (value > contentsHeight.getValue() - bounds.height)
+				value = contentsHeight.getValue() - bounds.height;
+			if (value < 0)
+				value = 0;
+			
+			if (value != offsetY.getValue())
+				offsetY.setValue(value);
+			if (context != null && bounds != null)
+				context.repaint(bounds);
+		}
+	}
+}

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

@@ -0,0 +1,23 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.scroll;
+
+import org.openzen.drawablegui.border.DBorder;
+import org.openzen.drawablegui.border.DLineBorder;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollPaneStyle {
+	public final DBorder border;
+	
+	public DScrollPaneStyle(DStyleDefinition style) {
+		this.border = style.getBorder("border", context -> new DLineBorder(0xFF888888, 1));
+	}
+}

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

@@ -0,0 +1,20 @@
+/*
+ * 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 DDimension {
+	float eval(DUIContext context);
+	
+	default int evalInt(DUIContext context) {
+		return (int)(eval(context) + 0.5f);
+	}
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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 DDpDimension implements DDimension {
+	private final float value;
+	
+	public DDpDimension(float value) {
+		this.value = value;
+	}
+
+	@Override
+	public float eval(DUIContext context) {
+		return value * context.getScale();
+	}
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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 class DEmptyStyleDefinition implements DStyleDefinition {
+	private final DUIContext context;
+	
+	public DEmptyStyleDefinition(DUIContext context) {
+		this.context = context;
+	}
+
+	@Override
+	public int getDimension(String name, DDimension defaultValue) {
+		return defaultValue.evalInt(context);
+	}
+	
+	@Override
+	public float getFloatDimension(String name, DDimension defaultValue) {
+		return defaultValue.eval(context);
+	}
+
+	@Override
+	public int getColor(String name, int defaultValue) {
+		return defaultValue;
+	}
+
+	@Override
+	public DShadow getShadow(String name, Function<DUIContext, DShadow> defaultValue) {
+		return defaultValue.apply(context);
+	}
+
+	@Override
+	public DFont getFont(String name, Function<DUIContext, DFont> defaultValue) {
+		return defaultValue.apply(context);
+	}
+
+	@Override
+	public DBorder getBorder(String name, Function<DUIContext, DBorder> defaultValue) {
+		return defaultValue.apply(context);
+	}
+}

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

@@ -0,0 +1,21 @@
+/*
+ * 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 DEmptyStylesheets implements DStyleSheets {
+	public static final DEmptyStylesheets INSTANCE = new DEmptyStylesheets();
+
+	@Override
+	public DStyleDefinition get(DUIContext context, DStylePath path) {
+		return new DEmptyStyleDefinition(context);
+	}
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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 DPxDimension implements DDimension {
+	private final float pixels;
+	
+	public DPxDimension(float pixels) {
+		this.pixels = pixels;
+	}
+
+	@Override
+	public float eval(DUIContext context) {
+		return pixels;
+	}
+}

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

@@ -0,0 +1,26 @@
+/*
+ * 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 DShadow {
+	public static final DShadow NONE = new DShadow(0, 0, 0, 0);
+	
+	public final int color;
+	public final float offsetX;
+	public final float offsetY;
+	public final float radius;
+	
+	public DShadow(int color, float offsetX, float offsetY, float radius) {
+		this.color = color;
+		this.offsetX = offsetX;
+		this.offsetY = offsetY;
+		this.radius = radius;
+	}
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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 DStyleClass {
+	private static final String[] NO_CLASSES = new String[0];
+	public static final DStyleClass EMPTY = new DStyleClass(null, NO_CLASSES);
+	
+	public static DStyleClass forId(String id) {
+		return new DStyleClass(id, NO_CLASSES);
+	}
+	
+	public final String id;
+	public final String[] classes;
+	
+	public DStyleClass(String id, String[] classes) {
+		this.id = id;
+		this.classes = classes;
+	}
+}

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

@@ -0,0 +1,29 @@
+/*
+ * 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 DStyleDefinition {
+	public int getDimension(String name, DDimension defaultValue);
+	
+	public float getFloatDimension(String name, DDimension defaultValue);
+	
+	public int getColor(String name, int defaultValue);
+	
+	public DShadow getShadow(String name, Function<DUIContext, DShadow> defaultValue);
+	
+	public DFont getFont(String name, Function<DUIContext, DFont> defaultValue);
+	
+	public DBorder getBorder(String name, Function<DUIContext, DBorder> defaultValue);
+}

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

@@ -0,0 +1,14 @@
+/*
+ * 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 interface DStylePath {
+	public DStylePath getChild(String element, DStyleClass styleClass);
+}

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

@@ -0,0 +1,38 @@
+/*
+ * 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 DStylePathRoot implements DStylePath {
+	public static final DStylePathRoot INSTANCE = new DStylePathRoot();
+	
+	private DStylePathRoot() {}
+
+	@Override
+	public DStylePath getChild(String element, DStyleClass styleClass) {
+		return new DStyleChildElement(this, element, styleClass);
+	}
+	
+	private static class DStyleChildElement implements DStylePath {
+		private final DStylePath parent;
+		private final String element;
+		private final DStyleClass styleClass;
+		
+		public DStyleChildElement(DStylePath parent, String element, DStyleClass styleClass) {
+			this.parent = parent;
+			this.element = element;
+			this.styleClass = styleClass;
+		}
+
+		@Override
+		public DStylePath getChild(String element, DStyleClass styleClass) {
+			return new DStyleChildElement(this, element, styleClass);
+		}
+	}
+}

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

@@ -0,0 +1,16 @@
+/*
+ * 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 DStyleSheets {
+	public DStyleDefinition get(DUIContext context, DStylePath path);
+}

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

@@ -0,0 +1,46 @@
+/*
+ * 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.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.StringSelection;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.io.IOException;
+import org.openzen.drawablegui.DClipboard;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaClipboard implements DClipboard {
+	private final Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+
+	@Override
+	public void copyAsString(String value) {
+		StringSelection stringSelection = new StringSelection(value);
+		clipboard.setContents(stringSelection, null);
+	}
+
+	@Override
+	public String getAsString() {
+		Transferable contents = clipboard.getContents(null);
+		if (contents == null)
+			return null;
+		
+		if (!contents.isDataFlavorSupported(DataFlavor.stringFlavor))
+			return null;
+		
+		try {
+			return (String)contents.getTransferData(DataFlavor.stringFlavor);
+		} catch (UnsupportedFlavorException | IOException ex) {
+			ex.printStackTrace();
+			return null;
+		}
+	}
+}

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

@@ -0,0 +1,209 @@
+/*
+ * 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/SwingFontMetrics.java

@@ -0,0 +1,49 @@
+/*
+ * 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.FontMetrics;
+import java.awt.Graphics;
+import org.openzen.drawablegui.DFontMetrics;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingFontMetrics implements DFontMetrics {
+	private final FontMetrics metrics;
+	private final Graphics context;
+	
+	public SwingFontMetrics(FontMetrics metrics, Graphics context) {
+		this.metrics = metrics;
+		this.context = context;
+	}
+
+	@Override
+	public int getAscent() {
+		return metrics.getAscent();
+	}
+
+	@Override
+	public int getDescent() {
+		return metrics.getDescent();
+	}
+
+	@Override
+	public int getLeading() {
+		return metrics.getLeading();
+	}
+
+	@Override
+	public int getWidth(String str) {
+		return (int) metrics.getStringBounds(str, context).getWidth();
+	}
+
+	@Override
+	public int getWidth(String str, int offset, int length) {
+		return (int) metrics.getStringBounds(str, offset, length, context).getWidth();
+	}
+}

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

@@ -0,0 +1,172 @@
+/*
+ * 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.Graphics;
+import java.awt.geom.GeneralPath;
+import java.util.WeakHashMap;
+import javax.swing.Timer;
+import org.openzen.drawablegui.DClipboard;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DPathTracer;
+import org.openzen.drawablegui.DTimerHandle;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.style.DStyleSheets;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingGraphicsContext implements DUIContext {
+	private final DStyleSheets stylesheets;
+	private final float scale;
+	private final WeakHashMap<DPath, GeneralPath> preparedPaths = new WeakHashMap<>();
+	private final SwingRoot root;
+	private final JavaClipboard clipboard = new JavaClipboard();
+	private Graphics graphics;
+	private DUIWindow window;
+	
+	public SwingGraphicsContext(DStyleSheets stylesheets, float scale, SwingRoot root) {
+		this.stylesheets = stylesheets;
+		this.scale = scale;
+		this.root = root;
+	}
+	
+	public GeneralPath getPath(DPath path) {
+		GeneralPath generalPath = preparedPaths.get(path);
+		if (generalPath == null) {
+			generalPath = new GeneralPath();
+			path.trace(new PathTracer(generalPath));
+			preparedPaths.put(path, generalPath);
+		}
+		return generalPath;
+	}
+	
+	public void setWindow(DUIWindow window) {
+		this.window = window;
+	}
+	
+	@Override
+	public DStyleSheets getStylesheets() {
+		return stylesheets;
+	}
+	
+	@Override
+	public float getScale() {
+		return scale;
+	}
+	
+	@Override
+	public void repaint(int x, int y, int width, int height) {
+		root.repaint(x, y, width, height);
+	}
+
+	@Override
+	public void setCursor(Cursor cursor) {
+		int translated = java.awt.Cursor.DEFAULT_CURSOR;
+		switch (cursor) {
+			case NORMAL:
+				translated = java.awt.Cursor.DEFAULT_CURSOR;
+				break;
+			case MOVE:
+				translated = java.awt.Cursor.MOVE_CURSOR;
+				break;
+			case HAND:
+				translated = java.awt.Cursor.HAND_CURSOR;
+				break;
+			case TEXT:
+				translated = java.awt.Cursor.TEXT_CURSOR;
+				break;
+			case E_RESIZE:
+				translated = java.awt.Cursor.E_RESIZE_CURSOR;
+				break;
+			case S_RESIZE:
+				translated = java.awt.Cursor.S_RESIZE_CURSOR;
+				break;
+			case NE_RESIZE:
+				translated = java.awt.Cursor.NE_RESIZE_CURSOR;
+				break;
+			case NW_RESIZE:
+				translated = java.awt.Cursor.NW_RESIZE_CURSOR;
+				break;
+		}
+		root.setCursor(java.awt.Cursor.getPredefinedCursor(translated));
+	}
+
+	@Override
+	public DFontMetrics getFontMetrics(DFont font) {
+		if (graphics == null)
+			graphics = root.getGraphics();
+		
+		SwingCanvas.prepare(font);
+		return new SwingFontMetrics(graphics.getFontMetrics((Font) font.cached), graphics);
+	}
+	
+	@Override
+	public void focus(DComponent component) {
+		this.root.focus(component);
+	}
+
+	@Override
+	public void scrollInView(int x, int y, int width, int height) {
+		// not in a scrollable context
+	}
+
+	@Override
+	public DTimerHandle setTimer(int millis, Runnable target) {
+		Timer timer = new Timer(millis, e -> target.run());
+		timer.start();
+		return () -> timer.stop();
+	}
+
+	@Override
+	public DClipboard getClipboard() {
+		return clipboard;
+	}
+
+	@Override
+	public DUIWindow getWindow() {
+		return window;
+	}
+	
+	private class PathTracer implements DPathTracer {
+		private final GeneralPath path;
+		
+		public PathTracer(GeneralPath path) {
+			this.path = path;
+		}
+
+		@Override
+		public void moveTo(float x, float y) {
+			path.moveTo(x, y);
+		}
+
+		@Override
+		public void lineTo(float x, float y) {
+			path.lineTo(x, y);
+		}
+
+		@Override
+		public void bezierCubic(float x1, float y1, float x2, float y2, float x3, float y3) {
+			path.curveTo(x1, y1, x2, y2, x3, y3);
+		}
+
+		@Override
+		public void bezierQuadratic(float x1, float y1, float x2, float y2) {
+			path.quadTo(x1, y1, x2, y2);
+		}
+
+		@Override
+		public void close() {
+			path.closePath();
+		}
+	}
+}

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

@@ -0,0 +1,553 @@
+/*
+ * 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.Component;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.Toolkit;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionListener;
+import java.awt.event.MouseWheelEvent;
+import java.awt.event.MouseWheelListener;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DKeyEvent;
+import static org.openzen.drawablegui.DKeyEvent.KeyCode.*;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.style.DEmptyStylesheets;
+import org.openzen.drawablegui.style.DStylePathRoot;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class SwingRoot extends Component implements ComponentListener, MouseListener, MouseMotionListener, MouseWheelListener, KeyListener {
+	public final SwingGraphicsContext context;
+	public final DComponent component;
+	private DComponent focus = null;
+	private boolean firstPaint = true;
+
+	public SwingRoot(DComponent root) {
+		this.component = root;
+		setFocusable(true);
+		setFocusTraversalKeysEnabled(false); // prevent tab from being handled by focus traversal
+		
+		context = new SwingGraphicsContext(
+				DEmptyStylesheets.INSTANCE,
+				Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f,
+				this);
+		component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
+		addComponentListener(this);
+		addMouseListener(this);
+		addMouseMotionListener(this);
+		addMouseWheelListener(this);
+		addKeyListener(this);
+	}
+	
+	public void setWindow(DUIWindow window) {
+		context.setWindow(window);
+	}
+	
+	public void focus(DComponent component) {
+		if (component == focus)
+			return;
+		
+		if (focus != null)
+			focus.onFocusLost();
+		this.focus = component;
+		if (focus != null)
+			focus.onFocusGained();
+	}
+
+	@Override
+	public void paint(Graphics g) {
+		if (firstPaint) {
+			firstPaint = false;
+			component.setContext(DStylePathRoot.INSTANCE, context);
+		}
+		
+		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);
+	}
+
+	@Override
+	public void componentResized(ComponentEvent e) {
+		component.setBounds(new DIRectangle(0, 0,
+				e.getComponent().getWidth(),
+				e.getComponent().getHeight()));
+
+		invalidate();
+	}
+
+	@Override
+	public void componentMoved(ComponentEvent e) {
+
+	}
+
+	@Override
+	public void componentShown(ComponentEvent e) {
+
+	}
+
+	@Override
+	public void componentHidden(ComponentEvent e) {
+
+	}
+
+	@Override
+	public void mouseClicked(MouseEvent e) {
+		component.onMouseClick(translateMouseEvent(e));
+	}
+
+	@Override
+	public void mousePressed(MouseEvent e) {
+		component.onMouseDown(translateMouseEvent(e));
+	}
+
+	@Override
+	public void mouseReleased(MouseEvent e) {
+		component.onMouseRelease(translateMouseEvent(e));
+	}
+
+	@Override
+	public void mouseEntered(MouseEvent e) {
+		component.onMouseEnter(translateMouseEvent(e));
+	}
+
+	@Override
+	public void mouseExited(MouseEvent e) {
+		component.onMouseExit(translateMouseEvent(e));
+	}
+
+	@Override
+	public void mouseDragged(MouseEvent e) {
+		component.onMouseDrag(translateMouseEvent(e));
+	}
+
+	@Override
+	public void mouseMoved(MouseEvent e) {
+		component.onMouseMove(translateMouseEvent(e));
+	}
+
+	@Override
+	public void mouseWheelMoved(MouseWheelEvent e) {
+		component.onMouseScroll(translateScrollEvent(e));
+	}
+
+	@Override
+	public void keyTyped(KeyEvent e) {
+		if (focus == null)
+			return;
+
+		focus.onKeyTyped(translateKeyEvent(e));
+	}
+
+	@Override
+	public void keyPressed(KeyEvent e) {
+		if (focus == null)
+			return;
+		
+		focus.onKeyPressed(translateKeyEvent(e));
+	}
+
+	@Override
+	public void keyReleased(KeyEvent e) {
+		if (focus == null)
+			return;
+		
+		focus.onKeyReleased(translateKeyEvent(e));
+	}
+
+	private DMouseEvent translateMouseEvent(MouseEvent e) {
+		return new DMouseEvent(e.getX(), e.getY(), getModifiers(e.getModifiersEx()), 0, e.getClickCount());
+	}
+
+	private DMouseEvent translateScrollEvent(MouseWheelEvent e) {
+		return new DMouseEvent(e.getX(), e.getY(), getModifiers(e.getModifiersEx()), e.getUnitsToScroll(), e.getClickCount());
+	}
+	
+	private DKeyEvent translateKeyEvent(KeyEvent e) {
+		return new DKeyEvent(e.getKeyChar(), getKeyCode(e.getKeyCode()), getModifiers(e.getModifiersEx()));
+	}
+	
+	private DKeyEvent.KeyCode getKeyCode(int code) {
+		switch (code) {
+			case KeyEvent.VK_ENTER:
+				return ENTER;
+			case KeyEvent.VK_BACK_SPACE:
+				return BACKSPACE;
+			case KeyEvent.VK_TAB:
+				return TAB;
+    		case KeyEvent.VK_CANCEL:
+				return DKeyEvent.KeyCode.CANCEL;
+    		case KeyEvent.VK_CLEAR:
+				return DKeyEvent.KeyCode.CLEAR;
+    		case KeyEvent.VK_SHIFT:
+				return DKeyEvent.KeyCode.SHIFT;
+    		case KeyEvent.VK_CONTROL:
+				return DKeyEvent.KeyCode.CONTROL;
+    		case KeyEvent.VK_ALT:
+				return DKeyEvent.KeyCode.ALT;
+    		case KeyEvent.VK_PAUSE:
+				return DKeyEvent.KeyCode.PAUSE;
+    		case KeyEvent.VK_CAPS_LOCK:
+				return DKeyEvent.KeyCode.CAPS_LOCK;
+    		case KeyEvent.VK_ESCAPE:
+				return DKeyEvent.KeyCode.ESCAPE;
+    		case KeyEvent.VK_SPACE:
+				return DKeyEvent.KeyCode.SPACE;
+    		case KeyEvent.VK_PAGE_UP:
+				return DKeyEvent.KeyCode.PAGE_UP;
+    		case KeyEvent.VK_PAGE_DOWN:
+				return DKeyEvent.KeyCode.PAGE_DOWN;
+    		case KeyEvent.VK_END:
+				return DKeyEvent.KeyCode.END;
+    		case KeyEvent.VK_HOME:
+				return DKeyEvent.KeyCode.HOME;
+    		case KeyEvent.VK_LEFT:
+				return DKeyEvent.KeyCode.LEFT;
+    		case KeyEvent.VK_UP:
+				return DKeyEvent.KeyCode.UP;
+    		case KeyEvent.VK_RIGHT:
+				return DKeyEvent.KeyCode.RIGHT;
+    		case KeyEvent.VK_DOWN:
+				return DKeyEvent.KeyCode.DOWN;
+    		case KeyEvent.VK_COMMA:
+				return DKeyEvent.KeyCode.COMMA;
+    		case KeyEvent.VK_MINUS:
+				return DKeyEvent.KeyCode.MINUS;
+    		case KeyEvent.VK_PERIOD:
+				return DKeyEvent.KeyCode.PERIOD;
+    		case KeyEvent.VK_SLASH:
+				return DKeyEvent.KeyCode.SLASH;
+    		case KeyEvent.VK_0:
+				return DKeyEvent.KeyCode.NUM0;
+    		case KeyEvent.VK_1:
+				return DKeyEvent.KeyCode.NUM1;
+    		case KeyEvent.VK_2:
+				return DKeyEvent.KeyCode.NUM2;
+    		case KeyEvent.VK_3:
+				return DKeyEvent.KeyCode.NUM3;
+    		case KeyEvent.VK_4:
+				return DKeyEvent.KeyCode.NUM4;
+    		case KeyEvent.VK_5:
+				return DKeyEvent.KeyCode.NUM5;
+    		case KeyEvent.VK_6:
+				return DKeyEvent.KeyCode.NUM6;
+    		case KeyEvent.VK_7:
+				return DKeyEvent.KeyCode.NUM7;
+    		case KeyEvent.VK_8:
+				return DKeyEvent.KeyCode.NUM8;
+    		case KeyEvent.VK_9:
+				return DKeyEvent.KeyCode.NUM9;
+    		case KeyEvent.VK_SEMICOLON:
+				return DKeyEvent.KeyCode.SEMICOLON;
+    		case KeyEvent.VK_EQUALS:
+				return DKeyEvent.KeyCode.EQUALS;
+    		case KeyEvent.VK_A:
+				return DKeyEvent.KeyCode.A;
+    		case KeyEvent.VK_B:
+				return DKeyEvent.KeyCode.B;
+    		case KeyEvent.VK_C:
+				return DKeyEvent.KeyCode.C;
+    		case KeyEvent.VK_D:
+				return DKeyEvent.KeyCode.D;
+    		case KeyEvent.VK_E:
+				return DKeyEvent.KeyCode.E;
+    		case KeyEvent.VK_F:
+				return DKeyEvent.KeyCode.F;
+    		case KeyEvent.VK_G:
+				return DKeyEvent.KeyCode.G;
+    		case KeyEvent.VK_H:
+				return DKeyEvent.KeyCode.H;
+    		case KeyEvent.VK_I:
+				return DKeyEvent.KeyCode.I;
+    		case KeyEvent.VK_J:
+				return DKeyEvent.KeyCode.J;
+    		case KeyEvent.VK_K:
+				return DKeyEvent.KeyCode.K;
+    		case KeyEvent.VK_L:
+				return DKeyEvent.KeyCode.L;
+    		case KeyEvent.VK_M:
+				return DKeyEvent.KeyCode.M;
+    		case KeyEvent.VK_N:
+				return DKeyEvent.KeyCode.N;
+    		case KeyEvent.VK_O:
+				return DKeyEvent.KeyCode.O;
+    		case KeyEvent.VK_P:
+				return DKeyEvent.KeyCode.P;
+    		case KeyEvent.VK_Q:
+				return DKeyEvent.KeyCode.Q;
+    		case KeyEvent.VK_R:
+				return DKeyEvent.KeyCode.R;
+    		case KeyEvent.VK_S:
+				return DKeyEvent.KeyCode.S;
+    		case KeyEvent.VK_T:
+				return DKeyEvent.KeyCode.T;
+    		case KeyEvent.VK_U:
+				return DKeyEvent.KeyCode.U;
+    		case KeyEvent.VK_V:
+				return DKeyEvent.KeyCode.V;
+    		case KeyEvent.VK_W:
+				return DKeyEvent.KeyCode.W;
+    		case KeyEvent.VK_X:
+				return DKeyEvent.KeyCode.X;
+    		case KeyEvent.VK_Y:
+				return DKeyEvent.KeyCode.Y;
+    		case KeyEvent.VK_Z:
+				return DKeyEvent.KeyCode.Z;
+    		case KeyEvent.VK_OPEN_BRACKET:
+				return DKeyEvent.KeyCode.OPEN_BRACKET;
+    		case KeyEvent.VK_BACK_SLASH:
+				return DKeyEvent.KeyCode.BACKSLASH;
+    		case KeyEvent.VK_CLOSE_BRACKET:
+				return DKeyEvent.KeyCode.CLOSE_BRACKET;
+    		case KeyEvent.VK_NUMPAD0:
+				return DKeyEvent.KeyCode.NUMPAD0;
+    		case KeyEvent.VK_NUMPAD1:
+				return DKeyEvent.KeyCode.NUMPAD1;
+    		case KeyEvent.VK_NUMPAD2:
+				return DKeyEvent.KeyCode.NUMPAD2;
+    		case KeyEvent.VK_NUMPAD3:
+				return DKeyEvent.KeyCode.NUMPAD3;
+    		case KeyEvent.VK_NUMPAD4:
+				return DKeyEvent.KeyCode.NUMPAD4;
+    		case KeyEvent.VK_NUMPAD5:
+				return DKeyEvent.KeyCode.NUMPAD5;
+    		case KeyEvent.VK_NUMPAD6:
+				return DKeyEvent.KeyCode.NUMPAD6;
+    		case KeyEvent.VK_NUMPAD7:
+				return DKeyEvent.KeyCode.NUMPAD7;
+    		case KeyEvent.VK_NUMPAD8:
+				return DKeyEvent.KeyCode.NUMPAD8;
+    		case KeyEvent.VK_NUMPAD9:
+				return DKeyEvent.KeyCode.NUMPAD9;
+    		case KeyEvent.VK_MULTIPLY:
+				return DKeyEvent.KeyCode.MULTIPLY;
+    		case KeyEvent.VK_ADD:
+				return DKeyEvent.KeyCode.ADD;
+			case KeyEvent.VK_SEPARATER:
+				return DKeyEvent.KeyCode.SEPARATOR;
+    		case KeyEvent.VK_SUBTRACT:
+				return DKeyEvent.KeyCode.SUBTRACT;
+    		case KeyEvent.VK_DECIMAL:
+				return DKeyEvent.KeyCode.DECIMAL;
+    		case KeyEvent.VK_DIVIDE:
+				return DKeyEvent.KeyCode.DIVIDE;
+    		case KeyEvent.VK_DELETE:
+				return DKeyEvent.KeyCode.DELETE; /* ASCII DEL */
+    		case KeyEvent.VK_NUM_LOCK:
+				return DKeyEvent.KeyCode.NUM_LOCK;
+    		case KeyEvent.VK_SCROLL_LOCK:
+				return DKeyEvent.KeyCode.SCROLL_LOCK;
+    		case KeyEvent.VK_F1:
+				return DKeyEvent.KeyCode.F1;
+    		case KeyEvent.VK_F2:
+				return DKeyEvent.KeyCode.F2;
+    		case KeyEvent.VK_F3:
+				return DKeyEvent.KeyCode.F3;
+    		case KeyEvent.VK_F4:
+				return DKeyEvent.KeyCode.F4;
+    		case KeyEvent.VK_F5:
+				return DKeyEvent.KeyCode.F5;
+    		case KeyEvent.VK_F6:
+				return DKeyEvent.KeyCode.F6;
+    		case KeyEvent.VK_F7:
+				return DKeyEvent.KeyCode.F7;
+    		case KeyEvent.VK_F8:
+				return DKeyEvent.KeyCode.F8;
+    		case KeyEvent.VK_F9:
+				return DKeyEvent.KeyCode.F9;
+    		case KeyEvent.VK_F10:
+				return DKeyEvent.KeyCode.F10;
+    		case KeyEvent.VK_F11:
+				return DKeyEvent.KeyCode.F11;
+    		case KeyEvent.VK_F12:
+				return DKeyEvent.KeyCode.F12;
+    		case KeyEvent.VK_F13:
+				return DKeyEvent.KeyCode.F13;
+    		case KeyEvent.VK_F14:
+				return DKeyEvent.KeyCode.F14;
+    		case KeyEvent.VK_F15:
+				return DKeyEvent.KeyCode.F15;
+    		case KeyEvent.VK_F16:
+				return DKeyEvent.KeyCode.F16;
+    		case KeyEvent.VK_F17:
+				return DKeyEvent.KeyCode.F17;
+    		case KeyEvent.VK_F18:
+				return DKeyEvent.KeyCode.F18;
+    		case KeyEvent.VK_F19:
+				return DKeyEvent.KeyCode.F19;
+    		case KeyEvent.VK_F20:
+				return DKeyEvent.KeyCode.F20;
+    		case KeyEvent.VK_F21:
+				return DKeyEvent.KeyCode.F21;
+    		case KeyEvent.VK_F22:
+				return DKeyEvent.KeyCode.F22;
+    		case KeyEvent.VK_F23:
+				return DKeyEvent.KeyCode.F23;
+    		case KeyEvent.VK_F24:
+				return DKeyEvent.KeyCode.F24;
+    		case KeyEvent.VK_PRINTSCREEN:
+				return DKeyEvent.KeyCode.PRINTSCREEN;
+    		case KeyEvent.VK_INSERT:
+				return DKeyEvent.KeyCode.INSERT;
+    		case KeyEvent.VK_HELP:
+				return DKeyEvent.KeyCode.HELP;
+    		case KeyEvent.VK_META:
+				return DKeyEvent.KeyCode.META;
+    		case KeyEvent.VK_BACK_QUOTE:
+				return DKeyEvent.KeyCode.BACKQUOTE;
+    		case KeyEvent.VK_QUOTE:
+				return DKeyEvent.KeyCode.QUOTE;
+    		case KeyEvent.VK_KP_UP:
+				return DKeyEvent.KeyCode.KEYPAD_UP;
+    		case KeyEvent.VK_KP_DOWN:
+				return DKeyEvent.KeyCode.KEYPAD_DOWN;
+    		case KeyEvent.VK_KP_LEFT:
+				return DKeyEvent.KeyCode.KEYPAD_LEFT;
+    		case KeyEvent.VK_KP_RIGHT:
+				return DKeyEvent.KeyCode.KEYPAD_RIGHT;
+    		case KeyEvent.VK_AMPERSAND:
+				return DKeyEvent.KeyCode.AMPERSAND;
+    		case KeyEvent.VK_ASTERISK:
+				return DKeyEvent.KeyCode.ASTERISK;
+    		case KeyEvent.VK_QUOTEDBL:
+				return DKeyEvent.KeyCode.QUOTEDBL;
+    		case KeyEvent.VK_LESS:
+				return DKeyEvent.KeyCode.LESS;
+			case KeyEvent.VK_GREATER:
+				return DKeyEvent.KeyCode.GREATER;
+			case KeyEvent.VK_BRACELEFT:
+				return DKeyEvent.KeyCode.BRACELEFT;
+			case KeyEvent.VK_BRACERIGHT:
+				return DKeyEvent.KeyCode.BRACERIGHT;
+    		case KeyEvent.VK_AT:
+				return DKeyEvent.KeyCode.AT;
+    		case KeyEvent.VK_COLON:
+				return DKeyEvent.KeyCode.COLON;
+    		case KeyEvent.VK_CIRCUMFLEX:
+				return DKeyEvent.KeyCode.CIRCUMFLEX;
+    		case KeyEvent.VK_DOLLAR:
+				return DKeyEvent.KeyCode.DOLLAR;
+    		case KeyEvent.VK_EURO_SIGN:
+				return DKeyEvent.KeyCode.EURO_SIGN;
+    		case KeyEvent.VK_EXCLAMATION_MARK:
+				return DKeyEvent.KeyCode.EXCLAMATION_MARK;
+    		case KeyEvent.VK_INVERTED_EXCLAMATION_MARK:
+				return DKeyEvent.KeyCode.INVERTED_EXCLAMATION_MARK;
+    		case KeyEvent.VK_LEFT_PARENTHESIS:
+				return DKeyEvent.KeyCode.LEFT_PARENTHESIS;
+    		case KeyEvent.VK_NUMBER_SIGN:
+				return DKeyEvent.KeyCode.NUMBER_SIGN;
+    		case KeyEvent.VK_PLUS:
+				return DKeyEvent.KeyCode.PLUS;
+    		case KeyEvent.VK_RIGHT_PARENTHESIS:
+				return DKeyEvent.KeyCode.RIGHT_PARENTHESIS;
+    		case KeyEvent.VK_UNDERSCORE:
+				return DKeyEvent.KeyCode.UNDERSCORE;
+    		case KeyEvent.VK_WINDOWS:
+				return DKeyEvent.KeyCode.WINDOWS;
+    		case KeyEvent.VK_CONTEXT_MENU:
+				return DKeyEvent.KeyCode.CONTEXT_MENU;
+    		case KeyEvent.VK_FINAL:
+				return DKeyEvent.KeyCode.FINAL;
+    		case KeyEvent.VK_CONVERT:
+				return DKeyEvent.KeyCode.CONVERT;
+    		case KeyEvent.VK_NONCONVERT:
+				return DKeyEvent.KeyCode.NONCONVERT;
+    		case KeyEvent.VK_ACCEPT:
+				return DKeyEvent.KeyCode.ACCEPT;
+    		case KeyEvent.VK_KANA:
+				return DKeyEvent.KeyCode.KANA;
+    		case KeyEvent.VK_KANJI:
+				return DKeyEvent.KeyCode.KANJI;
+    		case KeyEvent.VK_ALPHANUMERIC:
+				return DKeyEvent.KeyCode.ALPHANUMERIC;
+    		case KeyEvent.VK_KATAKANA:
+				return DKeyEvent.KeyCode.KATAKANA;
+    		case KeyEvent.VK_HIRAGANA:
+				return DKeyEvent.KeyCode.HIRAGANA;
+    		case KeyEvent.VK_FULL_WIDTH:
+				return DKeyEvent.KeyCode.FULL_WIDTH;
+    		case KeyEvent.VK_HALF_WIDTH:
+				return DKeyEvent.KeyCode.HALF_WIDTH;
+    		case KeyEvent.VK_ROMAN_CHARACTERS:
+				return DKeyEvent.KeyCode.ROMAN_CHARACTERS;
+    		case KeyEvent.VK_ALL_CANDIDATES:
+				return DKeyEvent.KeyCode.ALL_CANDIDATES;
+    		case KeyEvent.VK_PREVIOUS_CANDIDATE:
+				return DKeyEvent.KeyCode.PREVIOUS_CANDIDATE;
+    		case KeyEvent.VK_CODE_INPUT:
+				return DKeyEvent.KeyCode.CODE_INPUT;
+    		case KeyEvent.VK_JAPANESE_KATAKANA:
+				return DKeyEvent.KeyCode.JAPANESE_KATAKANA;
+    		case KeyEvent.VK_JAPANESE_HIRAGANA:
+				return DKeyEvent.KeyCode.JAPANESE_HIRAGANA;
+    		case KeyEvent.VK_JAPANESE_ROMAN:
+				return DKeyEvent.KeyCode.JAPANESE_ROMAN;
+			case KeyEvent.VK_KANA_LOCK:
+				return DKeyEvent.KeyCode.KANA_LOCK;
+    		case KeyEvent.VK_INPUT_METHOD_ON_OFF:
+				return DKeyEvent.KeyCode.INPUT_METHOD_ON_OFF;
+    		case KeyEvent.VK_CUT:
+				return DKeyEvent.KeyCode.CUT;
+    		case KeyEvent.VK_COPY:
+				return DKeyEvent.KeyCode.COPY;
+    		case KeyEvent.VK_PASTE:
+				return DKeyEvent.KeyCode.PASTE;
+    		case KeyEvent.VK_UNDO:
+				return DKeyEvent.KeyCode.UNDO;
+    		case KeyEvent.VK_AGAIN:
+				return DKeyEvent.KeyCode.AGAIN;
+    		case KeyEvent.VK_FIND:
+				return DKeyEvent.KeyCode.FIND;
+    		case KeyEvent.VK_PROPS:
+				return DKeyEvent.KeyCode.PROPS;
+    		case KeyEvent.VK_STOP:
+				return DKeyEvent.KeyCode.STOP;
+    		case KeyEvent.VK_COMPOSE:
+				return DKeyEvent.KeyCode.COMPOSE;
+    		case KeyEvent.VK_ALT_GRAPH:
+				return DKeyEvent.KeyCode.ALT_GRAPH;
+    		case KeyEvent.VK_BEGIN:
+				return DKeyEvent.KeyCode.BEGIN;
+			default:
+				return DKeyEvent.KeyCode.UNKNOWN;
+		}
+	}
+
+	private int getModifiers(int swingModifiers) {
+		int result = 0;
+		if ((swingModifiers & MouseEvent.BUTTON1_DOWN_MASK) > 0)
+			result |= DMouseEvent.BUTTON1;
+		if ((swingModifiers & MouseEvent.BUTTON2_DOWN_MASK) > 0)
+			result |= DMouseEvent.BUTTON2;
+		if ((swingModifiers & MouseEvent.BUTTON3_DOWN_MASK) > 0)
+			result |= DMouseEvent.BUTTON3;
+		if ((swingModifiers & MouseEvent.SHIFT_DOWN_MASK) > 0)
+			result |= DMouseEvent.SHIFT;
+		if ((swingModifiers & MouseEvent.CTRL_DOWN_MASK) > 0)
+			result |= DMouseEvent.CTRL;
+		if ((swingModifiers & MouseEvent.ALT_DOWN_MASK) > 0)
+			result |= DMouseEvent.ALT;
+		if ((swingModifiers & MouseEvent.ALT_GRAPH_DOWN_MASK) > 0)
+			result |= DMouseEvent.ALT_GRAPH;
+		if ((swingModifiers & MouseEvent.META_DOWN_MASK) > 0)
+			result |= DMouseEvent.META;
+		return result;
+	}
+}

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

@@ -0,0 +1,145 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.swing;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.awt.event.WindowStateListener;
+import javax.swing.JFrame;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.border.DCustomWindowBorder;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveBool;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class SwingWindow extends JFrame implements WindowListener, WindowStateListener, DUIWindow {
+	private final SwingRoot swingComponent;
+	private final boolean noTitleBar;
+	private final SimpleLiveObject<State> state = new SimpleLiveObject<>(State.NORMAL);
+	private final SimpleLiveBool active = new SimpleLiveBool(true);
+	
+	public SwingWindow(String title, DComponent root, boolean noTitleBar) {
+		super(title);
+		this.noTitleBar = noTitleBar;
+		
+		if (noTitleBar) {
+		    setUndecorated(true);
+			root = new DCustomWindowBorder(DStyleClass.EMPTY, root);
+			setBackground(new Color(0, 0, 0, 0));
+		}
+		
+		addWindowListener(this);
+		addWindowStateListener(this);
+		
+		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
+		swingComponent.setWindow(this);
+		swingComponent.requestFocusInWindow();
+	}
+	
+	public DUIContext getContext() {
+		return swingComponent.context;
+	}
+
+	@Override
+	public boolean hasTitleBar() {
+		return !noTitleBar;
+	}
+
+	@Override
+	public void close() {
+		System.exit(0);
+	}
+
+	@Override
+	public void maximize() {
+		setExtendedState(JFrame.MAXIMIZED_BOTH);
+	}
+
+	@Override
+	public void restore() {
+		setExtendedState(JFrame.NORMAL);
+	}
+
+	@Override
+	public void minimize() {
+		setExtendedState(JFrame.ICONIFIED);
+	}
+
+	@Override
+	public LiveObject<State> getWindowState() {
+		return state;
+	}
+	
+	@Override
+	public LiveBool getActive() {
+		return active;
+	}
+
+	@Override
+	public void windowOpened(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowClosing(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowClosed(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowIconified(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowDeiconified(WindowEvent e) {
+		
+	}
+
+	@Override
+	public void windowActivated(WindowEvent e) {
+		active.setValue(true);
+	}
+
+	@Override
+	public void windowDeactivated(WindowEvent e) {
+		active.setValue(false);
+	}
+
+	@Override
+	public void windowStateChanged(WindowEvent e) {
+		state.setValue(getStateFromWindowState());
+	}
+	
+	private State getStateFromWindowState() {
+		switch (getExtendedState()) {
+			case NORMAL:
+				return State.NORMAL;
+			case ICONIFIED:
+				return State.MINIMIZED;
+			case MAXIMIZED_HORIZ:
+			case MAXIMIZED_VERT:
+			case MAXIMIZED_BOTH:
+				return State.MAXIMIZED;
+			default:
+				return State.NORMAL;
+		}
+	}
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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.tree;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CollapsedArrow implements DDrawable {
+	public static final CollapsedArrow INSTANCE = new CollapsedArrow();
+	
+	private CollapsedArrow() {}
+
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform) {
+		ColoredCollapsedArrow.INSTANCE.draw(canvas, transform, 0xFF000000);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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.tree;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ColoredCollapsedArrow implements DColorableIcon {
+	public static final ColoredCollapsedArrow INSTANCE = new ColoredCollapsedArrow();
+	
+	private ColoredCollapsedArrow() {}
+	
+	private static final DPath PATH_0 = tracer -> {
+		tracer.moveTo(10, 19);
+		tracer.lineTo(17, 12);
+		tracer.lineTo(10, 5);
+		tracer.close();
+	};
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform, int color) {
+		canvas.fillPath(PATH_0, transform, color);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

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

@@ -0,0 +1,29 @@
+/*
+ * 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.tree;
+
+import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DTreeNode<N extends DTreeNode<N>> {
+	DColorableIcon getIcon();
+	
+	String getTitle();
+	
+	LiveList<N> getChildren();
+	
+	LiveBool isCollapsed();
+	
+	boolean isLeaf();
+	
+	default void onMouseClick(DMouseEvent e) {}
+}

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

@@ -0,0 +1,237 @@
+/*
+ * 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.tree;
+
+import java.io.Closeable;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DTreeView<N extends DTreeNode<N>> implements DComponent {
+	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private DIRectangle bounds;
+	
+	private int selectedRow = -1;
+	private N selectedNode = null;
+	
+	private final DTreeViewStyle styleDefinition;
+	private DTreeViewStyle.Calculated style;
+	private DFontMetrics fontMetrics;
+	
+	private DUIContext context;
+	private final N root;
+	private final boolean showRoot;
+	private final List<Row> rows = new ArrayList<>();
+	
+	public DTreeView(DTreeViewStyle style, N root, boolean showRoot) {
+		this.styleDefinition = style;
+		this.root = root;
+		this.showRoot = showRoot;
+	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		style = styleDefinition.forContext(context);
+		fontMetrics = context.getFontMetrics(style.font);
+		
+		updateLayout();
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+	
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@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, styleDefinition.backgroundColor);
+		
+		int drawX = bounds.x + style.padding;
+		int drawY = bounds.y + style.padding;
+		if (showRoot) {
+			paintNode(canvas, root, drawX, drawY);
+		} else {
+			for (N child : root.getChildren()) {
+				drawY = paintNode(canvas, child, drawX, drawY);
+				drawY += style.rowSpacing;
+			}
+		}
+	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		int row = yToRow(e.y);
+		if (row >= 0 && row < rows.size()) {
+			Row rowEntry = rows.get(row);
+			if (e.x >= rowEntry.x && e.x < (rowEntry.x + styleDefinition.nodeOpenedIcon.getNominalWidth())) {
+				if (!rowEntry.node.isLeaf())
+					rowEntry.node.isCollapsed().toggle();
+				return;
+			}
+			
+			rowEntry.node.onMouseClick(e);
+			
+			if (e.isSingleClick()) {
+				int oldRow = selectedRow;
+				selectedRow = row;
+				selectedNode = rows.get(row).node;
+
+				if (oldRow >= 0)
+					context.repaint(
+							bounds.x,
+							rowToY(oldRow) - style.selectedPaddingTop,
+							bounds.width,
+							fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom);
+				context.repaint(
+						bounds.x,
+						rowToY(row) - style.selectedPaddingTop,
+						bounds.width,
+						fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom);
+			}
+		}
+	}
+	
+	private int rowToY(int row) {
+		return row * (style.rowSpacing + fontMetrics.getAscent() + fontMetrics.getDescent()) + style.padding;
+	}
+	
+	private int yToRow(int y) {
+		return (y - bounds.y - style.padding) / (style.rowSpacing + fontMetrics.getAscent() + fontMetrics.getDescent());
+	}
+	
+	private int paintNode(DCanvas canvas, N node, int drawX, int drawY) {
+		int textColor = styleDefinition.nodeTextColor;
+		if (node == selectedNode) {
+			textColor = styleDefinition.selectedNodeTextColor;
+			canvas.fillRectangle(
+					bounds.x,
+					drawY - style.selectedPaddingTop,
+					bounds.width,
+					fontMetrics.getAscent() + fontMetrics.getDescent() + style.selectedPaddingTop + style.selectedPaddingBottom,
+					styleDefinition.selectedBackgroundColor);
+		}
+		
+		int drawingX = drawX;
+		if (!node.isLeaf()) {
+			DDrawable icon = node.isCollapsed().getValue() ? style.nodeClosedIcon : style.nodeOpenedIcon;
+			icon.draw(canvas, DTransform2D.translate(drawingX, drawY + fontMetrics.getAscent() + fontMetrics.getDescent() - icon.getNominalHeight()));
+			drawingX += style.iconTextSpacing + icon.getNominalWidth();
+		} else {
+			drawingX += style.iconTextSpacing + style.nodeClosedIcon.getNominalWidth();
+		}
+		node.getIcon().draw(canvas, DTransform2D.translate(drawingX, drawY + fontMetrics.getAscent() + fontMetrics.getDescent() - node.getIcon().getNominalHeight()), textColor);
+		drawingX += style.iconTextSpacing + node.getIcon().getNominalWidth();
+		canvas.drawText(style.font, textColor, drawingX, drawY + fontMetrics.getAscent(), node.getTitle());
+		drawY += fontMetrics.getAscent() + fontMetrics.getDescent();
+		
+		if (!node.isCollapsed().getValue()) {
+			for (N child : node.getChildren()) {
+				drawY += style.rowSpacing;
+				drawY = paintNode(canvas, child, drawX + style.indent, drawY);
+			}
+		}
+		
+		return drawY;
+	}
+	
+	private void updateLayout() {
+		int oldRowCount = rows.size();
+		
+		for (Row row : rows)
+			row.close();
+		
+		rows.clear();
+		
+		if (showRoot) {
+			updateLayout(root, 0);
+		} else {
+			for (N child : root.getChildren()) {
+				updateLayout(child, 0);
+			}
+		}
+		
+		if (rows.size() != oldRowCount) {
+			DDimensionPreferences preferences = dimensionPreferences.getValue();
+			dimensionPreferences.setValue(
+					new DDimensionPreferences(
+							preferences.minimumWidth,
+							preferences.minimumHeight,
+							preferences.preferredWidth,
+							rowToY(rows.size()),
+							preferences.maximumWidth,
+							1000000));
+		}
+		
+		System.out.println("Rows after updateLayout: " + rows.size());
+		System.out.println("Height: " + rowToY(rows.size()));
+	}
+	
+	private void updateLayout(N node, int x) {
+		rows.add(new Row(x, node));
+		
+		if (!node.isCollapsed().getValue()) {
+			for (N child : node.getChildren()) {
+				updateLayout(child, x + style.indent);
+			}
+		}
+	}
+
+	@Override
+	public void close() {
+		// nothing to clean up
+	}
+	
+	private class Row implements Closeable, LiveBool.Listener {
+		private final int x;
+		private final N node;
+		private final ListenerHandle<LiveBool.Listener> collapseListener;
+		
+		public Row(int x, N node) {
+			this.x = x;
+			this.node = node;
+			this.collapseListener = node.isCollapsed().addListener(this);
+		}
+
+		@Override
+		public void onChanged(boolean oldValue, boolean newValue) {
+			updateLayout();
+			context.repaint(bounds);
+		}
+		
+		@Override
+		public void close() {
+			collapseListener.close();
+		}
+	}
+}

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

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

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

@@ -0,0 +1,35 @@
+/*
+ * 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.tree;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ExpandedArrow implements DDrawable {
+	public static final ExpandedArrow INSTANCE = new ExpandedArrow();
+	
+	private ExpandedArrow() {}
+
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform) {
+		ExpandedColoredArrow.INSTANCE.draw(canvas, transform, 0xFF000000);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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.tree;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ExpandedColoredArrow implements DColorableIcon {
+	public static final ExpandedColoredArrow INSTANCE = new ExpandedColoredArrow();
+	
+	private ExpandedColoredArrow() {}
+	
+	private static final DPath PATH_0 = tracer -> {
+		tracer.moveTo(17, 7);
+		tracer.lineTo(17, 17);
+		tracer.lineTo(7, 17);
+		tracer.close();
+	};
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform, int color) {
+		canvas.fillPath(PATH_0, transform, color);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

DrawableGuiIconConverter/build.gradle

@@ -0,0 +1,24 @@
+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = 'org.openzen.drawablegui.iconconverter.Main'
+}
+
+dependencies {
+    // TODO: Add dependencies here
+    //   but note that JUnit should have already been added in parent.gradle.
+    //   By default, only the Maven Central Repository is specified in
+    //   parent.gradle.
+    //
+    // You can read more about how to add dependency here:
+    //   http://www.gradle.org/docs/current/userguide/dependency_management.html#sec:how_to_declare_your_dependencies
+}

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

@@ -0,0 +1,323 @@
+/*
+ * 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.iconconverter;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Main {
+	public static void main(String[] args) throws Exception {
+		String filename = "baseline-build-24px.svg"; //args[0];
+		//String filename = "baseline-dashboard-24px.svg";
+		String className = "BuildIcon";
+		File file = new File(filename);
+		if (!file.exists()) {
+			System.out.println("No such file: " + filename);
+			return;
+		}
+		
+		DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
+		DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
+		Document doc = dBuilder.parse(file);
+		doc.getDocumentElement().normalize();
+		
+		List<String> pathNames = new ArrayList<>();
+		
+		Element rootElement = doc.getDocumentElement();
+		String width = rootElement.getAttribute("width");
+		String height = rootElement.getAttribute("height");
+		StringBuilder output = new StringBuilder();
+		output.append("import org.openzen.drawablegui.DCanvas;\n");
+		output.append("import org.openzen.drawablegui.DPath;\n");
+		output.append("import org.openzen.drawablegui.DTransform2D;\n");
+		output.append("import org.openzen.drawablegui.DColorableIcon;\n");
+		output.append("\n");
+		output.append("public class ").append(className).append(" implements DColorableIcon {\n");
+		output.append("\tpublic static final ").append(className).append(" INSTANCE = new ").append(className).append("();\n");
+		output.append("\t\n");
+		output.append("\tprivate ").append(className).append("() {}\n");
+		output.append("\t\n");
+		
+		NodeList childNodes = rootElement.getChildNodes();
+		for (int i = 0; i < childNodes.getLength(); i++) {
+			Node node = childNodes.item(i);
+			if (node.getNodeName().equals("path")) {
+				Element pathElement = (Element)node;
+				String pathName = "PATH_" + pathNames.size();
+				output.append("\tprivate static final DPath ").append(pathName).append(" = tracer -> {\n");
+				convertPath(pathElement.getAttribute("d"), output, "\t\t");
+				output.append("\t};\n");
+				pathNames.add(pathName);
+			} else if (node.getNodeName().equals("#text")) {
+				// skip
+			} else {
+				System.out.println("Warning: " + node.getNodeName() + " not supported");
+			}
+		}
+		
+		output.append("\t\n");
+		output.append("\t@Override\n");
+		output.append("\tpublic void draw(DCanvas canvas, DTransform2D transform, int color) {\n");
+		for (String pathName : pathNames) {
+			output.append("\t\tcanvas.fillPath(").append(pathName).append(", transform, color);\n");
+		}
+		output.append("\t}\n");
+		output.append("\n");
+		output.append("\t@Override\n");
+		output.append("\tpublic float getNominalWidth() {\n");
+		output.append("\t\treturn ").append(width).append(";\n");
+		output.append("\t}\n");
+		output.append("\n");
+		output.append("\t@Override\n");
+		output.append("\tpublic float getNominalHeight() {\n");
+		output.append("\t\treturn ").append(height).append(";\n");
+		output.append("\t}\n");
+		output.append("}\n");
+		System.out.println(output.toString());
+	}
+	
+	private static void convertPath(String path, StringBuilder output, String indent) {
+		CharStream stream = new CharStream(path);
+		float x = 0;
+		float y = 0;
+		float guideX = 0;
+		float guideY = 0;
+		char instruction = stream.next();
+		while (stream.hasMore()) {
+			if (!stream.nextIsNumber())
+				instruction = stream.next();
+			
+			switch (instruction) {
+				case 'M': {
+					String sx = stream.nextFloat();
+					String sy = stream.nextFloat();
+					output.append(indent).append("tracer.moveTo(")
+							.append(sx).append("f, ")
+							.append(sy).append("f);\n");
+					x = Float.parseFloat(sx);
+					y = Float.parseFloat(sy);
+					break;
+				}
+				case 'm': {
+					x += stream.parseFloat();
+					y += stream.parseFloat();
+					output.append(indent)
+							.append("tracer.moveTo(")
+							.append(x).append("f, ")
+							.append(y).append("f);\n");
+					break;
+				}
+				case 'L': {
+					String sx = stream.nextFloat();
+					String sy = stream.nextFloat();
+					output.append(indent).append("tracer.lineTo(")
+							.append(sx).append("f, ")
+							.append(sy).append("f);\n");
+					x = Float.parseFloat(sx);
+					y = Float.parseFloat(sy);
+					break;
+				}
+				case 'l': {
+					x += stream.parseFloat();
+					y += stream.parseFloat();
+					output.append(indent)
+							.append("tracer.lineTo(")
+							.append(x).append("f, ")
+							.append(y).append("f);\n");
+					break;
+				}
+				case 'H': {
+					x = stream.parseFloat();
+					output.append(indent)
+							.append("tracer.lineTo(")
+							.append(x).append("f, ")
+							.append(y).append("f);\n");
+					break;
+				}
+				case 'h': {
+					x += stream.parseFloat();
+					output.append(indent)
+							.append("tracer.lineTo(")
+							.append(x).append("f, ")
+							.append(y).append("f);\n");
+					break;
+				}
+				case 'V': {
+					y = stream.parseFloat();
+					output.append(indent)
+							.append("tracer.lineTo(")
+							.append(x).append("f, ")
+							.append(y).append("f);\n");
+					break;
+				}
+				case 'v': {
+					y += stream.parseFloat();
+					output.append(indent)
+							.append("tracer.lineTo(")
+							.append(x).append("f, ")
+							.append(y).append("f);\n");
+					break;
+				}
+				case 'C': {
+					float x1 = stream.parseFloat();
+					float y1 = stream.parseFloat();
+					float x2 = stream.parseFloat();
+					float y2 = stream.parseFloat();
+					float x3 = stream.parseFloat();
+					float y3 = stream.parseFloat();
+					output.append(indent)
+							.append("tracer.bezierCubic(")
+							.append(x1).append("f, ")
+							.append(y1).append("f, ")
+							.append(x2).append("f, ")
+							.append(y2).append("f, ")
+							.append(x3).append("f, ")
+							.append(y3).append("f);\n");
+					x = x3;
+					y = y3;
+					guideX = x2;
+					guideY = y2;
+					break;
+				}
+				case 'c': {
+					float x1 = x + stream.parseFloat();
+					float y1 = y + stream.parseFloat();
+					float x2 = x + stream.parseFloat();
+					float y2 = y + stream.parseFloat();
+					float x3 = x + stream.parseFloat();
+					float y3 = y + stream.parseFloat();
+					x = x3;
+					y = y3;
+					guideX = x2;
+					guideY = y2;
+					output.append(indent)
+							.append("tracer.bezierCubic(")
+							.append(x1).append("f, ")
+							.append(y1).append("f, ")
+							.append(x2).append("f, ")
+							.append(y2).append("f, ")
+							.append(x3).append("f, ")
+							.append(y3).append("f);\n");
+					break;
+				}
+				case 'S': {
+					float x1 = x + (x - guideX);
+					float y1 = y + (y - guideY);
+					float x2 = stream.parseFloat();
+					float y2 = stream.parseFloat();
+					float x3 = stream.parseFloat();
+					float y3 = stream.parseFloat();
+					output.append(indent)
+							.append("tracer.bezierCubic(")
+							.append(x1).append("f, ")
+							.append(y1).append("f, ")
+							.append(x2).append("f, ")
+							.append(y2).append("f, ")
+							.append(x3).append("f, ")
+							.append(y3).append("f);\n");
+					x = x3;
+					y = y3;
+					guideX = x2;
+					guideY = y2;
+					break;
+				}
+				case 's': {
+					float x1 = x + (x - guideX);
+					float y1 = y + (y - guideY);
+					float x2 = x + stream.parseFloat();
+					float y2 = y + stream.parseFloat();
+					float x3 = x + stream.parseFloat();
+					float y3 = y + stream.parseFloat();
+					x = x3;
+					y = y3;
+					guideX = x2;
+					guideY = y2;
+					output.append(indent)
+							.append("tracer.bezierCubic(")
+							.append(x1).append("f, ")
+							.append(y1).append("f, ")
+							.append(x2).append("f, ")
+							.append(y2).append("f, ")
+							.append(x3).append("f, ")
+							.append(y3).append("f);\n");
+					break;
+				}
+				case 'Z':
+				case 'z':
+					output.append(indent).append("tracer.close();\n");
+					break;
+				default:
+					System.out.println("Error: path instruction " + instruction + " not supported");
+					return;
+			}
+		}
+	}
+	
+	private static class CharStream {
+		private int index;
+		private final String value;
+		
+		public CharStream(String value) {
+			this.index = 0;
+			this.value = value;
+		}
+		
+		public char next() {
+			skipWhitespace();
+			return value.charAt(index++);
+		}
+		
+		public boolean hasMore() {
+			return index < value.length();
+		}
+		
+		public boolean nextIsNumber() {
+			skipWhitespace();
+			char c = value.charAt(index);
+			return c == '-' || (c >= '0' && c <= '9');
+		}
+		
+		public String nextFloat() {
+			skipWhitespace();
+			int from = index;
+			if (value.charAt(index) == '-')
+				index++;
+			
+			char next = value.charAt(index);
+			while (next >= '0' && next <= '9')
+				next = value.charAt(++index);
+			if (value.charAt(index) == '.') {
+				index++;
+				next = value.charAt(index);
+				while (next >= '0' && next <= '9')
+					next = value.charAt(++index);
+			}
+			
+			return value.substring(from, index);
+		}
+		
+		public float parseFloat() {
+			return Float.parseFloat(nextFloat());
+		}
+		
+		public void skipWhitespace() {
+			char next = value.charAt(index);
+			while (next == ' ' || next == '\t' || next == '\r' || next == '\n' || next == ',')
+				next = value.charAt(++index);
+		}
+	}
+}

IDE/build.gradle

@@ -0,0 +1,19 @@
+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = 'org.openzen.zenscript.ide.Main'
+}
+
+dependencies {
+	compile project(':DrawableGui')
+	compile project(':Constructor')
+}

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

@@ -0,0 +1,35 @@
+package org.openzen.zenscript.ide;
+
+import java.io.File;
+import java.io.IOException;
+import javax.swing.JFrame;
+import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.local.LocalProjectDevelopmentHost;
+import org.openzen.drawablegui.swing.SwingWindow;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.constructor.Project;
+import org.openzen.zenscript.ide.ui.IDEWindow;
+import org.openzen.zenscript.ide.ui.view.WindowView;
+
+public class Main {
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) throws IOException {
+		File directory = new File("../../ZenCode");
+		ModuleLoader loader = new ModuleLoader();
+		Project project = new Project(loader, directory);
+		
+		DevelopmentHost host = new LocalProjectDevelopmentHost(project);
+		
+		int pixelPerInch = java.awt.Toolkit.getDefaultToolkit().getScreenResolution();
+		
+		IDEWindow window = new IDEWindow();
+		WindowView root = new WindowView(window, host);
+		
+		SwingWindow swingWindow = new SwingWindow("ZenCode IDE - " + host.getName(), root, false);
+		swingWindow.setSize(800 * pixelPerInch / 96, 600 * pixelPerInch / 96);
+		swingWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		swingWindow.setVisible(true);
+    }
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/DevelopmentHost.java

@@ -0,0 +1,20 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+import org.openzen.drawablegui.live.LiveList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DevelopmentHost {
+	public String getName();
+	
+	public LiveList<IDEModule> getModules();
+	
+	public LiveList<IDELibrary> getLibraries();
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/IDELibrary.java

@@ -0,0 +1,18 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+import org.openzen.drawablegui.live.LiveList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDELibrary {
+	public String getName();
+	
+	public LiveList<IDEModule> getModules();
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/IDEModule.java

@@ -0,0 +1,16 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDEModule {
+	public String getName();
+	
+	public IDEPackage getRootPackage();
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/IDEPackage.java

@@ -0,0 +1,20 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+import org.openzen.drawablegui.live.LiveList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDEPackage {
+	public String getName();
+	
+	public LiveList<IDEPackage> getSubPackages();
+	
+	public LiveList<IDESourceFile> getSourceFiles();
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/IDESourceFile.java

@@ -0,0 +1,21 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+import java.io.IOException;
+import java.io.Reader;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDESourceFile {
+	public String getName();
+	
+	public Reader read() throws IOException;
+	
+	public void update(String content);
+}

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

@@ -0,0 +1,39 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import org.openzen.drawablegui.live.LiveArrayList;
+import org.openzen.drawablegui.live.LiveList;
+import org.openzen.zenscript.constructor.Library;
+import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.ide.host.IDELibrary;
+import org.openzen.zenscript.ide.host.IDEModule;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalLibrary implements IDELibrary {
+	private final Library library;
+	private final LiveList<IDEModule> modules;
+	
+	public LocalLibrary(Library library) {
+		this.library = library;
+		modules = new LiveArrayList<>();
+		for (ModuleReference module : library.modules)
+			modules.add(new LocalModule(module));
+	}
+
+	@Override
+	public String getName() {
+		return library.name;
+	}
+
+	@Override
+	public LiveList<IDEModule> getModules() {
+		return modules;
+	}
+}

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

@@ -0,0 +1,32 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.ide.host.IDEModule;
+import org.openzen.zenscript.ide.host.IDEPackage;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalModule implements IDEModule {
+	private final ModuleReference module;
+	
+	public LocalModule(ModuleReference module) {
+		this.module = module;
+	}
+
+	@Override
+	public String getName() {
+		return module.getName();
+	}
+
+	@Override
+	public IDEPackage getRootPackage() {
+		return new LocalPackage(module.getRootPackage());
+	}
+}

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

@@ -0,0 +1,57 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import java.util.Arrays;
+import org.openzen.drawablegui.live.LiveArrayList;
+import org.openzen.drawablegui.live.LiveList;
+import org.openzen.zenscript.constructor.module.SourcePackage;
+import org.openzen.zenscript.ide.host.IDEPackage;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalPackage implements IDEPackage {
+	private final SourcePackage pkg;
+	private final LiveList<IDEPackage> subPackages = new LiveArrayList<>();
+	private final LiveList<IDESourceFile> sourceFiles = new LiveArrayList<>();
+	
+	public LocalPackage(SourcePackage pkg) {
+		this.pkg = pkg;
+		
+		String[] subPackageKeys = pkg.subPackages.keySet()
+				.toArray(new String[pkg.subPackages.size()]);
+		Arrays.sort(subPackageKeys);
+		
+		String[] sourceFileKeys = pkg.sourceFiles.keySet()
+				.toArray(new String[pkg.sourceFiles.size()]);
+		Arrays.sort(sourceFileKeys);
+		
+		for (String subKey : subPackageKeys) {
+			subPackages.add(new LocalPackage(pkg.subPackages.get(subKey)));
+		}
+		for (String sourceFileKey : sourceFileKeys) {
+			sourceFiles.add(new LocalSourceFile(pkg.sourceFiles.get(sourceFileKey)));
+		}
+	}
+	
+	@Override
+	public String getName() {
+		return pkg.name;
+	}
+
+	@Override
+	public LiveList<IDEPackage> getSubPackages() {
+		return subPackages;
+	}
+
+	@Override
+	public LiveList<IDESourceFile> getSourceFiles() {
+		return sourceFiles;
+	}
+}

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

@@ -0,0 +1,53 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import java.util.List;
+import org.openzen.drawablegui.live.LiveArrayList;
+import org.openzen.drawablegui.live.LiveList;
+import org.openzen.zenscript.constructor.Library;
+import org.openzen.zenscript.constructor.Project;
+import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.IDEModule;
+import org.openzen.zenscript.ide.host.IDELibrary;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalProjectDevelopmentHost implements DevelopmentHost {
+	private final Project project;
+	private final LiveList<IDEModule> modules;
+	private final LiveList<IDELibrary> libraries;
+	
+	public LocalProjectDevelopmentHost(Project project) {
+		this.project = project;
+		
+		modules = new LiveArrayList<>();
+		for (ModuleReference module : project.modules)
+			modules.add(new LocalModule(module));
+		
+		libraries = new LiveArrayList<>();
+		for (Library library : project.libraries)
+			libraries.add(new LocalLibrary(library));
+	}
+	
+	@Override
+	public String getName() {
+		return project.name;
+	}
+
+	@Override
+	public LiveList<IDEModule> getModules() {
+		return modules;
+	}
+
+	@Override
+	public LiveList<IDELibrary> getLibraries() {
+		return libraries;
+	}
+}

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

@@ -0,0 +1,54 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import org.openzen.zenscript.constructor.module.SourceFile;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalSourceFile implements IDESourceFile {
+	private final SourceFile file;
+	
+	public LocalSourceFile(SourceFile file) {
+		this.file = file;
+	}
+
+	@Override
+	public String getName() {
+		return file.name;
+	}
+
+	@Override
+	public Reader read() throws IOException {
+		return new InputStreamReader(
+				new BufferedInputStream(new FileInputStream(file.file)),
+				StandardCharsets.UTF_8);
+	}
+
+	@Override
+	public void update(String content) {
+		try {
+			Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file.file)), StandardCharsets.UTF_8);
+			writer.write(content);
+			writer.close();
+		} catch (IOException ex) {
+			ex.printStackTrace();
+		}
+	}
+}

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

@@ -0,0 +1,20 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui;
+
+import org.openzen.drawablegui.live.LiveArrayList;
+import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEAspectBar {
+	public final LiveList<IDEAspectToolbar> toolbars = new LiveArrayList<>(); // TODO: only expose read-only variant
+	public final LiveObject<IDEAspectToolbar> active = new SimpleLiveObject<>(null);
+}