Committing WIP on the IDE

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,90 @@
+/*
+ * 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.awt.event.MouseWheelEvent;
+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,74 @@
+/*
+ * 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 DCanvas {
+	void pushBounds(DIRectangle bounds);
+	
+	void popBounds();
+	
+	void pushOffset(int x, int y);
+	
+	void popOffset();
+	
+	DIRectangle getBounds();
+	
+	DDrawingContext getContext();
+	
+	void drawText(DFont font, int color, float x, float y, String text);
+	
+	default float measureTextLength(DFont font, String text) {
+		return measureTextLength(font, text, 0, text.length());
+	}
+	
+	float measureTextLength(DFont font, String text, int offset, int length);
+	
+	/**
+	 * 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 color
+	 * @param dx
+	 * @param dy
+	 * @param radius 
+	 */
+	void shadowPath(DPath path, DTransform2D transform, int color, float dx, float dy, float radius);
+	
+	/**
+	 * Fills a rectangle.
+	 * 
+	 * @param x
+	 * @param y
+	 * @param width
+	 * @param height
+	 * @param color 
+	 */
+	void fillRectangle(int x, int y, int width, int height, int color);
+}

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

@@ -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,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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DComponent {
+	void setContext(DDrawingContext context);
+	
+	LiveObject<DDimensionPreferences> getDimensionPreferences();
+	
+	DRectangle getBounds();
+	
+	void setBounds(DRectangle bounds);
+	
+	void paint(DCanvas canvas);
+	
+	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) {}
+}

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/DDrawingContext.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DDrawingContext {
+	float getScale();
+	
+	void repaint(int x, int y, int width, int height);
+	
+	void setCursor(Cursor cursor);
+	
+	void focus(DComponent component);
+	
+	void scrollInView(int x, int y, int width, int height);
+	
+	DFontMetrics getFontMetrics(DFont font);
+	
+	enum Cursor {
+		NORMAL,
+		HAND,
+		MOVE,
+		TEXT,
+		E_RESIZE,
+		S_RESIZE,
+		NE_RESIZE,
+		NW_RESIZE,
+	}
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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;
+
+/**
+ *
+ * @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 DRectangle NO_BOUNDS = new DRectangle(0, 0, 0, 0);
+	
+	private DEmptyView() {}
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		
+	}
+	
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return DIMENSION;
+	}
+	
+	@Override
+	public DRectangle getBounds() {
+		return NO_BOUNDS;
+	}
+
+	@Override
+	public void setBounds(DRectangle bounds) {
+		
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		
+	}
+}

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,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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DIRectangle {
+	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;
+	}
+}

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,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 DPath {
+	void trace(DPathTracer tracer);
+}

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/DRectangle.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class DRectangle {
+	public final int x;
+	public final int y;
+	public final int width;
+	public final int height;
+	
+	public DRectangle(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/DSideLayout.java

@@ -0,0 +1,240 @@
+/*
+ * 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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DSideLayout extends BaseComponentGroup {
+	private DComponent main;
+	private final List<SideComponent> sides = new ArrayList<>();
+	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	
+	private DDrawingContext context;
+	private DRectangle bounds;
+	
+	public DSideLayout(DComponent main) {
+		this.main = main;
+	}
+	
+	public void add(Side side, DComponent component) {
+		if (context != null)
+			component.setContext(context);
+		
+		sides.add(new SideComponent(side, component));
+	}
+	
+	public void setMain(DComponent component) {
+		this.main = component;
+		main.setContext(context);
+		setBounds(bounds);
+		context.repaint(bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		this.context = context;
+		main.setContext(context);
+		for (SideComponent side : sides)
+			side.component.setContext(context);
+	}
+	
+	@Override
+	public DRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+
+	@Override
+	public void setBounds(DRectangle 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 DRectangle(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 DRectangle(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 DRectangle(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 DRectangle(componentX, componentY, componentWidth, componentHeight));
+					break;
+				}
+			}
+		}
+		
+		main.setBounds(new DRectangle(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;
+	}
+	
+	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/DTransform2D.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;
+
+/**
+ *
+ * @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 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;
+	}
+}

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

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

@@ -0,0 +1,42 @@
+/*
+ * 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.DRectangle;
+import org.openzen.drawablegui.DCanvas;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DEmptyBorder implements DBorder {
+	public static final DEmptyBorder INSTANCE = new DEmptyBorder();
+
+	@Override
+	public void paint(DCanvas canvas, DRectangle 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,55 @@
+/*
+ * 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.DRectangle;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @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, DRectangle 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/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,40 @@
+/*
+ * 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 LiveBool {
+	private final ListenerList<Listener> listeners = new ListenerList<>();
+	private boolean value;
+	
+	public boolean getValue() {
+		return value;
+	}
+	
+	public void setValue(boolean value) {
+		boolean oldValue = this.value;
+		this.value = value;
+		listeners.accept(listener -> listener.onChanged(oldValue, value));
+	}
+	
+	public void toggle() {
+		setValue(!value);
+	}
+	
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return listeners.add(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/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/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,163 @@
+/*
+ * 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.DRectangle;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DDrawingContext;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.ImmutableLiveObject;
+import org.openzen.drawablegui.live.LiveInt;
+import org.openzen.drawablegui.live.LiveObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollBar implements DComponent {
+	private final DScrollBarStyle style;
+	private final LiveObject<DDimensionPreferences> preferences;
+	
+	private final LiveInt targetHeight;
+	private final LiveInt offset;
+	
+	private final ListenerHandle<LiveInt.Listener> targetHeightListener;
+	private final ListenerHandle<LiveInt.Listener> offsetListener;
+	
+	private DDrawingContext context;
+	private DRectangle 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(DScrollBarStyle style, LiveInt targetHeight, LiveInt offset) {
+		this.style = style;
+		this.targetHeight = targetHeight;
+		this.offset = offset;
+		this.preferences = new ImmutableLiveObject<>(new DDimensionPreferences(style.width, 0));
+		
+		targetHeightListener = targetHeight.addListener(new ScrollListener());
+		offsetListener = offset.addListener(new ScrollListener());
+	}
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		this.context = context;
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return preferences;
+	}
+
+	@Override
+	public DRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DRectangle 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, bounds.y + 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);
+	}
+	
+	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)
+			return;
+		
+		fromY = this.bounds.height * offset.getValue() / targetHeight.getValue();
+		toY = 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,33 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.scroll;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollBarStyle {
+	public static final DScrollBarStyle DEFAULT = new DScrollBarStyle(0xFFF0F0F0, 0xFFCDCDCD, 0xFF888888, 0xFF666666, 20);
+	
+	public final int scrollBarBackgroundColor;
+	public final int scrollBarNormalColor;
+	public final int scrollBarHoverColor;
+	public final int scrollBarPressColor;
+	public final int width;
+	
+	public DScrollBarStyle(
+			int scrollBarBackgroundColor,
+			int scrollBarNormalColor,
+			int scrollBarHoverColor,
+			int scrollBarPressColor,
+			int width) {
+		this.scrollBarBackgroundColor = scrollBarBackgroundColor;
+		this.scrollBarNormalColor = scrollBarNormalColor;
+		this.scrollBarHoverColor = scrollBarHoverColor;
+		this.scrollBarPressColor = scrollBarPressColor;
+		this.width = width;
+	}
+}

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

@@ -0,0 +1,269 @@
+/*
+ * 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.DRectangle;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DDrawingContext;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveInt;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveInt;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollPane implements DComponent {
+	private final DScrollPaneStyle style;
+	private final DComponent contents;
+	private final DScrollBar scrollBar;
+	private DDrawingContext context;
+	private DRectangle bounds;
+	
+	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(DScrollPaneStyle style, DComponent contents) {
+		this.style = style;
+		this.contents = contents;
+		
+		contentsHeight = new SimpleLiveInt();
+		offsetX = new SimpleLiveInt();
+		offsetY = new SimpleLiveInt();
+		
+		scrollBar = new DScrollBar(style.scrollBarStyle, 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 DRectangle(0, 0, bounds.width, Math.max(bounds.height, newPreferences.preferredHeight)));
+			contentsHeight.setValue(newPreferences.preferredHeight);
+		});
+	}
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		this.context = context;
+		contents.setContext(new TranslatedContext());
+		scrollBar.setContext(context);
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return contents.getDimensionPreferences(); // TODO: derived preferences
+	}
+
+	@Override
+	public DRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DRectangle bounds) {
+		this.bounds = bounds;
+		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 DRectangle(
+				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 DRectangle(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);
+	}
+	
+	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 DDrawingContext {
+
+		@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);
+		}
+	}
+	
+	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.x, bounds.y, bounds.width, bounds.height);
+		}
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollPaneStyle.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.scroll;
+
+import org.openzen.drawablegui.border.DBorder;
+import org.openzen.drawablegui.border.DLineBorder;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DScrollPaneStyle {
+	public static final DScrollPaneStyle DEFAULT = new DScrollPaneStyle(new DLineBorder(0xFF888888, 1), DScrollBarStyle.DEFAULT);
+	
+	public final DBorder border;
+	public final DScrollBarStyle scrollBarStyle;
+	
+	public DScrollPaneStyle(
+			DBorder border,
+			DScrollBarStyle scrollBarStyle) {
+		this.border = border;
+		this.scrollBarStyle = scrollBarStyle;
+	}
+}

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

@@ -0,0 +1,146 @@
+/*
+ * 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.geom.Rectangle2D;
+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.DDrawingContext;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+
+/**
+ *
+ * @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 float measureTextLength(DFont font, String text, int offset, int length) {
+		prepare(font);
+		g.setFont((Font) font.cached);
+		Rectangle2D rect = g.getFontMetrics().getStringBounds(text, offset, length, g);
+		return (float) rect.getWidth();
+	}
+
+	@Override
+	public DDrawingContext getContext() {
+		return context;
+	}
+
+	@Override
+	public void strokePath(DPath path, DTransform2D transform, int color, float lineWidth) {
+		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) {
+		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, int color, float dx, float dy, float radius) {
+		// TODO
+	}
+
+	@Override
+	public void fillRectangle(int x, int y, int width, int height, int color) {
+		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);
+	}
+}

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,137 @@
+/*
+ * 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 org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DDrawingContext;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DPathTracer;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwingGraphicsContext implements DDrawingContext {
+	public final float scale;
+	private final WeakHashMap<DPath, GeneralPath> preparedPaths = new WeakHashMap<>();
+	private final SwingRoot root;
+	private Graphics graphics;
+	
+	public SwingGraphicsContext(float scale, SwingRoot root) {
+		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;
+	}
+	
+	@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
+	}
+	
+	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,539 @@
+/*
+ * 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.DRectangle;
+
+/**
+ *
+ * @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;
+
+	public SwingRoot(DComponent root) {
+		this.component = root;
+		setFocusable(true);
+		setFocusTraversalKeysEnabled(false); // prevent tab from being handled by focus traversal
+		
+		context = new SwingGraphicsContext(Toolkit.getDefaultToolkit().getScreenResolution() / 96.0f, this);
+		component.setContext(context);
+		component.setBounds(new DRectangle(0, 0, getWidth(), getHeight()));
+		addComponentListener(this);
+		addMouseListener(this);
+		addMouseMotionListener(this);
+		addMouseWheelListener(this);
+		addKeyListener(this);
+	}
+	
+	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) {
+		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 DRectangle(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,30 @@
+/*
+ * 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 javax.swing.JFrame;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDrawingContext;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class SwingWindow extends JFrame {
+	private final SwingRoot swingComponent;
+	
+	public SwingWindow(String title, DComponent root) {
+		super(title);
+		
+		getContentPane().add(swingComponent = new SwingRoot(root), BorderLayout.CENTER);
+		swingComponent.requestFocusInWindow();
+	}
+	
+	public DDrawingContext getContext() {
+		return swingComponent.context;
+	}
+}

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,221 @@
+/*
+ * 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.DRectangle;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DDrawingContext;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DTreeView<N extends DTreeNode<N>> implements DComponent {
+	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private DRectangle bounds;
+	
+	private int selectedRow = -1;
+	private N selectedNode = null;
+	
+	private final DTreeViewStyle style;
+	
+	private DDrawingContext 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.style = style;
+		
+		this.root = root;
+		this.showRoot = showRoot;
+	}
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		this.context = context;
+		updateLayout();
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+	
+	@Override
+	public DRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.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 + style.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,
+							style.font.size + style.selectedPaddingTop + style.selectedPaddingBottom);
+				context.repaint(
+						bounds.x,
+						rowToY(row) - style.selectedPaddingTop,
+						bounds.width,
+						style.font.size + style.selectedPaddingTop + style.selectedPaddingBottom);
+			}
+		}
+	}
+	
+	private int rowToY(int row) {
+		return row * (style.rowSpacing + style.font.size) + style.padding;
+	}
+	
+	private int yToRow(int y) {
+		return (y - bounds.y - style.padding) / (style.rowSpacing + style.font.size);
+	}
+	
+	private int paintNode(DCanvas canvas, N node, int drawX, int drawY) {
+		int textColor = style.nodeTextColor;
+		if (node == selectedNode) {
+			textColor = style.selectedNodeTextColor;
+			canvas.fillRectangle(bounds.x, drawY - style.selectedPaddingTop, bounds.width, style.font.size + style.selectedPaddingTop + style.selectedPaddingBottom, style.selectedBackgroundColor);
+		}
+		
+		int drawingX = drawX;
+		if (!node.isLeaf()) {
+			DDrawable icon = node.isCollapsed().getValue() ? style.nodeClosedIcon : style.nodeOpenedIcon;
+			icon.draw(canvas, DTransform2D.translate(drawingX, drawY + style.font.size - icon.getNominalHeight()));
+			drawingX += style.iconTextSpacing + icon.getNominalWidth();
+		} else {
+			drawingX += style.iconTextSpacing + style.nodeClosedIcon.getNominalWidth();
+		}
+		node.getIcon().draw(canvas, DTransform2D.translate(drawingX, drawY + style.font.size - node.getIcon().getNominalHeight()), textColor);
+		drawingX += style.iconTextSpacing + node.getIcon().getNominalWidth();
+		canvas.drawText(style.font, textColor, drawingX, drawY + style.font.size + style.textShift, node.getTitle());
+		drawY += style.font.size;
+		
+		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);
+			}
+		}
+	}
+	
+	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.x, bounds.y, bounds.width, bounds.height);
+		}
+		
+		@Override
+		public void close() {
+			collapseListener.close();
+		}
+	}
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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;
+
+/**
+ *
+ * @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 int padding;
+	public final int rowSpacing;
+	public final DFont font;
+	public final int indent;
+	public final int textShift;
+	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 DTreeViewStyle() {
+		nodeOpenedIcon = ExpandedArrow.INSTANCE;
+		nodeClosedIcon = CollapsedArrow.INSTANCE;
+		backgroundColor = 0xFFFFFFFF;
+		borderColor = 0xFF888888;
+		padding = 5;
+		rowSpacing = 10;
+		font = new DFont(DFontFamily.UI, false, false, false, 22);
+		indent = 20;
+		textShift = -4;
+		iconTextSpacing = 3;
+		nodeTextColor = 0xFF000000;
+		selectedNodeTextColor = 0xFFFFFFFF;
+		selectedBackgroundColor = 0xFF007ACC;
+		selectedPaddingTop = 3;
+		selectedPaddingBottom = 3;
+	}
+}

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,275 @@
+/*
+ * 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-folder-24px.svg"; //args[0];
+		//String filename = "baseline-dashboard-24px.svg";
+		String className = "ColorableFolderIcon";
+		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;
+		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;
+					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;
+					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);
+		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,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.zenscript.ide.ui;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEAspectBar {
+	private final List<IDEAspectToolbar> aspectToolbars = new ArrayList<>();
+	private final ListenerList<Listener> listeners = new ListenerList<>();
+	
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return listeners.add(listener);
+	}
+	
+	public void addToolbar(IDEAspectToolbar toolbar) {
+		int index = insertToolbar(toolbar);
+		listeners.accept(listener -> listener.onAspectBarAdded(index, toolbar));
+	}
+	
+	public boolean removeToolbar(IDEAspectToolbar toolbar) {
+		int index = aspectToolbars.indexOf(toolbar);
+		if (index < 0)
+			return false;
+		
+		aspectToolbars.remove(index);
+		listeners.accept(listener -> listener.onAspectBarRemoved(index, toolbar));
+		return true;
+	}
+	
+	private int insertToolbar(IDEAspectToolbar toolbar) {
+		for (int i = 0; i < aspectToolbars.size(); i++) {
+			if (toolbar.order < aspectToolbars.get(i).order) {
+				aspectToolbars.add(i, toolbar);
+				return i;
+			}
+		}
+		int index = aspectToolbars.size();
+		aspectToolbars.add(toolbar);
+		return index;
+	}
+	
+	public interface Listener {
+		void onAspectBarAdded(int index, IDEAspectToolbar toolbar);
+		void onAspectBarRemoved(int index, IDEAspectToolbar toolbar);
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEAspectBarControl.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.zenscript.ide.ui;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDEAspectBarControl extends IDEDrawable {
+	ListenerHandle<InvalidationListener> addInvalidationListener(InvalidationListener listener);
+	
+	public interface InvalidationListener {
+		/* Indicates that this component needs to be redrawn */
+		void invalidateView(int x, int y, int width, int height);
+		
+		/* Indicates that layout should be recalculated for this component (eg because its size changed). */
+		void invalidateLayout();
+	}
+}

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

