Added output view

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  */
 package org.openzen.drawablegui;
 
-import java.io.Closeable;
 import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.style.DStylePath;
  *
  * @author Hoofdgebruiker
  */
-public interface DComponent extends Closeable {
+public interface DComponent extends Destructible {
 	void mount(DStylePath parent, int z, DDrawSurface surface);
 	
 	void unmount();
 	default void onKeyPressed(DKeyEvent e) {}
 	
 	default void onKeyReleased(DKeyEvent e) {}
-	
-	@Override
-	void close();
 }

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

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

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

 		fontMetrics = surface.getFontMetrics(style.font);
 		calculateSize();
 		
+		if (text != null)
+			text.close();
 		text = surface.drawText(z + 1, style.font, style.textColor, 0, 0, tooltip.getValue());
 	}
 	

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

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

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

  */
 package org.openzen.drawablegui.draw;
 
-import java.io.Closeable;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.Destructible;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public interface DDrawnElement extends Closeable {
+public interface DDrawnElement extends Destructible {
 	void setTransform(DTransform2D transform);
 	
 	DIRectangle getBounds();
-	
-	@Override
-	public void close();
 }

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

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

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

  */
 package org.openzen.drawablegui.live;
 
-import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.listeners.ListenerList;
 
  *
  * @author Hoofdgebruiker
  */
-public class LiveMappedList<T, U> implements Closeable, LiveList<U> {
+public class LiveMappedList<T, U> implements Destructible, LiveList<U> {
 	private final ListenerList<Listener<U>> listeners = new ListenerList<>();
 	private final Function<T, U> projection;
 	private final List<U> mapped;

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

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

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

 import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DSubSurface;
-import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.drawablegui.style.DStyleSheets;
 	private final LiveInt offsetX;
 	private final LiveInt offsetY;
 	
-	private final LiveInt preferredHeight;
+	private final LiveObject<DSizing> sizing;
-	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private final ListenerHandle<LiveInt.Listener> contentsHeightListener;
 	private final ListenerHandle<LiveInt.Listener> offsetXListener;
 	private final ListenerHandle<LiveInt.Listener> offsetYListener;
-	private final ListenerHandle<LiveInt.Listener> preferredHeightListener;
 	private final ListenerHandle<LiveObject.Listener<DSizing>> contentsSizingListener;
 	
 	private DComponent hovering = null;
 	
 	private DSubSurface subSurface;
 	
-	public DScrollPane(DStyleClass styleClass, DComponent contents, LiveInt preferredHeight) {
+	public DScrollPane(DStyleClass styleClass, DComponent contents, LiveObject<DSizing> sizing) {
+		this.sizing = sizing;
 		this.styleClass = styleClass;
 		this.contents = contents;
-		this.preferredHeight = preferredHeight;
 		
 		contentsHeight = new SimpleLiveInt(0);
 		offsetX = new SimpleLiveInt(0);
 		offsetXListener = offsetX.addListener(new ScrollListener());
 		offsetYListener = offsetY.addListener(new ScrollListener());
 		
-		contents.getSizing().addListener((oldPreferences, newPreferences) -> {
+		contentsSizingListener = contents.getSizing().addListener((oldPreferences, newPreferences) -> {
 			if (bounds == null)
 				return;
 			
 			contents.setBounds(new DIRectangle(0, 0, bounds.width, Math.max(bounds.height, newPreferences.preferredHeight)));
 			contentsHeight.setValue(newPreferences.preferredHeight);
 		});
-		preferredHeightListener = preferredHeight.addListener((oldValue, newValue) -> {
-			sizing.setValue(new DSizing(contents.getSizing().getValue().preferredWidth, newValue));
-		});
-		contentsSizingListener = contents.getSizing().addListener((oldValue, newValue) -> {
-			sizing.setValue(new DSizing(newValue.preferredWidth, preferredHeight.getValue()));
-		});
 	}
 	
 	@Override
 	@Override
 	public void mount(DStylePath parent, int z, DDrawSurface surface) {
 		this.surface = surface;
+		this.z = z;
 		
 		DStylePath path = parent.getChild("scrollpane", styleClass);
 		subSurface = surface.createSubSurface(z + 1);
-		contents.mount(path, 0, subSurface);
+		contents.mount(path, 1, subSurface);
 		scrollBar.mount(path, z + 2, surface);
 		style = new DScrollPaneStyle(surface.getStylesheet(path));
 	}
 		shape = surface.shadowPath(z, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		style.border.update(surface, z + 1, style.margin.apply(bounds));
 		
-		int height = Math.max(bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom(),
+		int height = Math.max(
+				bounds.height - style.border.getPaddingHorizontal(),
 				contents.getSizing().getValue().preferredHeight);
 		int scrollBarWidth = scrollBar.getSizing().getValue().preferredWidth;
 		scrollBar.setBounds(new DIRectangle(
 		
 		subSurface.setOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
 		subSurface.setClip(new DIRectangle(
-				bounds.x + style.border.getPaddingLeft(),
+				bounds.x + style.margin.left + style.border.getPaddingLeft(),
-				bounds.y + style.border.getPaddingTop(),
+				bounds.y + style.margin.top + style.border.getPaddingTop(),
-				bounds.width - style.border.getPaddingLeft() - style.border.getPaddingTop(),
+				bounds.width - style.margin.getHorizontal() - style.border.getPaddingHorizontal(),
-				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom()));
+				bounds.height - style.margin.getVertical() - style.border.getPaddingVertical()));
 	}
 	
 	@Override
 	public void close() {
 		contents.close();
 		unmount();
+		
+		contentsSizingListener.close();
+		contentsHeightListener.close();
+		offsetXListener.close();
+		offsetYListener.close();
 	}
 	
 	private DMouseEvent forward(DComponent target, DMouseEvent e) {
 		return y - bounds.y + offsetY.getValue();
 	}
 	
-	private class TranslatedContext implements DUIContext {
-		private final DUIContext context;
-		
-		public TranslatedContext(DUIContext context) {
-			this.context = context;
-		}
-		
-		@Override
-		public DStyleSheets getStylesheets(){
-			return context.getStylesheets();
-		}
-
-		@Override
-		public float getScale() {
-			return context.getScale();
-		}
-		
-		@Override
-		public float getTextScale() {
-			return context.getTextScale();
-		}
-
-		@Override
-		public void repaint(int x, int y, int width, int height) {
-			int left = toGlobalX(x);
-			int top = toGlobalY(y);
-			int right = left + width;
-			int bottom = top + height;
-			
-			left = Math.max(bounds.x, left);
-			top = Math.max(bounds.y, top);
-			right = Math.min(bounds.x + bounds.width, right);
-			bottom = Math.min(bounds.y + bounds.height, bottom);
-			
-			if (left >= right || top >= bottom)
-				return;
-			
-			context.repaint(left, top, right - left, bottom - top);
-		}
-
-		@Override
-		public void setCursor(Cursor cursor) {
-			context.setCursor(cursor);
-		}
-
-		@Override
-		public DFontMetrics getFontMetrics(DFont font) {
-			return context.getFontMetrics(font);
-		}
-
-		@Override
-		public void scrollInView(int x, int y, int width, int height) {
-			if (y < offsetY.getValue())
-				offsetY.setValue(y);
-			if (y + height > offsetY.getValue() + bounds.height)
-				offsetY.setValue(y + height - bounds.height);
-		}
-
-		@Override
-		public DTimerHandle setTimer(int millis, Runnable target) {
-			return context.setTimer(millis, target);
-		}
-
-		@Override
-		public DClipboard getClipboard() {
-			return context.getClipboard();
-		}
-
-		@Override
-		public DUIWindow getWindow() {
-			return context.getWindow();
-		}
-
-		@Override
-		public DUIWindow openDialog(int x, int y, DAnchor anchor, String title, DComponent root) {
-			return context.openDialog(toGlobalX(x), toGlobalY(y), anchor, title, root);
-		}
-
-		@Override
-		public DUIWindow openView(int x, int y, DAnchor anchor, DComponent root) {
-			return context.openView(toGlobalX(x), toGlobalY(y), anchor, root);
-		}
-	}
-	
 	private class ScrollListener implements LiveInt.Listener {
 
 		@Override

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

 		
 		AffineTransform oldTransform = g.getTransform();
 		g.transform(AffineTransform.getTranslateInstance(surface.offsetX, surface.offsetY));
-		DIRectangle newClip = this.clip == null ? clip : clip.offset(-surface.offsetX, -surface.offsetY).intersect(this.clip.offset(-surface.offsetX, -surface.offsetY));
+		
-		surface.paint(g, newClip);
+		DIRectangle intersection = this.clip == null ? clip : this.clip.intersect(clip);
+		surface.paint(g, intersection.offset(-surface.offsetX, -surface.offsetY));
 		g.setTransform(oldTransform);
 		g.setClip(clipBounds.x, clipBounds.y, clipBounds.width, clipBounds.height);
 	}
 	
 	@Override
 	public DIRectangle getBounds() {
-		return surface.calculateBounds();
+		return clip == null ? surface.calculateBounds().offset(surface.offsetX, surface.offsetY) : clip;
 	}
 
 	@Override

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

  */
 package org.openzen.drawablegui.tree;
 
-import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.drawablegui.DColorableIconInstance;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DDrawableInstance;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	}
 
 	@Override
-	public MutableLiveObject<DSizing> getSizing() {
+	public LiveObject<DSizing> getSizing() {
 		return sizing;
 	}
 	
 		// nothing to clean up
 	}
 	
-	private class Row implements Closeable, LiveBool.Listener, LiveList.Listener<N> {
+	private class Row implements Destructible, LiveBool.Listener, LiveList.Listener<N> {
 		private final int x;
 		private final int index;
 		private final N node;

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

 		Arguments arguments = new Arguments(args);
 		File directory = arguments.projectDirectory;
 		
-		CompilationUnit compilationUnit = new CompilationUnit();
+		Project project = new Project(directory);
-		ModuleLoader loader = new ModuleLoader(compilationUnit);
-		Project project = new Project(loader, directory);
-		
 		DevelopmentHost host = new LocalProjectDevelopmentHost(project);
 		open(host);
     }

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

  */
 package org.openzen.zenscript.ide.host;
 
+import java.util.function.Consumer;
+import org.openzen.zenscript.ide.ui.view.output.OutputLine;
+
 /**
  *
  * @author Hoofdgebruiker
 	
 	boolean canRun();
 	
-	void build();
+	void build(Consumer<OutputLine> output);
 	
-	void run();
+	void run(Consumer<OutputLine> output);
 }

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

 package org.openzen.zenscript.ide.host.local;
 
 import java.io.File;
-import java.io.IOException;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.function.Consumer;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
 import org.openzen.zenscript.constructor.Library;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.constructor.Project;
-import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.ide.host.IDETarget;
+import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
+import org.openzen.zenscript.ide.ui.view.output.OutputLine;
+import org.openzen.zenscript.validator.ValidationLogEntry;
+import stdlib.Strings;
 
 /**
  *
 	}
 
 	@Override
-	public void build() {
+	public void build(Consumer<OutputLine> output) {
-		buildInternal();
+		buildInternal(output);
 	}
 
 	@Override
-	public void run() {
+	public void run(Consumer<OutputLine> output) {
-		ZenCodeCompiler compiler = buildInternal();
+		ZenCodeCompiler compiler = buildInternal(output);
 		if (compiler != null)
 			compiler.run();
 	}
 	
-	private ZenCodeCompiler buildInternal() {
+	private ZenCodeCompiler buildInternal(Consumer<OutputLine> output) {
 		CompilationUnit compilationUnit = new CompilationUnit();
-		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit);
+		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit, exception -> output.accept(new OutputLine(new ErrorOutputSpan(exception.getMessage()))));
-		moduleLoader.register("stdlib", new DirectoryModuleLoader(moduleLoader, "stdlib", new File("../../StdLibs/stdlib"), true));
+		moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
 		Set<String> compiledModules = new HashSet<>();
 		
+		Consumer<ValidationLogEntry> validationLogger = entry -> {
+			String[] message = Strings.split(entry.message, '\n');
+			output.accept(new OutputLine(new ErrorOutputSpan(entry.kind + " " + entry.position.toString() + ": " + message[0])));
+			for (int i = 1; i < message.length; i++)
+				output.accept(new OutputLine(new ErrorOutputSpan("    " + message[i])));
+		};
 		try {
-			Project project = new Project(moduleLoader, this.project.directory);
 			for (Library library : project.libraries) {
 				for (ModuleReference module : library.modules)
 					moduleLoader.register(module.getName(), module);
 			
 			SemanticModule module = moduleLoader.getModule(target.getModule());
 			module = module.normalize();
-			module.validate();
+			module.validate(validationLogger);
 			
 			ZenCodeCompiler compiler = target.createCompiler(module);
 			if (!module.isValid())
 			
 			SemanticModule stdlib = moduleLoader.getModule("stdlib");
 			stdlib = stdlib.normalize();
-			stdlib.validate();
+			stdlib.validate(validationLogger);
 			if (!stdlib.isValid())
 				return compiler;
 			stdlib.compile(compiler);
 			compiledModules.add(stdlib.name);
 			
-			boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, module);
+			boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, module, validationLogger);
 			if (!isValid)
 				return compiler;
 			
 			module.compile(compiler);
 			compiler.finish();
 			return compiler;
-		} catch (IOException ex) {
+		} catch (Exception ex) {
 			ex.printStackTrace();
+			
+			for (String line : Strings.split(ex.toString(), '\n'))
+				output.accept(new OutputLine(new ErrorOutputSpan(line)));
+			for (StackTraceElement element : ex.getStackTrace()) {
+				String source;
+				if (element.isNativeMethod()) {
+					source = "(Native Method)";
+				} else {
+					source = "(" + element.getFileName() + ":" + element.getLineNumber() + ")";
+				}
+				output.accept(new OutputLine(new ErrorOutputSpan("    at " + element.getClassName() + "." + element.getMethodName() + source)));
+			}
+			
 			return null;
 		}
 	}
 	
-	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, SemanticModule module) {
+	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, SemanticModule module, Consumer<ValidationLogEntry> logger) {
 		for (String dependency : module.dependencies) {
 			if (compiledModules.contains(module.name))
 				continue;
 			
 			SemanticModule dependencyModule = loader.getModule(dependency);
 			module = module.normalize();
-			module.validate();
+			module.validate(logger);
 			if (!module.isValid())
 				return false;
 			
-			if (!compileDependencies(loader, compiler, compiledModules, dependencyModule))
+			if (!compileDependencies(loader, compiler, compiledModules, dependencyModule, logger))
 				return false;
 			
 			module.compile(compiler);

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.ui;
+
+import org.openzen.drawablegui.style.DRoundedRectangleShape;
+import org.openzen.drawablegui.style.DShadow;
+import org.openzen.drawablegui.style.DShadowElement;
+import org.openzen.drawablegui.style.DShapeElement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDEStyling {
+	public static final DShadowElement BLOCK_SHADOW = context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale());
+	public static final DShapeElement BLOCK_SHAPE = context -> new DRoundedRectangleShape(context.dp(2));
+	public static final int ERROR_RED = 0xFFE81123;
+}

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

 package org.openzen.zenscript.ide.ui;
 
 import org.openzen.drawablegui.live.ImmutableLiveString;
+import org.openzen.drawablegui.live.LiveArrayList;
+import org.openzen.drawablegui.live.MutableLiveList;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 import org.openzen.zenscript.ide.ui.icons.SettingsIcon;
 import org.openzen.zenscript.ide.ui.icons.ShadedProjectIcon;
 import org.openzen.zenscript.ide.ui.view.IconButtonControl;
+import org.openzen.zenscript.ide.ui.view.output.OutputLine;
 
 /**
  *
 	public final IDEAspectBar aspectBar;
 	public final IDEDockWindow dockWindow;
 	public final IDEStatusBar statusBar;
+	public final MutableLiveList<OutputLine> output = new LiveArrayList<>();
 	
 	public IDEAspectToolbar projectToolbar;
 	
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, BuildIcon.BLUE, new ImmutableLiveString("Build"), e -> {
 			for (IDETarget target : host.getTargets()) {
 				if (target.canBuild())
-					target.build();
+					target.build(line -> output.add(line));
 			}
 		}));
 		projectToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, PlayIcon.GREEN, new ImmutableLiveString("Run"), e -> {
 			for (IDETarget target : host.getTargets()) {
 				if (target.canRun())
-					target.run();
+					target.run(line -> output.add(line));
 			}
 		}));
 		aspectBar.toolbars.add(projectToolbar);

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

 		drawnIcon = new DColorableIconInstance(surface, z + 1, icon, DTransform2D.translate(
 				bounds.x + (bounds.width - icon.getNominalWidth()) / 2,
 				bounds.y + (bounds.height - icon.getNominalHeight()) / 2), 0xFF000000);
-		/*drawnIcon.setTransform(DTransform2D.translate(
-				bounds.x + (bounds.width - icon.getNominalWidth()) / 2,
-				bounds.y + (bounds.height - icon.getNominalHeight()) / 2));*/
 	}
 
 	@Override

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

 package org.openzen.zenscript.ide.ui.view;
 
 import org.openzen.drawablegui.DEmptyView;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.border.DLineBorder;
 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.layout.DSideLayout;
+import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.MutableLiveList;
 import org.openzen.drawablegui.live.SimpleLiveInt;
+import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveString;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.view.aspectbar.AspectBarView;
 import org.openzen.zenscript.ide.ui.view.editor.SourceEditor;
+import org.openzen.zenscript.ide.ui.view.output.OutputLine;
+import org.openzen.zenscript.ide.ui.view.output.OutputView;
 import org.openzen.zenscript.ide.ui.view.project.ProjectBrowser;
 
 /**
 		
 		projectBrowser = new ProjectBrowser(window, host);
 		
+		OutputView output = new OutputView(DStyleClass.EMPTY, window.output);
+		
+		DScrollPane scrollOutput = new DScrollPane(DStyleClass.inline(new DStylesheetBuilder()
+							//.border("border", context -> new DLineBorder(0xFF888888, 1))
+							.marginDp("margin", 3)
+							.color("backgroundColor", 0xFFFFFFFF)
+							.shadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()))
+							.build()), output, new SimpleLiveObject<>(new DSizing(400, 400)));
+		
 		setMain(tabs = new TabbedView(DStyleClass.inline(new DStylesheetBuilder()
 				.marginDp("margin", 3)
 				.build())));
+		add(Side.BOTTOM, scrollOutput);
 		add(Side.LEFT, projectBrowser.view);
 		add(Side.BOTTOM, new StatusBarView(DStyleClass.EMPTY, status));
 		add(Side.TOP, new AspectBarView(DStyleClass.EMPTY, window.aspectBar));
 					new DScrollPane(DStyleClass.inline(new DStylesheetBuilder()
 							.border("border", context -> new DLineBorder(0xFF888888, 1))
 							//.shadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()))
-							.build()), editor, new SimpleLiveInt(0)),
+							.build()), editor, new SimpleLiveObject<>(new DSizing(500, 500))),
 					editor.isUpdated());
 			tabs.tabs.add(tab);
 			tabs.currentTab.setValue(tab);

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

 	public String toString() {
 		return value;
 	}
+
+	@Override
+	public String getText() {
+		return value;
+	}
+
+	@Override
+	public int getColor() {
+		return 0xFF000000;
+	}
 }

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

  */
 package org.openzen.zenscript.ide.ui.view.output;
 
+import org.openzen.zenscript.ide.ui.IDEStyling;
+
 /**
  *
  * @author Hoofdgebruiker
 	public String toString() {
 		return value;
 	}
+
+	@Override
+	public String getText() {
+		return value;
+	}
+
+	@Override
+	public int getColor() {
+		return IDEStyling.ERROR_RED;
+	}
 }

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

 public class OutputLine {
 	public final OutputSpan[] spans;
 	
+	public OutputLine(String line) {
+		spans = new OutputSpan[] { new BasicOutputSpan(line) };
+	}
+	
+	public OutputLine(OutputSpan span) {
+		spans = new OutputSpan[] { span };
+	}
+	
 	public OutputLine(OutputSpan[] spans) {
 		this.spans = spans;
 	}

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

  * @author Hoofdgebruiker
  */
 public interface OutputSpan {
+	public String getText();
 	
+	public int getColor();
 }

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

  */
 package org.openzen.zenscript.ide.ui.view.output;
 
+import java.util.ArrayList;
+import java.util.List;
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnShape;
+import org.openzen.drawablegui.draw.DDrawnText;
+import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private int z;
 	private DIRectangle bounds;
 	private OutputViewStyle style;
+	private DFontMetrics fontMetrics;
+	private ListenerHandle<LiveList.Listener<OutputLine>> linesListener;
 	
 	private DDrawnShape shape;
+	private final List<List<DDrawnText>> outputText = new ArrayList<>();
 	
 	public OutputView(DStyleClass styleClass, LiveList<OutputLine> lines) {
 		this.styleClass = styleClass;
 
 	@Override
 	public void mount(DStylePath parent, int z, DDrawSurface surface) {
+		if (this.surface != null)
+			unmount();
+		
 		this.surface = surface;
 		this.z = z;
 		
 		DStylePath path = parent.getChild("outputview", styleClass);
 		style = new OutputViewStyle(surface.getStylesheet(path));
+		fontMetrics = surface.getFontMetrics(style.font);
+		
+		for (OutputLine line : lines)
+			outputText.add(draw(line));
+		
+		linesListener = lines.addListener(new LinesListener());
+		updateSizing();
 	}
 	
 	@Override
 	public void unmount() {
+		surface = null;
+		
 		if (shape != null) {
 			shape.close();
 			shape = null;
 		}
+		
+		for (List<DDrawnText> line : outputText)
+			Destructible.close(line);
+		
+		outputText.clear();
+		linesListener.close();
 	}
 
 	@Override
-	public MutableLiveObject<DSizing> getSizing() {
+	public LiveObject<DSizing> getSizing() {
 		return sizing;
 	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		shape = surface.shadowPath(z, style.shape.instance(bounds), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		
+		DIRectangle available = style.margin.apply(bounds);
+		shape = surface.shadowPath(z, style.shape.instance(available), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		
+		layout(0);
 	}
 
 	@Override
 	public void close() {
 		unmount();
 	}
+	
+	private void updateSizing() {
+		sizing.setValue(new DSizing(100, lines.size() * fontMetrics.getLineHeight() + style.margin.getVertical() + style.border.getPaddingVertical()));
+	}
+	
+	private List<DDrawnText> draw(OutputLine line) {
+		List<DDrawnText> lineText = new ArrayList<>();
+		for (OutputSpan span : line.spans)
+			lineText.add(surface.drawText(z + 1, style.font, span.getColor(), 0, 0, span.getText()));
+		return lineText;
+	}
+	
+	private void layout(int fromIndex) {
+		for (int i = fromIndex; i < outputText.size(); i++)
+			layout(i, outputText.get(i));
+	}
+	
+	private void layout(int index, List<DDrawnText> line) {
+		int x = bounds.x + style.margin.left + style.border.getPaddingTop();
+		int y = bounds.y + style.margin.top + style.border.getPaddingTop() + index * fontMetrics.getLineHeight() + fontMetrics.getAscent();
+		for (DDrawnText text : line) {
+			text.setPosition(x, y);
+			x += text.getBounds().width;
+		}
+	}
+	
+	private class LinesListener implements LiveList.Listener<OutputLine> {
+		@Override
+		public void onInserted(int index, OutputLine value) {
+			outputText.add(index, draw(value));
+			layout(index);
+			updateSizing();
+		}
+
+		@Override
+		public void onChanged(int index, OutputLine oldValue, OutputLine newValue) {
+			List<DDrawnText> line = draw(newValue);
+			layout(index, line);
+			Destructible.close(outputText.set(index, line));
+		}
+
+		@Override
+		public void onRemoved(int index, OutputLine oldValue) {
+			Destructible.close(outputText.remove(index));
+			updateSizing();
+		}
+	}
 }

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

 
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
-import org.openzen.drawablegui.border.DBorder;
 import org.openzen.drawablegui.border.DPaddedBorder;
-import org.openzen.drawablegui.style.DRoundedRectangleShape;
+import org.openzen.drawablegui.style.DBaseStyle;
-import org.openzen.drawablegui.style.DShadow;
-import org.openzen.drawablegui.style.DShape;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class OutputViewStyle {
+public class OutputViewStyle extends DBaseStyle {
-	public final int backgroundColor;
-	public final DBorder border;
-	public final DShadow shadow;
-	public final DShape shape;
 	public final DFont font;
 	
 	public OutputViewStyle(DStyleDefinition style) {
-		backgroundColor = style.getColor("backgroundColor", 0xFFFFFFFF);
+		super(style, context -> new DPaddedBorder(context.dp(8)), 0);
-		border = style.getBorder("border", context -> new DPaddedBorder(context.dp(8)));
+		
-		shadow = style.getShadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));
-		shape = style.getShape("shape", context -> new DRoundedRectangleShape(context.dp(2)));
 		font = style.getFont("font", context -> new DFont(DFontFamily.CODE, false, false, false, context.sp(14)));
 	}
 }

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

 package org.openzen.zenscript.ide.ui.view.project;
 
 import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DFont;
+import org.openzen.drawablegui.DFontFamily;
+import org.openzen.drawablegui.DLabel;
 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.border.DEmptyBorder;
 import org.openzen.drawablegui.border.DPaddedBorder;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LivePredicateBool;
 import org.openzen.drawablegui.live.MutableLiveObject;
-import org.openzen.drawablegui.live.SimpleLiveInt;
 import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.SimpleLiveString;
 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.style.DRoundedRectangleShape;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStylesheetBuilder;
 import org.openzen.drawablegui.tree.CollapsedArrow;
 import org.openzen.drawablegui.tree.DTreeView;
-import org.openzen.drawablegui.tree.DTreeViewStyle;
 import org.openzen.drawablegui.tree.ExpandedArrow;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDEModule;
 				.dimensionDp("padding", 0)
 				.build());
 		
+		DLabel label = new DLabel(
+				DStyleClass.inline(new DStylesheetBuilder()
+						.font("font", context -> new DFont(DFontFamily.UI, false, false, false, context.sp(14)))
+						.color("color", 0xFF888888)
+						.build()),
+				new SimpleLiveString("Project Browser"));
 		IconButtonControl addPackageButton = new IconButtonControl(
 				minimalButtonPadding,
 				AddBoxIcon.BLUE,
 						.build()),
 				Orientation.HORIZONTAL,
 				Alignment.LEFT,
+				new Element(label, 1, 1, ElementAlignment.CENTER),
 				new Element(addPackageButton, 0, 0, ElementAlignment.TOP),
 				new Element(addFileButton, 0, 0, ElementAlignment.TOP));
 		DTreeView projectTree = new DTreeView(
 				ExpandedArrow.INSTANCE,
 				CollapsedArrow.INSTANCE,
 				new RootTreeNode(this, host), false);
-		projectTree.getSizing().setValue(new DSizing(500, 500));
 		DScrollPane treeScrollPane = new DScrollPane(
 				DStyleClass.inline("projectView", new DStylesheetBuilder()
 						.shape("shape", context -> new DRoundedRectangleShape(0, 0, context.dp(2), context.dp(2)))
 						.shadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()))
 						.build()),
 				projectTree,
-				new SimpleLiveInt(0));
+				new SimpleLiveObject<>(new DSizing(500, 500)));
 		
 		view = new DLinearLayout(
 				DStyleClass.inline(new DStylesheetBuilder()

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 				Collections.emptyList());
 		
 		result = result.normalize();
-		result.validate();
+		result.validate(entry -> {
+			System.out.println(entry.kind + " " + entry.position.toString() + ": " + entry.message);
+		});
 		return result;
 	}