minigui/xml bridge

color.d

@@ -1389,3 +1389,5 @@ void floodFill(T)(
 			x, y + 1, additionalCheck);
 }
 
+// for scripting, so you can tag it without strictly needing to import arsd.jsvar
+enum arsd_jsvar_compatible = "arsd_jsvar_compatible";

jsvar.d

@@ -72,7 +72,7 @@ import std.conv;
 import std.json;
 
 // uda for wrapping classes
-enum Scriptable;
+enum scriptable = "arsd_jsvar_compatible";
 
 /*
 	PrototypeObject FIXME:
@@ -836,25 +836,29 @@ struct var {
 							if(no !is null)
 								return no;
 						}
+
+						// FIXME: this is kinda weird.
+						return null;
+					} else {
+
+						// failing that, generic struct or class getting: try to fill in the fields by name
+						T t;
+						bool initialized = true;
+						static if(is(T == class)) {
+							static if(__traits(compiles, new T()))
+								t = new T();
+							else
+								initialized = false;
+						}
+
+
+						if(initialized)
+						foreach(i, a; t.tupleof) {
+							cast(Unqual!(typeof((a)))) t.tupleof[i] = this[t.tupleof[i].stringof[2..$]].get!(typeof(a));
+						}
+
+						return t;
 					}
-
-					// failing that, generic struct or class getting: try to fill in the fields by name
-					T t;
-					bool initialized = true;
-					static if(is(T == class)) {
-						static if(__traits(compiles, new T()))
-							t = new T();
-						else
-							initialized = false;
-					}
-
-
-					if(initialized)
-					foreach(i, a; t.tupleof) {
-						cast(Unqual!(typeof((a)))) t.tupleof[i] = this[t.tupleof[i].stringof[2..$]].get!(typeof(a));
-					}
-
-					return t;
 				} else static if(isSomeString!T) {
 					if(this._object !is null)
 						return this._object.toString();
@@ -1664,6 +1668,7 @@ template helper(alias T) { alias helper = T; }
 ///
 /// That may be done automatically with opAssign in the future.
 WrappedNativeObject wrapNativeObject(Class)(Class obj) if(is(Class == class)) {
+	import std.meta;
 	return new class WrappedNativeObject {
 		override Object getObject() {
 			return obj;
@@ -1674,25 +1679,39 @@ WrappedNativeObject wrapNativeObject(Class)(Class obj) if(is(Class == class)) {
 			// wrap the other methods
 			// and wrap members as scriptable properties
 
-			foreach(memberName; __traits(allMembers, Class)) {
-				static if(is(typeof(__traits(getMember, obj, memberName)) type))
-				static if(is(typeof(__traits(getMember, obj, memberName)))) {
-					static if(is(type == function)) {
-						_properties[memberName] = &__traits(getMember, obj, memberName);
-					} else {
-						// if it has a type but is not a function, it is prolly a member
-						_properties[memberName] = new PropertyPrototype(
-							() => var(__traits(getMember, obj, memberName)),
-							(var v) {
-								__traits(getMember, obj, memberName) = v.get!(type);
-							});
+			foreach(memberName; __traits(allMembers, Class)) static if(is(typeof(__traits(getMember, obj, memberName)) type)) {
+				static if(is(type == function)) {
+					foreach(idx, overload; AliasSeq!(__traits(getOverloads, obj, memberName))) static if(.isScriptable!(__traits(getAttributes, overload))()) {
+						auto helper = &__traits(getOverloads, obj, memberName)[idx];
+						_properties[memberName] = (Parameters!helper args) {
+							return __traits(getOverloads, obj, memberName)[idx](args);
+						};
 					}
+				} else {
+					static if(.isScriptable!(__traits(getAttributes, __traits(getMember, Class, memberName)))())
+					// if it has a type but is not a function, it is prolly a member
+					_properties[memberName] = new PropertyPrototype(
+						() => var(__traits(getMember, obj, memberName)),
+						(var v) {
+							__traits(getMember, obj, memberName) = v.get!(type);
+						});
 				}
 			}
 		}
 	};
 }
 
+bool isScriptable(attributes...)() {
+	foreach(attribute; attributes) {
+		static if(is(typeof(attribute) == string)) {
+			static if(attribute == scriptable) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
 /// Wraps a struct by reference. The pointer is stored - be sure the struct doesn't get freed or go out of scope!
 ///
 /// BTW: structs by value can be put in vars with var.opAssign and var.get. It will generate an object with the same fields. The difference is changes to the jsvar won't be reflected in the original struct and native methods won't work if you do it that way.

minigui_xml.d

@@ -0,0 +1,107 @@
+/++
+	A small extension module to [arsd.minigu] that adds
+	functions for creating widgets and windows from short
+	XML descriptions.
+
+	If you choose to use this, it will require [arsd.dom]
+	to be compiled into your project too.
+
+	---
+	import arsd.minigui_xml;
+	Window window = createWindow(`
+		<MainWindow>
+			<Button label="Hi!" />
+		</MainWindow>
+	`);
+	---
++/
+module arsd.minigui_xml;
+
+public import arsd.minigui;
+
+import arsd.dom;
+
+private template ident(T...) {
+	static if(is(T[0]))
+		alias ident = T[0];
+	else
+		alias ident = void;
+}
+
+private
+Widget delegate(string[string] args, Widget parent)[string] widgetFactoryFunctions;
+
+private
+void loadMiniguiPublicClasses() {
+	if(widgetFactoryFunctions !is null)
+		return;
+
+	import std.traits;
+	import std.conv;
+
+	foreach(memberName; __traits(allMembers, mixin("arsd.minigui"))) static if(__traits(compiles, __traits(getMember, mixin("arsd.minigui"), memberName))) {
+		alias Member = ident!(__traits(getMember, mixin("arsd.minigui"), memberName));
+		static if(is(Member == class) && !isAbstractClass!Member && is(Member : Widget)) {
+			widgetFactoryFunctions[memberName] = (string[string] args, Widget parent) {
+				static if(is(Member : Dialog)) {
+					return new Member();
+				} else static if(is(Member : Window)) {
+					return new Member("test");
+				} else {
+					auto paramNames = ParameterIdentifierTuple!(__traits(getMember, Member, "__ctor"));
+					Parameters!(__traits(getMember, Member, "__ctor")) params;
+
+					foreach(idx, param; params[0 .. $-1]) {
+						if(auto arg = paramNames[idx] in args)
+							params[idx] = to!(typeof(param))(*arg);
+					}
+
+					params[$-1] = parent;
+
+					auto widget = new Member(params);
+
+					if(auto st = "statusTip" in args)
+						widget.statusTip = *st;
+					if(auto st = "name" in args)
+						widget.name = *st;
+					return widget;
+				}
+			};
+		}
+	}
+}
+
+///
+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) {
+	return createWindowFromXml(new Document(xml, true, true));
+}
+///
+Window createWindowFromXml(Document document) {
+	auto r = document.root;
+	return cast(Window) miniguiWidgetFromXml(r, null);
+}
+///
+Widget miniguiWidgetFromXml(Element element, Widget parent) {
+	if(widgetFactoryFunctions is null)
+		loadMiniguiPublicClasses();
+	if(auto factory = element.tagName in widgetFactoryFunctions) {
+		auto p = (*factory)(element.attributes, parent);
+		foreach(child; element.children)
+			if(child.tagName != "#text")
+				miniguiWidgetFromXml(child, p);
+		return p;
+	} else {
+		import std.stdio;
+		writeln("Unknown class: ", element.tagName);
+		return null;
+	}
+}
+
+

simpledisplay.d

@@ -11195,6 +11195,8 @@ mixin template ExperimentalTextComponent() {
 			auto y = caret.inlineElement.boundingBox.top + 2;
 
 			y -= caret.inlineElement.boundingBox.bottom - caret.inlineElement.boundingBox.top;
+			if(y < 0)
+				return;
 
 			auto i = identify(x, y);