it just continues to get more awesome

minigui.d

@@ -188,7 +188,9 @@ the virtual functions remain as the default calculated values. then the reads go
 
 			See [Widget.Style] for details.
 
-			* A widget must now opt in to receiving keyboard focus, rather than opting out.
+			// * A widget must now opt in to receiving keyboard focus, rather than opting out.
+
+			* Widgets now draw their keyboard focus by default instead of opt in. You may wish to set `tabStop = false;` if it wasn't supposed to receive it.
 
 			* Most Widget constructors no longer have a default `parent` argument. You must pass the parent to almost all widgets, or in rare cases, an explict `null`, but more often than not, you need the parent so the default argument was not very useful at best and misleading to a crash at worst.
 
@@ -372,6 +374,36 @@ version(Windows) {
 +/
 class Widget {
 
+	/++
+		Sets some internal param, `name`, to the string `value`. It is meant to be used from things like XML loaders.
+
+		If you subclass this, you should add your derived members, then `return super.addParameter(name, value);` in the default case.
+
+		Returns:
+			`true` if you handled it, `false` if you did not. This can be used to give user feedback.
+
+		History:
+			Added May 22, 2021
+	+/
+	bool addParameter(string name, string value) {
+		switch(name) {
+			case "name": this.name = value; return true;
+			default: return false;
+		}
+	}
+
+	/++
+		If `encapsulatedChildren` returns true, it changes the event handling mechanism to act as if events from the child widgets are actually targeted on this widget.
+
+		The idea is then you can use child widgets as part of your implementation, but not expose those details through the event system; if someone checks the mouse coordinates and target of the event once it bubbles past you, it will show as it it came from you.
+
+		History:
+			Added May 22, 2021
+	+/
+	protected bool encapsulatedChildren() {
+		return false;
+	}
+
 	// Default layout properties {
 
 		int minWidth() { return 0; }
@@ -570,14 +602,14 @@ class Widget {
 		}
 
 		///
-		Color backgroundColor() {
+		WidgetBackground background() {
 			// the default is a "transparent" background, which means
 			// it goes as far up as it can to get the color
 			if (widget.backgroundColor_ != Color.transparent)
-				return widget.backgroundColor_;
+				return WidgetBackground(widget.backgroundColor_);
 			if (widget.parent)
-				return StyleInformation.extractStyleProperty!"backgroundColor"(widget.parent);
+				return WidgetBackground(StyleInformation.extractStyleProperty!"background"(widget.parent));
-			return widget.backgroundColor_;
+			return WidgetBackground(widget.backgroundColor_);
 		}
 
 		private OperatingSystemFont fontCached_;
@@ -1300,7 +1332,7 @@ class Widget {
 		version(win32_widgets)
 			if(hwnd) return; // Windows will do it. I think.
 
-		auto c = getComputedStyle().backgroundColor;
+		auto c = getComputedStyle().background.color;
 		painter.fillColor = c;
 		painter.outlineColor = c;
 
@@ -1600,7 +1632,7 @@ abstract class ComboboxBase : Widget {
 			{
 				auto cs = getComputedStyle();
 				auto painter = dropDown.draw();
-				draw3dFrame(0, 0, w, h, painter, FrameStyle.risen, getComputedStyle().backgroundColor);
+				draw3dFrame(0, 0, w, h, painter, FrameStyle.risen, getComputedStyle().background.color);
 				auto p = Point(4, 4);
 				painter.outlineColor = cs.foregroundColor;
 				foreach(option; options) {
@@ -1612,13 +1644,13 @@ abstract class ComboboxBase : Widget {
 			dropDown.setEventHandlers(
 				(MouseEvent event) {
 					if(event.type == MouseEventType.buttonReleased) {
+						dropDown.close();
 						auto element = (event.y - 4) / Window.lineHeight;
 						if(element >= 0 && element <= options.length) {
 							selection = element;
 
 							fireChangeEvent();
 						}
-						dropDown.close();
 					}
 				}
 			);
@@ -2033,7 +2065,14 @@ int draw3dFrame(int x, int y, int width, int height, ScreenPainter painter, Fram
 	return borderWidth;
 }
 
-///
+/++
+	An `Action` represents some kind of user action they can trigger through menu options, toolbars, hotkeys, and similar mechanisms. The text label, icon, and handlers are centrally held here instead of repeated in each UI element.
+
+	See_Also:
+		[MenuItem]
+		[ToolButton]
+		[Menu.addItem]
++/
 class Action {
 	version(win32_widgets) {
 		private int id;
@@ -2043,7 +2082,16 @@ class Action {
 
 	KeyEvent accelerator;
 
-	///
+	// FIXME: disable message
+	// and toggle thing?
+	// ??? and trigger arguments too ???
+
+	/++
+		Params:
+			label = the textual label
+			icon = icon ID. See [GenericIcons]. There is currently no way to do custom icons.
+			triggered = initial handler, more can be added via the [triggered] member.
+	+/
 	this(string label, ushort icon = 0, void delegate() triggered = null) {
 		this.label = label;
 		this.iconId = icon;
@@ -2060,6 +2108,7 @@ class Action {
 	// icon
 
 	// when it is triggered, the triggered event is fired on the window
+	/// The list of handlers when it is triggered.
 	void delegate()[] triggered;
 }
 
@@ -2563,7 +2612,7 @@ struct WidgetPainter {
 
 	/// ditto
 	Color themeBackground() {
-		return drawingUpon.getComputedStyle().backgroundColor();
+		return drawingUpon.getComputedStyle().background.color;
 	}
 
 	int isDarkTheme() {
@@ -2606,7 +2655,7 @@ struct WidgetPainter {
 
 		auto cs = drawingUpon.getComputedStyle();
 
-		auto bg = cs.backgroundColor;
+		auto bg = cs.background.color;
 
 		auto borderWidth = draw3dFrame(0, 0, drawingUpon.width, drawingUpon.height, this, cs.borderStyle, bg, cs.borderColor);
 
@@ -2690,6 +2739,22 @@ struct WidgetPainter {
 	// done..........
 }
 
+
+struct Style {
+	static struct helper(string m, T) {
+		enum method = m;
+		T v;
+
+		mixin template MethodOverride(typeof(this) v) {
+			mixin("override typeof(v.v) "~v.method~"() { return v.v; }");
+		}
+	}
+
+	static auto opDispatch(string method, T)(T value) {
+		return helper!(method, T)(value);
+	}
+}
+
 /++
 	History:
 		Added Oct 28, 2020
@@ -2727,6 +2792,15 @@ struct ContainerMeta {
 	}
 }
 
+/++
+	This is a helper for [addDataControllerWidget]. You can use it as a UDA on the type. See
+	http://dpldocs.info/this-week-in-d/Blog.Posted_2020_11_02.html for more information.
+
+	Please note that as of May 28, 2021, a dmd bug prevents this from compiling on module-level
+	structures. It works fine on structs declared inside functions though.
+
+	See: https://issues.dlang.org/show_bug.cgi?id=21984
++/
 template Container(CArgs...) {
 	static if(CArgs.length && is(CArgs[0] : Widget)) {
 		private alias Super = CArgs[0];
@@ -2835,17 +2909,57 @@ class DataControllerWidget(T) : Widget {
 		foreach(member; __traits(allMembers, T))
 		static if(member != "this") // wtf
 		static if(__traits(getProtection, __traits(getMember, this.datum, member)) == "public") {
-			auto w = widgetFor!(__traits(getMember, T, member))(&__traits(getMember, this.datum, member), helper(member));
+			void delegate() update;
+
+			auto w = widgetFor!(__traits(getMember, T, member))(&__traits(getMember, this.datum, member), helper(member), update);
+
+			if(update)
+				updaters ~= update;
+
 			static if(is(typeof(__traits(getMember, this.datum, member)) == function))
-				w.addEventListener("triggered", &__traits(getMember, this.datum, member));
+				w.addEventListener("triggered", delegate() {
-			else static if(is(w : DropDownSelection))
+					__traits(getMember, this.datum, member)();
+					notifyDataUpdated();
+				});
+			else static if(is(typeof(w.value) == string) || is(typeof(w.content) == string))
 				w.addEventListener("change", (Event e) { genericSetValue(&__traits(getMember, this.datum, member), e.stringValue); } );
 			else
 				w.addEventListener("change", (Event e) { genericSetValue(&__traits(getMember, this.datum, member), e.intValue); } );
 		}
 	}
 
-	Widget[string] memberWidgets;
+	/++
+		If you modify the data in the structure directly, you need to call this to update the UI and propagate any change messages.
+
+		History:
+			Added May 28, 2021
+	+/
+	void notifyDataUpdated() {
+		foreach(updater; updaters)
+			updater();
+
+		this.emit!(ChangeEvent!void)(delegate{});
+	}
+
+	private Widget[string] memberWidgets;
+	private void delegate()[] updaters;
+
+	override int maxHeight() {
+		if(this.children.length == 1)
+			return this.children[0].maxHeight;
+		else
+			return int.max;
+	}
+
+	override int maxWidth() {
+		if(this.children.length == 1)
+			return this.children[0].maxWidth;
+		else
+			return int.max;
+	}
+
+
+	mixin Emits!(ChangeEvent!void);
 }
 
 void genericSetValue(T, W)(T* where, W what) {
@@ -2855,20 +2969,24 @@ void genericSetValue(T, W)(T* where, W what) {
 }
 
 // FIXME: integrate with AutomaticDialog
-static auto widgetFor(alias tt, P)(P valptr, Widget parent) {
+static auto widgetFor(alias tt, P)(P valptr, Widget parent, out void delegate() update) {
 	static if(controlledByCount!tt == 1) {
 		foreach(i, attr; __traits(getAttributes, tt)) {
 			static if(is(typeof(attr) == ControlledBy_!(T, Args), T, Args...)) {
 				auto w = attr.construct(parent);
 				static if(__traits(compiles, w.setPosition(*valptr)))
-					w.setPosition(*valptr);
+					update = () { w.setPosition(*valptr); };
 				else static if(__traits(compiles, w.setValue(*valptr)))
-					w.setValue(*valptr);
+					update = () { w.setValue(*valptr); };
+
+				if(update)
+					update();
 				return w;
 			}
 		}
 	} else static if(controlledByCount!tt == 0) {
 		static if(is(typeof(tt) == enum)) {
+			// FIXME: update
 			auto dds = new DropDownSelection(parent);
 			foreach(idx, option; __traits(allMembers, typeof(tt))) {
 				dds.addOption(option);
@@ -2879,7 +2997,13 @@ static auto widgetFor(alias tt, P)(P valptr, Widget parent) {
 		} else static if(is(typeof(tt) : const long)) {
 			static assert(0);
 		} else static if(is(typeof(tt) : const string)) {
-			static assert(0);
+			auto le = new LabeledLineEdit(__traits(identifier, tt), parent);
+			update = () { le.content = *valptr; };
+			update();
+			return le;
+		} else static if(is(typeof(tt) == function)) {
+			auto w = new Button(__traits(identifier, tt), parent);
+			return w;
 		}
 	} else static assert(0, "multiple controllers not yet supported");
 }
@@ -2899,14 +3023,27 @@ private template controlledByCount(alias tt) {
 /++
 	Intended for UFCS action like `window.addDataControllerWidget(new MyObject());`
 
+	If you provide a `redrawOnChange` widget, it will automatically register a change event handler that calls that widget's redraw method.
+
+	History:
+		The `redrawOnChange` parameter was added on May 28, 2021.
 +/
-DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T t) if(is(T == class)) {
+DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T t, Widget redrawOnChange = null) if(is(T == class)) {
-	return new DataControllerWidget!T(t, parent);
+	auto dcw = new DataControllerWidget!T(t, parent);
+	initializeDataControllerWidget(dcw, redrawOnChange);
+	return dcw;
 }
 
 /// ditto
-DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T* t) if(is(T == struct)) {
+DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T* t, Widget redrawOnChange = null) if(is(T == struct)) {
-	return new DataControllerWidget!T(t, parent);
+	auto dcw = new DataControllerWidget!T(t, parent);
+	initializeDataControllerWidget(dcw, redrawOnChange);
+	return dcw;
+}
+
+private void initializeDataControllerWidget(Widget w, Widget redrawOnChange) {
+	if(redrawOnChange !is null)
+		w.addEventListener("change", delegate() { redrawOnChange.redraw(); });
 }
 
 /+
@@ -2935,6 +3072,8 @@ struct StyleInformation {
 				return Color.fromString(str);
 			else static if(is(T == Measurement))
 				return Measurement(cast(int) toInternal!int(str));
+			else static if(is(T == WidgetBackground))
+				return WidgetBackground.fromString(str);
 			else static if(is(T == OperatingSystemFont)) {
 				if(auto f = str in fontCache)
 					return *f;
@@ -2985,7 +3124,7 @@ struct StyleInformation {
 	int minWidth() { return getProperty("min-width", Measurement(w.minWidth())); }
 
 
-	Color backgroundColor() { return getProperty("background-color", extractStyleProperty!"backgroundColor"(w)); }
+	WidgetBackground background() { return getProperty("background", extractStyleProperty!"background"(w)); }
 	Color foregroundColor() { return getProperty("foreground-color", extractStyleProperty!"foregroundColor"(w)); }
 
 	OperatingSystemFont font() { return getProperty("font", extractStyleProperty!"fontCached"(w)); }
@@ -3260,8 +3399,8 @@ class ListWidget : ListWidgetBase {
 	}
 
 	static class Style : Widget.Style {
-		override Color backgroundColor() {
+		override WidgetBackground background() {
-			return WidgetPainter.visualTheme.widgetBackgroundColor;
+			return WidgetBackground(WidgetPainter.visualTheme.widgetBackgroundColor);
 		}
 	}
 	mixin OverrideStyle!Style;
@@ -4175,6 +4314,7 @@ class HorizontalSlider : Slider {
 	protected override void setPositionCustom(int a) {
 		if(max())
 			thumb.positionX = a * (thumb.width - 16) / max();
+		redraw();
 	}
 }
 
@@ -4774,6 +4914,8 @@ class TabWidget : Widget {
 	this(Widget parent) {
 		super(parent);
 
+		tabStop = false;
+
 		version(win32_widgets) {
 			createWin32Window(this, WC_TABCONTROL, "", 0);
 		} else version(custom_widgets) {
@@ -4883,11 +5025,14 @@ class TabWidget : Widget {
 		int tabWidth = 80;
 	}
 
+	version(win32_widgets)
+	override void paint(WidgetPainter painter) {}
+
 	version(custom_widgets)
 	override void paint(WidgetPainter painter) {
 		auto cs = getComputedStyle();
 
-		draw3dFrame(0, tabBarHeight - 2, width, height - tabBarHeight + 2, painter, FrameStyle.risen, cs.backgroundColor);
+		draw3dFrame(0, tabBarHeight - 2, width, height - tabBarHeight + 2, painter, FrameStyle.risen, cs.background.color);
 
 		int posX = 0;
 		foreach(idx, child; children) {
@@ -5075,6 +5220,7 @@ class TabWidgetPage : Widget {
 	string title;
 	this(string title, Widget parent) {
 		this.title = title;
+		this.tabStop = false;
 		super(parent);
 
 		///*
@@ -5441,11 +5587,11 @@ class Window : Widget {
 	}
 
 	static class Style : Widget.Style {
-		override Color backgroundColor() {
+		override WidgetBackground background() {
 			version(custom_widgets)
-				return WidgetPainter.visualTheme.windowBackgroundColor;
+				return WidgetBackground(WidgetPainter.visualTheme.windowBackgroundColor);
 			else version(win32_widgets)
-				return Color.transparent;
+				return WidgetBackground(Color.transparent);
 			else static assert(0);
 		}
 	}
@@ -5843,15 +5989,17 @@ class Window : Widget {
 		auto eleR = widgetAtPoint(this, ev.x, ev.y);
 		auto ele = eleR.widget;
 
+		auto captureEle = ele;
+
 		if(mouseCapturedBy !is null) {
 			if(ele !is mouseCapturedBy && !mouseCapturedBy.isAParentOf(ele))
-				ele = mouseCapturedBy;
+				captureEle = mouseCapturedBy;
 		}
 
 		// a hack to get it relative to the widget.
 		eleR.x = ev.x;
 		eleR.y = ev.y;
-		auto pain = ele;
+		auto pain = captureEle;
 		while(pain) {
 			eleR.x -= pain.x;
 			eleR.y -= pain.y;
@@ -5859,7 +6007,7 @@ class Window : Widget {
 		}
 
 		if(ev.type == MouseEventType.buttonPressed) {
-			MouseEventBase event = new MouseDownEvent(ele);
+			MouseEventBase event = new MouseDownEvent(captureEle);
 			event.button = ev.button;
 			event.buttonLinear = ev.buttonLinear;
 			event.state = ev.modifierState;
@@ -5868,7 +6016,7 @@ class Window : Widget {
 			event.dispatch();
 
 			if(ev.button != MouseButton.wheelDown && ev.button != MouseButton.wheelUp && mouseLastDownOn is ele && ev.doubleClick) {
-				event = new DoubleClickEvent(ele);
+				event = new DoubleClickEvent(captureEle);
 				event.button = ev.button;
 				event.buttonLinear = ev.buttonLinear;
 				event.state = ev.modifierState;
@@ -5883,7 +6031,7 @@ class Window : Widget {
 			mouseLastDownOn = ele;
 		} else if(ev.type == MouseEventType.buttonReleased) {
 			{
-				auto event = new MouseUpEvent(ele);
+				auto event = new MouseUpEvent(captureEle);
 				event.button = ev.button;
 				event.buttonLinear = ev.buttonLinear;
 				event.clientX = eleR.x;
@@ -5892,7 +6040,7 @@ class Window : Widget {
 				event.dispatch();
 			}
 			if(!lastWasDoubleClick && mouseLastDownOn is ele) {
-				MouseEventBase event = new ClickEvent(ele);
+				MouseEventBase event = new ClickEvent(captureEle);
 				event.clientX = eleR.x;
 				event.clientY = eleR.y;
 				event.state = ev.modifierState;
@@ -5903,7 +6051,7 @@ class Window : Widget {
 		} else if(ev.type == MouseEventType.motion) {
 			// motion
 			{
-				auto event = new MouseMoveEvent(ele);
+				auto event = new MouseMoveEvent(captureEle);
 				event.state = ev.modifierState;
 				event.clientX = eleR.x;
 				event.clientY = eleR.y;
@@ -6143,11 +6291,11 @@ class Labeled(T) : Widget {
 	override int marginBottom() { return 4; }
 
 	///
-	string content() {
+	@property string content() {
 		return lineEdit.content;
 	}
 	///
-	void content(string c) {
+	@property void content(string c) {
 		return lineEdit.content(c);
 	}
 
@@ -6171,8 +6319,65 @@ class Labeled(T) : Widget {
 +/
 alias LabeledPasswordEdit = Labeled!PasswordEdit;
 
+private string toMenuLabel(string s) {
+	string n;
+	n.reserve(s.length);
+	foreach(c; s)
+		if(c == '_')
+			n ~= ' ';
+		else
+			n ~= c;
+	return n;
+}
 
-///
+private void delegate() makeAutomaticHandler(alias fn, T)(T t) {
+	static if(is(T : void delegate())) {
+		return t;
+	} else {
+		static if(is(typeof(fn) Params == __parameters))
+		struct S {
+			static foreach(idx, ignore; Params) {
+				mixin("Params[idx] " ~ __traits(identifier, Params[idx .. idx + 1]) ~ ";");
+			}
+		}
+		return () {
+			dialog((S s) {
+				t(s.tupleof);
+			}, null, __traits(identifier, fn));
+		};
+	}
+}
+
+private template hasAnyRelevantAnnotations(a...) {
+	bool helper() {
+		bool any;
+		foreach(attr; a) {
+			static if(is(typeof(attr) == .menu))
+				any = true;
+			else static if(is(typeof(attr) == .toolbar))
+				any = true;
+			else static if(is(attr == .separator))
+				any = true;
+			else static if(is(typeof(attr) == .accelerator))
+				any = true;
+			else static if(is(typeof(attr) == .hotkey))
+				any = true;
+			else static if(is(typeof(attr) == .icon))
+				any = true;
+			else static if(is(typeof(attr) == .label))
+				any = true;
+			else static if(is(typeof(attr) == .tip))
+				any = true;
+		}
+		return any;
+	}
+
+	enum bool hasAnyRelevantAnnotations = helper();
+}
+
+/++
+	A `MainWindow` is a window that includes turnkey support for a menu bar, tool bar, and status bar automatically positioned around a client area where you put your widgets.
++/
 class MainWindow : Window {
 	///
 	this(string title = null, int initialWidth = 500, int initialHeight = 500) {
@@ -6200,7 +6405,7 @@ class MainWindow : Window {
                         void Open() {}
                         void Save() {}
                         @separator
-                        void Exit() @accelerator("Alt+F4") {
+                        void Exit() @accelerator("Alt+F4") @hotkey('x') {
                                 window.close();
                         }
                 }
@@ -6225,6 +6430,8 @@ class MainWindow : Window {
         window.setMenuAndToolbarFromAnnotatedCode(commands);
 	---
 
+	Note that you can call this function multiple times and it will add the items in order to the given items.
+
 	+/
 	void setMenuAndToolbarFromAnnotatedCode(T)(ref T t) if(!is(T == class) && !is(T == interface)) {
 		setMenuAndToolbarFromAnnotatedCode_internal(t);
@@ -6241,10 +6448,9 @@ class MainWindow : Window {
 			mcs[menu.label] = menu;
 		}
 
-		void delegate() triggering;
-
 		foreach(memberName; __traits(derivedMembers, T)) {
-			static if(__traits(compiles, triggering = &__traits(getMember, t, memberName))) {
+			static if(memberName != "this")
+			static if(hasAnyRelevantAnnotations!(__traits(getAttributes, __traits(getMember, T, memberName)))) {
 				.menu menu;
 				.toolbar toolbar;
 				bool separator;
@@ -6275,13 +6481,16 @@ class MainWindow : Window {
 				if(menu !is .menu.init || toolbar !is .toolbar.init) {
 					ushort correctIcon = icon.id; // FIXME
 					if(label.length == 0)
-						label = memberName;
+						label = memberName.toMenuLabel;
-					auto action = new Action(label, correctIcon, &__traits(getMember, t, memberName));
+
+					auto handler = makeAutomaticHandler!(__traits(getMember, T, memberName))(&__traits(getMember, t, memberName));
+
+					auto action = new Action(label, correctIcon, handler);
 
 					if(accelerator.keyString.length) {
 						auto ke = KeyEvent.parse(accelerator.keyString);
 						action.accelerator = ke;
-						accelerators[ke.toStr] = &__traits(getMember, t, memberName);
+						accelerators[ke.toStr] = handler;
 					}
 
 					if(toolbar !is .toolbar.init)
@@ -6412,8 +6621,9 @@ class MainWindow : Window {
 /+
 	This is really an implementation detail of [MainWindow]
 +/
-class ClientAreaWidget : Widget {
+private class ClientAreaWidget : Widget {
 	this() {
+		this.tabStop = false;
 		super(null);
 		//sa = new ScrollableWidget(this);
 	}
@@ -6433,7 +6643,7 @@ class ClientAreaWidget : Widget {
 
 /**
 	Toolbars are lists of buttons (typically icons) that appear under the menu.
-	Each button ought to correspond to a menu item.
+	Each button ought to correspond to a menu item, represented by [Action] objects.
 */
 class ToolBar : Widget {
 	version(win32_widgets) {
@@ -6520,7 +6730,7 @@ class ToolBar : Widget {
 
 enum toolbarIconSize = 24;
 
-///
+/// An implementation helper for [ToolBar]. Generally, you shouldn't create these yourself and instead just pass [Action]s to [ToolBar]'s constructor and let it create the buttons for you.
 class ToolButton : Button {
 	///
 	this(string label, Widget parent) {
@@ -6680,7 +6890,7 @@ class MenuBar : Widget {
 
 	version(custom_widgets)
 	override void paint(WidgetPainter painter) {
-		draw3dFrame(this, painter, FrameStyle.risen, getComputedStyle().backgroundColor);
+		draw3dFrame(this, painter, FrameStyle.risen, getComputedStyle().background.color);
 	}
 
 	///
@@ -6839,13 +7049,13 @@ class StatusBar : Widget {
 	version(custom_widgets)
 	override void paint(WidgetPainter painter) {
 		auto cs = getComputedStyle();
-		this.draw3dFrame(painter, FrameStyle.sunk, cs.backgroundColor);
+		this.draw3dFrame(painter, FrameStyle.sunk, cs.background.color);
 		int cpos = 0;
 		int remainingLength = this.width;
 		foreach(idx, part; this.partsArray) {
 			auto partWidth = part.width ? part.width : ((idx + 1 == this.partsArray.length) ? remainingLength : 100);
 			painter.setClipRectangle(Point(cpos, 0), partWidth, height);
-			draw3dFrame(cpos, 0, partWidth, height, painter, FrameStyle.sunk, cs.backgroundColor);
+			draw3dFrame(cpos, 0, partWidth, height, painter, FrameStyle.sunk, cs.background.color);
 			painter.setClipRectangle(Point(cpos + 2, 2), partWidth - 4, height - 4);
 
 			painter.outlineColor = cs.foregroundColor();
@@ -6898,7 +7108,7 @@ class ProgressBar : Widget {
 	version(custom_widgets)
 	override void paint(WidgetPainter painter) {
 		auto cs = getComputedStyle();
-		this.draw3dFrame(painter, FrameStyle.sunk, cs.backgroundColor);
+		this.draw3dFrame(painter, FrameStyle.sunk, cs.background.color);
 		painter.fillColor = cs.progressBarColor;
 		painter.drawRectangle(Point(0, 0), width * current / max, height);
 	}
@@ -7236,7 +7446,7 @@ class Menu : Window {
 
 	version(custom_widgets)
 	override void paint(WidgetPainter painter) {
-		this.draw3dFrame(painter, FrameStyle.risen, getComputedStyle.backgroundColor);
+		this.draw3dFrame(painter, FrameStyle.risen, getComputedStyle.background.color);
 	}
 }
 
@@ -7282,7 +7492,7 @@ class MenuItem : MouseActivatedWidget {
 	override void paint(WidgetPainter painter) {
 		auto cs = getComputedStyle();
 		if(dynamicState & DynamicState.depressed)
-			this.draw3dFrame(painter, FrameStyle.sunk, cs.backgroundColor);
+			this.draw3dFrame(painter, FrameStyle.sunk, cs.background.color);
 		if(dynamicState & DynamicState.hover)
 			painter.outlineColor = cs.activeMenuItemColor;
 		else
@@ -7340,23 +7550,28 @@ class MouseActivatedWidget : Widget {
 
 	private bool isChecked_;
 
-	override void attachedToWindow(Window w) {
-		w.addEventListener("mouseup", delegate (Widget _this, Event ev) {
-			setDynamicState(DynamicState.depressed, false);
-		});
-	}
-
 	this(Widget parent) {
 		super(parent);
 
-		addEventListener("mousedown", delegate (Widget _this, Event ev) {
+		addEventListener((MouseDownEvent ev) {
-			setDynamicState(DynamicState.depressed, true);
+			if(ev.button == MouseButton.left) {
-			redraw();
+				setDynamicState(DynamicState.depressed, true);
+				redraw();
+			}
 		});
 
-		addEventListener("mouseup", delegate (Widget _this, Event ev) {
+		addEventListener((MouseUpEvent ev) {
-			setDynamicState(DynamicState.depressed, false);
+			if(ev.button == MouseButton.left) {
-			redraw();
+				setDynamicState(DynamicState.depressed, false);
+				redraw();
+			}
+		});
+
+		addEventListener((MouseMoveEvent mme) {
+			if(!(mme.state & ModifierState.leftButtonDown)) {
+				setDynamicState(DynamicState.depressed, false);
+				redraw();
+			}
 		});
 	}
 
@@ -7390,8 +7605,10 @@ class MouseActivatedWidget : Widget {
 		super.defaultEventHandler_click(ev);
 		if(this.tabStop)
 			this.focus();
-		auto event = new Event(EventType.triggered, this);
+		if(ev.button == MouseButton.left) {
-		event.sendDirectly();
+			auto event = new Event(EventType.triggered, this);
+			event.sendDirectly();
+		}
 	}
 
 }
@@ -7631,16 +7848,16 @@ class Button : MouseActivatedWidget {
 	override int minHeight() { return Window.lineHeight + 4; }
 
 	static class Style : Widget.Style {
-		override Color backgroundColor() {
+		override WidgetBackground background() {
 			auto cs = widget.getComputedStyle(); // FIXME: this is potentially recursive
 
 			auto pressed = DynamicState.depressed | DynamicState.hover;
 			if((widget.dynamicState & pressed) == pressed) {
-				return cs.depressedButtonColor();
+				return WidgetBackground(cs.depressedButtonColor());
 			} else if(widget.dynamicState & DynamicState.hover) {
-				return cs.hoveringColor();
+				return WidgetBackground(cs.hoveringColor());
 			} else {
-				return cs.buttonColor();
+				return WidgetBackground(cs.buttonColor());
 			}
 		}
 
@@ -8609,13 +8826,12 @@ enum EventType : string {
 
 	---
 	class MyEvent : Event {
+		this(Widget w) { super(w); }
 		mixin Register; // adds EventString and other reflection information
 	}
 	---
 
-	## General Conventions
+	Then declare that it is sent with the [Emits] mixin, so you can use [Widget.emit] to dispatch it.
-
-	Change events should NOT be emitted when a value is changed programmatically. Indeed, methods should usually not send events. The point of an event is to know something changed and when you call a method, you already know about it.
 
 	History:
 		Prior to May 2021, Event had a set of pre-made members with no extensibility (outside of diy casts) and no static checks on field presence.
@@ -8623,6 +8839,12 @@ enum EventType : string {
 		After that, those old pre-made members are deprecated accessors and the fields are moved to child classes. To transition, change string events to typed events or do a dynamic cast (don't forget the null check!) in your handler.
 +/
 /+
+
+	## General Conventions
+
+	Change events should NOT be emitted when a value is changed programmatically. Indeed, methods should usually not send events. The point of an event is to know something changed and when you call a method, you already know about it.
+
+
 	## Qt-style signals and slots
 
 	Some events make sense to use with just name and data type. These are one-way notifications with no propagation nor default behavior and thus separate from the other event system.
@@ -8749,7 +8971,10 @@ class Event {
 
 	private bool isBubbling;
 
+	/// This is an internal implementation detail you should not use. It would be private if the language allowed it and it may be removed without notice.
 	protected void adjustScrolling() { }
+	/// ditto
+	protected void adjustClientCoordinates(int deltaX, int deltaY) { }
 
 	/++
 		this sends it only to the target. If you want propagation, use dispatch() instead.
@@ -8839,6 +9064,9 @@ class Event {
 				break;
 		}
 
+		int adjustX;
+		int adjustY;
+
 		isBubbling = true;
 		if(!propagationStopped)
 		foreach(e; chain) {
@@ -8853,6 +9081,14 @@ class Event {
 
 			if(propagationStopped)
 				break;
+
+			if(e.encapsulatedChildren()) {
+				adjustClientCoordinates(adjustX, adjustY);
+				target = e;
+			} else {
+				adjustX += e.x;
+				adjustY += e.y;
+			}
 		}
 
 		if(!defaultPrevented)
@@ -9206,8 +9442,8 @@ abstract class MouseEventBase : Event {
 	int viewportX; /// The mouse event location relative to the window origin
 	int viewportY; /// ditto
 
-	int button; /// [MouseEvent.button]
+	int button; /// See: [MouseEvent.button]
-	int buttonLinear; /// [MouseEvent.buttonLinear]
+	int buttonLinear; /// See: [MouseEvent.buttonLinear]
 
 	int state; ///
 
@@ -9221,6 +9457,12 @@ abstract class MouseEventBase : Event {
 		return button == MouseButton.wheelUp || button == MouseButton.wheelDown;
 	}
 
+	// private
+	override void adjustClientCoordinates(int deltaX, int deltaY) {
+		clientX += deltaX;
+		clientY += deltaY;
+	}
+
 	override void adjustScrolling() {
 	version(custom_widgets) { // TEMP
 		viewportX = clientX;
@@ -9238,6 +9480,12 @@ abstract class MouseEventBase : Event {
 	Indicates that the user has worked with the mouse over your widget. For available properties, see [MouseEventBase].
 
 
+	$(WARNING
+		Important: MouseDownEvent, MouseUpEvent, ClickEvent, and DoubleClickEvent are all sent for all mouse buttons and
+		for wheel movement! You should check the [MouseEventBase.button|button] property in most your handlers to get correct
+		behavior.
+	)
+
 	[MouseDownEvent] is sent when the user presses a mouse button. It is also sent on mouse wheel movement.
 
 	[MouseUpEvent] is sent when the user releases a mouse button.
@@ -9355,6 +9603,7 @@ private WidgetAtPointResponse widgetAtPoint(Widget starting, int x, int y) {
 }
 
 version(win32_widgets) {
+private:
 	import core.sys.windows.commctrl;
 
 	pragma(lib, "comctl32");
@@ -9927,8 +10176,8 @@ class ObjectInspectionWindowImpl(T) : ObjectInspectionWindow {
 	---
 +/
 /// Group: generating_from_code
-void dialog(T)(void delegate(T) onOK, void delegate() onCancel = null) {
+void dialog(T)(void delegate(T) onOK, void delegate() onCancel = null, string title = T.stringof) {
-	auto dg = new AutomaticDialog!T(onOK, onCancel);
+	auto dg = new AutomaticDialog!T(onOK, onCancel, title);
 	dg.show();
 }
 
@@ -9991,12 +10240,12 @@ class AutomaticDialog(T) : Dialog {
 	override int paddingLeft() { return Window.lineHeight; }
 
 
-	this(void delegate(T) onOK, void delegate() onCancel) {
+	this(void delegate(T) onOK, void delegate() onCancel, string title) {
 		static if(is(T == class))
 			t = new T();
 		this.onOK = onOK;
 		this.onCancel = onCancel;
-		super(400, cast(int)(__traits(allMembers, T).length * 2) * (Window.lineHeight + 4 + 2) + Window.lineHeight + 56, T.stringof);
+		super(400, cast(int)(__traits(allMembers, T).length * 2) * (Window.lineHeight + 4 + 2) + Window.lineHeight + 56, title);
 
 		foreach(memberName; __traits(allMembers, T)) {
 			alias member = I!(__traits(getMember, t, memberName))[0];
@@ -10166,6 +10415,31 @@ interface Reflectable {
 	or stylesheets can override this. The virtual ones count as tag-level specificity in css.
 +/
 
+/++
+	Structure to represent a collection of background hints. New features can be added here, so make sure you use the provided constructors and factories for maximum compatibility.
+
+	History:
+		Added May 24, 2021.
++/
+struct WidgetBackground {
+	/++
+		A background with the given solid color.
+	+/
+	this(Color color) {
+		this.color = color;
+	}
+
+	this(WidgetBackground bg) {
+		this = bg;
+	}
+
+	static WidgetBackground fromString(string s) {
+		return WidgetBackground(Color.fromString(s));
+	}
+
+	private Color color;
+}
+
 /++
 	Interface to a custom visual theme which is able to access and use style hint properties, draw stylistic elements, and even completely override existing class' paint methods (though I'd note that can be a lot harder than it may seem due to the various little details of state you need to reflect visually, so that should be your last result!)
 

minigui_addons/color_dialog.d

@@ -123,16 +123,16 @@ class ColorPickerDialog : Dialog {
 			override int maxWidth() { return 150; };
 		};
 
-		h = new LabeledLineEdit("Hue:", vlHsl);
+		h = new LabeledLineEdit("Hue:", TextAlignment.Right, vlHsl);
-		s = new LabeledLineEdit("Saturation:", vlHsl);
+		s = new LabeledLineEdit("Saturation:", TextAlignment.Right, vlHsl);
-		l = new LabeledLineEdit("Lightness:", vlHsl);
+		l = new LabeledLineEdit("Lightness:", TextAlignment.Right, vlHsl);
 
-		css = new LabeledLineEdit("CSS:", vlHsl);
+		css = new LabeledLineEdit("CSS:", TextAlignment.Right, vlHsl);
 
-		r = new LabeledLineEdit("Red:", vlRgb);
+		r = new LabeledLineEdit("Red:", TextAlignment.Right, vlRgb);
-		g = new LabeledLineEdit("Green:", vlRgb);
+		g = new LabeledLineEdit("Green:", TextAlignment.Right, vlRgb);
-		b = new LabeledLineEdit("Blue:", vlRgb);
+		b = new LabeledLineEdit("Blue:", TextAlignment.Right, vlRgb);
-		a = new LabeledLineEdit("Alpha:", vlRgb);
+		a = new LabeledLineEdit("Alpha:", TextAlignment.Right, vlRgb);
 
 		import std.conv;
 		import std.format;

minigui_xml.d

@@ -67,104 +67,347 @@
 		auto page = new PageWidget(parent);
 		page.name = "mypage";
 
-		select.addEventListener("change", (Event event) {
+		select.addEventListener("change", (Event event)
+		{
 			page.setCurrentTab(event.intValue);
 		});
 	---
 +/
-module arsd.minigui_xml;
+module minigui_xml;
 
 public import arsd.minigui;
+public import arsd.minigui : Event;
 
 import arsd.dom;
 
-private template ident(T...) {
+import std.conv;
+import std.exception;
+import std.functional : toDelegate;
+import std.string : strip;
+import std.traits;
+
+private template ident(T...)
+{
 	static if(is(T[0]))
 		alias ident = T[0];
 	else
 		alias ident = void;
 }
 
-private
+enum ParseContinue { recurse, next, abort }
-Widget delegate(string[string] args, Widget parent)[string] widgetFactoryFunctions;
 
-private
+alias WidgetFactory = ParseContinue delegate(Widget parent, Element element, out Widget result);
-void loadMiniguiPublicClasses() {
+alias WidgetTextHandler = void delegate(Widget widget, string text);
-	if(widgetFactoryFunctions !is null)
-		return;
 
+WidgetFactory[string] widgetFactoryFunctions;
+WidgetTextHandler[string] widgetTextHandlers;
+
+void delegate(string eventName, Widget, Event, string content) xmlScriptEventHandler;
+static this()
+{
+	xmlScriptEventHandler = toDelegate(&nullScriptEventHandler);
+}
+
+void nullScriptEventHandler(string eventName, Widget w, Event e, string)
+{
+	import std.stdio : stderr;
+
+	stderr.writeln("Ignoring event ", eventName, " ", e, " on widget ", w.elementName, " because xmlScriptEventHandler is not set");
+}
+
+private bool startsWith(T)(T[] doesThis, T[] startWithThis)
+{
+	return doesThis.length >= startWithThis.length && doesThis[0 .. startWithThis.length] == startWithThis;
+}
+
+private bool isLower(char c)
+{
+	return c >= 'a' && c <= 'z';
+}
+
+private bool isUpper(char c)
+{
+	return c >= 'A' && c <= 'Z';
+}
+
+private char assumeLowerToUpper(char c)
+{
+	return cast(char)(c - 'a' + 'A');
+}
+
+private char assumeUpperToLower(char c)
+{
+	return cast(char)(c - 'A' + 'a');
+}
+
+string hyphenate(string argname)
+{
+	int hyphen;
+	foreach (i, char c; argname)
+		if (c.isUpper && (i == 0 || !argname[i - 1].isUpper))
+			hyphen++;
+
+	if (hyphen == 0)
+		return argname;
+	char[] ret = new char[argname.length + hyphen];
+	int i;
+	bool prevUpper;
+	foreach (char c; argname)
+	{
+		bool upper = c.isUpper;
+		if (upper)
+		{
+			if (!prevUpper)
+				ret[i++] = '-';
+			ret[i++] = c.assumeUpperToLower;
+		}
+		else
+		{
+			ret[i++] = c;
+		}
+		prevUpper = upper;
+	}
+	assert(i == ret.length);
+	return cast(string) ret;
+}
+
+string unhyphen(string argname)
+{
+	int hyphen;
+	foreach (i, char c; argname)
+		if (c == '-' && (i == 0 || argname[i - 1] != '-'))
+			hyphen++;
+
+	if (hyphen == 0)
+		return argname;
+	char[] ret = new char[argname.length - hyphen];
+	int i;
+	char prev;
+	foreach (char c; argname)
+	{
+		if (c != '-')
+		{
+			if (prev == '-' && c.isLower)
+				ret[i++] = c.assumeLowerToUpper;
+			else
+				ret[i++] = c;
+		}
+		prev = c;
+	}
+	assert(i == ret.length);
+	return cast(string) ret;
+}
+
+void initMinigui(Modules...)()
+{
 	import std.traits;
 	import std.conv;
 
-	foreach(memberName; __traits(allMembers, mixin("arsd.minigui"))) static if(!__traits(isDeprecated, __traits(getMember, mixin("arsd.minigui"), memberName))) {
+	static foreach (alias Module; Modules)
-		alias Member = ident!(__traits(getMember, mixin("arsd.minigui"), memberName));
+	{
-		static if(is(Member == class) && !isAbstractClass!Member && is(Member : Widget) && __traits(getProtection, Member) != "private") {
+		pragma(msg, Module.stringof);
-			widgetFactoryFunctions[memberName] = (string[string] args, Widget parent) {
+		appendMiniguiModule!Module;
-				static if(is(Member : Dialog)) {
+	}
-					return new Member();
+}
-				} else static if(is(Member : Window)) {
+
-					return new Member("test");
+void appendMiniguiModule(alias Module, string prefix = null)()
-				} else {
+{
-					auto paramNames = ParameterIdentifierTuple!(__traits(getMember, Member, "__ctor"));
+	foreach(memberName; __traits(allMembers, Module)) static if(!__traits(isDeprecated, __traits(getMember, Module, memberName)))
+	{
+		alias Member = ident!(__traits(getMember, Module, memberName));
+		static if(is(Member == class) && !isAbstractClass!Member && is(Member : Widget) && __traits(getProtection, Member) != "private")
+		{
+			widgetFactoryFunctions[prefix ~ memberName] = (Widget parent, Element element, out Widget widget)
+			{
+				static if(is(Member : Dialog))
+				{
+					widget = new Member();
+				}
+				else static if(is(Member : Menu))
+				{
+					widget = new Menu(null, null);
+				}
+				else static if(is(Member : Window))
+				{
+					widget = new Member("test");
+				}
+				else
+				{
+					string[string] args = element.attributes;
+
+					enum paramNames = ParameterIdentifierTuple!(__traits(getMember, Member, "__ctor"));
 					Parameters!(__traits(getMember, Member, "__ctor")) params;
+					static assert(paramNames.length, Member);
+					bool[cast(int)paramNames.length - 1] requiredParams;
 
-					foreach(idx, param; params[0 .. $-1]) {
+					static foreach (idx, param; params[0 .. $-1])
-						if(auto arg = paramNames[idx] in args) {
+					{{
-							static if(is(typeof(param) == MemoryImage)) {
+						enum hyphenated = paramNames[idx].hyphenate;
+						if (auto arg = hyphenated in args)
+						{
+							enforce(!requiredParams[idx], "May pass required parameter " ~ hyphenated ~ " only exactly once");
+							requiredParams[idx] = true;
+							static if(is(typeof(param) == MemoryImage))
+							{
 
-							} else static if(is(typeof(param) == Color)) {
+							}
+							else static if(is(typeof(param) == Color))
+							{
 								params[idx] = Color.fromString(*arg);
-							} else
+							}
+							else
 								params[idx] = to!(typeof(param))(*arg);
 						}
-					}
+						else
+						{
+							enforce(false, "Missing required parameter " ~ hyphenated ~ " for Widget " ~ memberName);
+							assert(false);
+						}
+					}}
 
 					params[$-1] = parent;
 
-					auto widget = new Member(params);
+					auto member = new Member(params);
+					widget = member;
 
-					if(auto st = "statusTip" in args)
+					foreach (argName, argValue; args)
-						widget.statusTip = *st;
+					{
-					if(auto st = "name" in args)
+						if (argName.startsWith("on-"))
-						widget.name = *st;
+						{
-					return widget;
+							auto eventName = argName[3 .. $].unhyphen;
+							widget.addEventListener(eventName, (event) { xmlScriptEventHandler(eventName, member, event, argValue); });
+						}
+						else
+						{
+							argName = argName.unhyphen;
+							switch (argName)
+							{
+								static foreach (idx, param; params[0 .. $-1])
+								{
+									case paramNames[idx]:
+								}
+									break;
+								static if (is(typeof(Member.addParameter)))
+								{
+								default:
+									member.addParameter(argName, argValue);
+									break;
+								}
+								else
+								{
+									// TODO: add generic parameter setting here (iterate by UDA maybe)
+								default:
+									enforce(false, "Unknown parameter " ~ argName ~ " for Widget " ~ memberName);
+									assert(false);
+								}
+							}
+						}
+					}
 				}
+				return ParseContinue.recurse;
 			};
+
+			enum hasText = is(typeof(Member.text) == string) || is(typeof(Member.text()) == string);
+			enum hasContent = is(typeof(Member.content) == string) || is(typeof(Member.content()) == string);
+			enum hasLabel = is(typeof(Member.label) == string) || is(typeof(Member.label()) == string);
+			static if (hasText || hasContent || hasLabel)
+			{
+				enum member = hasText ? "text" : hasContent ? "content" : hasLabel ? "label" : null;
+				widgetTextHandlers[memberName] = (Widget widget, string text)
+				{
+					auto w = cast(Member)widget;
+					assert(w, "Called widget text handler with widget of type "
+						~ typeid(widget).name ~ " but it was registered for "
+						~ memberName ~ " which is incompatible");
+					mixin("w.", member, " = w.", member, " ~ text;");
+				};
+			}
+
+			// TODO: might want to check for child methods/structs that register as child nodes
 		}
 	}
 }
 
 ///
-Widget makeWidgetFromString(string xml, Widget parent) {
+Widget makeWidgetFromString(string xml, Widget parent)
+{
 	auto document = new Document(xml, true, true);
 	auto r = document.root;
 	return miniguiWidgetFromXml(r, parent);
 }
 
 ///
-Window createWindowFromXml(string xml) {
+Window createWindowFromXml(string xml)
+{
 	return createWindowFromXml(new Document(xml, true, true));
 }
 ///
-Window createWindowFromXml(Document document) {
+Window createWindowFromXml(Document document)
+{
 	auto r = document.root;
 	return cast(Window) miniguiWidgetFromXml(r, null);
 }
 ///
-Widget miniguiWidgetFromXml(Element element, Widget parent) {
+Widget miniguiWidgetFromXml(Element element, Widget parent)
-	if(widgetFactoryFunctions is null)
+{
-		loadMiniguiPublicClasses();
+	Widget w;
-	if(auto factory = element.tagName in widgetFactoryFunctions) {
+	miniguiWidgetFromXml(element, parent, w);
-		auto p = (*factory)(element.attributes, parent);
+	return w;
-		foreach(child; element.children)
+}
-			if(child.tagName != "#text")
+///
-				miniguiWidgetFromXml(child, p);
+ParseContinue miniguiWidgetFromXml(Element element, Widget parent, out Widget w)
-		return p;
+{
-	} else {
+	assert(widgetFactoryFunctions !is null, "No widget factories have been registered, register them using initMinigui!(arsd.minigui); at startup");
-		import std.stdio;
+
-		writeln("Unknown class: ", element.tagName);
+	if (auto factory = element.tagName in widgetFactoryFunctions)
-		return null;
+	{
+		auto c = (*factory)(parent, element, w);
+
+		if (c == ParseContinue.recurse)
+		{
+			c = ParseContinue.next;
+			Widget dummy;
+			foreach (child; element.children)
+				if (miniguiWidgetFromXml(child, w, dummy) == ParseContinue.abort)
+				{
+					c = ParseContinue.abort;
+					break;
+				}
+		}
+		return c;
+	}
+	else if (element.tagName == "#text")
+	{
+		string text = element.nodeValue.strip;
+		if (text.length)
+		{
+			assert(parent, "got xml text without parent, make sure you only pass elements!");
+			if (auto factory = parent.elementName in widgetTextHandlers)
+				(*factory)(parent, text);
+			else
+			{
+				import std.stdio : stderr;
+
+				stderr.writeln("WARN: no text handler for widget ", parent.elementName, " ~= ", [text]);
+			}
+		}
+		return ParseContinue.next;
+	}
+	else
+	{
+		enforce(false, "Unknown tag " ~ element.tagName);
+		assert(false);
 	}
 }
 
+string elementName(Widget w)
+{
+	if (w is null)
+		return null;
+	auto name = typeid(w).name;
+	foreach_reverse (i, char c; name)
+		if (c == '.')
+			return name[i + 1 .. $];
+	return name;
+}
 

nanovega.d

@@ -28,77 +28,38 @@ If you know canvas, you're up to speed with NanoVega in no time.
 $(SIDE_BY_SIDE
 
 	$(COLUMN
-
 		D code with nanovega:
 
 		---
+		import arsd.nanovega;
 		import arsd.simpledisplay;
 
-		import arsd.nanovega;
-
 		void main () {
-		  NVGContext nvg; // our NanoVega context
+			// The NVGWindow class creates a window and sets up the nvg context for you
+			// you can also do these steps yourself, see the other examples in these docs
+			auto window = new NVGWindow(800, 600, "NanoVega Simple Sample");
 
-		  // we need at least OpenGL3 with GLSL to use NanoVega,
+			window.redrawNVGScene = delegate (nvg) {
-		  // so let's tell simpledisplay about that
+				nvg.beginPath(); // start new path
-		  setOpenGLContextVersion(3, 0);
+				nvg.roundedRect(20.5, 30.5, window.width-40, window.height-60, 8); // .5 to draw at pixel center (see NanoVega documentation)
+				// now set filling mode for our rectangle
+				// you can create colors using HTML syntax, or with convenient constants
+				nvg.fillPaint = nvg.linearGradient(20.5, 30.5, window.width-40, window.height-60,
+				NVGColor("#f70"), NVGColor.green);
+				// now fill our rect
+				nvg.fill();
+				// and draw a nice outline
+				nvg.strokeColor = NVGColor.white;
+				nvg.strokeWidth = 2;
+				nvg.stroke();
+				// that's all, folks!
+			};
 
-		  // now create OpenGL window
+			window.eventLoop(0,
-		  auto sdmain = new SimpleWindow(800, 600, "NanoVega Simple Sample", OpenGlOptions.yes, Resizability.allowResizing);
+				delegate (KeyEvent event) {
-
+					if (event == "*-Q" || event == "Escape") { window.close(); return; } // quit on Q, Ctrl+Q, and so on
-		  // we need to destroy NanoVega context on window close
+				},
-		  // stricly speaking, it is not necessary, as nothing fatal
+			);
-		  // will happen if you'll forget it, but let's be polite.
-		  // note that we cannot do that *after* our window was closed,
-		  // as we need alive OpenGL context to do proper cleanup.
-		  sdmain.onClosing = delegate () {
-		    nvg.kill();
-		  };
-
-		  // this is called just before our window will be shown for the first time.
-		  // we must create NanoVega context here, as it needs to initialize
-		  // internal OpenGL subsystem with valid OpenGL context.
-		  sdmain.visibleForTheFirstTime = delegate () {
-		    // yes, that's all
-		    nvg = nvgCreateContext();
-		    if (nvg is null) assert(0, "cannot initialize NanoVega");
-		  };
-
-		  // this callback will be called when we will need to repaint our window
-		  sdmain.redrawOpenGlScene = delegate () {
-		    // fix viewport (we can do this in resize event, or here, it doesn't matter)
-		    glViewport(0, 0, sdmain.width, sdmain.height);
-
-		    // clear window
-		    glClearColor(0, 0, 0, 0);
-		    glClear(glNVGClearFlags); // use NanoVega API to get flags for OpenGL call
-
-		    {
-		      nvg.beginFrame(sdmain.width, sdmain.height); // begin rendering
-		      scope(exit) nvg.endFrame(); // and flush render queue on exit
-
-		      nvg.beginPath(); // start new path
-		      nvg.roundedRect(20.5, 30.5, sdmain.width-40, sdmain.height-60, 8); // .5 to draw at pixel center (see NanoVega documentation)
-		      // now set filling mode for our rectangle
-		      // you can create colors using HTML syntax, or with convenient constants
-		      nvg.fillPaint = nvg.linearGradient(20.5, 30.5, sdmain.width-40, sdmain.height-60, NVGColor("#f70"), NVGColor.green);
-		      // now fill our rect
-		      nvg.fill();
-		      // and draw a nice outline
-		      nvg.strokeColor = NVGColor.white;
-		      nvg.strokeWidth = 2;
-		      nvg.stroke();
-		      // that's all, folks!
-		    }
-		  };
-
-		  sdmain.eventLoop(0, // no pulse timer required
-		    delegate (KeyEvent event) {
-		      if (event == "*-Q" || event == "Escape") { sdmain.close(); return; } // quit on Q, Ctrl+Q, and so on
-		    },
-		  );
-
-		  flushGui(); // let OS do it's cleanup
 		}
 		---
 	)
@@ -470,6 +431,79 @@ The following code illustrates the OpenGL state touched by the rendering code:
     TODO for Ketmar: write some nice example code here, and finish documenting FontStash API.
  */
 module arsd.nanovega;
+
+/// This example shows how to do the NanoVega sample without the [NVGWindow] helper class.
+unittest {
+	import arsd.simpledisplay;
+
+	import arsd.nanovega;
+
+	void main () {
+	  NVGContext nvg; // our NanoVega context
+
+	  // we need at least OpenGL3 with GLSL to use NanoVega,
+	  // so let's tell simpledisplay about that
+	  setOpenGLContextVersion(3, 0);
+
+	  // now create OpenGL window
+	  auto sdmain = new SimpleWindow(800, 600, "NanoVega Simple Sample", OpenGlOptions.yes, Resizability.allowResizing);
+
+	  // we need to destroy NanoVega context on window close
+	  // stricly speaking, it is not necessary, as nothing fatal
+	  // will happen if you'll forget it, but let's be polite.
+	  // note that we cannot do that *after* our window was closed,
+	  // as we need alive OpenGL context to do proper cleanup.
+	  sdmain.onClosing = delegate () {
+	    nvg.kill();
+	  };
+
+	  // this is called just before our window will be shown for the first time.
+	  // we must create NanoVega context here, as it needs to initialize
+	  // internal OpenGL subsystem with valid OpenGL context.
+	  sdmain.visibleForTheFirstTime = delegate () {
+	    // yes, that's all
+	    nvg = nvgCreateContext();
+	    if (nvg is null) assert(0, "cannot initialize NanoVega");
+	  };
+
+	  // this callback will be called when we will need to repaint our window
+	  sdmain.redrawOpenGlScene = delegate () {
+	    // fix viewport (we can do this in resize event, or here, it doesn't matter)
+	    glViewport(0, 0, sdmain.width, sdmain.height);
+
+	    // clear window
+	    glClearColor(0, 0, 0, 0);
+	    glClear(glNVGClearFlags); // use NanoVega API to get flags for OpenGL call
+
+	    {
+	      nvg.beginFrame(sdmain.width, sdmain.height); // begin rendering
+	      scope(exit) nvg.endFrame(); // and flush render queue on exit
+
+	      nvg.beginPath(); // start new path
+	      nvg.roundedRect(20.5, 30.5, sdmain.width-40, sdmain.height-60, 8); // .5 to draw at pixel center (see NanoVega documentation)
+	      // now set filling mode for our rectangle
+	      // you can create colors using HTML syntax, or with convenient constants
+	      nvg.fillPaint = nvg.linearGradient(20.5, 30.5, sdmain.width-40, sdmain.height-60, NVGColor("#f70"), NVGColor.green);
+	      // now fill our rect
+	      nvg.fill();
+	      // and draw a nice outline
+	      nvg.strokeColor = NVGColor.white;
+	      nvg.strokeWidth = 2;
+	      nvg.stroke();
+	      // that's all, folks!
+	    }
+	  };
+
+	  sdmain.eventLoop(0, // no pulse timer required
+	    delegate (KeyEvent event) {
+	      if (event == "*-Q" || event == "Escape") { sdmain.close(); return; } // quit on Q, Ctrl+Q, and so on
+	    },
+	  );
+
+	  flushGui(); // let OS do it's cleanup
+	}
+}
+
 private:
 
 version(aliced) {

simpleaudio.d

@@ -215,7 +215,10 @@ interface SampleController {
 	bool finished();
 
 	/++
-		If the sample has beend paused.
+		If the sample has been paused.
+
+		History:
+			Added May 26, 2021 (dub v10.0)
 	+/
 	bool paused();
 }

simpledisplay.d

@@ -1109,7 +1109,8 @@ version(Windows) {
 	pragma(lib, "user32");
 
 	// for AlphaBlend... a breaking change....
-	pragma(lib, "msimg32");
+	version(CRuntime_DigitalMars) { } else
+		pragma(lib, "msimg32");
 } else version (linux) {
 	//k8: this is hack for rdmd. sorry.
 	static import core.sys.linux.epoll;
@@ -5051,8 +5052,8 @@ void getClipboardImage()(SimpleWindow clipboardOwner, void delegate(MemoryImage)
 
 version(Windows)
 struct WCharzBuffer {
-	wchar[256] staticBuffer;
 	wchar[] buffer;
+	wchar[256] staticBuffer = void;
 
 	size_t length() {
 		return buffer.length;
@@ -6126,7 +6127,11 @@ version (X11) {
 			}
 		}
 
-		///
+		/++
+			Sends a fake press key event.
+
+			Please note you need to call [flushGui] or return to the event loop for this to actually be sent.
+		+/
 		void pressKey(Key key, bool pressed, int delay = 0) {
 			XTestFakeKeyEvent(XDisplayConnection.get, XKeysymToKeycode(XDisplayConnection.get, key), pressed, delay + pressed ? 0 : 5);
 		}
@@ -8532,6 +8537,11 @@ class Sprite : CapableOfBeingDrawnUpon {
 				xrenderPicture = XRenderCreatePicture(display, handle, ARGB32, 0, &attrs);
 			}
 		} else version(Windows) {
+			version(CRuntime_DigitalMars) {
+				//if(enableAlpha)
+					//throw new Exception("Alpha support not available, try recompiling with -m32mscoff");
+			}
+
 			BITMAPINFO infoheader;
 			infoheader.bmiHeader.biSize = infoheader.bmiHeader.sizeof;
 			infoheader.bmiHeader.biWidth = width;
@@ -9973,6 +9983,8 @@ version(Windows) {
 
 			GetObject(s.handle, bm.sizeof, &bm);
 
+			version(CRuntime_DigitalMars) goto noalpha;
+
 			// or should I AlphaBlend!??!?! note it is supposed to be premultiplied  http://www.fengyuan.com/article/alphablend.html
 			if(s.enableAlpha) {
 				auto dw = w ? w : bm.bmWidth;
@@ -9982,8 +9994,10 @@ version(Windows) {
 				bf.SourceConstantAlpha = 255;
 				bf.AlphaFormat = AC_SRC_ALPHA;
 				AlphaBlend(hdc, x, y, dw, dh, hdcMem, ix, iy, dw, dh, bf);
-			} else
+			} else {
+				noalpha:
 				BitBlt(hdc, x, y, w ? w : bm.bmWidth, h ? h : bm.bmHeight, hdcMem, ix, iy, SRCCOPY);
+			}
 
 			SelectObject(hdcMem, hbmOld);
 			DeleteDC(hdcMem);
@@ -10974,8 +10988,9 @@ version(X11) {
 				auto display = XDisplayConnection.get;
 				auto font = XLoadQueryFont(display, xfontstr.ptr);
 				// if the user font choice fails, fixed is pretty reliable (required by X to start!) and not bad either
+				xfontstr = "-*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*";
 				if(font is null)
-					font = XLoadQueryFont(display, "-*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*".ptr);
+					font = XLoadQueryFont(display, xfontstr.ptr);
 
 				char** lol;
 				int lol2;
@@ -11096,6 +11111,8 @@ version(X11) {
 				xftDraw = null;
 			}
 
+			/+
+			// this should prolly legit never be used since if it destroys the font handle from a OperatingSystemFont, it also ruins a reusable resource.
 			if(font && font !is defaultfont) {
 				XFreeFont(display, font);
 				font = null;
@@ -11104,6 +11121,7 @@ version(X11) {
 				XFreeFontSet(display, fontset);
 				fontset = null;
 			}
+			+/
 			XFlush(display);
 
 			if(window.paintingFinishedDg !is null)

terminal.d

@@ -976,10 +976,10 @@ struct Terminal {
 
 	uint tcaps;
 
-	bool inlineImagesSupported() {
+	bool inlineImagesSupported() const {
 		return (tcaps & TerminalCapabilities.arsdImage) ? true : false;
 	}
-	bool clipboardSupported() {
+	bool clipboardSupported() const {
 		version(Win32Console) return true;
 		else return (tcaps & TerminalCapabilities.arsdClipboard) ? true : false;
 	}
@@ -1053,7 +1053,7 @@ struct Terminal {
 	}
 
 	// dependent on tcaps...
-	void displayInlineImage()(ubyte[] imageData) {
+	void displayInlineImage()(in ubyte[] imageData) {
 		if(inlineImagesSupported) {
 			import std.base64;
 
@@ -1074,14 +1074,14 @@ struct Terminal {
 		}
 	}
 
-	void requestCopyToClipboard(string text) {
+	void requestCopyToClipboard(in char[] text) {
 		if(clipboardSupported) {
 			import std.base64;
 			writeStringRaw("\033]52;c;"~Base64.encode(cast(ubyte[])text)~"\007");
 		}
 	}
 
-	void requestCopyToPrimary(string text) {
+	void requestCopyToPrimary(in char[] text) {
 		if(clipboardSupported) {
 			import std.base64;
 			writeStringRaw("\033]52;p;"~Base64.encode(cast(ubyte[])text)~"\007");
@@ -1842,11 +1842,14 @@ struct Terminal {
 	/// It is important to call this when you are finished writing for now if you are using the version=with_eventloop
 	void flush() {
 		version(TerminalDirectToEmulator)
-		if(pipeThroughStdOut) {
+			if(windowGone)
-			fflush(stdout);
+				return;
-			fflush(stderr);
+		version(TerminalDirectToEmulator)
-			return;
+			if(pipeThroughStdOut) {
-		}
+				fflush(stdout);
+				fflush(stderr);
+				return;
+			}
 
 		if(writeBuffer.length == 0)
 			return;
@@ -5249,7 +5252,7 @@ class LineGetter {
 		}
 		cursorPosition++;
 
-		if(cursorPosition >= horizontalScrollPosition + availableLineLength())
+		if(cursorPosition > horizontalScrollPosition + availableLineLength())
 			horizontalScrollPosition++;
 
 		lineChanged = true;
@@ -5384,7 +5387,7 @@ class LineGetter {
 	}
 
 	int availableLineLength() {
-		return terminal.width - startOfLineX - promptLength - 1;
+		return maximumDrawWidth - promptLength - 1;
 	}
 
 
@@ -5494,6 +5497,43 @@ class LineGetter {
 
 	}
 
+	/++
+		If you are implementing a subclass, use this instead of `terminal.width` to see how far you can draw. Use care to remember this is a width, not a right coordinate.
+
+		History:
+			Added May 24, 2021
+	+/
+	final public @property int maximumDrawWidth() {
+		auto tw = terminal.width - startOfLineX;
+		if(_drawWidthMax && _drawWidthMax <= tw)
+			return _drawWidthMax;
+		return tw;
+	}
+
+	/++
+		Sets the maximum width the line getter will use. Set to 0 to disable, in which case it will use the entire width of the terminal.
+
+		History:
+			Added May 24, 2021
+	+/
+	final public @property void maximumDrawWidth(int newMax) {
+		_drawWidthMax = newMax;
+	}
+
+	/++
+		Returns the maximum vertical space available to draw.
+
+		Currently, this is always 1.
+
+		History:
+			Added May 24, 2021
+	+/
+	@property int maximumDrawHeight() {
+		return 1;
+	}
+
+	private int _drawWidthMax = 0;
+
 	private int lastDrawLength = 0;
 	void redraw() {
 		finalizeRedraw(coreRedraw());
@@ -5503,12 +5543,12 @@ class LineGetter {
 		if(!cdi.populated)
 			return;
 
-		if(UseVtSequences) {
+		if(UseVtSequences && !_drawWidthMax) {
 			terminal.writeStringRaw("\033[K");
 		} else {
 			// FIXME: graphemes
-			if(cdi.written < lastDrawLength)
+			if(cdi.written + promptLength < lastDrawLength)
-			foreach(i; cdi.written .. lastDrawLength)
+			foreach(i; cdi.written + promptLength .. lastDrawLength)
 				terminal.write(" ");
 			lastDrawLength = cdi.written;
 		}
@@ -5637,7 +5677,7 @@ class LineGetter {
 		else {
 			// otherwise just try to center it in the screen
 			horizontalScrollPosition = cursorPosition;
-			horizontalScrollPosition -= terminal.width / 2;
+			horizontalScrollPosition -= maximumDrawWidth / 2;
 			// align on a code point boundary
 			aligned(horizontalScrollPosition, -1);
 			if(horizontalScrollPosition < 0)
@@ -5664,7 +5704,7 @@ class LineGetter {
 			positionCursor();
 		}
 
-		lastDrawLength = terminal.width - terminal.cursorX;
+		lastDrawLength = maximumDrawWidth;
 		version(Win32Console)
 			lastDrawLength -= 1; // I don't like this but Windows resizing is different anyway and it is liable to scroll if i go over..
 
@@ -5907,7 +5947,7 @@ class LineGetter {
 
 				// but i do need to ensure we clear any
 				// stuff left on the screen from it.
-				lastDrawLength = terminal.width - 1;
+				lastDrawLength = maximumDrawWidth - 1;
 				supplementalGetter = null;
 				redraw();
 			}
@@ -6534,7 +6574,7 @@ class HistorySearchLineGetter : LineGetter {
 	}
 
 	override void initializeWithSize(bool firstEver = false) {
-		if(terminal.width > 60)
+		if(maximumDrawWidth > 60)
 			this.prompt = "(history search): \"";
 		else
 			this.prompt = "(hs): \"";
@@ -6542,7 +6582,7 @@ class HistorySearchLineGetter : LineGetter {
 	}
 
 	override int availableLineLength() {
-		return terminal.width / 2 - startOfLineX - promptLength - 1;
+		return maximumDrawWidth / 2 - promptLength - 1;
 	}
 
 	override void loadFromHistory(int howFarBack) {
@@ -6589,12 +6629,12 @@ class HistorySearchLineGetter : LineGetter {
 		auto cri = coreRedraw();
 		terminal.write("\" ");
 
-		int available = terminal.width / 2 - 1;
+		int available = maximumDrawWidth / 2 - 1;
 		auto used = prompt.length + cri.written + 3 /* the write above plus a space */;
 		if(used < available)
 			available += available - used;
 
-		//terminal.moveTo(terminal.width / 2, startOfLineY);
+		//terminal.moveTo(maximumDrawWidth / 2, startOfLineY);
 		Drawer drawer = Drawer(this);
 		drawer.lineLength = available;
 		drawer.drawContent(sideDisplay, highlightBegin, highlightEnd);
@@ -6713,105 +6753,225 @@ version(Windows) {
    that widget here too. */
 
 
+/++
+	The ScrollbackBuffer is a writable in-memory terminal that can be drawn to a real [Terminal]
+	and maintain some internal position state by handling events. It is your responsibility to
+	draw it (using the [drawInto] method) and dispatch events to its [handleEvent] method (if you
+	want to, you can also just call the methods yourself).
+
+
+	I originally wrote this to support my irc client and some of the features are geared toward
+	helping with that (for example, [name] and [demandsAttention]), but the main thrust is to
+	support either tabs or sub-sections of the terminal having their own output that can be displayed
+	and scrolled back independently while integrating with some larger application.
+
+	History:
+		Committed to git on August 4, 2015.
+
+		Cleaned up and documented on May 25, 2021.
++/
 struct ScrollbackBuffer {
+	/++
+		A string you can set and process on your own. The library only sets it from the
+		constructor, then leaves it alone.
 
-	bool demandsAttention;
+		In my irc client, I use this as the title of a tab I draw to indicate separate
+		conversations.
+	+/
+	public string name;
+	/++
+		A flag you can set and process on your own. All the library does with it is
+		set it to false when it handles an event, otherwise you can do whatever you
+		want with it.
 
+		In my irc client, I use this to add a * to the tab to indicate new messages.
+	+/
+	public bool demandsAttention;
+
+	/++
+		The coordinates of the last [drawInto]
+	+/
+	int x, y, width, height;
+
+	private CircularBuffer!Line lines;
+	private bool eol; // if the last line had an eol, next append needs a new line. doing this means we won't have a spurious blank line at the end of the draw-in
+
+	/++
+		Property to control the current scrollback position. 0 = latest message
+		at bottom of screen.
+
+		See_Also: [scrollToBottom], [scrollToTop], [scrollUp], [scrollDown], [scrollTopPosition]
+	+/
+	@property int scrollbackPosition() const pure @nogc nothrow @safe {
+		return scrollbackPosition_;
+	}
+
+	/// ditto
+	private @property void scrollbackPosition(int p) pure @nogc nothrow @safe {
+		scrollbackPosition_ = p;
+	}
+
+	private int scrollbackPosition_;
+
+	/++
+		This is the color it uses to clear the screen.
+
+		History:
+			Added May 26, 2021
+	+/
+	public Color defaultForeground = Color.DEFAULT;
+	/// ditto
+	public Color defaultBackground = Color.DEFAULT;
+
+	private int foreground_ = Color.DEFAULT, background_ = Color.DEFAULT;
+
+	/++
+		The name is for your own use only. I use the name as a tab title but you could ignore it and just pass `null` too.
+	+/
 	this(string name) {
 		this.name = name;
 	}
 
+	/++
+		Writing into the scrollback buffer can be done with the same normal functions.
+
+		Note that you will have to call [redraw] yourself to make this actually appear on screen.
+	+/
 	void write(T...)(T t) {
 		import std.conv : text;
 		addComponent(text(t), foreground_, background_, null);
 	}
 
+	/// ditto
 	void writeln(T...)(T t) {
 		write(t, "\n");
 	}
 
+	/// ditto
 	void writef(T...)(string fmt, T t) {
 		import std.format: format;
 		write(format(fmt, t));
 	}
 
+	/// ditto
 	void writefln(T...)(string fmt, T t) {
 		writef(fmt, t, "\n");
 	}
 
-	void clear() {
+	/// ditto
-		lines.clear();
-		clickRegions = null;
-		scrollbackPosition = 0;
-	}
-
-	int foreground_ = Color.DEFAULT, background_ = Color.DEFAULT;
 	void color(int foreground, int background) {
 		this.foreground_ = foreground;
 		this.background_ = background;
 	}
 
+	/++
+		Clears the scrollback buffer.
+	+/
+	void clear() {
+		lines.clear();
+		clickRegions = null;
+		scrollbackPosition_ = 0;
+	}
+
+	/++
+
+	+/
 	void addComponent(string text, int foreground, int background, bool delegate() onclick) {
-		if(lines.length == 0) {
+		addComponent(LineComponent(text, foreground, background, onclick));
+	}
+
+	/++
+
+	+/
+	void addComponent(LineComponent component) {
+		if(lines.length == 0 || eol) {
 			addLine();
+			eol = false;
 		}
 		bool first = true;
 		import std.algorithm;
-		foreach(t; splitter(text, "\n")) {
+
+		if(component.text.length && component.text[$-1] == '\n') {
+			eol = true;
+			component.text = component.text[0 .. $ - 1];
+		}
+
+		foreach(t; splitter(component.text, "\n")) {
 			if(!first) addLine();
 			first = false;
-			lines[$-1].components ~= LineComponent(t, foreground, background, onclick);
+			auto c = component;
+			c.text = t;
+			lines[$-1].components ~= c;
 		}
 	}
 
+	/++
+		Adds an empty line.
+	+/
 	void addLine() {
 		lines ~= Line();
-		if(scrollbackPosition) // if the user is scrolling back, we want to keep them basically centered where they are
+		if(scrollbackPosition_) // if the user is scrolling back, we want to keep them basically centered where they are
-			scrollbackPosition++;
+			scrollbackPosition_++;
 	}
 
+	/++
+		This is what [writeln] actually calls.
+
+		Using this exclusively though can give you more control, especially over the trailing \n.
+	+/
 	void addLine(string line) {
 		lines ~= Line([LineComponent(line)]);
-		if(scrollbackPosition) // if the user is scrolling back, we want to keep them basically centered where they are
+		if(scrollbackPosition_) // if the user is scrolling back, we want to keep them basically centered where they are
-			scrollbackPosition++;
+			scrollbackPosition_++;
 	}
 
+	/++
+		Scrolling controls.
+
+		Notice that `scrollToTop`  needs width and height to know how to word wrap it to determine the number of lines present to scroll back.
+	+/
 	void scrollUp(int lines = 1) {
-		scrollbackPosition += lines;
+		scrollbackPosition_ += lines;
 		//if(scrollbackPosition >= this.lines.length)
 		//	scrollbackPosition = cast(int) this.lines.length - 1;
 	}
 
+	/// ditto
 	void scrollDown(int lines = 1) {
-		scrollbackPosition -= lines;
+		scrollbackPosition_ -= lines;
-		if(scrollbackPosition < 0)
+		if(scrollbackPosition_ < 0)
-			scrollbackPosition = 0;
+			scrollbackPosition_ = 0;
 	}
 
+	/// ditto
 	void scrollToBottom() {
-		scrollbackPosition = 0;
+		scrollbackPosition_ = 0;
 	}
 
-	// this needs width and height to know how to word wrap it
+	/// ditto
 	void scrollToTop(int width, int height) {
-		scrollbackPosition = scrollTopPosition(width, height);
+		scrollbackPosition_ = scrollTopPosition(width, height);
 	}
 
 
+	/++
+		You can construct these to get more control over specifics including
+		setting RGB colors.
 
-
+		But generally just using [write] and friends is easier.
+	+/
 	struct LineComponent {
-		string text;
+		private string text;
-		bool isRgb;
+		private bool isRgb;
-		union {
+		private union {
 			int color;
 			RGB colorRgb;
 		}
-		union {
+		private union {
 			int background;
 			RGB backgroundRgb;
 		}
-		bool delegate() onclick; // return true if you need to redraw
+		private bool delegate() onclick; // return true if you need to redraw
 
 		// 16 color ctor
 		this(string text, int color = Color.DEFAULT, int background = Color.DEFAULT, bool delegate() onclick = null) {
@@ -6832,7 +6992,7 @@ struct ScrollbackBuffer {
 		}
 	}
 
-	struct Line {
+	private struct Line {
 		LineComponent[] components;
 		int length() {
 			int l = 0;
@@ -6842,6 +7002,13 @@ struct ScrollbackBuffer {
 		}
 	}
 
+	/++
+		This is an internal helper for its scrollback buffer.
+
+		It is fairly generic and I might move it somewhere else some day.
+
+		It has a compile-time specified limit of 8192 entries.
+	+/
 	static struct CircularBuffer(T) {
 		T[] backing;
 
@@ -6922,14 +7089,11 @@ struct ScrollbackBuffer {
 		Dollar opDollar() { return Dollar(0); }
 	}
 
-	CircularBuffer!Line lines;
+	/++
-	string name;
+		Given a size, how far would you have to scroll back to get to the top?
-
-	int x, y, width, height;
-
-	int scrollbackPosition;
-
 
+		Please note that this is O(n) with the length of the scrollback buffer.
+	+/
 	int scrollTopPosition(int width, int height) {
 		int lineCount;
 
@@ -6957,6 +7121,11 @@ struct ScrollbackBuffer {
 		//return 0;
 	}
 
+	/++
+		Draws the current state into the given terminal inside the given bounding box.
+
+		Also updates its internal position and click region data which it uses for event filtering in [handleEvent].
+	+/
 	void drawInto(Terminal* terminal, in int x = 0, in int y = 0, int width = 0, int height = 0) {
 		if(lines.length == 0)
 			return;
@@ -7072,7 +7241,10 @@ struct ScrollbackBuffer {
 				if(component.isRgb)
 					terminal.setTrueColor(component.colorRgb, component.backgroundRgb);
 				else
-					terminal.color(component.color, component.background);
+					terminal.color(
+						component.color == Color.DEFAULT ? defaultForeground : component.color,
+						component.background == Color.DEFAULT ? defaultBackground : component.background,
+					);
 				auto towrite = component.text;
 
 				again:
@@ -7109,7 +7281,7 @@ struct ScrollbackBuffer {
 			}
 
 			if(written < width) {
-				terminal.color(Color.DEFAULT, Color.DEFAULT);
+				terminal.color(defaultForeground, defaultBackground);
 				foreach(i; written .. width)
 					terminal.write(" ");
 			}
@@ -7121,7 +7293,7 @@ struct ScrollbackBuffer {
 		}
 
 		if(linePos < height) {
-			terminal.color(Color.DEFAULT, Color.DEFAULT);
+			terminal.color(defaultForeground, defaultBackground);
 			foreach(i; linePos .. height) {
 				if(i >= 0 && i < height) {
 					terminal.moveTo(x, y + i);
@@ -7140,11 +7312,13 @@ struct ScrollbackBuffer {
 	}
 	private ClickRegion[] clickRegions;
 
-	/// Default event handling for this widget. Call this only after drawing it into a rectangle
+	/++
-	/// and only if the event ought to be dispatched to it (which you determine however you want;
+		Default event handling for this widget. Call this only after drawing it into a rectangle
-	/// you could dispatch all events to it, or perhaps filter some out too)
+		and only if the event ought to be dispatched to it (which you determine however you want;
-	///
+		you could dispatch all events to it, or perhaps filter some out too)
-	/// Returns true if it should be redrawn
+
+		Returns: true if it should be redrawn
+	+/
 	bool handleEvent(InputEvent e) {
 		final switch(e.type) {
 			case InputEvent.Type.LinkEvent:
@@ -7163,10 +7337,16 @@ struct ScrollbackBuffer {
 						scrollDown();
 						return true;
 					case KeyboardEvent.Key.PageUp:
-						scrollUp(height);
+						if(ev.modifierState & ModifierState.control)
+							scrollToTop(width, height);
+						else
+							scrollUp(height);
 						return true;
 					case KeyboardEvent.Key.PageDown:
-						scrollDown(height);
+						if(ev.modifierState & ModifierState.control)
+							scrollToBottom();
+						else
+							scrollDown(height);
 						return true;
 					default:
 						// ignore