more stuff

jsvar.d

@@ -638,10 +638,10 @@ struct var {
 			// so prewrapped stuff can be easily passed.
 			this._type = Type.Object;
 			this._payload._object = t;
-		} else static if(is(T == class)) {
+		} else static if(is(T == class) || .isScriptableOpaque!T) {
 			// auto-wrap other classes with reference semantics
 			this._type = Type.Object;
-			this._payload._object = wrapNativeObject(t);
+			this._payload._object = wrapOpaquely(t);
 		} else static if(is(T == struct) || isAssociativeArray!T) {
 			// copy structs and assoc arrays by value into a var object
 			this._type = Type.Object;
@@ -830,6 +830,15 @@ struct var {
 				} else static if(is(T : PrototypeObject)) {
 					// they are requesting an implementation object, just give it to them
 					return cast(T) this._payload._object;
+				} else static if(isScriptableOpaque!(Unqual!T)) {
+					if(auto wno = cast(WrappedOpaque!(Unqual!T)) this._payload._object) {
+						return wno.wrapping();
+					}
+					static if(is(T == R*, R))
+					if(auto wno = cast(WrappedOpaque!(Unqual!(R))) this._payload._object) {
+						return wno.wrapping();
+					}
+					throw new DynamicTypeException(this, Type.Object); // FIXME: could be better
 				} else static if(is(T == struct) || is(T == class)) {
 					// first, we'll try to give them back the native object we have, if we have one
 					static if(is(T : Object)) {
@@ -1707,6 +1716,34 @@ WrappedNativeObject wrapNativeObject(Class)(Class obj) if(is(Class == class)) {
 	};
 }
 
+import std.traits;
+class WrappedOpaque(T) : PrototypeObject if(isPointer!T) {
+	T wrapped;
+	this(T t) {
+		wrapped = t;
+	}
+	T wrapping() {
+		return wrapped;
+	}
+}
+class WrappedOpaque(T) : PrototypeObject if(!isPointer!T) {
+	T* wrapped;
+	this(T t) {
+		wrapped = new T;
+		(cast() *wrapped) = t;
+	}
+	this(T* t) {
+		wrapped = t;
+	}
+	T* wrapping() {
+		return wrapped;
+	}
+}
+
+WrappedOpaque!Obj wrapOpaquely(Obj)(Obj obj) {
+	return new WrappedOpaque!Obj(obj);
+}
+
 /**
 	Wraps an opaque struct pointer in a module with ufcs functions
 */
@@ -1750,6 +1787,13 @@ bool isScriptable(attributes...)() {
 	return false;
 }
 
+bool isScriptableOpaque(T)() {
+	static if(is(typeof(T.isOpaqueStruct) == bool))
+		return T.isOpaqueStruct == 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.

nanovega.d

@@ -559,9 +559,19 @@ version(nanovg_disable_fontconfig) {
 //version = nanovg_bench_flatten;
 
 /++
-	Annotation to indicate it is compatible with [arsd.script]
+	Annotation to indicate the marked function is compatible with [arsd.script].
+
+
+	Any function that takes a [Color] argument will be passed a string instead.
+
+	Scriptable Functions
+	====================
+
+	$(UDA_USES)
+
+	$(ALWAYS_DOCUMENT)
 +/
-package(arsd) enum scriptable = "arsd_jsvar_compatible";
+private enum scriptable = "arsd_jsvar_compatible";
 
 public:
 alias NVG_PI = PI;
@@ -996,6 +1006,7 @@ public:
  * Group: images
  */
 struct NVGImage {
+	enum isOpaqueStruct = true;
 private:
   NVGContext ctx;
   int id; // backend image id
@@ -1070,6 +1081,8 @@ public:
 /// Paint parameters for various fills. Don't change anything here!
 /// Group: render_styles
 public struct NVGPaint {
+  enum isOpaqueStruct = true;
+
   NVGMatrix xform;
   float[2] extent = 0.0f;
   float radius = 0.0f;
@@ -3019,9 +3032,12 @@ public void globalAlpha (NVGContext ctx, float alpha) nothrow @trusted @nogc {
   state.alpha = alpha;
 }
 
+private void strokeColor() {}
+
 static if (NanoVegaHasArsdColor) {
 /// Sets current stroke style to a solid color.
 /// Group: render_styles
+@scriptable
 public void strokeColor (NVGContext ctx, Color color) nothrow @trusted @nogc {
   NVGstate* state = nvg__getState(ctx);
   nvg__setPaintColor(state.stroke, NVGColor(color));
@@ -3035,8 +3051,14 @@ public void strokeColor() (NVGContext ctx, in auto ref NVGColor color) nothrow @
   nvg__setPaintColor(state.stroke, color);
 }
 
+@scriptable
+public void strokePaint(NVGContext ctx, in NVGPaint* paint) nothrow @trusted @nogc {
+	strokePaint(ctx, *paint);
+}
+
 /// Sets current stroke style to a paint, which can be a one of the gradients or a pattern.
 /// Group: render_styles
+@scriptable
 public void strokePaint() (NVGContext ctx, in auto ref NVGPaint paint) nothrow @trusted @nogc {
   NVGstate* state = nvg__getState(ctx);
   state.stroke = paint;
@@ -3063,10 +3085,17 @@ public void fillColor (NVGContext ctx, Color color) nothrow @trusted @nogc {
 public void fillColor() (NVGContext ctx, in auto ref NVGColor color) nothrow @trusted @nogc {
   NVGstate* state = nvg__getState(ctx);
   nvg__setPaintColor(state.fill, color);
+
+}
+
+@scriptable // kinda a hack for bug 16206 but also because jsvar deals in opaque NVGPaint* instead of auto refs (which it doesn't  know how to reflect on)
+public void fillPaint (NVGContext ctx, in NVGPaint* paint) nothrow @trusted @nogc {
+	fillPaint(ctx, *paint);
 }
 
 /// Sets current fill style to a paint, which can be a one of the gradients or a pattern.
 /// Group: render_styles
+@scriptable
 public void fillPaint() (NVGContext ctx, in auto ref NVGPaint paint) nothrow @trusted @nogc {
   NVGstate* state = nvg__getState(ctx);
   state.fill = paint;
@@ -3299,6 +3328,8 @@ public void deleteImage() (NVGContext ctx, ref NVGImage image) nothrow @trusted
 // ////////////////////////////////////////////////////////////////////////// //
 // Paints
 
+private void linearGradient() {} // hack for dmd bug
+
 static if (NanoVegaHasArsdColor) {
 /** Creates and returns a linear gradient. Parameters `(sx, sy) (ex, ey)` specify the start and end coordinates
  * of the linear gradient, icol specifies the start color and ocol the end color.
@@ -3306,6 +3337,7 @@ static if (NanoVegaHasArsdColor) {
  *
  * Group: paints
  */
+@scriptable
 public NVGPaint linearGradient (NVGContext ctx, in float sx, in float sy, in float ex, in float ey, in Color icol, in Color ocol) nothrow @trusted @nogc {
   return ctx.linearGradient(sx, sy, ex, ey, NVGColor(icol), NVGColor(ocol));
 }