diff --git a/calendar.d b/calendar.d
index 1ec069d..1f0c0fe 100644
--- a/calendar.d
+++ b/calendar.d
@@ -289,3 +289,13 @@ immutable monthNames = [
 	"November",
 	"December"
 ];
+
+immutable daysOfWeekNames = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday",
+];
diff --git a/core.d b/core.d
index c200331..3488994 100644
--- a/core.d
+++ b/core.d
@@ -129,7 +129,8 @@ version(OSXCocoa) {
 		enum bool UseCocoa = false;
 	else
 		enum bool UseCocoa = true;
-}
+} else
+	enum bool UseCocoa = false;
 
 import core.attribute;
 static if(!__traits(hasMember, core.attribute, "mustuse"))
@@ -199,18 +200,22 @@ version(Emscripten)  {
 }
 
 // FIXME: pragma(linkerDirective, "-framework", "Cocoa") works in ldc
-version(OSXCocoa)
+static if(UseCocoa)
 	enum CocoaAvailable = true;
 else
 	enum CocoaAvailable = false;
 
 version(D_OpenD) {
-	version(OSXCocoa)
+	static if(UseCocoa) {
 		pragma(linkerDirective, "-framework", "Cocoa");
+		pragma(linkerDirective, "-framework", "QuartzCore");
+	}
 } else {
-	version(OSXCocoa)
-	version(LDC)
+	static if(UseCocoa)
+	version(LDC) {
 		pragma(linkerDirective, "-framework", "Cocoa");
+		pragma(linkerDirective, "-framework", "QuartzCore");
+	}
 }
 
 version(Posix) {
@@ -1897,7 +1902,7 @@ unittest {
 	assert(decodeUriComponent("+", true) == " ");
 }
 
-private auto toDelegate(T)(T t) {
+public auto toDelegate(T)(T t) {
 	// static assert(is(T == function)); // lol idk how to do what i actually want here
 
 	static if(is(T Return == return))
@@ -1908,8 +1913,8 @@ private auto toDelegate(T)(T t) {
 			}
 		}
 		return &((cast(Wrapper*) t).call);
-	} else static assert(0, "could not get params");
-	else static assert(0, "could not get return value");
+	} else static assert(0, "could not get params; is it already a delegate you can pass directly?");
+	else static assert(0, "could not get return value, if it is a functor maybe try getting a delegate with `&yourobj.opCall` instead of toDelegate(yourobj)");
 }
 
 @system unittest {
@@ -4519,7 +4524,8 @@ class Timer {
 
 	version(Windows) {} else
 	static void unregister(arsd.core.ICoreEventLoop.UnregisterToken urt) {
-		urt.unregister();
+		if(urt.impl !is null)
+			urt.unregister();
 	}
 
 
@@ -4576,7 +4582,7 @@ class Timer {
 		CallbackHelper cbh;
 	} else version(linux) {
 		int fd = -1;
-	} else version(OSXCocoa) {
+	} else static if(UseCocoa) {
 	} else static assert(0, "timer not supported");
 }
 
@@ -9242,7 +9248,7 @@ package(arsd) version(Windows) extern(Windows) {
 	int WSARecvFrom(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, sockaddr*, LPINT, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
 }
 
-package(arsd) version(OSXCocoa) {
+package(arsd) static if(UseCocoa) {
 
 /* Copy/paste chunk from Jacob Carlborg { */
 // from https://raw.githubusercontent.com/jacob-carlborg/druntime/550edd0a64f0eb2c4f35d3ec3d88e26b40ac779e/src/core/stdc/clang_block.d
diff --git a/discord.d b/discord.d
index db34f54..b9f68f9 100644
--- a/discord.d
+++ b/discord.d
@@ -22,6 +22,8 @@
 +/
 module arsd.discord;
 
+// FIXME: it thought it was still alive but showed as not online and idk why. maybe setPulseCallback stopped triggering?
+
 // FIXME: Secure Connect Failed sometimes on trying to reconnect, should prolly just try again after a short period, or ditch the whole thing if reconnectAndResume and try fresh
 
 // FIXME: User-Agent: DiscordBot ($url, $versionNumber)
@@ -672,6 +674,7 @@ class DiscordGatewayConnection {
 		} else {
 			// otherwise, unless we were asked by the api user to close, let's try reconnecting
 			// since discord just does discord things.
+			websocket_ = null;
 			connect();
 		}
 	}
@@ -947,6 +950,8 @@ class DiscordGatewayConnection {
 		auto d = 1.seconds;
 		int count = 0;
 
+		try_again:
+
 		try {
 			this.websocket_.connect();
 		} catch(Exception e) {
@@ -956,6 +961,8 @@ class DiscordGatewayConnection {
 			count++;
 			if(count == 10)
 				throw e;
+
+			goto try_again;
 		}
 	}
 
diff --git a/dom.d b/dom.d
index 86f19d7..24ece43 100644
--- a/dom.d
+++ b/dom.d
@@ -4825,6 +4825,19 @@ struct AttributesHolder {
 		}
 		return 0;
 	}
+
+	string toString() {
+		string ret;
+		foreach(k, v; this) {
+			if(ret.length)
+				ret ~= " ";
+			ret ~= k;
+			ret ~= `="`;
+			ret ~= v;
+			ret ~= `"`;
+		}
+		return ret;
+	}
 }
 
 unittest {
diff --git a/http2.d b/http2.d
index 20b0343..e29a625 100644
--- a/http2.d
+++ b/http2.d
@@ -5620,6 +5620,7 @@ class WebSocket {
 			activeSockets ~= s;
 			s.registered = true;
 			version(use_arsd_core) {
+				version(Posix)
 				s.unregisterToken = arsd.core.getThisThreadEventLoop().addCallbackOnFdReadable(s.socket.handle, new arsd.core.CallbackHelper(() { s.readyToRead(s); }));
 			}
 		}
diff --git a/minigui.d b/minigui.d
index 30d68c8..0274c5d 100644
--- a/minigui.d
+++ b/minigui.d
@@ -21,6 +21,8 @@
 
 // FIXME: add menu checkbox and menu icon eventually
 
+// FIXME: checkbox menus and submenus and stuff
+
 // FOXME: look at Windows rebar control too
 
 /*
@@ -668,11 +670,23 @@ version(Windows) {
 }
 
 version(Windows) {
-	version(minigui_manifest) {} else version=minigui_no_manifest;
+	// to swap the default
+	// version(minigui_manifest) {} else version=minigui_no_manifest;
 
-	version(minigui_no_manifest) {} else
-	static if(__VERSION__ >= 2_083)
-	version(CRuntime_Microsoft) { // FIXME: mingw?
+	version(minigui_no_manifest) {} else {
+		version(D_OpenD) {
+			// OpenD always supports it
+			version=UseManifestMinigui;
+		} else {
+			static if(__VERSION__ >= 2_083)
+			version(CRuntime_Microsoft) // FIXME: mingw?
+				version=UseManifestMinigui;
+		}
+
+	}
+
+
+	version(UseManifestMinigui) {
 		// assume we want commctrl6 whenever possible since there's really no reason not to
 		// and this avoids some of the manifest hassle
 		pragma(linkerDirective, "\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"");
@@ -1482,16 +1496,21 @@ class Widget : ReflectableProperties {
 	Menu contextMenu(int x, int y) { return null; }
 
 	/++
-		Shows the widget's context menu, as if the user right clicked at the x, y position. You should rarely, if ever, have to call this, since default event handlers will do it for you automatically. To control what menu shows up, override [contextMenu] instead.
+		Shows the widget's context menu, as if the user right clicked at the x, y position. You should rarely, if ever, have to call this, since default event handlers will do it for you automatically. To control what menu shows up, you can pass one as `menuToShow`, but if you don't, it will call [contextMenu], which you can override on a per-widget basis.
+
+		History:
+			The `menuToShow` parameter was added on March 19, 2025.
 	+/
-	final bool showContextMenu(int x, int y) {
-		return showContextMenu(x, y, -2, -2);
+	final bool showContextMenu(int x, int y, Menu menuToShow = null) {
+		return showContextMenu(x, y, -2, -2, menuToShow);
 	}
 
-	private final bool showContextMenu(int x, int y, int screenX, int screenY) {
+	private final bool showContextMenu(int x, int y, int screenX, int screenY, Menu menu = null) {
 		if(parentWindow is null || parentWindow.win is null) return false;
 
-		auto menu = this.contextMenu(x, y);
+		if(menu is null)
+			menu = this.contextMenu(x, y);
+
 		if(menu is null)
 			return false;
 
@@ -2312,7 +2331,7 @@ class Widget : ReflectableProperties {
 		bool invalidateChildren = invalidate;
 
 		if(redrawRequested || force) {
-			painter.setClipRectangle(clip.upperLeft - Point(painter.originX, painter.originY), clip.width, clip.height);
+			painter.setClipRectangleForWidget(clip.upperLeft - Point(painter.originX, painter.originY), clip.width, clip.height);
 
 			painter.drawingUpon = this;
 
@@ -4224,6 +4243,10 @@ struct WidgetPainter {
 	this(ScreenPainter screenPainter, Widget drawingUpon) {
 		this.drawingUpon = drawingUpon;
 		this.screenPainter = screenPainter;
+
+		this.widgetClipRectangle = screenPainter.currentClipRectangle;
+
+		// this.screenPainter.impl.enableXftDraw();
 		if(auto font = visualTheme.defaultFontCached(drawingUpon.currentDpi))
 			this.screenPainter.setFont(font);
 	}
@@ -4241,10 +4264,37 @@ struct WidgetPainter {
 		}
 	}
 
+	private Rectangle widgetClipRectangle;
+
+	private Rectangle setClipRectangleForWidget(Point upperLeft, int width, int height) {
+		widgetClipRectangle = Rectangle(upperLeft, Size(width, height));
+
+		return screenPainter.setClipRectangle(widgetClipRectangle);
+	}
+
+	/++
+		Sets the clip rectangle to the given settings. It will automatically calculate the intersection
+		of your widget's content boundaries and your requested clip rectangle.
+
+		History:
+			Before February 26, 2025, you could sometimes exceed widget boundaries, as this forwarded
+			directly to the underlying `ScreenPainter`. It now wraps it to calculate the intersection.
+	+/
+	Rectangle setClipRectangle(Rectangle rectangle) {
+		return screenPainter.setClipRectangle(rectangle.intersectionOf(widgetClipRectangle));
+	}
+	/// ditto
+	Rectangle setClipRectangle(Point upperLeft, int width, int height) {
+		return setClipRectangle(Rectangle(upperLeft, Size(width, height)));
+	}
+	/// ditto
+	Rectangle setClipRectangle(Point upperLeft, Size size) {
+		return setClipRectangle(Rectangle(upperLeft, size));
+	}
 
 	///
 	ScreenPainter screenPainter;
-	/// Forward to the screen painter for other methods
+	/// Forward to the screen painter for all other methods, see [arsd.simpledisplay.ScreenPainter] for more information
 	alias screenPainter this;
 
 	private Widget drawingUpon;
@@ -4718,6 +4768,10 @@ private static auto widgetFor(alias tt, P)(P valptr, Widget parent, out void del
 			update = () { le.content = *valptr; };
 			update();
 			return le;
+		} else static if(is(typeof(tt) == E[], E)) {
+			auto w = new ArrayEditingWidget!E(parent);
+			// FIXME update
+			return w;
 		} else static if(is(typeof(tt) == function)) {
 			auto w = new Button(displayName, parent);
 			return w;
@@ -4727,6 +4781,300 @@ private static auto widgetFor(alias tt, P)(P valptr, Widget parent, out void del
 	} else static assert(0, "multiple controllers not yet supported");
 }
 
+class ArrayEditingWidget(T) : ArrayEditingWidgetBase {
+	this(Widget parent) {
+		super(parent);
+	}
+}
+
+class ArrayEditingWidgetBase : Widget {
+	this(Widget parent) {
+		super(parent);
+
+		// FIXME: a trash can to move items into to delete them?
+		static class MyListViewItem : GenericListViewItem {
+			this(Widget parent) {
+				super(parent);
+
+				/+
+					drag handle
+						left click lets you move the whole selection. if the current element is not selected, it changes the selection to it.
+						right click here gives you the movement controls too
+					index/key view zone
+						left click here selects/unselects
+					element view/edit zone
+					delete button
+				+/
+
+				// FIXME: make sure the index is viewable
+
+				auto hl = new HorizontalLayout(this);
+
+				button = new CommandButton("d", hl);
+
+				label = new TextLabel("unloaded", TextAlignment.Left, hl);
+				// if member editable, have edit view... get from the subclass.
+
+				// or a "..." menu?
+				button = new CommandButton("Up", hl); // shift+click is move to top
+				button = new CommandButton("Down", hl); // shift+click is move to bottom
+				button = new CommandButton("Move to", hl); // move before, after, or swap
+				button = new CommandButton("Delete", hl);
+
+				button.addEventListener("triggered", delegate(){
+					//messageBox(text("clicked ", currentIndexLoaded()));
+				});
+			}
+			override void showItem(int idx) {
+				label.label = "Item ";// ~ to!string(idx);
+			}
+
+			TextLabel label;
+			Button button;
+		}
+
+		auto outer_this = this;
+
+		// FIXME: make sure item count is easy to see
+
+		glvw = new class GenericListViewWidget {
+			this() {
+				super(outer_this);
+			}
+			override GenericListViewItem itemFactory(Widget parent) {
+				return new MyListViewItem(parent);
+			}
+			override Size itemSize() {
+				return Size(0, scaleWithDpi(80));
+			}
+
+			override Menu contextMenu(int x, int y) {
+				return createContextMenuFromAnnotatedCode(this);
+			}
+
+			@context_menu {
+				void Select_All() {
+
+				}
+
+				void Undo() {
+
+				}
+
+				void Redo() {
+
+				}
+
+				void Cut() {
+
+				}
+
+				void Copy() {
+
+				}
+
+				void Paste() {
+
+				}
+
+				void Delete() {
+
+				}
+
+				void Find() {
+
+				}
+			}
+		};
+
+		glvw.setItemCount(400);
+
+		auto hl = new HorizontalLayout(this);
+		add = new FreeEntrySelection(hl);
+		addButton = new Button("Add", hl);
+	}
+
+	GenericListViewWidget glvw;
+	ComboboxBase add;
+	Button addButton;
+	/+
+		Controls:
+			clear (select all / delete)
+			reset (confirmation blocked button, maybe only on the whole form? or hit undo so many times to get back there)
+			add item
+				palette of options to add to the array (add prolly a combo box)
+			rearrange - move up/down, drag and drop a selection? right click can always do, left click only drags when on a selection handle.
+			edit/input/view items (GLVW? or it could be a table view in a way.)
+			undo/redo
+			select whole elements (even if a struct)
+			cut/copy/paste elements
+
+			could have an element picker, a details pane, and an add bare?
+
+
+			put a handle on the elements for left click dragging. allow right click drag anywhere but pretty big wiggle until it enables.
+			left click and drag should never work for plain text, i more want to change selection there and there no room to put a handle on it.
+			the handle should let dragging w/o changing the selection, or if part of the selection, drag the whole selection i think.
+			make it textured and use the grabby hand mouse cursor.
+	+/
+}
+
+/++
+	A button that pops up a menu on click for working on a particular item or selection.
+
+	History:
+		Added March 23, 2025
++/
+class MenuPopupButton : Button {
+	/++
+		You might consider using [createContextMenuFromAnnotatedCode] to populate the `menu` argument.
+
+		You also may want to set the [prepare] delegate after construction.
+	+/
+	this(Menu menu, Widget parent) {
+		assert(menu !is null);
+
+		this.menu = menu;
+		super("...", parent);
+	}
+
+	private Menu menu;
+	/++
+		If set, this delegate is called before popping up the window. This gives you a chance
+		to prepare your dynamic data structures for the element(s) selected.
+
+		For example, if your `MenuPopupButton` is attached to a [GenericListViewItem], you can call
+		[GenericListViewItem.currentIndexLoaded] in here and set it to a variable in the object you
+		called [createContextMenuFromAnnotatedCode] to apply the operation to the right object.
+
+		(The api could probably be simpler...)
+	+/
+	void delegate() prepare;
+
+	override void defaultEventHandler_triggered(scope Event e) {
+		if(prepare)
+			prepare();
+		showContextMenu(this.x, this.y + this.height, -2, -2, menu);
+	}
+
+	override int maxHeight() {
+		return defaultLineHeight;
+	}
+
+	override int maxWidth() {
+		return defaultLineHeight;
+	}
+}
+
+/++
+	A button that pops up an information box, similar to a tooltip, but explicitly triggered.
+
+	FIXME: i want to be able to easily embed these in other things too.
++/
+class TipPopupButton : Button {
+	/++
+	+/
+	this(Widget delegate(Widget p) factory, Widget parent) {
+		this.factory = factory;
+		super("?", parent);
+	}
+
+	private Widget delegate(Widget p) factory;
+
+	override void defaultEventHandler_triggered(scope Event e) {
+		auto window = new TooltipWindow(factory, this);
+		window.popup(this);
+	}
+}
+
+/++
+	History:
+		Added March 23, 2025
++/
+class TooltipWindow : Window {
+	void popup(Widget parent, int offsetX = 0, int offsetY = int.min) {
+		/+
+		this.menuParent = parent;
+
+		previouslyFocusedWidget = parent.parentWindow.focusedWidget;
+		previouslyFocusedWidgetBelongsIn = &parent.parentWindow.focusedWidget;
+		parent.parentWindow.focusedWidget = this;
+
+		int w = 150;
+		int h = paddingTop + paddingBottom;
+		if(this.children.length) {
+			// hacking it to get the ideal height out of recomputeChildLayout
+			this.width = w;
+			this.height = h;
+			this.recomputeChildLayoutEntry();
+			h = this.children[$-1].y + this.children[$-1].height + this.children[$-1].marginBottom;
+			h += paddingBottom;
+
+			h -= 2; // total hack, i just like the way it looks a bit tighter even though technically MenuItem reserves some space to center in normal circumstances
+		}
+		+/
+
+		if(offsetY == int.min)
+			offsetY = parent.defaultLineHeight;
+
+		int w = 150;
+		int h = 50;
+
+		auto coord = parent.globalCoordinates();
+		dropDown.moveResize(coord.x + offsetX, coord.y + offsetY, w, h);
+
+		static if(UsingSimpledisplayX11)
+			XSync(XDisplayConnection.get, 0);
+
+		dropDown.visibilityChanged = (bool visible) {
+			if(visible) {
+				this.redraw();
+				dropDown.grabInput();
+			} else {
+				dropDown.releaseInputGrab();
+			}
+		};
+
+		dropDown.show();
+
+		clickListener = this.addEventListener((scope ClickEvent ev) {
+			unpopup();
+			// need to unlock asap just in case other user handlers block...
+			static if(UsingSimpledisplayX11)
+				flushGui();
+		}, true /* again for asap action */);
+	}
+
+	private EventListener clickListener;
+
+	void unpopup() {
+		mouseLastOver = mouseLastDownOn = null;
+		dropDown.hide();
+		clickListener.disconnect();
+	}
+
+	private SimpleWindow dropDown;
+	private Widget child;
+
+	///
+	this(Widget delegate(Widget p) factory, Widget parent) {
+		assert(parent);
+		assert(parent.parentWindow);
+		assert(parent.parentWindow.win);
+		dropDown = new SimpleWindow(
+			250, 40,
+			null, OpenGlOptions.no, Resizability.fixedSize,
+			WindowTypes.tooltip,
+			WindowFlags.dontAutoShow,
+			parent ? parent.parentWindow.win : null
+		);
+
+		super(dropDown);
+
+		child = factory(this);
+	}
+}
+
 private template controlledByCount(alias tt) {
 	static int helper() {
 		int count;
@@ -5653,7 +6001,7 @@ enum ScrollBarShowPolicy {
 +/
 // FIXME ScrollBarShowPolicy
 // FIXME: use the ScrollMessageWidget in here now that it exists
-// deprecated("Use ScrollMessageWidget or ScrollableContainerWidget instead") // ugh compiler won't let me do it
+deprecated("Use ScrollMessageWidget or ScrollableContainerWidget instead") // ugh compiler won't let me do it
 class ScrollableWidget : Widget {
 	// FIXME: make line size configurable
 	// FIXME: add keyboard controls
@@ -6014,12 +6362,19 @@ class ScrollableWidget : Widget {
 		return WidgetPainter(painter, this);
 	}
 
+	override void addScrollPosition(ref int x, ref int y) {
+		x += scrollOrigin.x;
+		y += scrollOrigin.y;
+	}
+
 	mixin ScrollableChildren;
 }
 
 // you need to have a Point scrollOrigin in the class somewhere
 // and a paintFrameAndBackground
 private mixin template ScrollableChildren() {
+	static assert(!__traits(isSame, this.addScrollPosition, Widget.addScrollPosition), "Your widget should provide `Point scrollOrigin()` and `override void addScrollPosition`");
+
 	override protected void privatePaint(WidgetPainter painter, int lox, int loy, Rectangle containment, bool force, bool invalidate) {
 		if(hidden)
 			return;
@@ -6038,7 +6393,7 @@ private mixin template ScrollableChildren() {
 
 		if(force || redrawRequested) {
 			//painter.setClipRectangle(scrollOrigin, width, height);
-			painter.setClipRectangle(clip.upperLeft - Point(painter.originX, painter.originY), clip.width, clip.height);
+			painter.setClipRectangleForWidget(clip.upperLeft - Point(painter.originX, painter.originY), clip.width, clip.height);
 			paintFrameAndBackground(painter);
 		}
 
@@ -6051,7 +6406,7 @@ private mixin template ScrollableChildren() {
 		painter.originX = painter.originX - scrollOrigin.x;
 		painter.originY = painter.originY - scrollOrigin.y;
 		if(force || redrawRequested) {
-			painter.setClipRectangle(clip.upperLeft - Point(painter.originX, painter.originY) + Point(2, 2) /* border */, clip.width - 4, clip.height - 4);
+			painter.setClipRectangleForWidget(clip.upperLeft - Point(painter.originX, painter.originY) + Point(2, 2) /* border */, clip.width - 4, clip.height - 4);
 			//painter.setClipRectangle(scrollOrigin + Point(2, 2) /* border */, width - 4, height - 4);
 
 			//erase(painter); // we paintFrameAndBackground above so no need
@@ -6104,7 +6459,7 @@ private class InternalScrollableContainerInsideWidget : ContainerWidget {
 		painter.originX = lox + x - scrollOrigin.x;
 		painter.originY = loy + y - scrollOrigin.y;
 		if(force || redrawRequested) {
-			painter.setClipRectangle(clip.upperLeft - Point(painter.originX, painter.originY), clip.width, clip.height);
+			painter.setClipRectangleForWidget(clip.upperLeft - Point(painter.originX, painter.originY), clip.width, clip.height);
 
 			erase(painter);
 			if(painter.visualTheme)
@@ -6326,7 +6681,7 @@ class ScrollableContainerWidget : ContainerWidget {
 
 
 version(custom_widgets)
-// deprecated // i can't deprecate it w/o stupid messages ugh
+deprecated
 private class InternalScrollableContainerWidget : Widget {
 
 	ScrollableWidget sw;
@@ -9315,10 +9670,18 @@ class Window : Widget {
 		eleR.x = ev.x;
 		eleR.y = ev.y;
 		auto pain = captureEle;
+
+		auto vpx = eleR.x;
+		auto vpy = eleR.y;
+
 		while(pain) {
 			eleR.x -= pain.x;
 			eleR.y -= pain.y;
 			pain.addScrollPosition(eleR.x, eleR.y);
+
+			vpx -= pain.x;
+			vpy -= pain.y;
+
 			pain = pain.parent;
 		}
 
@@ -9329,6 +9692,9 @@ class Window : Widget {
 			event.clientX = eleR.x;
 			event.clientY = eleR.y;
 
+			event.viewportX = vpx;
+			event.viewportY = vpy;
+
 			event.shiftKey = (ev.modifierState & ModifierState.shift) ? true : false;
 			event.altKey = (ev.modifierState & ModifierState.alt) ? true : false;
 			event.ctrlKey = (ev.modifierState & ModifierState.ctrl) ? true : false;
@@ -9696,7 +10062,9 @@ class TableView : Widget {
 		super(parent);
 
 		version(win32_widgets) {
-			createWin32Window(this, WC_LISTVIEW, "", LVS_REPORT | LVS_OWNERDATA);//| LVS_OWNERDRAWFIXED);
+			// LVS_EX_LABELTIP might be worth too
+			// LVS_OWNERDRAWFIXED
+			createWin32Window(this, WC_LISTVIEW, "", LVS_REPORT | LVS_OWNERDATA);//, LVS_EX_TRACKSELECT); // ex style for for LVN_HOTTRACK
 		} else version(custom_widgets) {
 			auto smw = new ScrollMessageWidget(this);
 			smw.addDefaultKeyboardListeners();
@@ -9836,6 +10204,54 @@ class TableView : Widget {
 		}
 	}
 
+	version(custom_widgets)
+	private int getColumnSizeForContent(size_t columnIndex) {
+		// FIXME: idk where the problem is but with a 2x scale the horizontal scroll is insuffiicent. i think the SMW is doing it wrong.
+		// might also want a user-defined max size too
+		int padding = scaleWithDpi(6);
+		int m = this.defaultTextWidth(this.columns[columnIndex].name) + padding;
+
+		if(getData !is null)
+		foreach(row; 0 .. itemCount)
+			getData(row, cast(int) columnIndex, (txt) {
+				m = mymax(m, this.defaultTextWidth(txt) + padding);
+			});
+
+		if(m < 32)
+			m = 32;
+
+		return m;
+	}
+
+	/++
+		History:
+			Added February 26, 2025
+	+/
+	void autoSizeColumnsToContent() {
+		version(custom_widgets) {
+			foreach(idx, ref c; columns) {
+				c.width = getColumnSizeForContent(idx);
+			}
+			updateCalculatedWidth(false);
+			tvwi.updateScrolls();
+		} else version(win32_widgets) {
+			foreach(i, c; columns)
+				SendMessage(hwnd, LVM_SETCOLUMNWIDTH, i, LVSCW_AUTOSIZE); // LVSCW_AUTOSIZE or LVSCW_AUTOSIZE_USEHEADER are amazing omg
+		}
+	}
+
+	/++
+		History:
+			Added March 1, 2025
+	+/
+	bool supportsPerCellAlignment() {
+		version(custom_widgets)
+			return true;
+		else version(win32_widgets)
+			return false;
+		return false;
+	}
+
 	private int getActualSetSize(size_t i, bool askWindows) {
 		version(win32_widgets)
 			if(askWindows)
@@ -10017,12 +10433,26 @@ class TableView : Widget {
 				auto info = cast(LPNMLISTVIEW) hdr;
 				this.emit!HeaderClickedEvent(info.iSubItem);
 			break;
+			case (LVN_FIRST-21) /* LVN_HOTTRACK */:
+				// requires LVS_EX_TRACKSELECT
+				// sdpyPrintDebugString("here");
+				mustReturn = 1; // override Windows' auto selection
+			break;
 			case NM_CLICK:
+				NMITEMACTIVATE* info = cast(NMITEMACTIVATE*) hdr;
+				this.emit!CellClickedEvent(info.iItem, info.iSubItem, MouseButton.left, MouseButtonLinear.left, info.ptAction.x, info.ptAction.y, !!(info.uKeyFlags & LVKF_ALT), !!(info.uKeyFlags & LVKF_CONTROL), !!(info.uKeyFlags & LVKF_SHIFT), false);
+			break;
 			case NM_DBLCLK:
+				NMITEMACTIVATE* info = cast(NMITEMACTIVATE*) hdr;
+				this.emit!CellClickedEvent(info.iItem, info.iSubItem, MouseButton.left, MouseButtonLinear.left, info.ptAction.x, info.ptAction.y, !!(info.uKeyFlags & LVKF_ALT), !!(info.uKeyFlags & LVKF_CONTROL), !!(info.uKeyFlags & LVKF_SHIFT), true);
+			break;
 			case NM_RCLICK:
+				NMITEMACTIVATE* info = cast(NMITEMACTIVATE*) hdr;
+				this.emit!CellClickedEvent(info.iItem, info.iSubItem, MouseButton.right, MouseButtonLinear.left, info.ptAction.x, info.ptAction.y, !!(info.uKeyFlags & LVKF_ALT), !!(info.uKeyFlags & LVKF_CONTROL), !!(info.uKeyFlags & LVKF_SHIFT), false);
+			break;
 			case NM_RDBLCLK:
-				// the item/subitem is set here and that can be a useful notification
-				// even beyond the normal click notification
+				NMITEMACTIVATE* info = cast(NMITEMACTIVATE*) hdr;
+				this.emit!CellClickedEvent(info.iItem, info.iSubItem, MouseButton.right, MouseButtonLinear.left, info.ptAction.x, info.ptAction.y, !!(info.uKeyFlags & LVKF_ALT), !!(info.uKeyFlags & LVKF_CONTROL), !!(info.uKeyFlags & LVKF_SHIFT), true);
 			break;
 			case LVN_GETDISPINFO:
 				LV_DISPINFO* info = cast(LV_DISPINFO*) hdr;
@@ -10048,6 +10478,7 @@ class TableView : Widget {
 		return 0;
 	}
 
+	// FIXME: this throws off mouse calculations, it should only happen when we're at the top level or something idk
 	override bool encapsulatedChildren() {
 		return true;
 	}
@@ -10120,7 +10551,28 @@ class TableView : Widget {
 			this.backgroundColor = backgroundColor;
 			this.flags |= Flags.textColorSet | Flags.backgroundColorSet;
 		}
+		/++
+			Alignment is only supported on some platforms.
+		+/
+		this(TextAlignment alignment) {
+			this.alignment = alignment;
+			this.flags |= Flags.alignmentSet;
+		}
+		/// ditto
+		this(TextAlignment alignment, Color textColor) {
+			this.alignment = alignment;
+			this.textColor = textColor;
+			this.flags |= Flags.alignmentSet | Flags.textColorSet;
+		}
+		/// ditto
+		this(TextAlignment alignment, Color textColor, Color backgroundColor) {
+			this.alignment = alignment;
+			this.textColor = textColor;
+			this.backgroundColor = backgroundColor;
+			this.flags |= Flags.alignmentSet | Flags.textColorSet | Flags.backgroundColorSet;
+		}
 
+		TextAlignment alignment;
 		Color textColor;
 		Color backgroundColor;
 		int flags; /// bitmask of [Flags]
@@ -10128,6 +10580,7 @@ class TableView : Widget {
 		enum Flags {
 			textColorSet = 1 << 0,
 			backgroundColorSet = 1 << 1,
+			alignmentSet = 1 << 2,
 		}
 	}
 	/++
@@ -10148,9 +10601,15 @@ class TableView : Widget {
 	// void delegate(int row, int column, WidgetPainter painter, int width, int height, in char[] text) drawCell;
 
 	/++
-		When the user clicks on a header, this event is emitted. It has a meber to identify which header (by index) was clicked.
+		When the user clicks on a header, this event is emitted. It has a member to identify which header (by index) was clicked.
 	+/
 	mixin Emits!HeaderClickedEvent;
+
+	/++
+		History:
+			Added March 2, 2025
+	+/
+	mixin Emits!CellClickedEvent;
 }
 
 /++
@@ -10181,6 +10640,54 @@ final class HeaderClickedEvent : Event {
 	}
 }
 
+/++
+	History:
+		Added March 2, 2025
++/
+final class CellClickedEvent : MouseEventBase {
+	enum EventString = "CellClicked";
+	this(Widget target, int rowIndex, int columnIndex, MouseButton button, MouseButtonLinear mouseButtonLinear, int x, int y, bool altKey, bool ctrlKey, bool shiftKey, bool isDoubleClick) {
+		this.rowIndex = rowIndex;
+		this.columnIndex = columnIndex;
+		this.button = button;
+		this.buttonLinear = mouseButtonLinear;
+		this.isDoubleClick = isDoubleClick;
+		this.clientX = x;
+		this.clientY = y;
+
+		this.altKey = altKey;
+		this.ctrlKey = ctrlKey;
+		this.shiftKey = shiftKey;
+
+		// import std.stdio; std.stdio.writeln(rowIndex, "x", columnIndex, " @ ", x, ",", y, " ", button, " ", isDoubleClick, " ", altKey, " ", ctrlKey, " ", shiftKey);
+
+		// FIXME: x, y, state, altButton etc?
+		super(EventString, target);
+	}
+
+	/++
+		See also: [button] inherited from the base class.
+
+		clientX and clientY are irrespective of scrolling - FIXME is that sane?
+	+/
+	int columnIndex;
+
+	/// ditto
+	int rowIndex;
+
+	/// ditto
+	bool isDoubleClick;
+
+	/+
+	// i could do intValue as a linear index if we know the width
+	// and a stringValue with the string in the cell. but idk if worth.
+	override @property int intValue() {
+		return columnIndex;
+	}
+	+/
+
+}
+
 version(custom_widgets)
 private class TableViewWidgetInner : Widget {
 
@@ -10214,8 +10721,7 @@ private class TableViewWidgetInner : Widget {
 	void updateScrolls() {
 		int w;
 		foreach(idx, column; tvw.columns) {
-			if(column.width == 0) continue;
-			w += tvw.getActualSetSize(idx, false);// + padding;
+			w += column.calculatedWidth;
 		}
 		smw.setTotalArea(w, tvw.itemCount);
 		columnsWidth = w;
@@ -10256,10 +10762,13 @@ private class TableViewWidgetInner : Widget {
 					}
 					if(column.width != 0) // no point drawing an invisible column
 					tvw.getData(row, cast(int) columnNumber, (in char[] info) {
-						auto clip = painter.setClipRectangle(Rectangle(Point(startX - smw.position.x, y), Point(endX - smw.position.x, y + lh)));
+						auto endClip = endX - smw.position.x;
+						if(endClip > this.width - padding)
+							endClip = this.width - padding;
+						auto clip = painter.setClipRectangle(Rectangle(Point(startX - smw.position.x, y), Point(endClip, y + lh)));
 
-						void dotext(WidgetPainter painter) {
-							painter.drawText(Point(startX - smw.position.x, y), info, Point(endX - smw.position.x, y + lh), column.alignment);
+						void dotext(WidgetPainter painter, TextAlignment alignment) {
+							painter.drawText(Point(startX - smw.position.x, y), info, Point(endX - smw.position.x - padding, y + lh), alignment);
 						}
 
 						if(tvw.getCellStyle !is null) {
@@ -10277,9 +10786,12 @@ private class TableViewWidgetInner : Widget {
 							if(style.flags & TableView.CellStyle.Flags.textColorSet)
 								tempPainter.outlineColor = style.textColor;
 
-							dotext(tempPainter);
+							auto alignment = column.alignment;
+							if(style.flags & TableView.CellStyle.Flags.alignmentSet)
+								alignment = style.alignment;
+							dotext(tempPainter, alignment);
 						} else {
-							dotext(painter);
+							dotext(painter, column.alignment);
 						}
 					});
 				}
@@ -10327,6 +10839,10 @@ private class TableViewWidgetInner : Widget {
 			});
 		}
 
+		override int minHeight() {
+			return defaultLineHeight + 4; // same as Button
+		}
+
 		void updateHeaders() {
 			foreach(child; children[1 .. $])
 				child.removeWidget();
@@ -10376,8 +10892,55 @@ private class TableViewWidgetInner : Widget {
 		}
 		void paintFrameAndBackground(WidgetPainter painter) { }
 
+		// for mouse event dispatching
+		override protected void addScrollPosition(ref int x, ref int y) {
+			x += scrollOrigin.x;
+			y += scrollOrigin.y;
+		}
+
 		mixin ScrollableChildren;
 	}
+
+	private void emitCellClickedEvent(scope MouseEventBase event, bool isDoubleClick) {
+		int mx = event.clientX + smw.position.x;
+		int my = event.clientY;
+
+		Widget par = this;
+		while(par && !par.encapsulatedChildren) {
+			my -= par.y; // to undo the encapsulatedChildren adjustClientCoordinates effect
+			par = par.parent;
+		}
+		if(par is null)
+			my = event.clientY; // encapsulatedChildren not present?
+
+		int row = my / lh + smw.position.y; // scrolling here is done per-item, not per pixel
+		if(row > tvw.itemCount)
+			row = -1;
+
+		int column = -1;
+		if(row != -1) {
+			int pos;
+			foreach(idx, col; tvw.columns) {
+				pos += col.calculatedWidth;
+				if(mx < pos) {
+					column = cast(int) idx;
+					break;
+				}
+			}
+		}
+
+		// wtf are these casts about?
+		tvw.emit!CellClickedEvent(row, column, cast(MouseButton) event.button, cast(MouseButtonLinear) event.buttonLinear, event.clientX, event.clientY, event.altKey, event.ctrlKey, event.shiftKey, isDoubleClick);
+	}
+
+	override void defaultEventHandler_click(scope ClickEvent ce) {
+		// FIXME: should i filter mouse wheel events? Windows doesn't send them but i can.
+		emitCellClickedEvent(ce, false);
+	}
+
+	override void defaultEventHandler_dblclick(scope DoubleClickEvent ce) {
+		emitCellClickedEvent(ce, true);
+	}
 }
 
 /+
@@ -11410,6 +11973,7 @@ class MenuBar : Widget {
 
 	sb.parts[0].content = "Status bar text!";
 */
+// https://learn.microsoft.com/en-us/windows/win32/controls/status-bars#owner-drawn-status-bars
 class StatusBar : Widget {
 	private Part[] partsArray;
 	///
@@ -12106,6 +12670,7 @@ class Menu : Window {
 			}
 			dropDown = new SimpleWindow(
 				150, 4,
+				// FIXME: what if it is a popupMenu ?
 				null, OpenGlOptions.no, Resizability.fixedSize, WindowTypes.dropdownMenu, WindowFlags.dontAutoShow, parent ? parent.parentWindow.win : null);
 
 			this.label = label;
@@ -13924,8 +14489,8 @@ class TextDisplayHelper : Widget {
 		auto cs = getComputedStyle();
 		auto defaultColor = cs.foregroundColor;
 
-		auto old = painter.setClipRectangle(bounds);
-		scope(exit) painter.setClipRectangle(old);
+		auto old = painter.setClipRectangleForWidget(bounds.upperLeft, bounds.width, bounds.height);
+		scope(exit) painter.setClipRectangleForWidget(old.upperLeft, old.width, old.height);
 
 		l.getDrawableText(delegate bool(txt, style, info, carets...) {
 			//writeln("Segment: ", txt);
@@ -13990,6 +14555,17 @@ class TextDisplayHelper : Widget {
 		override OperatingSystemFont font() {
 			return font_;
 		}
+
+		bool foregroundColorOverridden;
+		bool backgroundColorOverridden;
+		Color foregroundColor;
+		Color backgroundColor; // should this be inline segment or the whole paragraph block?
+		bool italic;
+		bool bold;
+		bool underline;
+		bool strikeout;
+		bool subscript;
+		bool superscript;
 	}
 
 	static class MyImageStyle : TextStyle, MeasurableFont {
@@ -15207,7 +15783,7 @@ alias void delegate(Widget handlerAttachedTo, Event event) EventHandler;
 	This is an opaque type you can use to disconnect an event handler when you're no longer interested.
 
 	History:
-		The data members were `public` (albiet undocumented and not intended for use) prior to May 13, 2021. They are now `private`, reflecting the single intended use of this object.
+		The data members were `public` (albeit undocumented and not intended for use) prior to May 13, 2021. They are now `private`, reflecting the single intended use of this object.
 +/
 struct EventListener {
 	private Widget widget;
@@ -15217,7 +15793,8 @@ struct EventListener {
 
 	///
 	void disconnect() {
-		widget.removeEventListener(this);
+		if(widget !is null && handler !is null)
+			widget.removeEventListener(this);
 	}
 }
 
@@ -15569,8 +16146,6 @@ class Event : ReflectableProperties {
 	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) { }
 
 	/++
@@ -15588,8 +16163,6 @@ class Event : ReflectableProperties {
 		//debug if(eventName != "mousemove" && target !is null && target.parentWindow && target.parentWindow.devTools)
 			//target.parentWindow.devTools.log("Event ", eventName, " dispatched directly to ", srcElement);
 
-		adjustScrolling();
-
 		if(auto e = target.parentWindow) {
 			if(auto handlers = "*" in e.capturingEventHandlers)
 			foreach(handler; *handlers)
@@ -15628,7 +16201,6 @@ class Event : ReflectableProperties {
 		//debug if(eventName != "mousemove" && target !is null && target.parentWindow && target.parentWindow.devTools)
 			//target.parentWindow.devTools.log("Event ", eventName, " dispatched to ", srcElement);
 
-		adjustScrolling();
 		// first capture, then bubble
 
 		Widget[] chain;
@@ -16153,20 +16725,6 @@ abstract class MouseEventBase : Event {
 		clientY += deltaY;
 	}
 
-	override void adjustScrolling() {
-	version(custom_widgets) { // TEMP
-		viewportX = clientX;
-		viewportY = clientY;
-		if(auto se = cast(ScrollableWidget) srcElement) {
-			clientX += se.scrollOrigin.x;
-			clientY += se.scrollOrigin.y;
-		} else if(auto se = cast(ScrollableContainerWidget) srcElement) {
-			//clientX += se.scrollX_;
-			//clientY += se.scrollY_;
-		}
-	}
-	}
-
 	mixin Register;
 }
 
@@ -17510,6 +18068,33 @@ struct tip { string tip; }
 ///
 /// Group: generating_from_code
 enum context_menu = menu.init;
+/++
+	// FIXME: the options should have both a label and a value
+
+	if label is null, it will try to just stringify value.
+
+	if type is int or size_t and it returns a string array, we can use the index but this will implicitly not allow custom, even if allowCustom is set.
++/
+/// Group: generating_from_code
+Choices!T choices(T)(T[] options, bool allowCustom = false, bool allowReordering = true, bool allowDuplicates = true) {
+	return Choices!T(() => options, allowCustom, allowReordering, allowDuplicates);
+}
+/// ditto
+Choices!T choices(T)(T[] delegate() options, bool allowCustom = false, bool allowReordering = true, bool allowDuplicates = true) {
+	return Choices!T(options, allowCustom, allowReordering, allowDuplicates);
+}
+/// ditto
+struct Choices(T) {
+	///
+	T[] delegate() options;
+	bool allowCustom = false;
+	/// only relevant if attached to an array
+	bool allowReordering = true;
+	/// ditto
+	bool allowDuplicates = true;
+	/// makes no sense on a set
+	bool requireAll = false;
+}
 
 
 /++
@@ -18334,23 +18919,28 @@ void addWhenTriggered(Widget w, void delegate() dg) {
 }
 
 /++
-	Observable varables can be added to widgets and when they are changed, it fires
+	Observable variables can be added to widgets and when they are changed, it fires
 	off a [StateChanged] event so you can react to it.
 
 	It is implemented as a getter and setter property, along with another helper you
-	can use to subscribe whith is `name_changed`. You can also subscribe to the [StateChanged]
+	can use to subscribe with is `name_changed`. You can also subscribe to the [StateChanged]
 	event through the usual means. Just give the name of the variable. See [StateChanged] for an
 	example.
 
+	To get an `ObservableReference` to the observable, use `&yourname_changed`.
+
 	History:
 		Moved from minigui_addons.webview to main minigui on November 27, 2021 (dub v10.4)
+
+		As of March 5, 2025, the changed function now returns an [EventListener] handle, which
+		you can use to disconnect the observer.
 +/
 mixin template Observable(T, string name) {
 	private T backing;
 
 	mixin(q{
-		void } ~ name ~ q{_changed (void delegate(T) dg) {
-			this.addEventListener((StateChanged!this_thing ev) {
+		EventListener } ~ name ~ q{_changed (void delegate(T) dg) {
+			return this.addEventListener((StateChanged!this_thing ev) {
 				dg(ev.newValue);
 			});
 		}
@@ -18369,6 +18959,8 @@ mixin template Observable(T, string name) {
 	mixin("private alias this_thing = " ~ name ~ ";");
 }
 
+/// ditto
+alias ObservableReference(T) = EventListener delegate(void delegate(T));
 
 private bool startsWith(string test, string thing) {
 	if(test.length < thing.length)
diff --git a/rtf.d b/rtf.d
index 5016e67..c3f3aea 100644
--- a/rtf.d
+++ b/rtf.d
@@ -96,6 +96,9 @@ unittest {
 	// writeln(toPlainText(document));
 }
 
+/++
+	Returns a plan text string that represents the jist of the document's content.
++/
 string toPlainText(RtfDocument document) {
 	string ret;
 	document.process((piece, ref state) {
@@ -243,6 +246,9 @@ private string parseRtfText(ref const(ubyte)[] s) {
 // \t is read but you should use \tab generally
 // when reading, ima translate the ascii tab to \tab control word
 // and ignore
+/++
+	A union of entities you can see while parsing a RTF file.
++/
 struct RtfPiece {
 	/++
 	+/
@@ -301,6 +307,9 @@ struct RtfPiece {
 }
 
 // a \word thing
+/++
+	A control word directly from the RTF file format.
++/
 struct RtfControlWord {
 	bool hadSpaceAtEnd;
 	bool hadNumber;
@@ -371,6 +380,9 @@ private bool isAlpha(char c) {
 }
 
 // a { ... } thing
+/++
+	A group directly from the RTF file.
++/
 struct RtfGroup {
 	RtfPiece[] pieces;
 
diff --git a/simpledisplay.d b/simpledisplay.d
index 4cca55e..0da75eb 100644
--- a/simpledisplay.d
+++ b/simpledisplay.d
@@ -1162,7 +1162,16 @@ unittest {
 
 import arsd.core;
 
-version(OSX) version(DigitalMars) version=OSXCocoa;
+version(D_OpenD) {
+	version(OSX)
+		version=OSXCocoa;
+	version(iOS)
+		version=OSXCocoa;
+} else {
+	version(OSX) version(DigitalMars) version=OSXCocoa;
+}
+
+
 
 version(Emscripten) {
 	version=allow_unimplemented_features;
@@ -18686,10 +18695,10 @@ struct Visual
 		SimpleWindow simpleWindow;
 
 		override static SDGraphicsView alloc() @selector("alloc");
-		override SDGraphicsView init() @selector("init") {
+		override SDGraphicsView init() @selector("init");/* {
 			super.init();
 			return this;
-		}
+		}*/
 
 		override void drawRect(NSRect rect) @selector("drawRect:") {
 			auto curCtx = NSGraphicsContext.currentContext.graphicsPort;
diff --git a/textlayouter.d b/textlayouter.d
index 211495f..b26e426 100644
--- a/textlayouter.d
+++ b/textlayouter.d
@@ -36,6 +36,9 @@ Each cell ends with a tab character. A column block is a run of uninterrupted ve
 
 // want to support PS (new paragraph), LS (forced line break), FF (next page)
 // and GS = <table> RS = <tr> US = <td> FS = </table> maybe.
+// use \a bell for bookmarks in the text?
+
+// note: ctrl+c == ascii 3 and ctrl+d == ascii 4 == end of text
 
 
 // FIXME: maybe i need another overlay of block style not just text style. list, alignment, heading, paragraph spacing, etc. should it nest?
@@ -130,6 +133,8 @@ import arsd.simpledisplay;
 // You can do the caret by any time it gets drawn, you set the flag that it is on, then you can xor it to turn it off and keep track of that at top level.
 
 
+// FIXME: might want to be able to swap out all styles at once and trigger whole relayout, as if a document theme changed wholesale, without changing the saved style handles
+// FIXME: line and paragrpah numbering options while drawing
 /++
 	Represents the style of a span of text.
 
@@ -143,6 +148,39 @@ interface TextStyle {
 	+/
 	MeasurableFont font();
 
+	/++
+		History:
+			Added February 24, 2025
+	+/
+	//ParagraphMetrics paragraphMetrics();
+
+	// FIXME: list styles?
+	// FIXME: table styles?
+
+	/// ditto
+	static struct ParagraphMetrics {
+		/++
+			Extra spacing between each line, given in physical pixels.
+		+/
+		int lineSpacing;
+		/++
+			Spacing between each paragraph, given in physical pixels.
+		+/
+		int paragraphSpacing;
+		/++
+			Extra indentation on the first line of each paragraph, given in physical pixels.
+		+/
+		int paragraphIndentation;
+
+		// margin left and right?
+
+		/++
+			Note that TextAlignment.Left might be redefined to mean "Forward", meaning left if left-to-right, right if right-to-left,
+			but right now it ignores bidi anyway.
+		+/
+		TextAlignment alignment = TextAlignment.Left;
+	}
+
 	// FIXME: I might also want a duplicate function for saving state.
 
 	// verticalAlign?
@@ -167,6 +205,13 @@ interface TextStyle {
 			return TerminalFontRepresentation.instance;
 		}
 
+		/++
+			The default returns reasonable values, you might want to call this to get the defaults,
+			then change some values and return the rest.
+		+/
+		ParagraphMetrics paragraphMetrics() {
+			return  ParagraphMetrics.init;
+		}
 	}
 }
 
diff --git a/xlsx.d b/xlsx.d
index 0218f84..5c16f08 100644
--- a/xlsx.d
+++ b/xlsx.d
@@ -1,7 +1,7 @@
 /++
 	Some support for the Microsoft Excel Spreadsheet file format.
 
-	Don't expect much from it.
+	Don't expect much from it, not even API stability.
 
 	Some code is borrowed from the xlsxreader package.
 
@@ -13,6 +13,19 @@
 +/
 module arsd.xlsx;
 
+/+
+./csv-viewer ~/Downloads/UI_comparison.xlsx
+arsd.dom.ElementNotFoundException@/home/me/program/lib/arsd/xlsx.d(823): Element of type 'Element' matching {worksheet > dimension} not found.
++/
+
+/+
+	sheet at double[]:
+
+	nan payloads for blank, errors, then strings as indexes into a table.
++/
+
+// FIXME: does excel save errors like DIV0 to content in the file?
+
 // See also Robert's impl: https://github.com/symmetryinvestments/xlsxreader/blob/master/source/xlsxreader.d
 
 import arsd.core;
@@ -22,13 +35,825 @@ import arsd.color;
 
 import std.conv;
 
-/+
-struct XlsxCell {
-	string type;
-	string formula;
-	string value;
+private struct ExcelFormatStringLexeme {
+	string lexeme;
+	bool isLiteral;
+}
+
+class ExcelFormatStringException : Exception {
+	this(string msg, string file = __FILE__, size_t line = __LINE__) {
+		super(msg, file, line);
+	}
+}
+
+// FIXME: out contract that asserts s_io.length has indeed been reduced
+private ExcelFormatStringLexeme extractExcelFormatStringLexeme(ref string s_io) {
+	assert(s_io.length);
+	string s = s_io;
+
+	switch(s[0]) {
+		case '[':
+			// condition or color
+			// or elapsed time thing.
+			// or a locale setting thing for dates (and more?)
+			int count = 0;
+			int size = 0;
+			while(s[0]) {
+				if(s[0] == '[')
+					count++;
+				if(s[0] == ']')
+					count--;
+				s = s[1 .. $];
+				size++;
+				if(count == 0)
+					break;
+				if(s.length == 0)
+					throw new ExcelFormatStringException("unclosed [");
+			}
+
+			string ret = s_io[0 .. size];
+			s_io = s_io[size .. $];
+
+			return ExcelFormatStringLexeme(ret, false);
+		case '"':
+			// quoted thing watching for backslash
+			bool escaped;
+			int size;
+
+			size++;
+			s = s[1 .. $]; // skip the first "
+
+			string ret;
+
+			while(escaped || s[0] != '"') {
+				if(!escaped) {
+					if(s[0] == '"') {
+						break;
+					}
+					if(s[0] == '\\')
+						escaped = true;
+					else
+						ret ~= s[0];
+				} else {
+					ret ~= s[0];
+					escaped = false;
+				}
+
+				s = s[1 .. $];
+				size++;
+			}
+			if(s.length == 0)
+				throw new ExcelFormatStringException("unclosed \"");
+			size++;
+
+			s_io = s_io[size .. $];
+			return ExcelFormatStringLexeme(ret, true);
+
+		case '\\':
+			// escaped character
+			s = s[1 .. $]; // skip the \
+			s_io = s_io[1 .. $];
+
+			// FIXME: need real stride
+			auto stride = 1;
+			s_io = s_io[stride .. $];
+			return ExcelFormatStringLexeme(s[0 .. stride], true);
+		case '$', '+', '(', ':', '^', '\'', '{', '<', '=', '-', ')', '!', '&', '~', '}', '>', ' ': // they say slash but that seems to be fraction instead
+			// character literals w/o needing to be quoted
+			s_io = s_io[1 .. $];
+			return ExcelFormatStringLexeme(s[0 .. 1], true);
+		case 'A', 'a', 'P', 'p':
+			// am/pm
+
+			int size = 0;
+			while(
+				s[0] == 'a' || s[0] == 'A' ||
+				s[0] == 'p' || s[0] == 'P' ||
+				s[0] == 'm' || s[0] == 'M' ||
+				s[0] == '/'
+			) {
+				size++;
+				s = s[1 .. $];
+				if(s.length == 0)
+					break;
+			}
+			// also switches hour to 12 hour format when it happens
+			string ret = s_io[0 .. size];
+			s_io = s_io[size .. $];
+
+			return ExcelFormatStringLexeme(ret, false);
+
+		// the single char directives
+		case '@': // text placeholder
+		case ';': // clause separator
+			s_io = s_io[1 .. $];
+			return ExcelFormatStringLexeme(s[0 .. 1], false);
+		case '_': // padding char - this adds a space with the same width as the char that follows it, for column alignment.
+		case '*': // fill char
+			// the padding or fill is the next lexeme, not the next char!
+			s_io = s_io[1 .. $];
+			return ExcelFormatStringLexeme(s[0 .. 1], false);
+		case 'e', 'E': // scientific notation request
+		case '%': // percent indicator
+		case ',': // thousands separator
+		case '.': // decimal separator
+		case '/': // fraction or date separator
+			s_io = s_io[1 .. $];
+			return ExcelFormatStringLexeme(s[0 .. 1], false);
+		case /*'m',*/ 'd', 'y': // date parts
+		case 'h', 'm', 's': // time parts
+
+			/+
+			Note: The m or mm code must appear immediately after the h or hh code or immediately before the ss code; otherwise, Excel displays the month instead of minutes.
+
+			it can be either a date/time OR a number/fraction, not both.
+			+/
+
+			auto thing = s[0];
+			int size;
+			while(s.length && s[0] == thing) {
+				s = s[1 .. $];
+				size++;
+			}
+			auto keep = s_io[0 .. size];
+			s_io = s_io[size .. $];
+			return ExcelFormatStringLexeme(keep, false);
+		case '1': .. case '9': // fraction denominators or just literal numbers
+			int size;
+			while(s.length && s[0] >= '1' && s[0] <= '9') {
+				s = s[1 .. $];
+				size++;
+			}
+			auto keep = s_io[0 .. size];
+			s_io = s_io[size .. $];
+			return ExcelFormatStringLexeme(keep, false);
+		case '0', '#', '?': // digit placeholder
+			int size;
+
+			while(s[0] == '0' || s[0] == '#' || s[0] == '?') {
+				s = s[1 .. $];
+				size++;
+				if(s.length == 0)
+					break;
+			}
+
+			auto keep = s_io[0 .. size];
+			s_io = s_io[size .. $];
+			return ExcelFormatStringLexeme(keep, false);
+
+		default:
+			// idk
+			throw new ExcelFormatStringException("unknown char " ~ s);
+	}
+
+	assert(0);
+}
+
+unittest {
+	string thing = `[>50][Red]"foo"`;
+	ExcelFormatStringLexeme lexeme;
+
+	lexeme = extractExcelFormatStringLexeme(thing);
+	assert(thing == `[Red]"foo"`);
+	lexeme = extractExcelFormatStringLexeme(thing);
+	assert(thing == `"foo"`);
+	lexeme = extractExcelFormatStringLexeme(thing);
+	assert(thing == "");
+	assert(lexeme.lexeme == "foo");
+
+	thing = `"\""`;
+	lexeme = extractExcelFormatStringLexeme(thing);
+	assert(thing == "");
+	assert(lexeme.lexeme == `"`);
+
+	thing = `\,`;
+	lexeme = extractExcelFormatStringLexeme(thing);
+	assert(thing == "");
+	assert(lexeme.lexeme == `,`);
+
+	/*
+	thing = `"A\""`;
+	lexeme = extractExcelFormatStringLexeme(thing);
+	assert(thing == "");
+	assert(lexeme.lexeme == `"`);
+	*/
+
+	/+
+	thing = "mm-yyyy";
+	lexeme = extractExcelFormatStringLexeme(thing);
+	import std.stdio; writeln(thing); writeln(lexeme);
+	+/
+}
+
+struct XlsxFormat {
+	string originalFormatString;
+
+	Color foregroundColor;
+	Color backgroundColor;
+
+	int alignment; // 0 = left, 1 = right, 2 = center
+
+	enum Type {
+		/++
+		+/
+		String,
+		/++
+
+		+/
+		Number,
+		/++
+			A Date is a special kind of number in Excel.
+		+/
+		Date,
+		/++
+			things like # ?/4
+
+		+/
+		Fraction,
+		Percent
+	}
+	Type type;
+
+	/++
+	+/
+	static struct Result {
+		string content;
+		string color;
+		int alignment;
+	}
+
+	/++
+	+/
+	Result applyTo(string s) const {
+		if(this.type == Type.String || originalFormatString == "@" || originalFormatString.length == 0)
+			return Result(s, null, alignment);
+
+		int alignment = this.alignment;
+
+		// need to check for a text thing and if conversion fails, we use that
+		double value;
+		try {
+			value = to!double(s);
+		} catch(Exception e) {
+			value = double.nan;
+		}
+
+		DateTime date_;
+		bool dateCalculated;
+
+		DateTime getDate() {
+			// make sure value is not nan before here or it will throw "negative overflow"!
+			if(!dateCalculated) {
+				date_ = doubleToDateTime(value);
+				dateCalculated = true;
+			}
+
+			return date_;
+		}
+
+		// parse out the original format string
+		// the ordering by default is positive;negative;zero;text
+		//
+		// these can also be like [Color][Condition]fmt;generic
+		// color is allowed anywhere
+		// but condition can only have two things following: `[Color][Condition];` repeated any number of times then `;generic-number;text`. no more negative/zero stuff.
+		// once we see a condition, it switches modes - following things MUST have condition or else are treated as just generic catch all for number and then text.
+		//
+		// it matches linearly.
+		/+
+			so it goes:
+				implicit match >0
+				implicit match <0
+				implicit match =0
+				text
+
+			but if at any point one of them has a condition, the following ones must be either more conditions (immediately!) or unconditional:
+				fallthrough for number
+				text
+
+
+			and if i dont support a format thing i can always fall back to the original text.
+		+/
+
+		try {
+			string fmt = originalFormatString;
+
+			int state = 0; // 0 == positive, 1 == negative or custom, 2 == other, 3 == text
+			bool matchesCurrentCondition = value > 0;
+
+			bool hasMultipleClauses = false;
+			{
+				string fmt2 = fmt;
+				while(fmt2.length) {
+					auto next = extractExcelFormatStringLexeme(fmt2);
+					if(!next.isLiteral && next.lexeme == ";")
+						hasMultipleClauses = true;
+						break;
+				}
+			}
+			if(hasMultipleClauses == false)
+				matchesCurrentCondition = true; // only one thing means we must always match it
+
+			int numericState;
+			bool inDenominator;
+			bool inAmPm;
+			bool inDecimal;
+			bool justSawHours;
+
+			// these are populated below once we match a clause
+			bool hasAmPm;
+			bool hasFraction;
+			bool hasScientificNotation;
+			bool hasPercent;
+			bool first = true;
+
+			string color;
+			string ret;
+
+			while(fmt.length) {
+				auto lexeme = extractExcelFormatStringLexeme(fmt);
+
+				ExcelFormatStringLexeme peekLexeme(bool returnLiteral = false) {
+					string fmt2 = fmt;
+					skip:
+					if(fmt2.length == 0)
+						return ExcelFormatStringLexeme.init;
+					auto next = extractExcelFormatStringLexeme(fmt2);
+					if(next.isLiteral && !returnLiteral)
+						goto skip;
+					return next;
+				}
+
+				if(!lexeme.isLiteral && lexeme.lexeme[0] == ';') {
+					// we finished the format of the match, so no need to continue
+					if(matchesCurrentCondition)
+						break;
+					// otherwise, we go to the next thing
+					state++;
+					if(state == 1) {
+						matchesCurrentCondition = value < 0;
+					} else if(state == 2) {
+						// this is going to be either the catch-all fallback or another custom one
+						// for now, assume it is a catch-all
+						import std.math;
+						matchesCurrentCondition = !isNaN(value) ? true : false; // only numbers, so not text, matches the catch-all
+					} else if(state == 3) {
+						matchesCurrentCondition = true; // this needs to match, we're at the end, so this is the text display
+					} else {
+						throw new ExcelFormatStringException("too many ; pieces");
+					}
+
+					continue;
+				}
+
+				if(!matchesCurrentCondition)
+					continue;
+
+				// scan ahead to see if we're doing some special cases: fractions, 12 hour clock, percentages, and sci notation
+				if(first) {
+					string fmt2 = fmt;
+					while(fmt2.length) {
+						auto next = extractExcelFormatStringLexeme(fmt2);
+						if(!next.isLiteral) {
+							// don't proceed into the next clause
+							if(next.lexeme == ";")
+								break;
+
+							char c = next.lexeme[0] | 0x20;
+							if(next.lexeme == "/")
+								hasFraction = true;
+							else if(next.lexeme == "%") {
+								hasPercent = true;
+								value *= 100.0;
+							} else if(c == 'e')
+								hasScientificNotation = true;
+							else if(c == 'a' || c == 'p')
+								hasAmPm = true;
+						}
+					}
+					first = false;
+				}
+
+				if(hasScientificNotation)
+					return Result(s, "unsupported feature: scientific notation"); // FIXME
+				if(hasFraction)
+					return Result(s, "unsupported feature: fractions"); // FIXME
+
+				if(!lexeme.isLiteral && lexeme.lexeme[0] == '[') {
+					// look for color, condition, or locale
+					char nc = lexeme.lexeme[1];
+					if(nc == '$')
+						continue; // locale i think, skip it
+					if(nc == '<' || nc == '>' || nc == '=') {
+						// condition
+
+						if(state == 1 || state == 2) {
+							state = 1;
+							// read the condition, see if we match it
+							auto condition = lexeme.lexeme[1 .. $-1];
+
+							string operator;
+							string num;
+							if(condition[1] == '=') {
+								operator = condition[0 .. 2];
+								num = condition[2 .. $];
+							} else {
+								operator = condition[0 .. 1];
+								num = condition[1 .. $];
+							}
+
+							double compareTo;
+							try {
+								compareTo = to!double(num);
+							} catch(Exception e) {
+								throw new ExcelFormatStringException("not a number: " ~ num);
+							}
+							switch(operator) {
+								case "<":
+									matchesCurrentCondition = value < compareTo;
+								break;
+								case "<=":
+									matchesCurrentCondition = value <= compareTo;
+								break;
+								case ">":
+									matchesCurrentCondition = value > compareTo;
+								break;
+								case ">=":
+									matchesCurrentCondition = value >= compareTo;
+								break;
+								case "=":
+									// FIXME: approxEqual?
+									matchesCurrentCondition = value == compareTo;
+								break;
+
+								default:
+									throw new ExcelFormatStringException("not a supported comparison operator " ~ operator);
+							}
+
+							continue;
+						} else {
+							throw new ExcelFormatStringException("inappropriately placed custom condition");
+						}
+					} else {
+						// color, we hope. FIXME can also be [s], [m], or [h] or maybe [ss], [mm], [hh]
+						// colors are capitalized...
+						color = lexeme.lexeme[1 .. $-1];
+						continue;
+					}
+				}
+
+				// if we're here, it should actually match and need some processing.
+
+				if(lexeme.isLiteral) {
+					// literals are easy...
+					ret ~= lexeme.lexeme;
+				} else {
+					// but the rest of these are formatting commands
+					switch(lexeme.lexeme[0]) {
+						case ',':
+							// thousands separator requested,
+							// handled below in the decimal placeholder thing
+						break;
+						case '_', '*':
+							auto lexemeToPadWith = extractExcelFormatStringLexeme(fmt);
+							if(lexeme.lexeme[0] == '_')
+								ret ~= " "; // FIXME supposed to match width of the char
+							else if(lexeme.lexeme[0] == '*')
+								ret ~= lexemeToPadWith.lexeme; // FIXME: supposed to repeat to fill the column width
+						break;
+						case '@': // the original text
+							ret ~= s;
+						break;
+						case '%':
+							ret ~= lexeme.lexeme;
+						break;
+						case '.':
+							inDecimal = true;
+							ret ~= lexeme.lexeme;
+						break;
+						case '/':
+							if(!inAmPm) {
+								inDenominator = true;
+								ret ~= lexeme.lexeme;
+							}
+						break;
+						case '#', '0', '?':
+							// decimal group
+							// # = digit
+							// 0 = digit, pad with 0 if not significant
+							// ? = digit, pad with space (same sized as digit) if not significant
+
+							if(value is double.nan)
+								return Result(s, "NaN");
+
+							alignment = 1; // if we are printing numbers let's assume right align FIXME
+							/+
+							if(s.length == 0 && value is double.nan) // and if we printing numbers, treat empty cell as 0
+								value = 0.0;
+							+/
+
+							bool appendNumber(double v, bool includeThousandsSeparator) {
+								if(v < 0)
+									v = -v;
+								string f = to!string(cast(int) v);
+								if(f.length < lexeme.lexeme.length)
+								foreach(l; lexeme.lexeme[0 .. $ - f.length]) {
+									if(l == '0')
+										ret ~= '0';
+									else if(l == '?')
+										ret ~= ' ';
+								}
+								if(f.length) {
+									if(includeThousandsSeparator) {
+										// 14532
+										// 1234
+										// 123
+										auto offset = cast(int) f.length % 3;
+										while(f.length > 3) {
+											ret ~= f[offset .. offset + 3];
+											ret ~= ",";
+											f = f[3 .. $];
+										}
+										ret ~= f;
+									} else {
+										ret ~= f;
+									}
+									return true;
+								}
+								return false;
+							}
+
+							if(peekLexeme().lexeme == ",") {
+								// thousands separator requested...
+								auto v = cast(int) value / 1000;
+
+								if(v == 0)
+									continue; // FIXME? maybe we want some leading 0 padding?
+
+								auto hadOutput = appendNumber(v, true);
+
+								value = value - v * 1000; // take the remainder for the next iteration of the loop
+
+								if(hadOutput)
+									ret ~= ","; // append the comma before the final thousands digits in the next iteration
+
+								continue;
+							}
+
+
+							if(inDecimal) {
+								// FIXME: no more std.format
+								import std.format;
+								string f = format("%."~to!string(lexeme.lexeme.length)~"f", value - cast(int) value)[2..$]; // slice off the "0."
+								ret ~= f;
+							} else {
+								appendNumber(value, false);
+							}
+
+							inDenominator = false;
+						break;
+						case '1': .. case '9':
+							// number,  if in denominator position
+							// otherwise treat as string
+							if(inDenominator)
+								inDenominator = false; // the rest is handled elsewhere
+							else
+								ret ~= lexeme.lexeme;
+						break;
+						case 'y':
+							if(value is double.nan)
+								return Result(s, "NaN date");
+
+							justSawHours = false;
+							auto y = getDate().year;
+
+							char[16] buffer;
+
+							switch(lexeme.lexeme.length) {
+								case 2:
+									ret ~= intToString(y % 100, buffer[], IntToStringArgs().withPadding(2));
+								break;
+								case 4:
+									ret ~= intToString(y, buffer[], IntToStringArgs().withPadding(4));
+								break;
+								default:
+									throw new ExcelFormatStringException("unknown thing " ~ lexeme.lexeme);
+							}
+						break;
+						case 'm':
+							if(value is double.nan)
+								return Result(s, "NaN date");
+							auto peek = peekLexeme(false);
+							bool precedesSeconds =
+								(peek.lexeme.length && peek.lexeme[0] == 's')
+								||
+								(peek.lexeme.length > 1 && peek.lexeme[1] == 's')
+							;
+
+							if(justSawHours || precedesSeconds) {
+								// minutes
+								auto m = getDate().timeOfDay.minute;
+
+								char[16] buffer;
+
+								switch(lexeme.lexeme.length) {
+									case 1:
+										ret ~= intToString(m, buffer[]);
+									break;
+									case 2:
+										ret ~= intToString(m, buffer[], IntToStringArgs().withPadding(2));
+									break;
+									default:
+										throw new ExcelFormatStringException("unknown thing " ~ lexeme.lexeme);
+								}
+							} else {
+								// month
+								auto m = cast(int) getDate().month;
+
+								char[16] buffer;
+
+								import arsd.calendar;
+
+								switch(lexeme.lexeme.length) {
+									case 1:
+										ret ~= intToString(m, buffer[]);
+									break;
+									case 2:
+										ret ~= intToString(m, buffer[], IntToStringArgs().withPadding(2));
+									break;
+									case 3: // abbreviation
+										ret ~= monthNames[m][0 .. 3];
+									break;
+									case 4: // full name
+										ret ~= monthNames[m];
+									break;
+									case 5: // single letter
+										ret ~= monthNames[m][0 .. 1]; // FIXME?
+									break;
+									default:
+										throw new ExcelFormatStringException("unknown thing " ~ lexeme.lexeme);
+								}
+							}
+
+							justSawHours = false;
+						break;
+						case 'd':
+							if(value is double.nan)
+								return Result(s, "NaN date");
+							justSawHours = false;
+
+							char[16] buffer;
+
+							import arsd.calendar;
+
+							auto d = getDate().day;
+							auto dow = cast(int) getDate().dayOfWeek;
+
+							switch(lexeme.lexeme.length) {
+								case 1:
+									ret ~= intToString(d, buffer[]);
+								break;
+								case 2:
+									ret ~= intToString(d, buffer[], IntToStringArgs().withPadding(2));
+								break;
+								case 3:
+									// abbreviation
+									ret ~= daysOfWeekNames[dow][0 .. 3];
+								break;
+								case 4:
+									// full name
+									ret ~= daysOfWeekNames[dow];
+								break;
+								default:
+									throw new ExcelFormatStringException("unknown thing " ~ lexeme.lexeme);
+							}
+						break;
+						case 'h':
+							if(value is double.nan)
+								return Result(s, "NaN date");
+							justSawHours = true;
+
+							auto m = getDate().timeOfDay.hour;
+							char[16] buffer;
+
+							if(hasAmPm && m > 12)
+								m -= 12;
+							if(hasAmPm && m == 0)
+								m = 12;
+
+							switch(lexeme.lexeme.length) {
+								case 1:
+									ret ~= intToString(m, buffer[]);
+								break;
+								case 2:
+									ret ~= intToString(m, buffer[], IntToStringArgs().withPadding(2));
+								break;
+								default:
+									throw new ExcelFormatStringException("unknown thing " ~ lexeme.lexeme);
+							}
+						break;
+						case 'a', 'A':
+							if(value is double.nan)
+								return Result(s, "NaN date");
+							inAmPm = true;
+							auto m = getDate().timeOfDay.hour;
+							if(m >= 12)
+								ret ~= lexeme.lexeme[0] == 'a' ? "pm" : "PM";
+							else
+								ret ~= lexeme.lexeme[0] == 'a' ? "am" : "AM";
+						break;
+						case 'p', 'P':
+							inAmPm = false;
+						break;
+						case 's':
+							if(value is double.nan)
+								return Result(s, "NaN date");
+							auto m = getDate().timeOfDay.second;
+							char[16] buffer;
+							switch(lexeme.lexeme.length) {
+								case 1:
+									ret ~= intToString(m, buffer[]);
+								break;
+								case 2:
+									ret ~= intToString(m, buffer[], IntToStringArgs().withPadding(2));
+								break;
+								default:
+									throw new ExcelFormatStringException("unknown thing " ~ lexeme.lexeme);
+							}
+						break;
+						case 'e', 'E':
+							// FIXME: scientific notation
+						break;
+						default:
+							assert(0, "unsupported formatting command: " ~ lexeme.lexeme);
+					}
+				}
+			}
+
+			return Result(ret, color, alignment);
+		} catch(ExcelFormatStringException e) {
+			// we'll fall back to just displaying the original input text
+			return Result(s, e.msg /* FIXME should be null */, alignment);
+		}
+	}
+
+	/+
+		positive;negative;zero;text
+		can include formats and dates and tons of stuff.
+		https://support.microsoft.com/en-us/office/review-guidelines-for-customizing-a-number-format-c0a1d1fa-d3f4-4018-96b7-9c9354dd99f5
+	+/
+	private this(XlsxFile file, XlsxFile.StyleInternal.xf formatting) {
+		if(formatting.applyNumberFormat) {
+			// dates too depending on format
+			 //import std.stdio; writeln(formatting.numFmtId); writeln(file.styleInternal.numFmts);
+			this.originalFormatString = file.styleInternal.numFmts[formatting.numFmtId];
+
+			this.type = Type.Number;
+		} else {
+			this.type = Type.String;
+		}
+
+		/+
+			xf also has:
+
+			int xfId;
+			int numFmtId;
+			int fontId;
+			int fillId;
+			int borderId;
+		+/
+	}
+
+	private this(string f) {
+		this.originalFormatString = f;
+		this.type = Type.Number;
+	}
+}
+
+unittest {
+	assert(XlsxFormat(`;;;"foo"`).applyTo("anything") == XlsxFormat.Result("foo", null));
+	assert(XlsxFormat(`#.#;;;"foo"`).applyTo("2.0") == XlsxFormat.Result("2.0", null, 1));
+	assert(XlsxFormat(`0#.##;;;"foo"`).applyTo("24.25") == XlsxFormat.Result("24.25", null, 1));
+	assert(XlsxFormat(`0#.##;;;"foo"`).applyTo("2.25") == XlsxFormat.Result("02.25", null, 1));
+	assert(XlsxFormat(`#,#.##`).applyTo("2.25") == XlsxFormat.Result("2.25", null, 1));
+	assert(XlsxFormat(`#,#.##`).applyTo("123.25") == XlsxFormat.Result("123.25", null, 1));
+	assert(XlsxFormat(`#,#.##`).applyTo("1234.25") == XlsxFormat.Result("1,234.25", null, 1));
+	assert(XlsxFormat(`#,#.##`).applyTo("123456.25") == XlsxFormat.Result("123,456.25", null, 1));
+}
+
+struct XlsxCell {
+	string formula;
+	string content;
+	XlsxFormat formatting;
+
+	XlsxFormat.Result displayableResult() {
+		return formatting.applyTo(content);
+	}
+
+	string toString() {
+		return displayableResult().content;
+	}
 }
-+/
 
 struct CellReference {
 	string name;
@@ -37,8 +862,11 @@ struct CellReference {
 		string ret;
 
 		string piece;
+		int adjustment = 0;
 		do {
-			piece ~= cast(char)(column % 26 + 'A');
+			piece ~= cast(char)(column % 26 + 'A' - adjustment);
+			if(adjustment == 0)
+				adjustment = 1;
 			column /= 26;
 		} while(column);
 
@@ -59,12 +887,26 @@ struct CellReference {
 	}
 
 	int toColumnIndex() {
-		int accumulator;
-		foreach(ch; name) {
-			if(ch < 'A' || ch > 'Z')
+		size_t endSlice = name.length;
+		foreach(idx, ch; name) {
+			if(ch < 'A' || ch > 'Z') {
+				endSlice = idx;
 				break;
+			}
+		}
+
+		int accumulator;
+		foreach(idx, ch; name[0 .. endSlice]) {
+			int value;
+			if(idx + 1 == endSlice) {
+				// an A in the last "digit" is a 0, elsewhere it is a 1
+				value = ch - 'A';
+			} else {
+				value = ch - 'A' + 1;
+			}
+
 			accumulator *= 26;
-			accumulator += ch - 'A';
+			accumulator += value;
 		}
 		return accumulator;
 	}
@@ -81,6 +923,18 @@ struct CellReference {
 	}
 }
 
+unittest {
+	auto cr = CellReference("AE434");
+	assert(cr.toColumnIndex == 30);
+	cr = CellReference("E434");
+	assert(cr.toColumnIndex == 4); // zero-based
+
+	// zero-based column, 1-based row. wtf?
+	assert(CellReference("AE434") == CellReference.fromInts(30, 434));
+
+	assert(CellReference("Z1") == CellReference.fromInts(25, 1));
+}
+
 /++
 
 +/
@@ -123,7 +977,8 @@ class XlsxSheet {
 		foreach(idx, ch; dimension)
 			if(ch == ':')
 				return CellReference(dimension[0 .. idx]);
-		assert(0);
+		//assert(0); // it has no lower right...
+		return CellReference(dimension);
 	}
 
 	private CellReference lowerRight() {
@@ -145,27 +1000,98 @@ class XlsxSheet {
 		Suitable for passing to [arsd.csv.toCsv]
 	+/
 	string[][] toStringGrid() {
+		auto grid = this.toGrid();
+
+		string[][] ret;
+		ret.length = size.height;
+		foreach(i, ref row; ret) {
+			row.length = size.width;
+			foreach(k, ref cell; row)
+				cell = grid[i][k].toString();
+		}
+
+		return ret;
+	}
+
+	/++
+
+	+/
+	XlsxCell[][] toGrid() {
 		// FIXME: this crashes on opend dmd!
 		// string[][] ret = new string[][](size.height, size.width);
 
-		string[][] ret;
+		/+
+		// almost everything we allocate in here is to keep, so
+		// turning off the GC while working prevents unnecessary
+		// collection attempts that won't find any garbage anyway.
+
+		// but meh no significant difference in perf anyway.
+		import core.memory;
+		GC.disable();
+		scope(exit)
+			GC.enable();
+		+/
+
+		XlsxCell[][] ret;
 		ret.length = size.height;
 		foreach(ref row; ret)
 			row.length = size.width;
 
 		//alloc done
 
-		foreach(int rowIdx, row; ret)
-		foreach(int cellIdx, ref cell; row) {
-			string cellReference = CellReference.fromInts(cellIdx + minColumn, rowIdx + minRow).name;
-			// FIXME: i should prolly read left to right here at least and not iterate the whole document over and over
-			auto element = document.querySelector("c[r=\""~cellReference~"\"]");
-			if(element is null)
-				continue;
-			string v = element.requireSelector("v").textContent;
-			if(element.attrs.t == "s")
-				v = file.sharedStrings[v.to!int()];
-			cell = v;
+		auto sheetData = document.requireSelector("sheetData");
+		Element[] rowElements = sheetData.childNodes;
+
+		Element[] nextRow(int expected) {
+			if(rowElements.length == 0)
+				throw new Exception("ran out of row elements...");
+
+			Element rowElement;
+			Element[] before = rowElements;
+
+			do {
+				rowElement = rowElements[0];
+				rowElements = rowElements[1 .. $];
+			} while(rowElement.tagName != "row");
+
+			if(rowElement.attrs.r.to!int != expected) {
+				// a row was skipped in the file, so we'll
+				// return an empty placeholder too
+				rowElements = before;
+				return null;
+			}
+
+			return rowElement.childNodes;
+		}
+
+		foreach(int rowIdx, row; ret) {
+			auto cellElements = nextRow(rowIdx + 1);
+
+			foreach(int cellIdx, ref cell; row) {
+				string cellReference = CellReference.fromInts(cellIdx + minColumn, rowIdx + minRow).name;
+
+				Element element = null;
+				foreach(idx, thing; cellElements) {
+					if(thing.attrs.r == cellReference) {
+						element = thing;
+						cellElements = cellElements[idx + 1 .. $];
+						break;
+					}
+				}
+
+				if(element is null)
+					continue;
+				string v = element.optionSelector("v").textContent;
+				if(element.attrs.t == "s")
+					v = file.sharedStrings[v.to!int()];
+
+				auto sString = element.attrs.s;
+				auto sId = sString.length ? to!int(sString) : 0;
+
+				string f = element.optionSelector("f").textContent;
+
+				cell = XlsxCell(f, v, XlsxFormat(file, file.styleInternal.xfs[sId]));
+			}
 		}
 		return ret;
 	}
@@ -245,6 +1171,33 @@ class XlsxFile {
 	}
 	private SheetInternal[] sheetsInternal;
 
+	// https://stackoverflow.com/questions/3154646/what-does-the-s-attribute-signify-in-a-cell-tag-in-xlsx
+	private struct StyleInternal {
+		string[int] numFmts;
+		// fonts
+			// font references color theme from xl/themes
+		// fills
+		// borders
+		// cellStyleXfs
+		// cellXfs
+		struct xf {
+			int xfId;
+			int numFmtId;
+			int fontId;
+			int fillId;
+			int borderId;
+
+			bool applyNumberFormat; // if yes, you get default right alignment
+		}
+		xf[] xfs;
+
+		// cellStyles
+		// dxfs
+		// tableStyles
+
+	}
+	private StyleInternal styleInternal;
+
 	private XmlDocument getSheetXml(ref SheetInternal sheet) {
 		if(sheet.cached is null)
 			loadXml("xl/" ~ relationships[sheet.rel].target, (document) { sheet.cached = document; });
@@ -276,6 +1229,64 @@ class XlsxFile {
 				sharedStrings ~= element.textContent;
 		});
 
+		loadXml("xl/styles.xml", (document) {
+			// need to keep the generic hardcoded formats first
+			styleInternal.numFmts = [
+				 0: "@",
+				 1: "0",
+				 2: "0.00",
+				 3: "#,##0",
+				 4: "#,##0.00",
+				 5: "$#,##0_);($#,##0)",
+				 6: "$#,##0_);[Red]($#,##0)",
+				 7: "$#,##0.00_);($#,##0.00)",
+				 8: "$#,##0.00_);[Red]($#,##0.00)",
+				 9: "0%",
+				10: "0.00%",
+				11: "0.00E+00",
+				12: "# ?/?",
+				13: "# ??/??",
+				14: "m/d/yyyy", // ive heard this one does different things in different locales
+				15: "d-mmm-yy",
+				16: "d-mmm",
+				17: "mmm-yy",
+				18: "h:mm AM/PM",
+				19: "h:mm:ss AM/PM",
+				20: "h:mm",
+				21: "h:mm:ss",
+				22: "m/d/yyyy h:mm",
+				37: "#,##0_);(#,##0)",
+				38: "#,##0_);[Red](#,##0)",
+				39: "#,##0.00_);(#,##0.00)",
+				40: "#,##0.00_);[Red](#,##0.00)",
+				45: "mm:ss",
+				46: "[h]:mm:ss",
+				47: "mm:ss.0",
+				48: "##0.0E+0",
+				49: "@",
+			];
+
+
+			foreach(element; document.querySelectorAll("numFmts > numFmt")) {
+				styleInternal.numFmts[to!int(element.attrs.numFmtId)] = element.attrs.formatCode;
+			}
+
+			foreach(element; document.querySelectorAll("cellXfs > xf")) {
+				StyleInternal.xf xf;
+
+				xf.xfId = element.attrs.xfId.to!int;
+				xf.fontId = element.attrs.fontId.to!int;
+				xf.fillId = element.attrs.fillId.to!int;
+				xf.borderId = element.attrs.borderId.to!int;
+				xf.numFmtId = element.attrs.numFmtId.to!int;
+
+				if(element.attrs.applyNumberFormat == "1")
+					xf.applyNumberFormat = true;
+
+				styleInternal.xfs ~= xf;
+			}
+		});
+
 		loadXml("xl/workbook.xml", (document) {
 			foreach(element; document.querySelectorAll("sheets > sheet")) {
 				sheetsInternal ~= SheetInternal(element.attrs.name, element.attrs.sheetId, element.getAttribute("r:id"));
@@ -288,3 +1299,140 @@ class XlsxFile {
 		handler(document);
 	}
 }
+
+
+// from Robert Schadek's code {
+
+import std.datetime;
+version(unittest) import std.format;
+
+Date longToDate(long d) @safe {
+	// modifed from https://www.codeproject.com/Articles/2750/
+	// Excel-Serial-Date-to-Day-Month-Year-and-Vice-Versa
+
+	// Excel/Lotus 123 have a bug with 29-02-1900. 1900 is not a
+	// leap year, but Excel/Lotus 123 think it is...
+	if(d == 60) {
+		return Date(1900, 2,  29);
+	} else if(d < 60) {
+		// Because of the 29-02-1900 bug, any serial date
+		// under 60 is one off... Compensate.
+		++d;
+	}
+
+	// Modified Julian to DMY calculation with an addition of 2415019
+	int l = cast(int)d + 68569 + 2415019;
+	int n = int(( 4 * l ) / 146097);
+	l = l - int(( 146097 * n + 3 ) / 4);
+	int i = int(( 4000 * ( l + 1 ) ) / 1461001);
+	l = l - int(( 1461 * i ) / 4) + 31;
+	int j = int(( 80 * l ) / 2447);
+	int nDay = l - int(( 2447 * j ) / 80);
+	l = int(j / 11);
+	int nMonth = j + 2 - ( 12 * l );
+	int nYear = 100 * ( n - 49 ) + i + l;
+	return Date(nYear, nMonth, nDay);
+}
+
+long dateToLong(Date d) @safe {
+	// modifed from https://www.codeproject.com/Articles/2750/
+	// Excel-Serial-Date-to-Day-Month-Year-and-Vice-Versa
+
+	// Excel/Lotus 123 have a bug with 29-02-1900. 1900 is not a
+	// leap year, but Excel/Lotus 123 think it is...
+	if(d.day == 29 && d.month == 2 && d.year == 1900) {
+		return 60;
+	}
+
+	// DMY to Modified Julian calculated with an extra subtraction of 2415019.
+	long nSerialDate =
+			int(( 1461 * ( d.year + 4800 + int(( d.month - 14 ) / 12) ) ) / 4) +
+			int(( 367 * ( d.month - 2 - 12 *
+				( ( d.month - 14 ) / 12 ) ) ) / 12) -
+				int(( 3 * ( int(( d.year + 4900
+				+ int(( d.month - 14 ) / 12) ) / 100) ) ) / 4) +
+				d.day - 2415019 - 32075;
+
+	if(nSerialDate < 60) {
+		// Because of the 29-02-1900 bug, any serial date
+		// under 60 is one off... Compensate.
+		nSerialDate--;
+	}
+
+	return nSerialDate;
+}
+
+@safe unittest {
+	auto ds = [ Date(1900,2,1), Date(1901, 2, 28), Date(2019, 06, 05) ];
+	foreach(const d; ds) {
+		long l = dateToLong(d);
+		Date r = longToDate(l);
+		assert(r == d, format("%s %s", r, d));
+	}
+}
+
+TimeOfDay doubleToTimeOfDay(double s) @safe {
+	import core.stdc.math : lround;
+	double secs = (24.0 * 60.0 * 60.0) * s;
+
+	// TODO not one-hundred my lround is needed
+	int secI = to!int(lround(secs));
+
+	return TimeOfDay(secI / 3600, (secI / 60) % 60, secI % 60);
+}
+
+double timeOfDayToDouble(TimeOfDay tod) @safe {
+	long h = tod.hour * 60 * 60;
+	long m = tod.minute * 60;
+	long s = tod.second;
+	return (h + m + s) / (24.0 * 60.0 * 60.0);
+}
+
+@safe unittest {
+	auto tods = [ TimeOfDay(23, 12, 11), TimeOfDay(11, 0, 11),
+		 TimeOfDay(0, 0, 0), TimeOfDay(0, 1, 0),
+		 TimeOfDay(23, 59, 59), TimeOfDay(0, 0, 0)];
+	foreach(const tod; tods) {
+		double d = timeOfDayToDouble(tod);
+		assert(d <= 1.0, format("%s", d));
+		TimeOfDay r = doubleToTimeOfDay(d);
+		assert(r == tod, format("%s %s", r, tod));
+	}
+}
+
+double datetimeToDouble(DateTime dt) @safe {
+	double d = dateToLong(dt.date);
+	double t = timeOfDayToDouble(dt.timeOfDay);
+	return d + t;
+}
+
+DateTime doubleToDateTime(double d) @safe {
+	long l = cast(long)d;
+	Date dt = longToDate(l);
+	TimeOfDay t = doubleToTimeOfDay(d - l);
+	return DateTime(dt, t);
+}
+
+@safe unittest {
+	auto ds = [ Date(1900,2,1), Date(1901, 2, 28), Date(2019, 06, 05) ];
+	auto tods = [ TimeOfDay(23, 12, 11), TimeOfDay(11, 0, 11),
+		 TimeOfDay(0, 0, 0), TimeOfDay(0, 1, 0),
+		 TimeOfDay(23, 59, 59), TimeOfDay(0, 0, 0)];
+	foreach(const d; ds) {
+		foreach(const tod; tods) {
+			DateTime dt = DateTime(d, tod);
+			double dou = datetimeToDouble(dt);
+
+			Date rd = longToDate(cast(long)dou);
+			assert(rd == d, format("%s %s", rd, d));
+
+			double rest = dou - cast(long)dou;
+			TimeOfDay rt = doubleToTimeOfDay(dou - cast(long)dou);
+			assert(rt == tod, format("%s %s", rt, tod));
+
+			DateTime r = doubleToDateTime(dou);
+			assert(r == dt, format("%s %s", r, dt));
+		}
+	}
+}
+// end from burner's code }