- Refactored horizontal and vertical layout in linear layout

- Added shape styling
- Minor code improvements and refactorings

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

 		};
 	}
 	
+	public static DPath roundedRectangle(float x, float y, float width, float height, float radiusTopLeft, float radiusTopRight, float radiusBottomLeft, float radiusBottomRight) {
+		return tracer -> {
+			float cTopLeft = radiusTopLeft - radiusTopLeft * 0.551915024494f;
+			float cTopRight = radiusTopRight - radiusTopRight * 0.551915024494f;
+			float cBottomLeft = radiusBottomLeft - radiusBottomLeft * 0.551915024494f;
+			float cBottomRight = radiusBottomRight - radiusBottomRight * 0.551915024494f;
+			
+			tracer.moveTo(x + width - radiusBottomRight, y + height);
+			if (radiusBottomRight > 0.01f) {
+				tracer.bezierCubic(
+						x + width - cBottomRight, y + height,
+						x + width, y + height - cBottomRight,
+						x + width, y + height - radiusBottomRight);
+			}
+			tracer.lineTo(x + width, y + radiusTopRight);
+			if (radiusTopRight > 0.01f) {
+				tracer.bezierCubic(
+						x + width, y + cTopRight,
+						x + width - cTopRight, y,
+						x + width - radiusTopRight, y);
+			}
+			tracer.lineTo(x + radiusTopLeft, y);
+			if (radiusTopLeft > 0.01f) {
+				tracer.bezierCubic(
+						x + cTopLeft, y,
+						x, y + cTopLeft,
+						x, y + radiusTopLeft);
+			}
+			tracer.lineTo(x, y + height - radiusBottomLeft);
+			if (radiusBottomLeft > 0.01f) {
+				tracer.bezierCubic(
+						x, y + height - cBottomLeft,
+						x + cBottomLeft, y + height,
+						x + radiusBottomLeft, y + height);
+			}
+			tracer.close();
+		};
+	}
+	
 	void trace(DPathTracer tracer);
 }

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

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

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

  *
  * @author Hoofdgebruiker
  */
