Implemented some code improvements on the IDE. Preparing work for tooltips.

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

 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 public class DButton implements DComponent {
 	private final DStyleClass styleClass;
 	private final LiveString label;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final LiveBool disabled;
 	private final Runnable action;
 	
 		this.style = new DButtonStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
 		
-		dimensionPreferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				style.paddingLeft + style.paddingRight + fontMetrics.getWidth(label.getValue()),
 				style.paddingTop + style.paddingBottom + fontMetrics.getAscent() + fontMetrics.getDescent()));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

  */
 package org.openzen.drawablegui;
 
-import org.openzen.drawablegui.DCanvas;
-import org.openzen.drawablegui.DTransform2D;
-
 /**
  *
  * @author Hoofdgebruiker

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

 public interface DComponent extends Closeable {
 	void setContext(DStylePath parent, DUIContext context);
 	
-	LiveObject<DDimensionPreferences> getDimensionPreferences();
+	LiveObject<DSizing> getSizing();
 	
 	DIRectangle getBounds();
 	

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

 public class DEmptyView implements DComponent {
 	public static final DEmptyView INSTANCE = new DEmptyView();
 	
-	private static final LiveObject<DDimensionPreferences> DIMENSION = new ImmutableLiveObject(new DDimensionPreferences(0, 0));
-	private static final DIRectangle NO_BOUNDS = new DIRectangle(0, 0, 0, 0);
+	private static final LiveObject<DSizing> DIMENSION = new ImmutableLiveObject(DSizing.EMPTY);
 	
 	private DEmptyView() {}
 
 	}
 	
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+	public LiveObject<DSizing> getSizing() {
 		return DIMENSION;
 	}
 	
 	@Override
 	public DIRectangle getBounds() {
-		return NO_BOUNDS;
+		return DIRectangle.EMPTY;
 	}
 
 	@Override

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private final DStyleClass styleClass;
 	private final Alignment alignment;
 	private final Element[] components;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>>[] componentSizeListeners;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DUIContext context;
 	private DHorizontalLayoutStyle style;
 		totalShrink = 0;
 		
 		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i] = components[i].component.getDimensionPreferences().addListener((oldValue, newValue) -> updateDimensionPreferences());
+			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateDimensionPreferences());
 			
 			totalGrow += components[i].grow;
 			totalShrink += components[i].shrink;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		if (bounds == null || context == null)
 			return;
 		
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (bounds.width < myPreferences.preferredWidth) {
 			layoutShrinked();
 		} else {
 	}
 	
 	private void layoutShrinked() {
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (totalShrink == 0) {
 			// now what?
 			// shrink proportionally, we have to shrink...
 			
 			for (int i = 0; i < components.length; i++) {
 				Element element = components[i];
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newX = x + preferences.preferredWidth;
 				float idealUnspacedX = newX * scale;
 				int idealX = (int)(idealUnspacedX + 0.5f + i * style.spacing);
 			float deltaScaled = delta / totalShrink;
 			int x = 0;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredWidth + deltaScaled * element.shrink;
 				float idealUnspacedX = x + scaledSize;
 				int newX = (int)(idealUnspacedX + 0.5f);
 	
 	private void layoutGrown() {
 		// resize according to grow values
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		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) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newX = x + preferences.preferredWidth;
 				layout(element, x, newX - x);
 				x = newX + style.spacing;
 			float deltaScaled = delta / totalGrow;
 			int x = 0;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredWidth + deltaScaled * element.grow;
 				float idealUnspacedX = x + scaledSize;
 				int newX = (int)(idealUnspacedX + 0.5f);
 	}
 	
 	private void layout(Element element, int x, int width) {
-		DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+		DSizing preferences = element.component.getSizing().getValue();
 		int height;
 		int y;
 		switch (element.alignment) {
 		int maximumWidth = -style.spacing;
 		int maximumHeight = Integer.MAX_VALUE;
 		for (Element element : components) {
-			DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+			DSizing preferences = element.component.getSizing().getValue();
 			preferredWidth += preferences.preferredWidth + style.spacing;
 			preferredHeight = Math.max(preferredHeight, preferences.preferredHeight);
 			
 			maximumHeight = Math.min(maximumHeight, preferences.maximumHeight);
 		}
 		
-		DDimensionPreferences preferences = new DDimensionPreferences(
+		DSizing preferences = new DSizing(
 				minimumWidth + style.paddingLeft + style.paddingRight,
 				minimumHeight + style.paddingTop + style.paddingBottom,
 				preferredWidth + style.paddingLeft + style.paddingRight,
 				preferredHeight + style.paddingTop + style.paddingBottom,
 				maximumWidth + style.paddingLeft + style.paddingRight,
 				maximumHeight + style.paddingTop + style.paddingBottom);
-		dimensionPreferences.setValue(preferences);
+		sizing.setValue(preferences);
 	}
 }

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

 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.MutableLiveString;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DDimension;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private final ListenerHandle<LiveString.Listener> valueListener;
 	
 	private final DStyleClass styleClass;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private DIRectangle bounds = DIRectangle.EMPTY;
 	private final DDimension preferredWidth;
 	
 		DStylePath path = parent.getChild("input", styleClass);
 		style = new DInputFieldStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
-		dimensionPreferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				preferredWidth.evalInt(context) + style.paddingLeft + style.paddingRight + 2 * style.borderWidth,
 				fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingTop + style.paddingBottom + 2 * style.borderWidth));
 		
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 public class DLabel implements DComponent {
 	private final LiveString label;
 	private final DStyleClass styleClass;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final ListenerHandle<LiveString.Listener> labelListener;
 	
 	private DUIContext context;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 	}
 	
 	private void calculateDimension() {
-		preferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 			style.border.getPaddingLeft() + fontMetrics.getWidth(label.getValue()) + style.border.getPaddingRight(),
 			style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingTop()));
 	}

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	
 	private DComponent main;
 	private final List<SideComponent> sides = new ArrayList<>();
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DStylePath path;
 	private DUIContext context;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		int bottom = bounds.y + bounds.height;
 		for (int i = sides.size() - 1; i >= 0; i--) {
 			SideComponent side = sides.get(i);
-			DDimensionPreferences preferences = side.component.getDimensionPreferences().getValue();
+			DSizing preferences = side.component.getSizing().getValue();
 			
 			switch (side.side) {
 				case TOP: {
 	}
 	
 	private void recalculateSize() {
-		DDimensionPreferences mainPreferences = main.getDimensionPreferences().getValue();
+		DSizing mainPreferences = main.getSizing().getValue();
 		int minimumWidth = mainPreferences.minimumWidth;
 		int minimumHeight = mainPreferences.minimumHeight;
 		int preferredWidth = mainPreferences.preferredWidth;
 		int maximumHeight = mainPreferences.maximumHeight;
 		
 		for (SideComponent side : sides) {
-			DDimensionPreferences sidePreferences = side.component.getDimensionPreferences().getValue();
+			DSizing sidePreferences = side.component.getSizing().getValue();
 			switch (side.side) {
 				case LEFT:
 				case RIGHT:
 			}
 		}
 		
-		dimensionPreferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				minimumWidth,
 				minimumHeight,
 				preferredWidth,
 			side.close();
 	}
 	
-	public class SideComponent implements Closeable, LiveObject.Listener<DDimensionPreferences> {
+	public class SideComponent implements Closeable, LiveObject.Listener<DSizing> {
 		public final Side side;
 		public final DComponent component;
-		public final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> listenerHandle;
+		public final ListenerHandle<LiveObject.Listener<DSizing>> listenerHandle;
 
 		public SideComponent(Side side, DComponent component) {
 			this.side = side;
 			this.component = component;
-			listenerHandle = component.getDimensionPreferences().addListener(this);
+			listenerHandle = component.getSizing().addListener(this);
 		}
 		
 		@Override
 		}
 
 		@Override
-		public void onUpdated(DDimensionPreferences oldValue, DDimensionPreferences newValue) {
+		public void onUpdated(DSizing oldValue, DSizing newValue) {
 			recalculateSize();
 		}
 	}

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

  */
 package org.openzen.drawablegui;
 
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.live.SimpleLiveObject;
+
 /**
  *
  * @author Hoofdgebruiker
  */