@@ -0,0 +1,71 @@
+/*
+ * 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.DColorableIcon;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEAspectToolbar {
+	private final ListenerList<Listener> listeners = new ListenerList<>();
+	
+	public final int order;
+	public final DColorableIcon icon;
+	public final String title;
+	public final String description;
+	private boolean active;
+	private final List<IDEAspectBarControl> controls = new ArrayList<>();
+	
+	public IDEAspectToolbar(int order, DColorableIcon icon, String title, String description) {
+		this.order = order;
+		this.icon = icon;
+		this.title = title;
+		this.description = description;
+		this.active = true;
+	}
+	
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return listeners.add(listener);
+	}
+	
+	public boolean getActive() {
+		return active;
+	}
+	
+	public void setActive(boolean active) {
+		this.active = active;
+		listeners.accept(listener -> listener.onActiveChanged(active));
+	}
+	
+	public List<IDEAspectBarControl> getControls() {
+		return Collections.unmodifiableList(controls);
+	}
+	
+	public void addControl(IDEAspectBarControl control) {
+		controls.add(control);
+		listeners.accept(listener -> listener.onControlAdded(control));
+	}
+	
+	public void removeControl(IDEAspectBarControl control) {
+		controls.remove(control);
+		listeners.accept(listener -> listener.onControlRemoved(control));
+	}
+	
+	public interface Listener {
+		void onActiveChanged(boolean active);
+		
+		void onControlAdded(IDEAspectBarControl control);
+		
+		void onControlRemoved(IDEAspectBarControl control);
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEDockWindow.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.ui;
+
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEDockWindow {
+	public final LiveObject<IDESourceFile> currentSourceFile = new SimpleLiveObject<>(null);
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEDrawable.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.ui;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DTransform2D;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDEDrawable {
+	void draw(DCanvas canvas, DTransform2D transform, IDEStyle style);
+	
+	float getNominalWidth();
+	
+	float getNominalHeight();
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEStatusBar.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.zenscript.ide.ui;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.listeners.ListenerList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEStatusBar {
+	private final ListenerList<Listener> listeners = new ListenerList<>();
+	private String message;
+	
+	public ListenerHandle<Listener> addListener(Listener listener) {
+		return listeners.add(listener);
+	}
+	
+	public String getMessage() {
+		return message;
+	}
+	
+	public void setMessage(String message) {
+		this.message = message;
+		listeners.accept(listener -> listener.onMessageUpdated(message));
+	}
+	
+	public interface Listener {
+		void onMessageUpdated(String message);
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEStyle.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.ui;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEStyle {
+	public final int primaryColor;
+	
+	public IDEStyle(int primaryColor) {
+		this.primaryColor = primaryColor;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/IDEWindow.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.ide.ui;
+
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEWindow {
+	public final IDEAspectBar aspectBar;
+	public final IDEDockWindow dockWindow;
+	public final IDEStatusBar statusBar;
+	
+	public IDEWindow() {
+		aspectBar = new IDEAspectBar();
+		dockWindow = new IDEDockWindow();
+		statusBar = new IDEStatusBar();
+	}
+	
+	public IDEWindow(IDEAspectBar aspectBar, IDEDockWindow dockWindow, IDEStatusBar statusBar) {
+		this.aspectBar = aspectBar;
+		this.dockWindow = dockWindow;
+		this.statusBar = statusBar;
+	}
+	
+	public void open(IDESourceFile sourceFile) {
+		dockWindow.currentSourceFile.setValue(sourceFile);
+	}
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ChevronRight implements DColorableIcon {
+	public static final ChevronRight INSTANCE = new ChevronRight();
+	
+	private ChevronRight() {}
+	
+	private static final DPath PATH_0 = tracer -> {
+		tracer.moveTo(10f, 6f);
+		tracer.lineTo(8.59f, 7.41f);
+		tracer.lineTo(13.17f, 12f);
+		tracer.lineTo(8.59f, 16.59f);
+		tracer.lineTo(10f, 18f);
+		tracer.lineTo(16.0f, 12.0f);
+		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;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/CodeIcon.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.ide.ui.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DTransform2D;
+
+public class CodeIcon implements DDrawable {
+	public static final CodeIcon INSTANCE = new CodeIcon();
+	
+	private CodeIcon() {}
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform) {
+		ColorableCodeIcon.INSTANCE.draw(canvas, transform, 0xFF000000);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/ColorableCodeIcon.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.zenscript.ide.ui.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ColorableCodeIcon implements DColorableIcon {
+	public static final ColorableCodeIcon INSTANCE = new ColorableCodeIcon();
+	
+	private ColorableCodeIcon() {}
+	
+	private static final DPath PATH = tracer -> {
+		tracer.moveTo(9.4f, 16.6f);
+		tracer.lineTo(4.8f, 12f);
+		tracer.lineTo(9.4f, 7.4f);
+		tracer.lineTo(8f, 6f);
+		tracer.lineTo(2.0f, 12.0f);
+		tracer.lineTo(8.0f, 18.0f);
+		tracer.lineTo(9.4f, 16.6f);
+		tracer.close();
+		tracer.moveTo(14.599999f, 16.6f);
+		tracer.lineTo(19.199999f, 12.0f);
+		tracer.lineTo(14.599998f, 7.4f);
+		tracer.lineTo(16f, 6f);
+		tracer.lineTo(22.0f, 12.0f);
+		tracer.lineTo(16.0f, 18.0f);
+		tracer.lineTo(14.6f, 16.6f);
+		tracer.close();
+	};
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform, int color) {
+		canvas.fillPath(PATH, transform, color);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ColorableFolderIcon implements DColorableIcon {
+	public static final ColorableFolderIcon INSTANCE = new ColorableFolderIcon();
+	
+	private ColorableFolderIcon() {}
+	
+	private static final DPath PATH = tracer -> {
+		tracer.moveTo(10f, 4f);
+		tracer.lineTo(4.0f, 4.0f);
+		tracer.bezierCubic(2.9f, 4.0f, 2.01f, 4.9f, 2.01f, 6.0f);
+		tracer.lineTo(2f, 18f);
+		tracer.bezierCubic(2.0f, 19.1f, 2.9f, 20.0f, 4.0f, 20.0f);
+		tracer.lineTo(20.0f, 20.0f);
+		tracer.bezierCubic(21.1f, 20.0f, 22.0f, 19.1f, 22.0f, 18.0f);
+		tracer.lineTo(22.0f, 8.0f);
+		tracer.bezierCubic(22.0f, 6.9f, 21.1f, 6.0f, 20.0f, 6.0f);
+		tracer.lineTo(12.0f, 6.0f);
+		tracer.lineTo(10.0f, 4.0f);
+		tracer.close();
+	};
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform, int color) {
+		canvas.fillPath(PATH, transform, color);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/ColorableLibraryIcon.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.zenscript.ide.ui.icons;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ColorableLibraryIcon implements DColorableIcon {
+	public static final ColorableLibraryIcon INSTANCE = new ColorableLibraryIcon();
+	
+	private ColorableLibraryIcon() {}
+	
+	private static final DPath PATH_0 = tracer -> {
+		tracer.moveTo(20.54f, 5.23f);
+		tracer.lineTo(19.15f, 3.55f);
+		tracer.bezierCubic(18.88f, 3.21f, 18.47f, 3.0f, 18.0f, 3.0f);
+		tracer.lineTo(6f, 3f);
+		tracer.bezierCubic(5.53f, 3.0f, 5.12f, 3.21f, 4.84f, 3.55f);
+		tracer.lineTo(3.46f, 5.23f);
+		tracer.bezierCubic(3.17f, 5.57f, 3.0f, 6.02f, 3.0f, 6.5f);
+		tracer.lineTo(3f, 19f);
+		tracer.bezierCubic(3.0f, 20.1f, 3.9f, 21.0f, 5.0f, 21.0f);
+		tracer.lineTo(19f, 21f);
+		tracer.bezierCubic(20.1f, 21.0f, 21.0f, 20.1f, 21.0f, 19.0f);
+		tracer.lineTo(21f, 6.5f);
+		tracer.bezierCubic(21.0f, 6.02f, 20.83f, 5.57f, 20.54f, 5.23f);
+		tracer.close();
+		tracer.moveTo(5.12f, 5f);
+		tracer.lineTo(5.93f, 4f);
+		tracer.lineTo(17.93f, 4f);
+		tracer.lineTo(18.87f, 5f);
+		tracer.lineTo(5.12f, 5f);
+		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;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/ColorableModuleIcon.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.ui.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ColorableModuleIcon implements DColorableIcon {
+	public static final ColorableModuleIcon INSTANCE = new ColorableModuleIcon();
+	
+	private ColorableModuleIcon() {}
+	
+	private static final DPath PATH = tracer -> {
+		tracer.moveTo(3f, 19f);
+		tracer.lineTo(9.0f, 19.0f);
+		tracer.lineTo(9.0f, 12.0f);
+		tracer.lineTo(3.0f, 12.0f);
+		tracer.lineTo(3.0f, 19.0f);
+		tracer.close();
+		tracer.moveTo(10.0f, 19.0f);
+		tracer.lineTo(22.0f, 19.0f);
+		tracer.lineTo(22.0f, 12.0f);
+		tracer.lineTo(10.0f, 12.0f);
+		tracer.lineTo(10.0f, 19.0f);
+		tracer.close();
+		tracer.moveTo(3f, 5f);
+		tracer.lineTo(3.0f, 11.0f);
+		tracer.lineTo(22.0f, 11.0f);
+		tracer.lineTo(22.0f, 5.0f);
+		tracer.lineTo(3.0f, 5.0f);
+		tracer.close();
+	};
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform, int color) {
+		canvas.fillPath(PATH, transform, color);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

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

@@ -0,0 +1,60 @@
+/*
+ * 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.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.zenscript.ide.ui.IDEStyle;
+import org.openzen.drawablegui.DColorableIcon;
+
+public class ColorableProjectIcon implements DColorableIcon {
+	public static final ColorableProjectIcon INSTANCE = new ColorableProjectIcon();
+	
+	private ColorableProjectIcon() {}
+	
+	private static final DPath PATH_0 = tracer -> {
+		tracer.moveTo(3f, 13f);
+		tracer.lineTo(11.0f, 13.0f);
+		tracer.lineTo(11.0f, 3.0f);
+		tracer.lineTo(3.0f, 3.0f);
+		tracer.lineTo(3.0f, 13.0f);
+		tracer.close();
+		tracer.moveTo(3.0f, 21.0f);
+		tracer.lineTo(11.0f, 21.0f);
+		tracer.lineTo(11.0f, 15.0f);
+		tracer.lineTo(3.0f, 15.0f);
+		tracer.lineTo(3.0f, 21.0f);
+		tracer.close();
+		tracer.moveTo(13.0f, 21.0f);
+		tracer.lineTo(21.0f, 21.0f);
+		tracer.lineTo(21.0f, 11.0f);
+		tracer.lineTo(13.0f, 11.0f);
+		tracer.lineTo(13.0f, 21.0f);
+		tracer.close();
+		tracer.moveTo(13.0f, 3.0f);
+		tracer.lineTo(13.0f, 9.0f);
+		tracer.lineTo(21.0f, 9.0f);
+		tracer.lineTo(21.0f, 3.0f);
+		tracer.lineTo(13.0f, 3.0f);
+		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;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/FolderIcon.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.ide.ui.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DTransform2D;
+
+public class FolderIcon implements DDrawable {
+	public static final FolderIcon INSTANCE = new FolderIcon();
+	
+	private FolderIcon() {}
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform) {
+		ColorableFolderIcon.INSTANCE.draw(canvas, transform, 0xFF000000);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/LibraryIcon.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.ui.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+
+public class LibraryIcon implements DDrawable {
+	public static final LibraryIcon INSTANCE = new LibraryIcon();
+	
+	private LibraryIcon() {}
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform) {
+		ColorableLibraryIcon.INSTANCE.draw(canvas, transform, 0xFF888888);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/ModuleIcon.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.ui.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+
+public class ModuleIcon implements DDrawable {
+	public static final ModuleIcon INSTANCE = new ModuleIcon();
+	
+	private ModuleIcon() {}
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform) {
+		ColorableModuleIcon.INSTANCE.draw(canvas, transform, 0xFF000000);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/icons/ProjectIcon.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.ui.icons;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
+
+public class ProjectIcon implements DDrawable {
+	public static final ProjectIcon INSTANCE = new ProjectIcon();
+	
+	private ProjectIcon() {}
+	
+	@Override
+	public void draw(DCanvas canvas, DTransform2D transform) {
+		ColorableProjectIcon.INSTANCE.draw(canvas, transform, 0xFF000000);
+	}
+
+	@Override
+	public float getNominalWidth() {
+		return 24;
+	}
+
+	@Override
+	public float getNominalHeight() {
+		return 24;
+	}
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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.view;
+
+import org.openzen.drawablegui.DRectangle;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DDrawingContext;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StatusBarView implements DComponent {
+	private static final int COLOR = 0xFFF0F0F0;
+	//private static final int COLOR = 0xFFFFFFFF;
+	
+	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 40));
+	private DRectangle bounds;
+	private DDrawingContext context;
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		this.context = context;
+	}
+	
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+	
+	@Override
+	public DRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, COLOR);
+	}
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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.view;
+
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DEmptyView;
+import org.openzen.drawablegui.scroll.DScrollPane;
+import org.openzen.drawablegui.scroll.DScrollPaneStyle;
+import org.openzen.drawablegui.DSideLayout;
+import org.openzen.drawablegui.tree.DTreeView;
+import org.openzen.drawablegui.tree.DTreeViewStyle;
+import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.ui.IDEWindow;
+import org.openzen.zenscript.ide.ui.view.editor.SourceEditor;
+import org.openzen.zenscript.ide.ui.view.project.RootTreeNode;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class WindowView extends DSideLayout {
+	public WindowView(IDEWindow window, DevelopmentHost host) {
+		super(DEmptyView.INSTANCE);
+		
+		DTreeView projectView = new DTreeView(DTreeViewStyle.DEFAULT, new RootTreeNode(window, host), false);
+		projectView.getDimensionPreferences().setValue(new DDimensionPreferences(500, 500));
+		add(Side.LEFT, new DScrollPane(DScrollPaneStyle.DEFAULT, projectView));
+		add(Side.BOTTOM, new StatusBarView());
+		
+		window.dockWindow.currentSourceFile.addListener((oldSource, newSource) -> {
+			if (newSource == null) {
+				setMain(DEmptyView.INSTANCE);
+			} else {
+				setMain(new DScrollPane(DScrollPaneStyle.DEFAULT, new SourceEditor(newSource)));
+			}
+		});
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/aspectbar/AspectBarView.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.ui.view.aspectbar;
+
+import org.openzen.zenscript.ide.ui.view.*;
+import org.openzen.drawablegui.DRectangle;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DDrawingContext;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class AspectBarView implements DComponent {
+	private static final int COLOR = 0xFFF0F0F0;
+	//private static final int COLOR = 0xFFFFFFFF;
+	
+	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 40));
+	private DRectangle bounds;
+	private DDrawingContext context;
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		this.context = context;
+	}
+	
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+	
+	@Override
+	public DRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, COLOR);
+	}
+}

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

@@ -0,0 +1,858 @@
+/*
+ * 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.view.editor;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DDrawingContext;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontFamily;
+import org.openzen.drawablegui.DFontMetrics;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DKeyEvent;
+import org.openzen.drawablegui.DKeyEvent.KeyCode;
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.DRectangle;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+import org.openzen.zenscript.lexer.ReaderCharReader;
+import org.openzen.zenscript.lexer.TokenParser;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SourceEditor implements DComponent {
+	private final SourceEditorStyle style = SourceEditorStyle.DEFAULT;
+	private final DFont font = new DFont(DFontFamily.CODE, false, false, false, 24);
+	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 0));
+	private final String tab = "    ";
+	private final IDESourceFile sourceFile;
+	
+	private DRectangle bounds;
+	private DDrawingContext context;
+	private DFontMetrics fontMetrics;
+	private int textLineHeight;
+	private int fullLineHeight;
+	private int selectionLineHeight;
+	private final List<Line> lines = new ArrayList<>();
+	
+	private int lineBarWidth;
+	private CursorPosition cursorStart = null;
+	private CursorPosition cursorEnd = null;
+	
+	private Timer blink = new Timer();
+	private boolean cursorBlink = true;
+	
+	private int mouseDownX = -1;
+	private int mouseDownY = -1;
+	private boolean dragging = false;
+	
+	public SourceEditor(IDESourceFile sourceFile) {
+		this.sourceFile = sourceFile;
+		
+		blink.scheduleAtFixedRate(new TimerTask() {
+			@Override
+			public void run() {
+				blink();
+			}
+		}, 300, 300);
+		
+		try {
+			parse();
+		} catch (IOException ex) {
+			ex.printStackTrace();
+		}
+	}
+
+	@Override
+	public void setContext(DDrawingContext context) {
+		this.context = context;
+		fontMetrics = context.getFontMetrics(font);
+		textLineHeight = fontMetrics.getAscent() + fontMetrics.getDescent();
+		fullLineHeight = textLineHeight + fontMetrics.getLeading() + style.extraLineSpacing;
+		selectionLineHeight = textLineHeight + style.selectionPaddingTop + style.selectionPaddingBottom;
+		
+		dimensionPreferences.setValue(new DDimensionPreferences(0, fullLineHeight * lines.size()));
+	}
+
+	@Override
+	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+		return dimensionPreferences;
+	}
+
+	@Override
+	public DRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public void setBounds(DRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		DIRectangle canvasBounds = canvas.getBounds();
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, 0xFFFFFFFF);
+		
+		lineBarWidth = Math.max(50, fontMetrics.getWidth(Integer.toString(lines.size()))) + 5;
+		canvas.fillRectangle(bounds.x, bounds.y, lineBarWidth, bounds.height, 0xFFE9E8E2);
+		canvas.strokePath(tracer -> {
+			tracer.moveTo(bounds.x + lineBarWidth, bounds.y);
+			tracer.lineTo(bounds.x + lineBarWidth, bounds.y + bounds.height);
+		}, DTransform2D.IDENTITY, 0xFFA0A0A0, 1);
+		
+		int x = bounds.x + lineBarWidth + 10;
+		if (cursorEnd != null)
+			canvas.fillRectangle(x, lineToY(cursorEnd.line), bounds.width - x, selectionLineHeight, style.currentLineHighlight);
+		
+		if (cursorStart != null && !cursorStart.equals(cursorEnd)) {
+			if (cursorStart.line == cursorEnd.line) {
+				int y = cursorStart.getY();
+				int x1 = cursorStart.getX();
+				int x2 = cursorEnd.getX();
+				int fromX = Math.min(x1, x2);
+				int toX = Math.max(x1, x2);
+				canvas.fillRectangle(fromX, y, toX - fromX, selectionLineHeight, style.selectionColor);
+			} else {
+				CursorPosition from = cursorStart.line < cursorEnd.line ? cursorStart : cursorEnd;
+				CursorPosition to = cursorStart.line < cursorEnd.line ? cursorEnd : cursorStart;
+				
+				int fromX = from.getX();
+				canvas.fillRectangle(fromX, from.getY(), bounds.width - fromX, selectionLineHeight, style.selectionColor);
+				
+				for (int i = from.line + 1; i < to.line; i++) {
+					canvas.fillRectangle(x, lineToY(i), bounds.width - x, selectionLineHeight, style.selectionColor);
+				}
+				
+				int toX = to.getX();
+				canvas.fillRectangle(x, to.getY(), toX - x, selectionLineHeight, style.selectionColor);
+			}
+		}
+		
+		int y = bounds.y + style.selectionPaddingTop;
+		int lineIndex = 1;
+		for (Line line : lines) {
+			if (y + textLineHeight  >= canvasBounds.y && y < canvasBounds.y + canvasBounds.height) {
+				String lineNumber = Integer.toString(lineIndex);
+				int lineNumberX = x - 15 - (int)canvas.measureTextLength(font, lineNumber);
+				canvas.drawText(font, 0xFFA0A0A0, lineNumberX, y + fontMetrics.getAscent(), lineNumber);
+
+				int lineX = x;
+				for (ZSToken token : line.tokens) {
+					String content = getDisplayContent(token);
+					canvas.drawText(font, TokenClass.get(token.type).color, lineX, y + fontMetrics.getAscent(), content);
+					lineX += canvas.measureTextLength(font, content);
+				}
+			}
+			
+			y += fullLineHeight;
+			lineIndex++;
+		}
+		
+		if (cursorEnd != null && cursorBlink) {
+			int cursorX = cursorEnd.getX();
+			int cursorY = cursorEnd.getY();
+			canvas.fillRectangle(cursorX, cursorY, 2, selectionLineHeight, 0xFF000000);
+		}
+	}
+	
+	@Override
+	public void onMouseEnter(DMouseEvent e) {
+		context.setCursor(DDrawingContext.Cursor.TEXT);
+	}
+	
+	@Override
+	public void onMouseExit(DMouseEvent e) {
+		context.setCursor(DDrawingContext.Cursor.NORMAL);
+	}
+	
+	@Override
+	public void onMouseClick(DMouseEvent e) {
+		context.focus(this);
+		
+		CursorPosition position = getPositionAt(e.x, e.y);
+		if (e.isDoubleClick()) {
+			// select entire word
+			TokenPosition token = getTokenAt(position);
+			setCursor(
+					new CursorPosition(position.line, position.offset - token.offset),
+					new CursorPosition(position.line, position.offset + token.token.content.length() - token.offset));
+		} else if (e.isTripleClick()) {
+			setCursor(
+					new CursorPosition(position.line, 0),
+					new CursorPosition(position.line + 1, 0));
+		} else {
+			setCursor(position, position);
+		}
+	}
+	
+	private void setCursor(CursorPosition start, CursorPosition end) {
+		if (cursorStart != null)
+			repaint(cursorStart, cursorEnd);
+		
+		int previousLine = cursorEnd == null ? -1 : cursorEnd.line;
+		
+		cursorStart = start;
+		cursorEnd = end;
+		
+		if (previousLine != cursorEnd.line) {
+			if (previousLine >= 0)
+				repaintLine(previousLine);
+			repaintLine(cursorEnd.line);
+		}
+		repaint(cursorStart, cursorEnd);
+		scrollTo(cursorEnd);
+	}
+	
+	@Override
+	public void onMouseDown(DMouseEvent e) {
+		mouseDownX = e.x;
+		mouseDownY = e.y;
+	}
+	
+	@Override
+	public void onMouseDrag(DMouseEvent e) {
+		CursorPosition start = cursorStart;
+		if (!dragging)
+			start = getPositionAt(mouseDownX, mouseDownY);
+		
+		setCursor(start, getPositionAt(e.x, e.y));
+	}
+	
+	@Override
+	public void onKeyPressed(DKeyEvent e) {
+		boolean shift = e.has(DKeyEvent.SHIFT);
+		switch (e.keyCode) {
+			case UP:
+				if (cursorEnd == null || cursorEnd.line == 0)
+					return;
+				
+				{
+					int line = cursorEnd.line - 1;
+					CursorPosition position = new CursorPosition(
+							line,
+							Math.min(lines.get(line).length, cursorEnd.offset));
+					setCursor(shift ? cursorStart : position, position);
+				}
+				break;
+			case DOWN:
+				if (cursorEnd == null || cursorEnd.line >= lines.size() - 1)
+					return;
+				
+				{
+					int line = cursorEnd.line + 1;
+					CursorPosition position = new CursorPosition(
+							line,
+							Math.min(lines.get(line).length, cursorEnd.offset));
+					setCursor(shift ? cursorStart : position, position);
+				}
+				break;
+			case LEFT:
+				if (cursorEnd == null || (cursorEnd.line == 0 && cursorEnd.offset == 0))
+					return;
+				
+				{
+					CursorPosition position;
+					if (cursorEnd.offset == 0) {
+						int line = cursorEnd.line - 1;
+						position = new CursorPosition(line, lines.get(line).length);
+					} else {
+						position = new CursorPosition(cursorEnd.line, cursorEnd.offset - 1);
+					}
+					setCursor(shift ? cursorStart : position, position);
+				}
+				break;
+			case RIGHT:
+				if (cursorEnd == null || (cursorEnd.offset == lines.get(cursorEnd.line).length && cursorEnd.line >= lines.size() - 1))
+					return;
+				
+				{
+					CursorPosition position;
+					if (cursorEnd.offset == lines.get(cursorEnd.line).length) {
+						position = new CursorPosition(cursorEnd.line + 1, 0);
+					} else {
+						position = new CursorPosition(cursorEnd.line, cursorEnd.offset + 1);
+					}
+					setCursor(shift ? cursorStart : position, position);
+				}
+				break;
+			case DELETE:
+				delete();
+				break;
+			case BACKSPACE:
+				backspace();
+				break;
+			case ENTER:
+				newline();
+				break;
+			case TAB:
+				type(tab);
+				break;
+			default:
+				if (e.character == DKeyEvent.CHAR_UNDEFINED)
+					return;
+				if (e.has(DKeyEvent.CTRL) || e.has(DKeyEvent.ALT)) {
+					handleShortcut(e);
+				} else {
+					type(Character.toString(e.character));
+				}
+				break;
+		}
+	}
+	
+	private void handleShortcut(DKeyEvent e) {
+		if (e.has(DKeyEvent.CTRL)) {
+			if (e.keyCode == KeyCode.S) {
+				save();
+			}
+		}
+	}
+	
+	private void save() {
+		String content = contentToString();
+		sourceFile.update(content);
+	}
+	
+	private String contentToString() {
+		StringBuilder result = new StringBuilder();
+		for (int i = 0; i < lines.size(); i++) {
+			if (i > 0)
+				result.append("\n");
+			
+			Line line = lines.get(i);
+			for (ZSToken token : line.tokens) {
+				result.append(token.content);
+			}
+		}
+		return result.toString();
+	}
+	
+	private void delete() {
+		Line line = lines.get(cursorEnd.line);
+		if (cursorEnd.offset == line.length) {
+			// merge 2 lines
+			if (cursorEnd.line == lines.size() - 1)
+				return;
+			
+			line.merge(cursorEnd.line, lines.get(cursorEnd.line + 1));
+			lines.remove(cursorEnd.line + 1);
+			onLinesUpdated();
+			return;
+		}
+		
+		line.delete(cursorEnd.line, cursorEnd.offset);
+		repaintLine(cursorEnd.line);
+	}
+	
+	private void backspace() {
+		if (cursorEnd.offset == 0) {
+			if (cursorEnd.line == 0)
+				return;
+			
+			int length = lines.get(cursorEnd.line - 1).length;
+			lines.get(cursorEnd.line - 1).merge(cursorEnd.line - 1, lines.get(cursorEnd.line));
+			lines.remove(cursorEnd.line);
+			onLinesUpdated();
+			
+			CursorPosition position = new CursorPosition(cursorEnd.line - 1, length);
+			setCursor(position, position);
+			return;
+		}
+		
+		lines.get(cursorEnd.line).delete(cursorEnd.line, cursorEnd.offset - 1);
+		CursorPosition position = new CursorPosition(cursorEnd.line, cursorEnd.offset - 1);
+		setCursor(position, position);
+		repaintLine(cursorEnd.line);
+	}
+	
+	private void type(String value) {
+		lines.get(cursorEnd.line).insert(cursorEnd.line, cursorEnd.offset, value);
+		CursorPosition position = new CursorPosition(cursorEnd.line, cursorEnd.offset + value.length());
+		setCursor(position, position);
+		repaintLine(cursorEnd.line);
+	}
+	
+	private void newline() {
+		lines.get(cursorEnd.line).split(cursorEnd.line, cursorEnd.offset);
+		onLinesUpdated();
+		
+		CursorPosition position = new CursorPosition(cursorEnd.line + 1, 0);
+		setCursor(position, position);
+	}
+	
+	private TokenPosition getTokenAt(CursorPosition position) {
+		Line line = lines.get(position.line);
+		int offset = 0;
+		for (ZSToken token : line.tokens) {
+			if (offset + token.content.length() > position.offset)
+				return new TokenPosition(token, position.offset - offset);
+			offset += token.content.length();
+		}
+		
+		return new TokenPosition(line.tokens.get(line.tokens.size() - 1), position.offset - offset);
+	}
+	
+	private class TokenPosition {
+		public final ZSToken token;
+		public final int offset;
+		
+		public TokenPosition(ZSToken token, int offset) {
+			this.token = token;
+			this.offset = offset;
+		}
+	}
+	
+	private void repaint(CursorPosition from, CursorPosition to) {
+		if (from.line == to.line) {
+			int y = lineToY(from.line);
+			int fromX = offsetToX(from.line, Math.min(from.offset, to.offset));
+			int toX = offsetToX(from.line, Math.max(from.offset, to.offset)) + 2;
+			context.repaint(fromX, y, toX - fromX, selectionLineHeight);
+		} else {
+			int fromY = lineToY(Math.min(from.line, to.line));
+			int toY = lineToY(Math.max(from.line, to.line) + 1);
+			context.repaint(bounds.x, fromY, bounds.width, toY - fromY);
+		}
+	}
+	
+	private void repaintLine(int line) {
+		context.repaint(bounds.x, lineToY(line), bounds.width, selectionLineHeight);
+	}
+	
+	private void scrollTo(CursorPosition position) {
+		int y = lineToY(position.line);
+		int x = offsetToX(position.line, position.offset);
+		context.scrollInView(x, y, 2, selectionLineHeight);
+	}
+	
+	private void blink() {
+		if (cursorEnd != null) {
+			cursorBlink = !cursorBlink;
+			repaint(cursorEnd, cursorEnd);
+		}
+	}
+	
+	private CursorPosition getPositionAt(int x, int y) {
+		int line = yToLine(y);
+		int offset = xToOffset(line, x);
+		
+		if (line < 0)
+			line = 0;
+		if (line >= lines.size())
+			line = lines.size() - 1;
+		
+		return new CursorPosition(line, offset);
+	}
+	
+	private int xToOffset(int lineIndex, int x) {
+		if (lineIndex < 0 || lineIndex >= lines.size())
+			return 0;
+		
+		Line line = lines.get(lineIndex);
+		int lineX = bounds.x + lineBarWidth + 10;
+		int offset = 0;
+		for (ZSToken token : line.tokens) {
+			String content = getDisplayContent(token);
+			int tokenWidth = fontMetrics.getWidth(content);
+			if (lineX + tokenWidth > x) {
+				return offset + getStringIndexForToken(token, tokenWidth, x - lineX);
+			}
+			lineX += tokenWidth;
+			offset += token.content.length();
+		}
+		
+		return offset;
+	}
+	
+	private int getStringIndexForToken(ZSToken token, int strWidth, int pixels) {
+		if (token.type == ZSTokenType.T_WHITESPACE_TAB)
+			return pixels > strWidth / 2 ? 1 : 0;
+		
+		return getStringIndexForPixels(token.content, pixels);
+	}
+	
+	private int getStringIndexForPixels(String str, int pixels) {
+		int previousX = 0;
+		for (int i = 1; i < str.length(); i++) {
+			int currentX = fontMetrics.getWidth(str, 0, i);
+			if (currentX >= pixels)
+				return (pixels - previousX < currentX - pixels) ? i - 1 : i;
+		}
+		
+		return str.length();
+	}
+	
+	private int yToLine(int y) {
+		int startY = bounds.y;
+		return (y - startY) / fullLineHeight;
+	}
+	
+	private int lineToY(int line) {
+		int startY = bounds.y;
+		return startY + line * fullLineHeight;
+	}
+	
+	private int offsetToX(int line, int offset) {
+		if (line >= lines.size())
+			return 0;
+		
+		int tokensOffset = 0;
+		int x = bounds.x + lineBarWidth + 10;
+		Line lineData = lines.get(line);
+		for (ZSToken token : lineData.tokens) {
+			String content = getDisplayContent(token);
+			if (tokensOffset + token.content.length() >= offset) {
+				if (token.type == ZSTokenType.T_WHITESPACE_TAB)
+					return offset == tokensOffset ? x : x + fontMetrics.getWidth(tab);
+				
+				return x + fontMetrics.getWidth(token.content, 0, offset - tokensOffset);
+			}
+			
+			x += fontMetrics.getWidth(content);
+			tokensOffset += token.content.length();
+		}
+		return x;
+	}
+	
+	private String getDisplayContent(ZSToken token) {
+		return token.type == ZSTokenType.T_WHITESPACE_TAB ? tab : token.content;
+	}
+	
+	private void parse() throws IOException {
+		lines.clear();
+		lines.add(new Line());
+		
+		TokenParser<ZSToken, ZSTokenType> parser = ZSTokenParser.createRaw(sourceFile.getName(), new ReaderCharReader(sourceFile.read()), tab.length());
+		insertTokens(0, 0, parser);
+	}
+	
+	private void onLinesUpdated() {
+		dimensionPreferences.setValue(new DDimensionPreferences(0, fullLineHeight * lines.size()));
+		
+		if (bounds != null)
+			context.repaint(bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+	
+	public class Line {
+		public final List<ZSToken> tokens = new ArrayList<>();
+		private int length;
+		
+		private void calculateLength() {
+			length = 0;
+			for (ZSToken token : tokens)
+				length += token.content.length();
+		}
+		
+		public void merge(int lineIndex, Line other) {
+			if (tokens.isEmpty()) {
+				tokens.addAll(other.tokens);
+				length = other.length;
+				return;
+			}
+			
+			int fromToken = tokens.size() - 1;
+			int toToken = other.tokens.size() > 0 ? fromToken + 2 : fromToken + 1;
+			tokens.addAll(other.tokens);
+			length += other.length;
+			reparse(lineIndex, fromToken, lineIndex, toToken);
+		}
+		
+		public Line split(int lineIndex, int offset) {
+			if (offset < 0)
+				throw new IllegalArgumentException("offset must be >= 0");
+			
+			int tokenOffset = 0;
+			for (int i = 0; i < tokens.size(); i++) {
+				ZSToken token = tokens.get(i);
+				if (tokenOffset + token.content.length() > offset) {
+					ZSToken broken = token;
+					Line newLine = new Line();
+					if (offset - tokenOffset != token.content.length() && offset - tokenOffset != 0) {
+						ZSToken.Pair split = token.split(offset - tokenOffset);
+						broken = split.first;
+						newLine.tokens.add(split.second);
+					}
+					
+					tokens.set(i, broken);
+					for (int j = i + 1; j < tokens.size(); j++)
+						newLine.tokens.add(tokens.get(j));
+					for (int j = tokens.size() - 1; j > i; j--)
+						tokens.remove(j);
+					
+					lines.add(lineIndex + 1, newLine);
+					reparse(lineIndex, i, lineIndex + 1, 1);
+					return newLine;
+				}
+				tokenOffset += token.content.length();
+			}
+			
+			Line result = new Line();
+			lines.add(result);
+			return result;
+		}
+		
+		public void delete(int lineIndex, int offset) {
+			int tokenOffset = 0;
+			for (int i = 0; i < tokens.size(); i++) {
+				ZSToken token = tokens.get(i);
+				if (tokenOffset + token.content.length() > offset) {
+					if (token.content.length() == 1) {
+						tokens.remove(i);
+					} else {
+						token = token.delete(offset - tokenOffset, 1);
+						tokens.set(i, token);
+					}
+					length--;
+					
+					reparse(lineIndex, i, lineIndex, i + 1);
+					return;
+				}
+				tokenOffset += token.content.length();
+			}
+		}
+		
+		public void insert(int lineIndex, int offset, String value) {
+			int tokenOffset = 0;
+			if (tokens.isEmpty()) {
+				tokens.add(new ZSToken(ZSTokenType.INVALID, value));
+				reparse(lineIndex, 0, lineIndex, 1);
+				return;
+			}
+			
+			for (int i = 0; i < tokens.size(); i++) {
+				ZSToken token = tokens.get(i);
+				if (tokenOffset + token.content.length() > offset) {
+					token = token.insert(offset - tokenOffset, value);
+					tokens.set(i, token);
+					length += value.length();
+					reparse(lineIndex, i, lineIndex, i + 1);
+					return;
+				}
+				tokenOffset += token.content.length();
+			}
+			
+			ZSToken token = tokens.get(tokens.size() - 1);
+			token = new ZSToken(token.type, token.content + value);
+			tokens.set(tokens.size() - 1, token);
+			length += value.length();
+			reparse(lineIndex, tokens.size() - 1, lineIndex, tokens.size());
+		}
+	}
+	
+	private void reparse(int fromLine, int fromToken, int toLine, int toToken) {
+		TokenReparser reparser = new TokenReparser(sourceFile.getName(), lines, fromLine, fromToken, toLine, toToken, tab.length());
+		List<ZSToken> tokens = reparser.reparse();
+		replaceTokens(fromLine, fromToken, reparser.getLine(), reparser.getToken(), tokens);
+	}
+	
+	private void replaceTokens(int fromLine, int fromToken, int toLine, int toToken, List<ZSToken> tokens) {
+		removeTokens(fromLine, fromToken, toLine, toToken);
+		insertTokens(fromLine, fromToken, tokens.iterator());
+	}
+	
+	private void removeTokens(int fromLine, int fromToken, int toLine, int toToken) {
+		if (toLine > fromLine) {
+			Line fromLineObject = lines.get(fromLine);
+			for (int i = fromLineObject.tokens.size() - 1; i >= fromToken; i--)
+				fromLineObject.tokens.remove(i);
+			
+			Line toLineObject = lines.get(fromLine);
+			for (int i = toToken - 1; i >= 0; i--)
+				toLineObject.tokens.remove(i);
+			
+			fromLineObject.merge(fromLine, lines.remove(toLine));
+			for (int i = toLine - 1; i > fromLine; i--)
+				lines.remove(i);
+			
+			onLinesUpdated();
+		} else {
+			Line line = lines.get(fromLine);
+			for (int i = toToken - 1; i >= fromToken; i--)
+				line.tokens.remove(i);
+		}
+	}
+	
+	private void insertTokens(int line, int tokenIndex, Iterator<ZSToken> tokens) {
+		boolean linesUpdated = false;
+		Line currentLine = lines.get(line);
+		while (tokens.hasNext()) {
+			ZSToken token = tokens.next();
+			if (token.type == ZSTokenType.T_WHITESPACE_NEWLINE) {
+				currentLine.calculateLength();
+				
+				Line newLine = new Line();
+				if (tokenIndex < currentLine.tokens.size()) {
+					for (int i = tokenIndex; i < currentLine.tokens.size(); i++) {
+						newLine.tokens.add(currentLine.tokens.remove(tokenIndex));
+					}
+				}
+				currentLine = newLine;
+				tokenIndex = 0;
+				lines.add(++line, currentLine);
+				linesUpdated = true;
+			} else if (token.type != ZSTokenType.T_WHITESPACE_CARRIAGE_RETURN) {
+				currentLine.tokens.add(tokenIndex++, token);
+			}
+		}
+		
+		currentLine.calculateLength();
+		
+		if (linesUpdated) {
+			onLinesUpdated();
+		} else {
+			// Could be further optimized to only repaint the modified characters
+			repaintLine(line);
+		}
+	}
+	
+	private enum TokenClass {
+		WHITESPACE(0xFF969696),
+		KEYWORD(0xFF0000E6),
+		OPERATOR(0xFF000000),
+		TYPE(0xFF0000E6),
+		IDENTIFIER(0xFF000000),
+		NUMBER(0xFF444444),
+		STRING(0xFFCE7B00),
+		INVALID(0xFFFA0A00);
+		
+		public final int color;
+		
+		TokenClass(int color) {
+			this.color = color;
+		}
+		
+		public static TokenClass get(ZSTokenType type) {
+			switch (type) {
+				case T_WHITESPACE_CARRIAGE_RETURN:
+				case T_WHITESPACE_NEWLINE:
+				case T_WHITESPACE_SPACE:
+				case T_WHITESPACE_TAB:
+					return WHITESPACE;
+				case T_IDENTIFIER:
+				case T_DOLLAR:
+					return IDENTIFIER;
+				case T_FLOAT:
+				case T_INT:
+					return NUMBER;
+				case T_STRING_SQ:
+				case T_STRING_DQ:
+					return STRING;
+				case K_IMPORT:
+				case K_ALIAS:
+				case K_CLASS:
+				case K_FUNCTION:
+				case K_INTERFACE:
+				case K_ENUM:
+				case K_STRUCT:
+				case K_EXPAND:
+				case K_VARIANT:
+				case K_ABSTRACT:
+				case K_FINAL:
+				case K_OVERRIDE:
+				case K_CONST:
+				case K_PRIVATE:
+				case K_PUBLIC:
+				case K_EXPORT:
+				case K_STATIC:
+				case K_PROTECTED:
+				case K_IMPLICIT:
+				case K_VIRTUAL:
+				case K_EXTERN:
+				case K_VAL:
+				case K_VAR:
+				case K_GET:
+				case K_IMPLEMENTS:
+				case K_SET:
+				case K_IN:
+				case K_IS:
+				case K_AS:
+				case K_MATCH:
+				case K_THROWS:
+				case K_SUPER:
+				case K_THIS:
+				case K_NULL:
+				case K_TRUE:
+				case K_FALSE:
+				case K_NEW:
+					
+				case K_IF:
+				case K_ELSE:
+				case K_DO:
+				case K_WHILE:
+				case K_FOR:
+				case K_THROW:
+				case K_LOCK:
+				case K_TRY:
+				case K_CATCH:
+				case K_FINALLY:
+				case K_RETURN:
+				case K_BREAK:
+				case K_CONTINUE:
+				case K_SWITCH:
+				case K_CASE:
+				case K_DEFAULT:
+					return KEYWORD;
+					
+				case K_VOID:
+				case K_ANY:
+				case K_BOOL:
+				case K_BYTE:
+				case K_SBYTE:
+				case K_SHORT:
+				case K_USHORT:
+				case K_INT:
+				case K_UINT:
+				case K_LONG:
+				case K_ULONG:
+				case K_FLOAT:
+				case K_DOUBLE:
+				case K_CHAR:
+				case K_STRING:
+					return TYPE;
+				case INVALID:
+					return INVALID;
+				default:
+					return OPERATOR;
+			}
+		}
+	}
+	
+	public class CursorPosition {
+		public final int line;
+		public final int offset;
+		
+		public CursorPosition(int line, int offset) {
+			this.line = line;
+			this.offset = offset;
+		}
+		
+		public int getX() {
+			return offsetToX(line, offset);
+		}
+		
+		public int getY() {
+			return lineToY(line);
+		}
+		
+		public boolean equals(CursorPosition other) {
+			return line == other.line && offset == other.offset;
+		}
+	}
+}

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

@@ -0,0 +1,33 @@
+/*
+ * 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.view.editor;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SourceEditorStyle {
+	public static final SourceEditorStyle DEFAULT = new SourceEditorStyle(3, 0xFFE9EFF8, 0xFFB0C5E3, 2, 2);
+	
+	public final int extraLineSpacing;
+	public final int currentLineHighlight;
+	public final int selectionColor;
+	public final int selectionPaddingTop;
+	public final int selectionPaddingBottom;
+	
+	public SourceEditorStyle(
+			int extraLineSpacing,
+			int currentLineHighlight,
+			int selectionColor,
+			int selectionPaddingTop,
+			int selectionPaddingBottom) {
+		this.extraLineSpacing = extraLineSpacing;
+		this.currentLineHighlight = currentLineHighlight;
+		this.selectionColor = selectionColor;
+		this.selectionPaddingTop = selectionPaddingTop;
+		this.selectionPaddingBottom = selectionPaddingBottom;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/TokenReparser.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.zenscript.ide.ui.view.editor;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.lexer.CharReader;
+import org.openzen.zenscript.lexer.TokenParser;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TokenReparser {
+	private final List<SourceEditor.Line> lines;
+	private final String filename;
+	private final int toLine;
+	private final int toToken;
+	private final int spacesPerTab;
+	
+	private int lineIndex;
+	private int token;
+	
+	public TokenReparser(String filename, List<SourceEditor.Line> lines, int fromLine, int fromToken, int toLine, int toToken, int spacesPerTab) {
+		if (fromToken < 0 || toToken < 0)
+			throw new IllegalArgumentException("fromToken or toToken cannot be < 0");
+		
+		this.lines = lines;
+		this.filename = filename;
+		this.toLine = toLine;
+		this.toToken = toToken;
+		
+		this.lineIndex = fromLine;
+		this.token = fromToken;
+		this.spacesPerTab = spacesPerTab;
+	}
+	
+	public List<ZSToken> reparse() {
+		ReparseCharReader reader = new ReparseCharReader();
+		TokenParser<ZSToken, ZSTokenType> reparser = ZSTokenParser.createRaw(filename, reader, spacesPerTab);
+		List<ZSToken> result = new ArrayList<>();
+		while ((lineIndex < toLine || token < toToken || !reader.isAtTokenBoundary()) && reparser.hasNext())
+			result.add(reparser.next());
+		return result;
+	}
+	
+	private String get() {
+		SourceEditor.Line line = lines.get(lineIndex);
+		if (token == line.tokens.size())
+			return "\n"; // special "newline" token for transitions to next line
+		
+		return line.tokens.get(token).content;
+	}
+	
+	private boolean advance() {
+		if (lineIndex == lines.size() - 1 && token == lines.get(lineIndex).tokens.size())
+			return false;
+		
+		token++;
+		if (token > lines.get(lineIndex).tokens.size()) {
+			lineIndex++;
+			token = 0;
+		}
+		return true;
+	}
+	
+	public int getLine() {
+		return lineIndex;
+	}
+	
+	public int getToken() {
+		return token;
+	}
+	
+	private class ReparseCharReader implements CharReader {
+		private String token;
+		private int tokenOffset;
+		
+		public ReparseCharReader() {
+			token = get();
+		}
+		
+		public boolean isAtTokenBoundary() {
+			return tokenOffset == 0;
+		}
+
+		@Override
+		public int peek() throws IOException {
+			return token == null ? -1 : token.charAt(tokenOffset);
+		}
+
+		@Override
+		public int next() throws IOException {
+			int result = peek();
+			tokenOffset++;
+			if (tokenOffset == token.length()) {
+				advance();
+				token = get();
+				tokenOffset = 0;
+			}
+			return result;
+		}
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/LibraryTreeNode.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.ui.view.project;
+
+import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.LiveMappedList;
+import org.openzen.zenscript.ide.host.IDELibrary;
+import org.openzen.zenscript.ide.ui.IDEWindow;
+import org.openzen.zenscript.ide.ui.icons.ColorableLibraryIcon;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LibraryTreeNode extends ProjectOverviewNode {
+	private final IDELibrary library;
+	private final LiveList<ProjectOverviewNode> modules;
+	
+	public LibraryTreeNode(IDEWindow window, IDELibrary library) {
+		this.library = library;
+		
+		modules = new LiveMappedList<>(library.getModules(), module -> new ModuleTreeNode(window, module));
+	}
+	
+	@Override
+	public DColorableIcon getIcon() {
+		return ColorableLibraryIcon.INSTANCE;
+	}
+
+	@Override
+	public Kind getKind() {
+		return Kind.PROJECT;
+	}
+
+	@Override
+	public String getTitle() {
+		return library.getName();
+	}
+
+	@Override
+	public LiveList<ProjectOverviewNode> getChildren() {
+		return modules;
+	}
+
+	@Override
+	public boolean isLeaf() {
+		return false;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/ModuleTreeNode.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.zenscript.ide.ui.view.project;
+
+import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.zenscript.ide.host.IDEModule;
+import org.openzen.zenscript.ide.ui.IDEWindow;
+import org.openzen.zenscript.ide.ui.icons.ColorableModuleIcon;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ModuleTreeNode extends PackageTreeNode {
+	private final IDEModule module;
+	
+	public ModuleTreeNode(IDEWindow window, IDEModule module) {
+		super(window, module.getRootPackage());
+		this.module = module;
+	}
+
+	@Override
+	public Kind getKind() {
+		return Kind.MODULE;
+	}
+
+	@Override
+	public DColorableIcon getIcon() {
+		return ColorableModuleIcon.INSTANCE;
+	}
+
+	@Override
+	public String getTitle() {
+		return module.getName();
+	}
+
+	@Override
+	public boolean isLeaf() {
+		return false;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/PackageTreeNode.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.ui.view.project;
+
+import org.openzen.drawablegui.DColorableIcon;
+import org.openzen.drawablegui.live.LiveConcatList;
+import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.LiveMappedList;
+import org.openzen.zenscript.ide.host.IDEPackage;
+import org.openzen.zenscript.ide.ui.IDEWindow;
+import org.openzen.zenscript.ide.ui.icons.ColorableFolderIcon;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PackageTreeNode extends ProjectOverviewNode {
+	private final IDEPackage pkg;
+	private final LiveList<ProjectOverviewNode> contents;
+	
+	public PackageTreeNode(IDEWindow window, IDEPackage pkg) {
+		this.pkg = pkg;
+		
+		contents = new LiveConcatList<>(
+				new LiveMappedList<>(pkg.getSubPackages(), sub -> new PackageTreeNode(window, sub)),
+				new LiveMappedList<>(pkg.getSourceFiles(), source -> new SourceFileTreeNode(window, source))
+		);
+	}
+
+	@Override
+	public LiveList<ProjectOverviewNode> getChildren() {
+		return contents;
+	}
+
+	@Override
+	public Kind getKind() {
+		return Kind.PACKAGE;
+	}
+
+	@Override
+	public DColorableIcon getIcon() {
+		return ColorableFolderIcon.INSTANCE;
+	}
+
+	@Override
+	public String getTitle() {
+		return pkg.getName();
+	}
+
+	@Override
+	public boolean isLeaf() {
+		return false;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/project/ProjectOverviewNode.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.ide.ui.view.project;
+
+import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.live.LiveBool;
+import org.openzen.drawablegui.tree.DTreeNode;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class ProjectOverviewNode implements DTreeNode<ProjectOverviewNode> {
+	private final LiveBool collapsed = new LiveBool();
+	
+	public abstract Kind getKind();
+	
+	@Override
+	public LiveBool isCollapsed() {
+		return collapsed;
+	}
+	
+	public enum Kind {
+		ROOT,
+		PROJECT,
+		LIBRARY,
+		MODULE,
+		PACKAGE,
+		SCRIPT
+	}
+}