-public class DVerticalLayout extends BaseComponentGroup {
+public class DLinearLayout extends BaseComponentGroup {
 	private final DStyleClass styleClass;
+	private final Orientation orientation;
 	private final Alignment alignment;
 	private final Element[] components;
 	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DUIContext context;
-	private DVerticalLayoutStyle style;
+	private DLinearLayoutStyle style;
 	private DIRectangle bounds;
 	private float totalGrow;
 	private float totalShrink;
 	private DPath shape;
 	
-	public DVerticalLayout(DStyleClass styleClass, Alignment alignment, Element... components) {
+	public DLinearLayout(DStyleClass styleClass, Orientation orientation, Alignment alignment, Element... components) {
 		this.styleClass = styleClass;
+		this.orientation = orientation;
 		this.alignment = alignment;
 		this.components = components;
 		
 		totalShrink = 0;
 		
 		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateDimensionPreferences());
+			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateSizing());
 			
 			totalGrow += components[i].grow;
 			totalShrink += components[i].shrink;
 		this.context = context;
 		
 		DStylePath path = parent.getChild("verticalLayout", styleClass);
-		style = new DVerticalLayoutStyle(context.getStylesheets().get(context, path));
+		style = new DLinearLayoutStyle(context.getStylesheets().get(context, path));
 		
 		for (Element element : components)
 			element.component.setContext(parent, context);
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		shape = DPath.roundedRectangle(
-				bounds.x + style.margin.left,
-				bounds.y + style.margin.top,
-				bounds.width - style.margin.getHorizontal(),
-				bounds.height - style.margin.getVertical(),
-				style.cornerRadius);
+		shape = style.shape.instance(style.margin.apply(bounds));
 		layout();
 	}
 
 	@Override
 	public void paint(DCanvas canvas) {
 		canvas.shadowPath(shape, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		style.border.paint(canvas, bounds);
 		for (Element element : components) {
 			element.component.paint(canvas);
 		}
 		}
 	}
 	
-	public static enum Alignment {
-		TOP(0),
-		MIDDLE(0.5f),
-		BOTTOM(1);
-		
-		public final float align;
-		
-		Alignment(float align) {
-			this.align = align;
-		}
+	private int getInnerWidth() {
+		return bounds.width - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
 	}
 	
-	public static enum ElementAlignment {
-		LEFT,
-		CENTER,
-		RIGHT,
-		STRETCH
+	private int getInnerHeight() {
+		return bounds.height - style.margin.getVertical() - style.border.getPaddingVertical();
 	}
 	
-	public static class Element {
-		public final DComponent component;
-		public final float grow;
-		public final float shrink;
-		public final ElementAlignment alignment;
-		
-		public Element(DComponent component, float grow, float shrink, ElementAlignment alignment) {
-			this.component = component;
-			this.grow = grow;
-			this.shrink = shrink;
-			this.alignment = alignment;
-		}
+	private int getPreferredInnerWidth() {
+		DSizing myPreferences = sizing.getValue();
+		return myPreferences.preferredWidth - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
+	}
+	
+	private int getPreferredInnerHeight() {
+		DSizing myPreferences = sizing.getValue();
+		return myPreferences.preferredHeight - style.margin.getVertical() - style.border.getPaddingVertical();
 	}
 	
 	private void layout() {
+		if (orientation == Orientation.HORIZONTAL) {
+			layoutHorizontal();
+		} else {
+			layoutVertical();
+		}
+	}
+	
+	private void layoutHorizontal() {
 		if (bounds == null || context == null)
 			return;
 		
 		DSizing myPreferences = sizing.getValue();
-		if (bounds.height < myPreferences.preferredHeight) {
-			layoutShrinked();
+		if (bounds.width < myPreferences.preferredWidth) {
+			layoutHorizontalShrinked();
 		} else {
-			layoutGrown();
+			layoutHorizontalGrown();
 		}
 	}
 	
-	private int getInnerWidth() {
-		return bounds.width - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
-	}
-	
-	private int getInnerHeight() {
-		return bounds.height - style.margin.getVertical() - style.border.getPaddingVertical();
-	}
-	
-	private int getPreferredInnerWidth() {
+	private void layoutVertical() {
+		if (bounds == null || context == null)
+			return;
+		
 		DSizing myPreferences = sizing.getValue();
-		return myPreferences.preferredWidth - style.margin.getHorizontal() - style.border.getPaddingHorizontal();
+		if (bounds.height < myPreferences.preferredHeight) {
+			layoutVerticalShrinked();
+		} else {
+			layoutVerticalGrown();
+		}
 	}
 	
-	private int getPreferredInnerHeight() {
-		DSizing myPreferences = sizing.getValue();
-		return myPreferences.preferredHeight - style.margin.getVertical() - style.border.getPaddingVertical();
+	private void layoutHorizontalShrinked() {
+		float availableWidth = getInnerWidth() - (components.length - 1) * style.spacing;
+		float preferredInnerWidth = getPreferredInnerWidth() - (components.length - 1) * style.spacing;
+		
+		if (totalShrink == 0) {
+			// now what?
+			// shrink proportionally, we have to shrink...
+			float scale = availableWidth / preferredInnerWidth;
+			int x = bounds.x + style.margin.left + style.border.getPaddingLeft();
+			
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				int newX = (int)(x + preferences.preferredWidth * scale + 0.5f);
+				layoutHorizontal(element, bounds.x + x, newX - x);
+				x = newX + style.spacing;
+			}
+		} else {
+			int delta = getInnerHeight() - getPreferredInnerHeight();
+			float deltaScaled = delta / totalShrink;
+			int y = bounds.y;
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
+				float idealUnspacedY = y + scaledSize;
+				int newX = (int)(idealUnspacedY + 0.5f);
+				layoutHorizontal(element, y, newX - y);
+				y = newX + style.spacing;
+			}
+		}
 	}
 	
-	private void layoutShrinked() {
+	private void layoutVerticalShrinked() {
+		float availableHeight = getInnerHeight() - (components.length - 1) * style.spacing;
+		float preferredInnerHeight = getPreferredInnerHeight() - (components.length - 1) * style.spacing;
+		
 		if (totalShrink == 0) {
 			// now what?
 			// shrink proportionally, we have to shrink...
-			float availableHeight = getInnerHeight() - (components.length - 1) * style.spacing;
-			float scale = (float)(availableHeight) / (getPreferredInnerHeight() - (components.length - 1) * style.spacing);
+			float scale = availableHeight / preferredInnerHeight;
 			int y = bounds.y + style.margin.top + style.border.getPaddingTop();
 			
 			for (int i = 0; i < components.length; i++) {
 				Element element = components[i];
 				DSizing preferences = element.component.getSizing().getValue();
-				int newY = y + preferences.preferredHeight;
-				float idealUnspacedY = newY * scale;
-				int idealY = (int)(idealUnspacedY + 0.5f + i * style.spacing);
-				layout(element, bounds.y + y, idealY - y);
-				y = idealY;
+				int newY = (int)(y + preferences.preferredHeight * scale + 0.5f);
+				layoutVertical(element, bounds.y + y, newY - y);
+				y = newY + style.spacing;
 			}
 		} else {
 			int delta = getInnerHeight() - getPreferredInnerHeight();
 				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
 				float idealUnspacedY = y + scaledSize;
 				int newY = (int)(idealUnspacedY + 0.5f);
-				layout(element, y, newY - y);
+				layoutVertical(element, y, newY - y);
 				y = newY + style.spacing;
 			}
 		}
 	}
 	
-	private void layoutGrown() {
+	private void layoutHorizontalGrown() {
 		// resize according to grow values
+		int delta = getPreferredInnerWidth() - getInnerWidth();
 		if (totalGrow == 0) {
-			int deltaY = getPreferredInnerHeight() - getInnerHeight();
-			int y = bounds.y + style.margin.top + style.border.getPaddingTop() + (int)(deltaY * alignment.align);
+			int x = bounds.x + style.margin.left + style.border.getPaddingLeft() + (int)(delta * alignment.align);
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				int newX = x + preferences.preferredWidth;
+				layoutHorizontal(element, x, newX - x);
+				x = newX;
+			}
+		} else {
+			float deltaScaled = delta / totalGrow;
+			int x = bounds.x + style.margin.left + style.border.getPaddingLeft();
+			for (Element element : components) {
+				DSizing preferences = element.component.getSizing().getValue();
+				float scaledSize = preferences.preferredWidth - deltaScaled * element.grow;
+				float idealUnspacedX = x + scaledSize;
+				int newX = (int)(idealUnspacedX + 0.5f);
+				layoutHorizontal(element, x, newX - x);
+				x = newX + style.spacing;
+			}
+		}
+	}
+	
+	private void layoutVerticalGrown() {
+		// resize according to grow values
+		int delta = getPreferredInnerHeight() - getInnerHeight();
+		if (totalGrow == 0) {
+			int y = bounds.y + style.margin.top + style.border.getPaddingTop() + (int)(delta * alignment.align);
 			for (Element element : components) {
 				DSizing preferences = element.component.getSizing().getValue();
 				int newY = y + preferences.preferredHeight;
-				layout(element, y, newY - y);
+				layoutVertical(element, y, newY - y);
 				y = newY;
 			}
 		} else {
-			int delta = getPreferredInnerHeight() - getInnerHeight();
 			float deltaScaled = delta / totalGrow;
 			int y = bounds.y + style.margin.top + style.border.getPaddingTop();
 			for (Element element : components) {
 				DSizing preferences = element.component.getSizing().getValue();
-				float scaledSize = preferences.preferredHeight + deltaScaled * element.grow;
+				float scaledSize = preferences.preferredHeight - deltaScaled * element.grow;
 				float idealUnspacedY = y + scaledSize;
 				int newY = (int)(idealUnspacedY + 0.5f);
-				layout(element, y, newY - y);
+				layoutVertical(element, y, newY - y);
 				y = newY + style.spacing;
 			}
 		}
 	}
 	
-	private void layout(Element element, int y, int height) {
+	private void layoutHorizontal(Element element, int x, int width) {
+		DSizing preferences = element.component.getSizing().getValue();
+		int height;
+		int y;
+		switch (element.alignment) {
+			case BOTTOM:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.border.getPaddingVertical());
+				y = bounds.y + style.border.getPaddingTop();
+				break;
+			case MIDDLE:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.border.getPaddingVertical());
+				y = bounds.y + style.border.getPaddingTop() + (bounds.height - style.border.getPaddingVertical() - height) / 2;
+				break;
+			case TOP:
+				height = Math.min(preferences.preferredHeight, bounds.height - style.border.getPaddingVertical());
+				y = bounds.y + bounds.height - style.border.getPaddingBottom() - height;
+				break;
+			case STRETCH:
+			default:
+				height = bounds.height - style.border.getPaddingVertical();
+				y = bounds.y + style.border.getPaddingTop();
+				break;
+		}
+		element.component.setBounds(new DIRectangle(x, y, width, height));
+	}
+	
+	private void layoutVertical(Element element, int y, int height) {
 		DSizing preferences = element.component.getSizing().getValue();
 		int x;
 		int width;
 		element.component.setBounds(new DIRectangle(x, y, width, height));
 	}
 	
-	private void updateDimensionPreferences() {
+	private void updateSizing() {
+		if (orientation == Orientation.HORIZONTAL) {
+			updateSizingHorizontal();
+		} else {
+			updateSizingVertical();
+		}
+	}
+	
+	private void updateSizingHorizontal() {
+		int preferredWidth = -style.spacing;
+		int preferredHeight = 0;
+		int minimumWidth = -style.spacing;
+		int minimumHeight = Integer.MAX_VALUE;
+		int maximumWidth = -style.spacing;
+		int maximumHeight = 0;
+		
+		for (Element element : components) {
+			DSizing preferences = element.component.getSizing().getValue();
+			preferredWidth += preferences.preferredWidth + style.spacing;
+			preferredHeight = Math.max(preferredHeight, preferences.preferredHeight);
+			
+			minimumWidth += preferences.minimumWidth + style.spacing;
+			minimumHeight = Math.max(minimumHeight, preferences.minimumHeight);
+			
+			maximumHeight += preferences.maximumWidth + style.spacing;
+			maximumWidth = Math.min(maximumHeight, preferences.maximumHeight);
+		}
+		
+		int paddingHorizontal = style.border.getPaddingHorizontal() + style.margin.getHorizontal();
+		int paddingVertical = style.border.getPaddingVertical() + style.margin.getVertical();
+		DSizing preferences = new DSizing(
+				minimumWidth + paddingHorizontal,
+				minimumHeight + paddingVertical,
+				preferredWidth + paddingHorizontal,
+				preferredHeight + paddingVertical,
+				maximumWidth + paddingHorizontal,
+				maximumHeight + paddingVertical);
+		sizing.setValue(preferences);
+	}
+	
+	private void updateSizingVertical() {
 		int preferredWidth = 0;
 		int preferredHeight = -style.spacing;
 		int minimumWidth = 0;
 			maximumHeight += preferences.maximumHeight + style.spacing;
 		}
 		
-		int paddingHorizontal = style.border.getPaddingHorizontal();
-		int paddingVertical = style.border.getPaddingVertical();
+		int paddingHorizontal = style.border.getPaddingHorizontal() + style.margin.getHorizontal();
+		int paddingVertical = style.border.getPaddingVertical() + style.margin.getVertical();
 		DSizing preferences = new DSizing(
 				minimumWidth + paddingHorizontal,
 				minimumHeight + paddingVertical,
 				maximumHeight + paddingVertical);
 		sizing.setValue(preferences);
 	}
+	
+	public static enum Orientation {
+		HORIZONTAL,
+		VERTICAL
+	}
+	
+	public static enum Alignment {
+		TOP(0),
+		LEFT(0),
+		MIDDLE(0.5f),
+		CENTER(0.5f),
+		BOTTOM(1),
+		RIGHT(1);
+		
+		public final float align;
+		
+		Alignment(float align) {
+			this.align = align;
+		}
+	}
+	
+	public static enum ElementAlignment {
+		LEFT,
+		CENTER,
+		RIGHT,
+		TOP,
+		MIDDLE,
+		BOTTOM,
+		STRETCH
+	}
+	
+	public static class Element {
+		public final DComponent component;
+		public final float grow;
+		public final float shrink;
+		public final ElementAlignment alignment;
+		
+		public Element(DComponent component, float grow, float shrink, ElementAlignment alignment) {
+			this.component = component;
+			this.grow = grow;
+			this.shrink = shrink;
+			this.alignment = alignment;
+		}
+	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/layout/DHorizontalLayoutStyle.java → DrawableGui/src/main/java/org/openzen/drawablegui/layout/DLinearLayoutStyle.java

  */
 package org.openzen.drawablegui.layout;
 
-import org.openzen.drawablegui.border.DBorder;
-import org.openzen.drawablegui.border.DPaddedBorder;
+import org.openzen.drawablegui.style.DBaseStyle;
 import org.openzen.drawablegui.style.DDpDimension;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
  *
  * @author Hoofdgebruiker
  */
-public class DHorizontalLayoutStyle {
+public class DLinearLayoutStyle extends DBaseStyle {
 	public final int spacing;
-	public final DBorder border;
-	public final int backgroundColor;
 	
-	public DHorizontalLayoutStyle(DStyleDefinition style) {
+	public DLinearLayoutStyle(DStyleDefinition style) {
+		super(style);
+		
 		spacing = style.getDimension("spacing", new DDpDimension(8));
-		border = style.getBorder("border", context -> new DPaddedBorder(context.dp(8)));
-		backgroundColor = style.getColor("backgroundColor", 0);
 	}
 }

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.layout;
-
-import org.openzen.drawablegui.border.DBorder;
-import org.openzen.drawablegui.border.DPaddedBorder;
-import org.openzen.drawablegui.style.DDpDimension;
-import org.openzen.drawablegui.style.DMargin;
-import org.openzen.drawablegui.style.DPxDimension;
-import org.openzen.drawablegui.style.DShadow;
-import org.openzen.drawablegui.style.DStyleDefinition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class DVerticalLayoutStyle {
-	public final int spacing;
-	public final DBorder border;
-	public final int backgroundColor;
-	public final DMargin margin;
-	public final int cornerRadius;
-	public final DShadow shadow;
-	
-	public DVerticalLayoutStyle(DStyleDefinition style) {
-		spacing = style.getDimension("spacing", new DDpDimension(8));
-		border = style.getBorder("border", context -> new DPaddedBorder(context.dp(8)));
-		backgroundColor = style.getColor("backgroundColor", 0);
-		margin = style.getMargin("margin", DMargin.EMPTY_ELEMENT);
-		cornerRadius = style.getDimension("cornerRadius", DPxDimension.ZERO);
-		shadow = style.getShadow("shadow", DShadow.NONE_ELEMENT);
-	}
-}

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

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

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

 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
+import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTimerHandle;
+import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveInt;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.SimpleLiveInt;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.drawablegui.style.DStyleSheets;
 	private DIRectangle bounds;
 	
 	private DScrollPaneStyle style;
+	private DPath shape;
 	private final LiveInt contentsHeight;
 	private final LiveInt offsetX;
 	private final LiveInt offsetY;
 	
+	private final LiveInt preferredHeight;
+	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;
 	
-	public DScrollPane(DStyleClass styleClass, DComponent contents) {
+	public DScrollPane(DStyleClass styleClass, DComponent contents, LiveInt preferredHeight) {
 		this.styleClass = styleClass;
 		this.contents = contents;
+		this.preferredHeight = preferredHeight;
 		
-		contentsHeight = new SimpleLiveInt();
-		offsetX = new SimpleLiveInt();
-		offsetY = new SimpleLiveInt();
+		contentsHeight = new SimpleLiveInt(0);
+		offsetX = new SimpleLiveInt(0);
+		offsetY = new SimpleLiveInt(0);
 		
 		scrollBar = new DScrollBar(DStyleClass.EMPTY, contentsHeight, offsetY);
 		
 			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
 		contents.setContext(path, new TranslatedContext());
 		scrollBar.setContext(path, context);
 		style = new DScrollPaneStyle(context.getStylesheets().get(context, path));
-		
-		if (bounds != null)
-			setBounds(bounds);
 	}
 
 	@Override
 	public LiveObject<DSizing> getSizing() {
-		return contents.getSizing(); // TODO: derived preferences
+		return sizing;
 	}
 
 	@Override
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
-		
-		if (this.context == null)
-			return;
+		shape = style.shape.instance(style.margin.apply(bounds));
 		
 		int height = Math.max(bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom(),
 				contents.getSizing().getValue().preferredHeight);
 		int scrollBarWidth = scrollBar.getSizing().getValue().preferredWidth;
 		scrollBar.setBounds(new DIRectangle(
-				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight(),
-				bounds.y + style.border.getPaddingTop(),
+				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight() - style.margin.right,
+				bounds.y + style.border.getPaddingTop() + style.margin.top,
 				scrollBarWidth,
-				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom()));
+				bounds.height - style.border.getPaddingVertical() - style.margin.getVertical()));
 		contents.setBounds(new DIRectangle(0, 0, bounds.width - scrollBar.getBounds().width, height));
 		contentsHeight.setValue(height);
 	}
 
 	@Override
 	public void paint(DCanvas canvas) {
-		if (bounds == null)
-			return;
-		
-		style.border.paint(canvas, bounds);
+		canvas.shadowPath(shape, DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
+		style.border.paint(canvas, style.margin.apply(bounds));
 		scrollBar.paint(canvas);
 		
 		canvas.pushBounds(new DIRectangle(

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

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

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

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

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

 	public DMargin getMargin(String name, DMarginElement defaultValue) {
 		return defaultValue.eval(context);
 	}
+	
+	@Override
+	public DShape getShape(String name, DShapeElement defaultValue) {
+		return defaultValue.eval(context);
+	}
 }

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

  */
 package org.openzen.drawablegui.style;
 
+import org.openzen.drawablegui.DIRectangle;
+
 /**
  *
  * @author Hoofdgebruiker
 	public int getHorizontal() {
 		return left + right;
 	}
+	
+	public DIRectangle apply(DIRectangle bounds) {
+		return new DIRectangle(
+				bounds.x + left,
+				bounds.y + top,
+				bounds.width - left - right,
+				bounds.height - top - bottom);
+	}
 }

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

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

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

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

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

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

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

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

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

 			
 			return elements.get(name).asMargin().eval(context);
 		}
+		
+		@Override
+		public DShape getShape(String name, DShapeElement defaultValue) {
+			if (!elements.containsKey(name))
+				return defaultValue.eval(context);
+			
+			return elements.get(name).asShape().eval(context);
+		}
 	}
 }

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

 		return new DStyleClass(null, NO_CLASSES, stylesheet);
 	}
 	
+	public static DStyleClass inline(String id, DStylesheet stylesheet) {
+		return new DStyleClass(id, NO_CLASSES, stylesheet);
+	}
+	
 	public final String id;
 	public final String[] classes;
 	public final DStylesheet inline;

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

 	public DBorder getBorder(String name, DBorderElement defaultValue);
 	
 	public DMargin getMargin(String name, DMarginElement defaultValue);
+	
+	public DShape getShape(String name, DShapeElement defaultValue);
 }

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

 	default DShadowElement asShadow() {
 		throw new RuntimeException("Not a shadow!");
 	}
+	
+	default DShapeElement asShape() {
+		throw new RuntimeException("Not a shape!");
+	}
 }

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

 		return this;
 	}
 	
+	public DStylesheetBuilder shape(String name, DShapeElement shape) {
+		elements.put(name, shape);
+		return this;
+	}
+	
 	public DStylesheet build() {
 		return new DSimpleStylesheet(elements);
 	}

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

 			component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
 		}
 		
+		long start = System.currentTimeMillis();
 		Rectangle clipBounds = g.getClipBounds();
 		DIRectangle clipBounds2 = clipBounds == null ? null : new DIRectangle(clipBounds.x, clipBounds.y, clipBounds.width, clipBounds.height);
 		SwingCanvas canvas = new SwingCanvas((Graphics2D) g, context, clipBounds2);
 		component.paint(canvas);
+		
+		System.out.println("Paint in " + (System.currentTimeMillis() - start) + " ms");
 	}
 
 	@Override

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

 	@Override
 	public void windowStateChanged(WindowEvent e) {
 		state.setValue(getStateFromWindowState());
+		swingComponent.repaint();
 	}
 	
 	private void updateBounds() {

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

 	private DTreeViewStyle() {
 		nodeOpenedIcon = ExpandedArrow.INSTANCE;
 		nodeClosedIcon = CollapsedArrow.INSTANCE;
-		backgroundColor = 0xFFFFFFFF;
+		backgroundColor = 0;
 		borderColor = 0xFF888888;
 		padding = new DDpDimension(3);
 		rowSpacing = new DDpDimension(2);

IDE/src/main/java/org/openzen/zenscript/ide/ui/dialog/CreatePackageDialog.java

 import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DButton;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.layout.DHorizontalLayout;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DInputField;
 import org.openzen.drawablegui.DLabel;
 import org.openzen.drawablegui.DUIWindow;
-import org.openzen.drawablegui.layout.DVerticalLayout;
 import org.openzen.drawablegui.form.DForm;
 import org.openzen.drawablegui.form.DFormComponent;
+import org.openzen.drawablegui.layout.DLinearLayout;
+import org.openzen.drawablegui.layout.DLinearLayout.Alignment;
+import org.openzen.drawablegui.layout.DLinearLayout.Element;
+import org.openzen.drawablegui.layout.DLinearLayout.ElementAlignment;
+import org.openzen.drawablegui.layout.DLinearLayout.Orientation;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 import org.openzen.drawablegui.live.ImmutableLiveString;
 import org.openzen.drawablegui.live.SimpleLiveString;
 
 		DButton ok = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Create"), ImmutableLiveBool.FALSE, this::ok);
 		DButton cancel = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Cancel"), ImmutableLiveBool.FALSE, this::cancel);
-		DHorizontalLayout buttons = new DHorizontalLayout(
+		DLinearLayout buttons = new DLinearLayout(
 				DStyleClass.EMPTY,
-				DHorizontalLayout.Alignment.RIGHT,
-				new DHorizontalLayout.Element(cancel, 0, 0, DHorizontalLayout.ElementAlignment.TOP),
-				new DHorizontalLayout.Element(ok, 0, 0, DHorizontalLayout.ElementAlignment.TOP));
+				Orientation.HORIZONTAL,
+				Alignment.RIGHT,
+				new Element(cancel, 0, 0, ElementAlignment.TOP),
+				new Element(ok, 0, 0, ElementAlignment.TOP));
 
-		root = new DVerticalLayout(
+		root = new DLinearLayout(
 				DStyleClass.EMPTY,
-				DVerticalLayout.Alignment.MIDDLE,
-				new DVerticalLayout.Element(form, 1, 1, DVerticalLayout.ElementAlignment.CENTER),
-				new DVerticalLayout.Element(buttons, 0, 0, DVerticalLayout.ElementAlignment.RIGHT));
+				Orientation.VERTICAL,
+				Alignment.MIDDLE,
+				new Element(form, 1, 1, ElementAlignment.CENTER),
+				new Element(buttons, 0, 0, ElementAlignment.RIGHT));
 	}
 	
 	public void open(DUIWindow parent) {

IDE/src/main/java/org/openzen/zenscript/ide/ui/dialog/CreateSourceFileDialog.java

 import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DButton;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.layout.DHorizontalLayout;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DInputField;
 import org.openzen.drawablegui.DLabel;
 import org.openzen.drawablegui.DUIWindow;
-import org.openzen.drawablegui.layout.DVerticalLayout;
 import org.openzen.drawablegui.form.DForm;
 import org.openzen.drawablegui.form.DFormComponent;
+import org.openzen.drawablegui.layout.DLinearLayout;
+import org.openzen.drawablegui.layout.DLinearLayout.Alignment;
+import org.openzen.drawablegui.layout.DLinearLayout.Element;
+import org.openzen.drawablegui.layout.DLinearLayout.ElementAlignment;
+import org.openzen.drawablegui.layout.DLinearLayout.Orientation;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 import org.openzen.drawablegui.live.ImmutableLiveString;
 import org.openzen.drawablegui.live.SimpleLiveString;
 
 		DButton ok = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Create"), ImmutableLiveBool.FALSE, this::ok);
 		DButton cancel = new DButton(DStyleClass.EMPTY, new SimpleLiveString("Cancel"), ImmutableLiveBool.FALSE, this::cancel);
-		DHorizontalLayout buttons = new DHorizontalLayout(
+		DLinearLayout buttons = new DLinearLayout(
 				DStyleClass.EMPTY,
-				DHorizontalLayout.Alignment.RIGHT,
-				new DHorizontalLayout.Element(cancel, 0, 0, DHorizontalLayout.ElementAlignment.TOP),
-				new DHorizontalLayout.Element(ok, 0, 0, DHorizontalLayout.ElementAlignment.TOP));
+				Orientation.HORIZONTAL,
+				Alignment.RIGHT,
+				new Element(cancel, 0, 0, ElementAlignment.TOP),
+				new Element(ok, 0, 0, ElementAlignment.TOP));
 
-		root = new DVerticalLayout(
+		root = new DLinearLayout(
 				DStyleClass.EMPTY,
-				DVerticalLayout.Alignment.MIDDLE,
-				new DVerticalLayout.Element(form, 1, 1, DVerticalLayout.ElementAlignment.CENTER),
-				new DVerticalLayout.Element(buttons, 0, 0, DVerticalLayout.ElementAlignment.RIGHT));
+				Orientation.VERTICAL,
+				Alignment.MIDDLE,
+				new Element(form, 1, 1, ElementAlignment.CENTER),
+				new Element(buttons, 0, 0, ElementAlignment.RIGHT));
 	}
 	
 	public void open(DUIWindow parent) {

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

 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
 import org.openzen.drawablegui.style.DDpDimension;
+import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
 	public final DFont font;
 	public final int backgroundColor;
 	public final int textColor;
+	public final DShadow shadow;
 	
 	public StatusBarStyle(DStyleDefinition style) {
 		paddingTop = style.getDimension("paddingTop", new DDpDimension(4));
 		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, (int)(14 * context.getScale())));
 		backgroundColor = style.getColor("backgroundColor", 0xFFF0F0F0);
 		textColor = style.getColor("textColor", 0xFF000000);
+		shadow = style.getShadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()));
 	}
 }

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

 import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.DUIContext;
 
 	@Override
 	public void paint(DCanvas canvas) {
-		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		canvas.shadowPath(DPath.rectangle(bounds.x, bounds.y, bounds.width, bounds.height), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		canvas.drawText(style.font, style.textColor, style.paddingLeft, style.paddingTop + fontMetrics.getAscent(), content.getValue());
 	}
 

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

 		path = parent.getChild("tabbedView", styleClass);
 		style = new TabbedViewStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.tabFont);
-		totalTabHeight = style.paddingTop + style.paddingBottom + fontMetrics.getAscent() + fontMetrics.getDescent();
+		totalTabHeight = style.tabBorder.getPaddingVertical() + fontMetrics.getAscent() + fontMetrics.getDescent();
 		
 		for (TabbedViewComponent tab : tabs)
 			prepare(tab);
 
 	@Override
 	public void close() {
-		
+		for (Map.Entry<TabbedViewTab, ListenerHandle<LiveObject.Listener<DSizing>>> entry : tabSizeListeners.entrySet()) {
+			entry.getValue().close();
+		}
 	}
 	
 	private void repaintTabs() {
-		if (context == null)
-			return;
-		
 		context.repaint(bounds.x, bounds.y, bounds.width, totalTabHeight);
 	}
 	
 	private class TabListListener implements LiveList.Listener<TabbedViewComponent> {
 		@Override
 		public void onInserted(int index, TabbedViewComponent value) {
-			if (currentTab.getValue() == null)
-				currentTab.setValue(value);
-			
 			prepare(value);
 			layoutTabs();
+			
+			if (currentTab.getValue() == null)
+				currentTab.setValue(value);
 		}
 
 		@Override

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

 
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
+import org.openzen.drawablegui.border.DBorder;
+import org.openzen.drawablegui.border.DCompositeBorder;
+import org.openzen.drawablegui.border.DLineBorder;
+import org.openzen.drawablegui.border.DPaddedBorder;
+import org.openzen.drawablegui.style.DBaseStyle;
 import org.openzen.drawablegui.style.DDpDimension;
-import org.openzen.drawablegui.style.DPxDimension;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class TabbedViewStyle {
-	public final int backgroundColor;
+public class TabbedViewStyle extends DBaseStyle {
 	public final DFont tabFont;
 	public final int tabFontColor;
+	public final DBorder tabBorder;
 	
-	public final int paddingTop;
-	public final int paddingBottom;
-	public final int paddingLeft;
-	public final int paddingRight;
 	public final int tabBarSpacingLeft;
 	public final int tabBarSpacingRight;
 	public final int tabSpacing;
 	
-	public final int borderColor;
-	public final int borderWidth;
-	
 	public TabbedViewStyle(DStyleDefinition style) {
-		backgroundColor = style.getColor("backgroundColor", 0xFFEEEEEE);
+		super(style);
+		
 		tabFont = style.getFont("tabFont", context -> new DFont(DFontFamily.UI, false, false, false, (int)(12 * context.getScale())));
 		tabFontColor = style.getColor("tabFontColor", 0xFF000000);
+		tabBorder = style.getBorder("tabBorder", context -> new DCompositeBorder(new DLineBorder(0xFF888888, 1), new DPaddedBorder(context.dp(4))));
 		
-		paddingTop = style.getDimension("paddingTop", new DDpDimension(4));
-		paddingBottom = style.getDimension("paddingTop", new DDpDimension(4));
-		paddingLeft = style.getDimension("paddingLeft", new DDpDimension(4));
-		paddingRight = style.getDimension("paddingRight", new DDpDimension(4));
 		tabBarSpacingLeft = style.getDimension("tabBarSpacingLeft", new DDpDimension(4));
 		tabBarSpacingRight = style.getDimension("tabBarSpacingRight", new DDpDimension(4));
 		tabSpacing = style.getDimension("tabSpacing", new DDpDimension(4));
-		
-		borderColor = style.getColor("borderColor", 0xFF888888);
-		borderWidth = style.getDimension("borderWidth", new DPxDimension(1));
 	}
 }

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

 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.layout.DSideLayout;
 import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.SimpleLiveInt;
 import org.openzen.drawablegui.live.SimpleLiveString;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylesheetBuilder;
 		
 		projectBrowser = new ProjectBrowser(window, host);
 		
-		setMain(tabs = new TabbedView(DStyleClass.EMPTY));
+		setMain(tabs = new TabbedView(DStyleClass.inline(new DStylesheetBuilder()
+				.marginDp("margin", 3)
+				.build())));
 		add(Side.LEFT, projectBrowser.view);
 		add(Side.BOTTOM, new StatusBarView(DStyleClass.EMPTY, status));
 		add(Side.TOP, new AspectBarView(DStyleClass.EMPTY, window.aspectBar));
 			TabbedViewComponent tab = new TabbedViewComponent(
 					sourceFile.getName(),
 					null,
-					new DScrollPane(DStyleClass.EMPTY, editor),
+					new DScrollPane(DStyleClass.EMPTY, editor, new SimpleLiveInt(0)),
 					editor.isUpdated());
 			tabs.tabs.add(tab);
 			tabs.currentTab.setValue(tab);

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

  */
 package org.openzen.zenscript.ide.ui.view.output;
 
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DComponent;
+import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DSizing;
+import org.openzen.drawablegui.DTransform2D;
+import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.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;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class OutputView {
-	public final LiveList<OutputLine> lines;
+public class OutputView implements DComponent {
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	private final DStyleClass styleClass;
+	private final LiveList<OutputLine> lines;
 	
-	public OutputView(LiveList<OutputLine> lines) {
+	private DUIContext context;
+	private DIRectangle bounds;
+	private DPath shape;
+	private OutputViewStyle style;
+	
+	public OutputView(DStyleClass styleClass, LiveList<OutputLine> lines) {
+		this.styleClass = styleClass;
 		this.lines = lines;
 	}
+
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("outputview", styleClass);
+		style = new OutputViewStyle(context.getStylesheets().get(context, path));
+	}
+
+	@Override
+	public MutableLiveObject<DSizing> getSizing() {
+		return sizing;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public int getBaselineY() {
+		return -1;
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+		shape = style.shape.instance(bounds);
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		canvas.shadowPath(
+				shape,
+				DTransform2D.IDENTITY,
+				style.backgroundColor,
+				style.shadow);
+	}
+
+	@Override
+	public void close() {
+		
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/output/OutputViewStyle.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.view.output;
+
+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.DShadow;
+import org.openzen.drawablegui.style.DShape;
+import org.openzen.drawablegui.style.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class OutputViewStyle {
+	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);
+		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.layout.DHorizontalLayout;
 import org.openzen.drawablegui.DSizing;
-import org.openzen.drawablegui.layout.DVerticalLayout;
 import org.openzen.drawablegui.border.DEmptyBorder;
 import org.openzen.drawablegui.border.DPaddedBorder;
+import org.openzen.drawablegui.layout.DLinearLayout;
+import org.openzen.drawablegui.layout.DLinearLayout.Alignment;
+import org.openzen.drawablegui.layout.DLinearLayout.Element;
+import org.openzen.drawablegui.layout.DLinearLayout.ElementAlignment;
+import org.openzen.drawablegui.layout.DLinearLayout.Orientation;
 import org.openzen.drawablegui.live.ImmutableLiveString;
 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.scroll.DScrollPane;
+import org.openzen.drawablegui.style.DRoundedRectangleShape;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylesheetBuilder;
 					dialog.open(e.window);
 				});
 		
-		DHorizontalLayout toolbar = new DHorizontalLayout(
+		DLinearLayout toolbar = new DLinearLayout(
 				DStyleClass.inline(new DStylesheetBuilder()
 						.border("border", context -> new DPaddedBorder(0, context.dp(2), 0, 0))
+						.shape("shape", context -> new DRoundedRectangleShape(context.dp(2), context.dp(2), 0, 0))
+						.color("backgroundColor", 0xFFFFFFFF)
+						.shadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()))
 						.dimensionPx("spacing", 0)
 						.build()),
-				DHorizontalLayout.Alignment.LEFT,
-				new DHorizontalLayout.Element(addPackageButton, 0, 0, DHorizontalLayout.ElementAlignment.TOP),
-				new DHorizontalLayout.Element(addFileButton, 0, 0, DHorizontalLayout.ElementAlignment.TOP));
+				Orientation.HORIZONTAL,
+				Alignment.LEFT,
+				new Element(addPackageButton, 0, 0, ElementAlignment.TOP),
+				new Element(addFileButton, 0, 0, ElementAlignment.TOP));
 		DTreeView projectTree = new DTreeView(
 				DTreeViewStyle.DEFAULT,
 				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)))
+						.color("backgroundColor", 0xFFFFFFFF)
+						.shadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()))
+						.build()),
+				projectTree,
+				new SimpleLiveInt(0));
 		
-		view = new DVerticalLayout(
+		view = new DLinearLayout(
 				DStyleClass.inline(new DStylesheetBuilder()
 						.border("border", DEmptyBorder.ELEMENT)
-						.dimensionPx("spacing", 0)
+						.dimensionDp("spacing", 2)
 						.marginDp("margin", 3)
-						.dimensionDp("cornerRadius", 2)
-						.color("backgroundColor", 0xFFFFFFFF)
-						.shadow("shadow", context -> new DShadow(0xFF888888, 0, 0.5f * context.getScale(), 3 * context.getScale()))
 						.build()),
-				DVerticalLayout.Alignment.TOP,
-				new DVerticalLayout.Element(toolbar, 0, 0, DVerticalLayout.ElementAlignment.STRETCH),
-				new DVerticalLayout.Element(new DScrollPane(DStyleClass.forId("projectView"), projectTree), 1, 1, DVerticalLayout.ElementAlignment.STRETCH));
+				Orientation.VERTICAL,
+				Alignment.TOP,
+				new Element(toolbar, 0, 0, ElementAlignment.STRETCH),
+				new Element(treeScrollPane, 1, 1, ElementAlignment.STRETCH));
 	}
 	
 	public void setContextModule(IDEModule module) {