-public class DDimensionPreferences {
-	public static final DDimensionPreferences EMPTY = new DDimensionPreferences(0, 0);
+public class DSizing {
+	public static MutableLiveObject<DSizing> create() {
+		return new SimpleLiveObject<>(DSizing.EMPTY);
+	}
+	
+	public static final DSizing EMPTY = new DSizing(0, 0);
 	
 	public final int minimumWidth;
 	public final int minimumHeight;
 	public final int maximumWidth;
 	public final int maximumHeight;
 	
-	public DDimensionPreferences(int preferredWidth, int preferredHeight) {
+	public DSizing(int preferredWidth, int preferredHeight) {
 		this.minimumWidth = 0;
 		this.minimumHeight = 0;
 		this.preferredWidth = preferredWidth;
 		this.maximumHeight = 1000000;
 	}
 	
-	public DDimensionPreferences(int minimumWidth, int minimumHeight, int preferredWidth, int preferredHeight, int maximumWidth, int maximumHeight) {
+	public DSizing(int minimumWidth, int minimumHeight, int preferredWidth, int preferredHeight, int maximumWidth, int maximumHeight) {
 		this.minimumWidth = minimumWidth;
 		this.minimumHeight = minimumHeight;
 		this.preferredWidth = preferredWidth;

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.LiveString;
+import org.openzen.drawablegui.live.MutableLiveObject;
+import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.drawablegui.style.DStylePath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DTooltip implements DComponent {
+	private final DStyleClass styleClass;
+	private final LiveString tooltip;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	private final ListenerHandle<LiveString.Listener> tooltipListener;
+	
+	private DUIContext context;
+	private DIRectangle bounds;
+	private DFontMetrics fontMetrics;
+	private DTooltipStyle style;
+	private boolean visible = false;
+	private DTimerHandle timerHandle = null;
+	
+	public DTooltip(DStyleClass styleClass, LiveString tooltip) {
+		this.styleClass = styleClass;
+		this.tooltip = tooltip;
+		tooltipListener = tooltip.addListener(this::onTooltipChanged);
+	}
+	
+	private void onTooltipChanged(String oldValue, String newValue) {
+		if (context == null)
+			return;
+		
+		sizing.setValue(new DSizing(
+				style.border.getPaddingLeft() + fontMetrics.getWidth(newValue) + style.border.getPaddingRight(),
+				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom()));
+	}
+	
+	public void onTargetMouseEnter(DMouseEvent e) {
+		if (timerHandle != null)
+			timerHandle.close();
+		
+		timerHandle = context.setTimer(1000, this::show);
+		setBounds(new DIRectangle(e.x, e.y, sizing.getValue().preferredWidth, sizing.getValue().preferredHeight));
+	}
+	
+	public void onTargetMouseExit(DMouseEvent e) {
+		if (timerHandle != null) {
+			timerHandle.close();
+			timerHandle = null;
+		}
+		
+		hide();
+	}
+	
+	private void show() {
+		visible = true;
+		context.repaint(bounds);
+		
+		if (timerHandle != null) {
+			timerHandle.close();
+			timerHandle = null;
+		}
+	}
+	
+	private void hide() {
+		visible = false;
+		context.repaint(bounds);
+	}
+	
+	@Override
+	public void setContext(DStylePath parent, DUIContext context) {
+		this.context = context;
+		
+		DStylePath path = parent.getChild("tooltip", styleClass);
+		style = new DTooltipStyle(context.getStylesheets().get(context, path));
+		fontMetrics = context.getFontMetrics(style.font);
+	}
+
+	@Override
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
+	}
+
+	@Override
+	public DIRectangle getBounds() {
+		return bounds;
+	}
+
+	@Override
+	public int getBaselineY() {
+		return style.border.getPaddingTop() + fontMetrics.getAscent();
+	}
+
+	@Override
+	public void setBounds(DIRectangle bounds) {
+		this.bounds = bounds;
+	}
+
+	@Override
+	public void paint(DCanvas canvas) {
+		if (!visible)
+			return;
+		
+		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
+		style.border.paint(canvas, bounds);
+		canvas.drawText(style.font, style.textColor, bounds.x + style.border.getPaddingLeft(), style.border.getPaddingTop(), tooltip.getValue());
+	}
+
+	@Override
+	public void close() {
+		tooltipListener.close();
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui;
+
+import org.openzen.drawablegui.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.DStyleDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DTooltipStyle {
+	public final DBorder border;
+	public final DFont font;
+	public final int backgroundColor;
+	public final int textColor;
+	
+	public DTooltipStyle(DStyleDefinition style) {
+		border = style.getBorder("border", context -> new DCompositeBorder(
+				new DLineBorder(0xFF, 1),
+				new DPaddedBorder(context.dp(4), context.dp(4), context.dp(4), context.dp(4))));
+		font = style.getFont("font", context -> new DFont(DFontFamily.UI, false, false, false, context.sp(12)));
+		backgroundColor = style.getColor("backgroundColor", 0xFFFFFFE1);
+		textColor = style.getColor("textColor", 0xFF000000);
+	}
+}

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

 		return (int)(dp * getScale());
 	}
 	
+	default int sp(float sp) {
+		return (int)(sp * getTextScale());
+	}
+	
 	enum Cursor {
 		NORMAL,
 		HAND,

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

 import java.util.function.Predicate;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 	private final DStyleClass styleClass;
 	private final Alignment alignment;
 	private final Element[] components;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>>[] componentSizeListeners;
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final ListenerHandle<LiveObject.Listener<DSizing>>[] componentSizeListeners;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DUIContext context;
 	private DHorizontalLayoutStyle style;
 		totalShrink = 0;
 		
 		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i] = components[i].component.getDimensionPreferences().addListener((oldValue, newValue) -> updateDimensionPreferences());
+			componentSizeListeners[i] = components[i].component.getSizing().addListener((oldValue, newValue) -> updateDimensionPreferences());
 			
 			totalGrow += components[i].grow;
 			totalShrink += components[i].shrink;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 
 	@Override
 	public void close() {
-		for (int i = 0; i < componentSizeListeners.length; i++) {
-			componentSizeListeners[i].close();
+		for (ListenerHandle<LiveObject.Listener<DSizing>> listener : componentSizeListeners) {
+			listener.close();
 		}
 	}
 	
 		if (bounds == null || context == null)
 			return;
 		
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (bounds.height < myPreferences.preferredHeight) {
 			layoutShrinked();
 		} else {
 	}
 	
 	private void layoutShrinked() {
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		if (totalShrink == 0) {
 			// now what?
 			// shrink proportionally, we have to shrink...
 			
 			for (int i = 0; i < components.length; i++) {
 				Element element = components[i];
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newY = y + preferences.preferredHeight;
 				float idealUnspacedY = newY * scale;
 				int idealY = (int)(idealUnspacedY + 0.5f + i * style.spacing);
 			float deltaScaled = delta / totalShrink;
 			int y = bounds.y;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredHeight + deltaScaled * element.shrink;
 				float idealUnspacedY = y + scaledSize;
 				int newY = (int)(idealUnspacedY + 0.5f);
 	
 	private void layoutGrown() {
 		// resize according to grow values
-		DDimensionPreferences myPreferences = dimensionPreferences.getValue();
+		DSizing myPreferences = sizing.getValue();
 		
 		if (totalGrow == 0) {
 			int deltaY = (int)(myPreferences.preferredHeight - bounds.height);
 			int y = bounds.y + (int)(deltaY * alignment.align);
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				int newY = y + preferences.preferredHeight;
 				layout(element, y, newY - y);
 				y = newY;
 			float deltaScaled = delta / totalGrow;
 			int y = bounds.y;
 			for (Element element : components) {
-				DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+				DSizing preferences = element.component.getSizing().getValue();
 				float scaledSize = preferences.preferredHeight + deltaScaled * element.grow;
 				float idealUnspacedY = y + scaledSize;
 				int newY = (int)(idealUnspacedY + 0.5f);
 	}
 	
 	private void layout(Element element, int y, int height) {
-		DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+		DSizing preferences = element.component.getSizing().getValue();
 		int x;
 		int width;
 		switch (element.alignment) {
 		int maximumHeight = -style.spacing;
 		
 		for (Element element : components) {
-			DDimensionPreferences preferences = element.component.getDimensionPreferences().getValue();
+			DSizing preferences = element.component.getSizing().getValue();
 			preferredWidth = Math.max(preferredWidth, preferences.preferredWidth);
 			preferredHeight += preferences.preferredHeight + style.spacing;
 			
 			maximumHeight += preferences.maximumHeight + style.spacing;
 		}
 		
-		DDimensionPreferences preferences = new DDimensionPreferences(
+		DSizing preferences = new DSizing(
 				minimumWidth + style.paddingLeft + style.paddingRight,
 				minimumHeight + style.paddingTop + style.paddingBottom,
 				preferredWidth + style.paddingLeft + style.paddingRight,
 				preferredHeight + style.paddingTop + style.paddingBottom,
 				maximumWidth + style.paddingLeft + style.paddingRight,
 				maximumHeight + style.paddingTop + style.paddingBottom);
-		dimensionPreferences.setValue(preferences);
+		sizing.setValue(preferences);
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.border;
+
+import org.openzen.drawablegui.DCanvas;
+import org.openzen.drawablegui.DIRectangle;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DCompositeBorder implements DBorder {
+	private final DBorder[] borders;
+	
+	public DCompositeBorder(DBorder... borders) {
+		this.borders = borders;
+	}
+
+	@Override
+	public void paint(DCanvas canvas, DIRectangle bounds) {
+		for (DBorder border : borders) {
+			border.paint(canvas, bounds);
+			bounds = new DIRectangle(
+					bounds.x + border.getPaddingLeft(),
+					bounds.y + border.getPaddingTop(),
+					bounds.width - border.getPaddingLeft() - border.getPaddingRight(),
+					bounds.height - border.getPaddingTop() - border.getPaddingBottom());
+		}
+	}
+
+	@Override
+	public int getPaddingLeft() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingLeft();
+		return total;
+	}
+
+	@Override
+	public int getPaddingRight() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingRight();
+		return total;
+	}
+
+	@Override
+	public int getPaddingTop() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingTop();
+		return total;
+	}
+
+	@Override
+	public int getPaddingBottom() {
+		int total = 0;
+		for (DBorder border : borders)
+			total += border.getPaddingBottom();
+		return total;
+	}
+}

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 public class DCustomWindowBorder implements DComponent {
 	private final DStyleClass styleClass;
 	private final DComponent content;
-	private final LiveObject<DDimensionPreferences> preferences = new ImmutableLiveObject<>(DDimensionPreferences.EMPTY);
+	private final LiveObject<DSizing> sizing = new ImmutableLiveObject<>(DSizing.EMPTY);
 	
 	private DUIContext context;
 	private DCustomWindowBorderStyle style;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DUIContext;
 
 /**
  *

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
-import org.openzen.drawablegui.DUIContext;
 
 /**
  *

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

 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 public class DForm extends BaseComponentGroup {
 	private final DFormComponent[] components;
 	private final DStyleClass styleClass;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DIRectangle bounds;
 	private DUIContext context;
 		
 		for (DFormComponent component : components) {
 			maxLabelWidth = Math.max(maxLabelWidth, fontMetrics.getWidth(component.label));
-			int componentWidth = component.component.getDimensionPreferences().getValue().preferredWidth;
+			int componentWidth = component.component.getSizing().getValue().preferredWidth;
 			maxFieldWidth = Math.max(maxFieldWidth, componentWidth);
 		}
 		
 		for (DFormComponent component : components) {
-			height += component.component.getDimensionPreferences().getValue().preferredHeight;
+			height += component.component.getSizing().getValue().preferredHeight;
 			height += style.spacing;
 		}
 		
 		this.maxFieldWidth = maxFieldWidth;
 		this.maxLabelWidth = maxLabelWidth;
-		preferences.setValue(new DDimensionPreferences(maxLabelWidth + maxFieldWidth + style.paddingLeft + style.paddingRight + style.spacing, height));
+		sizing.setValue(new DSizing(maxLabelWidth + maxFieldWidth + style.paddingLeft + style.paddingRight + style.spacing, height));
 		
 		if (bounds != null)
 			layout();
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 			canvas.drawText(style.labelFont, style.labelColor, x, y + baseline, component.label);
 			component.component.paint(canvas);
 			
-			y += component.component.getDimensionPreferences().getValue().preferredHeight + style.spacing;
+			y += component.component.getSizing().getValue().preferredHeight + style.spacing;
 		}
 	}
 
 		int y = bounds.y + style.paddingBottom;
 		
 		for (DFormComponent component : components) {
-			int preferredHeight = component.component.getDimensionPreferences().getValue().preferredHeight;
+			int preferredHeight = component.component.getSizing().getValue().preferredHeight;
 			DIRectangle componentBounds = new DIRectangle(x + maxLabelWidth, y, bounds.width - maxLabelWidth - style.paddingLeft - style.paddingRight - style.spacing, preferredHeight);
 			component.component.setBounds(componentBounds);
 			

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

 		return value;
 	}
 
-	@Override
-	public void setValue(T value) {
-		throw new UnsupportedOperationException("Immutable value");
-	}
-
 	@Override
 	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
 		return new DummyListenerHandle<>(listener);

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

 public interface LiveObject<T> {
 	public T getValue();
 	
-	public void setValue(T value);
-	
 	public ListenerHandle<Listener<T>> addListener(Listener<T> listener);
 	
 	public interface Listener<T> {

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.drawablegui.live;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MutableLiveObject<T> extends LiveObject<T> {
+	public void setValue(T value);
+}

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

  *
  * @author Hoofdgebruiker
  */
-public class SimpleLiveObject<T> implements LiveObject<T> {
+public class SimpleLiveObject<T> implements MutableLiveObject<T> {
 	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
 	private T value;
 	

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveInt;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
  * @author Hoofdgebruiker
  */
 public class DScrollBar implements DComponent {
-	private final LiveObject<DDimensionPreferences> preferences;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private final DStyleClass styleClass;
 	private final LiveInt targetHeight;
 		this.styleClass = styleClass;
 		this.targetHeight = targetHeight;
 		this.offset = offset;
-		this.preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
 		
 		targetHeightListener = targetHeight.addListener(new ScrollListener());
 		offsetListener = offset.addListener(new ScrollListener());
 	public void setContext(DStylePath parent, DUIContext context) {
 		this.context = context;
 		this.style = new DScrollBarStyle(context.getStylesheets().get(context, parent.getChild("scrollbar", styleClass)));
-		preferences.setValue(new DDimensionPreferences(style.width, 0));
+		sizing.setValue(new DSizing(style.width, 0));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 
 	@Override
 	public void close() {
-		// nothing to clean up
+		targetHeightListener.close();
+		offsetListener.close();
 	}
 	
 	private void checkHover(DMouseEvent e) {

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 		offsetXListener = offsetX.addListener(new ScrollListener());
 		offsetYListener = offsetY.addListener(new ScrollListener());
 		
-		contents.getDimensionPreferences().addListener((oldPreferences, newPreferences) -> {
+		contents.getSizing().addListener((oldPreferences, newPreferences) -> {
 			if (bounds == null)
 				return;
 			
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return contents.getDimensionPreferences(); // TODO: derived preferences
+	public LiveObject<DSizing> getSizing() {
+		return contents.getSizing(); // TODO: derived preferences
 	}
 
 	@Override
 		if (this.context == null)
 			return;
 		
-		int height = Math.max(
-				bounds.height - style.border.getPaddingTop() - style.border.getPaddingBottom(),
-				contents.getDimensionPreferences().getValue().preferredHeight);
-		int scrollBarWidth = scrollBar.getDimensionPreferences().getValue().preferredWidth;
+		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(),

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

 
 import org.openzen.drawablegui.border.DBorder;
 import org.openzen.drawablegui.border.DLineBorder;
-import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.style.DStyleDefinition;
 
 /**

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

 import javax.swing.JDialog;
 import javax.swing.JFrame;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
 		SwingDialog result = new SwingDialog(this, title, component, false);
 		result.setResizable(false);
 		
-		DDimensionPreferences size = component.getDimensionPreferences().getValue();
+		DSizing size = component.getSizing().getValue();
 		result.setLocation(
 				getX() + (getWidth() - size.preferredWidth) / 2,
 				getY() + (getHeight() - size.preferredHeight) / 2);

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

 import org.openzen.drawablegui.DAnchor;
 import org.openzen.drawablegui.DClipboard;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontMetrics;
 		windowContext.graphics = this.graphics; // help a little...
 		
 		root.setContext(DStylePathRoot.INSTANCE, windowContext);
-		DDimensionPreferences dimension = root.getDimensionPreferences().getValue();
+		DSizing dimension = root.getSizing().getValue();
 		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
 		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
 		
 		windowContext.graphics = this.graphics; // help a little...
 		
 		root.setContext(DStylePathRoot.INSTANCE, windowContext);
-		DDimensionPreferences dimension = root.getDimensionPreferences().getValue();
+		DSizing dimension = root.getSizing().getValue();
 		int tx = (int)(x - anchor.alignX * dimension.preferredWidth);
 		int ty = (int)(y - anchor.alignY * dimension.preferredHeight);
 		

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

 import java.awt.event.WindowStateListener;
 import javax.swing.JFrame;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DUIWindow;
 		SwingWindow result = new SwingWindow(title, component, false);
 		result.setResizable(false);
 		
-		DDimensionPreferences size = component.getDimensionPreferences().getValue();
+		DSizing size = component.getSizing().getValue();
 		result.setLocation(
 				getX() + (getWidth() - size.preferredWidth) / 2,
 				getY() + (getHeight() - size.preferredHeight) / 2);

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

 import java.util.List;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
-import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveList;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStylePath;
 
 /**
  * @author Hoofdgebruiker
  */
 public class DTreeView<N extends DTreeNode<N>> implements DComponent {
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private DIRectangle bounds;
 	
 	private int selectedRow = -1;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public MutableLiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 	
 	@Override
 		}
 		
 		if (rows.size() != oldRowCount) {
-			DDimensionPreferences preferences = dimensionPreferences.getValue();
-			dimensionPreferences.setValue(
-					new DDimensionPreferences(
+			DSizing preferences = sizing.getValue();
+			sizing.setValue(new DSizing(
 							preferences.minimumWidth,
 							preferences.minimumHeight,
 							preferences.preferredWidth,

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

 package org.openzen.zenscript.ide.ui;
 
 import org.openzen.drawablegui.live.LiveArrayList;
-import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveList;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 
 /**
  */
 public class IDEAspectBar {
 	public final MutableLiveList<IDEAspectToolbar> toolbars = new LiveArrayList<>();
-	public final LiveObject<IDEAspectToolbar> active = new SimpleLiveObject<>(null);
+	public final MutableLiveObject<IDEAspectToolbar> active = new SimpleLiveObject<>(null);
 }

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

 package org.openzen.zenscript.ide.ui;
 
 import org.openzen.drawablegui.live.LiveBool;
-import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LivePredicateBool;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 	
 	public IDEAspectToolbar projectToolbar;
 	
-	private final LiveObject<IDEModule> contextModule = new SimpleLiveObject<>(null);
-	private final LiveObject<IDEPackage> contextPackage = new SimpleLiveObject<>(null);
-	private final LiveObject<IDESourceFile> contextFile = new SimpleLiveObject<>(null);
+	private final MutableLiveObject<IDEModule> contextModule = new SimpleLiveObject<>(null);
+	private final MutableLiveObject<IDEPackage> contextPackage = new SimpleLiveObject<>(null);
+	private final MutableLiveObject<IDESourceFile> contextFile = new SimpleLiveObject<>(null);
 	private final LiveBool addContentDisabled = new LivePredicateBool(contextPackage, pkg -> pkg == null);
 	
 	public IDEWindow(DevelopmentHost host) {

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

 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEPackage;
+import org.openzen.zenscript.ide.host.IDESourceFile;
 import org.openzen.zenscript.ide.ui.IDEWindow;
 
 /**
 	
 	private void ok() {
 		window.close();
-		pkg.createSourceFile(name.getValue() + ".zs");
+		IDESourceFile file = pkg.createSourceFile(name.getValue() + ".zs");
+		ideWindow.open(file);
 	}
 }

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

 import java.util.function.Consumer;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.live.ImmutableLiveBool;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
 	private DUIContext context;
 	private IconButtonControlStyle style;
 	private DIRectangle bounds;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> preferences = DSizing.create();
 	private boolean hover;
 	private boolean press;
 	private DPath shape;
 		int iconHeight = (int)(icon.getNominalWidth() * context.getScale() + 0.5f);
 		int width = iconWidth + 2 * style.padding + 2 * style.margin;
 		int height = iconHeight + 2 * style.padding + 2 * style.margin;
-		preferences.setValue(new DDimensionPreferences(width, height));
+		preferences.setValue(new DSizing(width, height));
 		
 		if (bounds != null)
 			setBounds(bounds);
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+	public LiveObject<DSizing> getSizing() {
 		return preferences;
 	}
 

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.live.LiveObject;
  * @author Hoofdgebruiker
  */
 public class StatusBarView implements DComponent {
-	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 0));
+	private final SimpleLiveObject<DSizing> dimensionPreferences = new SimpleLiveObject<>(new DSizing(0, 0));
 	
 	private final DStyleClass styleClass;
 	private final LiveString content;
 		style = new StatusBarStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
 		
-		dimensionPreferences.setValue(new DDimensionPreferences(0, style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingBottom));
+		dimensionPreferences.setValue(new DSizing(0, style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent() + style.paddingBottom));
 	}
 	
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
+	public LiveObject<DSizing> getSizing() {
 		return dimensionPreferences;
 	}
 	

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

 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DUIContext;
-import org.openzen.drawablegui.live.ImmutableLiveObject;
 import org.openzen.drawablegui.live.LiveArrayList;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveList;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 public class TabbedView extends BaseComponentGroup {
 	private final DStyleClass styleClass;
 	public final MutableLiveList<TabbedViewComponent> tabs = new LiveArrayList<>();
-	private final LiveObject<DDimensionPreferences> preferences = new ImmutableLiveObject<>(DDimensionPreferences.EMPTY);
-	public final LiveObject<TabbedViewComponent> currentTab = new SimpleLiveObject<>(null);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	public final MutableLiveObject<TabbedViewComponent> currentTab = new SimpleLiveObject<>(null);
 	
 	private DUIContext context;
 	private DStylePath path;
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		
 		int x = bounds.x + style.tabBarSpacingLeft;
 		for (DComponent tab : tabComponents) {
-			DDimensionPreferences preferences = tab.getDimensionPreferences().getValue();
+			DSizing preferences = tab.getSizing().getValue();
 			tab.setBounds(new DIRectangle(
 					x, bounds.y + totalTabHeight - preferences.preferredHeight, preferences.preferredWidth, preferences.preferredHeight));
 			

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

 
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
  */
 public class TabbedViewTab implements DComponent {
 	private final TabbedViewComponent tab;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
-	private final LiveObject<TabbedViewComponent> currentTab;
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
+	private final MutableLiveObject<TabbedViewComponent> currentTab;
 	
 	private final TabbedView parent;
 	public final TabbedViewTabClose closeButton;
 	private boolean hover;
 	private boolean press;
 	
-	public TabbedViewTab(TabbedView parent, LiveObject<TabbedViewComponent> currentTab, TabbedViewComponent tab) {
+	public TabbedViewTab(TabbedView parent, MutableLiveObject<TabbedViewComponent> currentTab, TabbedViewComponent tab) {
 		this.parent = parent;
 		this.currentTab = currentTab;
 		this.tab = tab;
 		closeButton.setContext(path, context);
 		
 		textWidth = fontMetrics.getWidth(tab.title);
-		preferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				style.paddingLeft + textWidth + style.paddingRight
 						+ style.closeIconPadding
-						+ closeButton.getDimensionPreferences().getValue().preferredWidth,
+						+ closeButton.getSizing().getValue().preferredWidth,
 				style.paddingTop + fontMetrics.getAscent() + fontMetrics.getDescent()
 						+ style.paddingBottom));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 	public void setBounds(DIRectangle bounds) {
 		this.bounds = bounds;
 		
-		DDimensionPreferences close = closeButton.getDimensionPreferences().getValue();
+		DSizing close = closeButton.getSizing().getValue();
 		closeButton.setBounds(new DIRectangle(
 				bounds.x + bounds.width - close.preferredWidth - style.paddingRight,
 				bounds.y + (bounds.height - close.preferredHeight) / 2,
 	@Override
 	public void paint(DCanvas canvas) {
 		int width = style.paddingLeft + textWidth + style.paddingRight
-				+ closeButton.getDimensionPreferences().getValue().preferredWidth + style.closeIconPadding;
+				+ closeButton.getSizing().getValue().preferredWidth + style.closeIconPadding;
 
 		int color = style.tabColorNormal;
 		if (currentTab.getValue() == tab)

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
-import org.openzen.drawablegui.DDrawable;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
-import org.openzen.zenscript.ide.ui.icons.ColoredIcon;
 import org.openzen.zenscript.ide.ui.icons.ScalableCloseIcon;
 
 /**
  */
 public class TabbedViewTabClose implements DComponent {
 	private final TabbedViewTab tab;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private DUIContext context;
 	private DIRectangle bounds;
 		
 		DStylePath path = parent.getChild("tabClose", DStyleClass.EMPTY);
 		style = new TabbedViewTabCloseStyle(context.getStylesheets().get(context, path));
-		preferences.setValue(new DDimensionPreferences(style.size, style.size));
+		sizing.setValue(new DSizing(style.size, style.size));
 		icon = new ScalableCloseIcon(style.size / 24);
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.ide.ui.view;
 
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DEmptyView;
 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.DSideLayout;
 		this.window = window;
 		
 		DTreeView projectView = new DTreeView(DTreeViewStyle.DEFAULT, new RootTreeNode(window, host), false);
-		projectView.getDimensionPreferences().setValue(new DDimensionPreferences(500, 500));
+		projectView.getSizing().setValue(new DSizing(500, 500));
 		setMain(tabs = new TabbedView(DStyleClass.EMPTY));
 		add(Side.LEFT, new DScrollPane(DStyleClass.forId("projectView"), projectView));
 		add(Side.BOTTOM, new StatusBarView(DStyleClass.EMPTY, status));

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

 import java.util.function.Consumer;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
  * @author Hoofdgebruiker
  */
 public class AspectBarSelectorButton implements DComponent {
-	
 	public final LiveBool active;
 	
 	private final DStyleClass styleClass;
 	private final DDrawable icon;
-	private final LiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final Consumer<DMouseEvent> onClick;
 	private DUIContext context;
 	private AspectBarSelectorButtonStyle style;
 		this.context = context;
 		DStylePath path = parent.getChild("selectorbutton", styleClass);
 		style = new AspectBarSelectorButtonStyle(context.getStylesheets().get(context, path));
-		preferences.setValue(new DDimensionPreferences(style.width, style.height));
+		sizing.setValue(new DSizing(style.width, style.height));
 		shape = DPath.roundedRectangle(
 				0,
 				0,
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

 	public final DShadow windowControlShadow;
 	
 	public AspectBarStyle(DStyleDefinition style) {
-		height = style.getDimension("height", new DDpDimension(32));
+		height = style.getDimension("height", new DDpDimension(38));
 		aspectSelectorPaddingLeft = style.getDimension("aspectSelectorPaddingLeft", new DDpDimension(4));
 		aspectSelectorToToolbarSpacing = style.getDimension("aspectSelectorToToolbarSpacing", new DDpDimension(16));
 		toolbarTitleToControlsSpacing = style.getDimension("toolbarTitleToControlsSpacing", new DDpDimension(8));

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

 import org.openzen.drawablegui.BaseComponentGroup;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.drawablegui.DPath;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DIRectangle;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
 import org.openzen.zenscript.ide.ui.IDEAspectBar;
 import org.openzen.zenscript.ide.ui.IDEAspectToolbar;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.LiveMappedList;
 import org.openzen.drawablegui.live.LivePredicateBool;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.zenscript.ide.ui.IDEAspectBarControl;
  * @author Hoofdgebruiker
  */
 public class AspectBarView extends BaseComponentGroup {
-	private final SimpleLiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 64));
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final DStyleClass styleClass;
 	private final IDEAspectBar aspectBar;
-	private final List<IDEAspectToolbar> contextBars = new ArrayList<>();
 	
 	private DIRectangle bounds;
 	private DUIContext context;
 	private WindowActionButton maximizeRestore;
 	private WindowActionButton close;
 	
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> minimizeRelayout;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> maximizeRestoreRelayout;
-	private final ListenerHandle<LiveObject.Listener<DDimensionPreferences>> closeRelayout;
+	private final ListenerHandle<LiveObject.Listener<DSizing>> minimizeRelayout;
+	private final ListenerHandle<LiveObject.Listener<DSizing>> maximizeRestoreRelayout;
+	private final ListenerHandle<LiveObject.Listener<DSizing>> closeRelayout;
 	
 	public AspectBarView(DStyleClass styleClass, IDEAspectBar aspectBar) {
 		this.styleClass = styleClass;
 		listener = aspectBar.toolbars.addListener(new ToolbarListListener());
 		
 		minimize = new WindowActionButton(scale -> new ScalableMinimizeIcon(scale), e -> context.getWindow().minimize());
-		minimizeRelayout = minimize.getDimensionPreferences().addListener((a, b) -> layout());
+		minimizeRelayout = minimize.getSizing().addListener((a, b) -> layout());
 		maximizeRestore = new WindowActionButton(ScalableMaximizeIcon::new, e -> {
 			if (context.getWindow().getWindowState().getValue() == DUIWindow.State.MAXIMIZED)
 				context.getWindow().restore();
 			else
 				context.getWindow().maximize();
 		});
-		maximizeRestoreRelayout = maximizeRestore.getDimensionPreferences().addListener((a, b) -> layout());
+		maximizeRestoreRelayout = maximizeRestore.getSizing().addListener((a, b) -> layout());
 		close = new WindowActionButton(scale -> new ScalableCloseIcon(scale), e -> context.getWindow().close());
-		closeRelayout = close.getDimensionPreferences().addListener((a, b) -> layout());
+		closeRelayout = close.getSizing().addListener((a, b) -> layout());
 		
 		selectorButtons = new LiveMappedList<>(
 				aspectBar.toolbars,
 		activeToolbarTitleFontMetrics = context.getFontMetrics(style.activeToolbarTitleFont);
 		showWindowControls = !context.getWindow().hasTitleBar();
 		
+		sizing.setValue(new DSizing(0, style.height));
+		
 		for (DComponent selectorButton : selectorButtons)
 			selectorButton.setContext(path, context);
 		
-		if (bounds != null) {
-			layout();
-			aspectBar.active.setValue(aspectBar.active.getValue());
-		}
-		
 		if (activeToolbarComponents != null)
 			for (DComponent component : activeToolbarComponents)
 				component.setContext(path, context);
 	}
 	
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 	
 	@Override
 		layoutActiveToolbarComponents();
 		
 		int x = bounds.x + bounds.width;
-		DDimensionPreferences closeSize = close.getDimensionPreferences().getValue();
-		DDimensionPreferences maximizeRestoreSize = maximizeRestore.getDimensionPreferences().getValue();
-		DDimensionPreferences minimizeSize = minimize.getDimensionPreferences().getValue();
+		DSizing closeSize = close.getSizing().getValue();
+		DSizing maximizeRestoreSize = maximizeRestore.getSizing().getValue();
+		DSizing minimizeSize = minimize.getSizing().getValue();
 		
 		x -= closeSize.preferredWidth;
 		close.setBounds(new DIRectangle(x, bounds.y, closeSize.preferredWidth, closeSize.preferredHeight));
 		int x = bounds.x + style.aspectSelectorPaddingLeft;
 		
 		for (DComponent component : selectorButtons) {
-			int width = component.getDimensionPreferences().getValue().preferredWidth;
-			int height = component.getDimensionPreferences().getValue().preferredHeight;
+			int width = component.getSizing().getValue().preferredWidth;
+			int height = component.getSizing().getValue().preferredHeight;
 			int y = bounds.y + (bounds.height - style.aspectSelectorBottomSize - height) / 2;
 			component.setBounds(new DIRectangle(x, y, width, height));
 			
 	}
 	
 	private void layoutActiveToolbarComponents() {
-		if (bounds == null)
+		if (bounds == null || bounds.height < (style.aspectBarPaddingTop + style.controlPaddingTop + style.controlPaddingBottom))
 			return;
 		
 		int x = aspectSelectorEndX
 		
 		int y = style.aspectBarPaddingTop + style.controlPaddingTop;
 		int height = bounds.height - y - style.controlPaddingBottom;
+		
 		for (DComponent toolbarComponent : activeToolbarComponents) {
-			int width = toolbarComponent.getDimensionPreferences().getValue().preferredWidth;
+			int width = toolbarComponent.getSizing().getValue().preferredWidth;
 			toolbarComponent.setBounds(
 					new DIRectangle(x, bounds.y + y, width, height));
 			x += width;

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

 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DColorableIcon;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DMouseEvent;
 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
-import org.openzen.drawablegui.live.SimpleLiveObject;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStylePath;
 import org.openzen.zenscript.ide.ui.icons.ScalableCloseIcon;
 
  * @author Hoofdgebruiker
  */
 public class WindowActionButton implements DComponent {
-	private final SimpleLiveObject<DDimensionPreferences> preferences = new SimpleLiveObject<>(DDimensionPreferences.EMPTY);
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private final Function<Float, DColorableIcon> scalableIcon;
 	private final Consumer<DMouseEvent> action;
 		windowFocusedListener = windowFocused.addListener((a, b) -> repaint());
 		
 		icon = scalableIcon == null ? null : scalableIcon.apply(context.getScale());
-		preferences.setValue(new DDimensionPreferences(
+		sizing.setValue(new DSizing(
 				(int)(48 * context.getScale()),
 				(int)(24 * context.getScale())));
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return preferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override

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

 import java.io.IOException;
 import org.openzen.drawablegui.DCanvas;
 import org.openzen.drawablegui.DComponent;
-import org.openzen.drawablegui.DDimensionPreferences;
+import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.DFont;
 import org.openzen.drawablegui.DFontFamily;
 import org.openzen.drawablegui.DFontMetrics;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.live.SimpleLiveBool;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 public class SourceEditor implements DComponent {
 	private final DStyleClass styleClass;
 	private final DFont font = new DFont(DFontFamily.CODE, false, false, false, 24);
-	private final LiveObject<DDimensionPreferences> dimensionPreferences = new SimpleLiveObject<>(new DDimensionPreferences(0, 0));
+	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final String tab = "    ";
 	private final IDESourceFile sourceFile;
 	private final TokenModel tokens;
 		fullLineHeight = textLineHeight + fontMetrics.getLeading() + style.extraLineSpacing;
 		selectionLineHeight = textLineHeight + style.selectionPaddingTop + style.selectionPaddingBottom;
 		
-		dimensionPreferences.setValue(new DDimensionPreferences(0, fullLineHeight * tokens.getLineCount()));
+		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
 		
 		if (blinkTimer != null)
 			blinkTimer.close();
 	}
 
 	@Override
-	public LiveObject<DDimensionPreferences> getDimensionPreferences() {
-		return dimensionPreferences;
+	public LiveObject<DSizing> getSizing() {
+		return sizing;
 	}
 
 	@Override
 		if (deleteSelection())
 			return;
 		
+		if (cursorEnd.line > 0) {
+			String indent = tokens.getLine(cursorEnd.line - 1).getIndent(); // TODO: get nominal indent for current scope
+			if (cursorEnd.offset == indent.length()) {
+				// remove entire indent
+				SourcePosition deleteFrom = new SourcePosition(tokens, cursorEnd.line - 1, tokens.getLine(cursorEnd.line - 1).length());
+				tokens.delete(deleteFrom, cursorEnd);
+				unchanged.setValue(false);
+				setCursor(deleteFrom, deleteFrom);
+				return;
+			}
+		}
+		
 		if (cursorEnd.offset == 0) {
 			if (cursorEnd.line == 0)
 				return;
 	private void type(String value) {
 		deleteSelection();
 		
-		tokens.insert(cursorEnd, value);
-		SourcePosition position = new SourcePosition(tokens, cursorEnd.line, cursorEnd.offset + value.length());
-		setCursor(position, position);
+		if (value.equals("{")) {
+			String indent = tokens.getLine(cursorEnd.line).getIndent();
+			tokens.insert(cursorEnd, "{\n" + indent + "\t\n" + indent + "}");
+			
+			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length() + 1);
+			setCursor(position, position);
+		} else if (value.equals(";")) {
+			String indent = tokens.getLine(cursorEnd.line).getIndent();
+			tokens.insert(cursorEnd, ";\n" + indent);
+			
+			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length());
+			setCursor(position, position);
+		} else {
+			tokens.insert(cursorEnd, value);
+			
+			SourcePosition position = new SourcePosition(tokens, cursorEnd.line, cursorEnd.offset + value.length());
+			setCursor(position, position);
+		}
+		
 		unchanged.setValue(false);
 	}
 	
 	}
 	
 	private void onLinesUpdated() {
-		dimensionPreferences.setValue(new DDimensionPreferences(0, fullLineHeight * tokens.getLineCount()));
+		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
 		
 		if (bounds != null)
 			context.repaint(bounds);