public static void RegisterProxyConverter <T>(this IJSValueConverterService service, Action <JSValueBinding, T, IServiceNode> createBinding) where T : class
{
toJSValueDelegate <T> tojs = (IServiceNode node, T value) =>
{
return(node.GetService <IContextSwitchService>().With(() =>
{
var result = JavaScriptValue.CreateExternalObject(IntPtr.Zero, null);
JSValueBinding binding = new JSValueBinding(node, result);
var handle = node.GetService <IGCSyncService>().SyncWithJsValue(value, result);
result.ExternalData = GCHandle.ToIntPtr(handle);//save the object reference to javascript values's external data
createBinding?.Invoke(binding, value, node);
return result;
}));
};
fromJSValueDelegate <T> fromjs = (IServiceNode node, JavaScriptValue value) =>
{
if (value.HasExternalData)
{
GCHandle handle = GCHandle.FromIntPtr(value.ExternalData);
return(handle.Target as T);
}
else
{
throw new ArgumentOutOfRangeException("Convert from jsValue to proxy object failed, jsValue does not have a linked CLR object");
}
};
service.RegisterConverter <T>(tojs, fromjs);
}
public static void RegisterTask(this IJSValueConverterService target)
{
if (target.CanConvert <Task>())
{
return;
}
//register internal call back types
target.RegisterMethodConverter <string>();
target.RegisterFunctionConverter <JSValue>();
target.RegisterMethodConverter <JavaScriptValue>();
target.RegisterConverter <Task>(
(node, value) =>
{
var jsValueService = node.GetService <IJSValueService>();
var globalObject = jsValueService.JSGlobalObject;
var converter = node.GetService <IJSValueConverterService>();
var tmp = node.WithContext(() =>
{
JavaScriptValue.CreatePromise(out var result, out var resolve, out var reject);
return(Tuple.Create(result, resolve, reject));
});
//start the task on new thread
Task.Factory.StartNew(async() =>
{
try
{
await value;
jsValueService.CallFunction(tmp.Item2, globalObject);
}
catch (PromiseRejectedException ex)
{
var message = converter.ToJSValue(ex.ToString());
jsValueService.CallFunction(tmp.Item3, globalObject, message);
}
catch (Exception)
{
throw;
}
});
//return the promise without wait task complete
return(tmp.Item1);
},
(node, value) =>
{
//from a promise
return(Task.Factory.FromAsync(
(callback, state) =>
{
return BeginMethod(value, node, callback, state);
}
, EndMethod, null
));
}, false
);
}
private void registerTTexture(IJSValueConverterService converter)
{
converter.RegisterProxyConverter <TTexture>(
(binding, obj, node) =>
{
binding.SetFunction <SizeF>(nameof(obj.GetSize), () => obj.GetSize);
});
}
private void registerTDrawingSurface(IJSValueConverterService converter)
{
converter.RegisterProxyConverter <TDrawingSurface>(
(binding, obj, node) =>
{
binding.SetFunction(nameof(obj.CreateSpritBatch), obj.CreateSpritBatch);
});
}
public static void RegisterMethodConverter <T1, T2, T3, T4>(this IJSValueConverterService service)
{
if (service.CanConvert <Action <T1, T2, T3, T4> >())
{
return;
}
service.RegisterConverter <Action <T1, T2, T3, T4> >(toJSMethod <T1, T2, T3, T4>, fromJSMethod <T1, T2, T3, T4>, false);
}
public virtual void TestInitialize()
{
runtime = ChakraRuntime.Create();
LogAndPush("Runtime Created");
context = runtime.CreateContext(true);
LogAndPush("Context created");
converter = context.ServiceNode.GetService <IJSValueConverterService>();
SetupContext();
Log("Context setup complete");
}
private static void registerProxy(IJSValueConverterService converter)
{
converter.RegisterProxyConverter <HostingProxy>(
(binding, obj, node) =>
{
binding.SetFunction <string, string, Task <string> >("Dispatch", obj.Dispatch);
}
);
converter.RegisterTask <HostingProxy>();
converter.RegisterTask <string>();
}
//register direct call delegate and callback delegate
public static void RegisterFunctionConverter <T1, T2, T3, TResult>(this IJSValueConverterService service)
{
if (!service.CanConvert <Func <bool, T1, T2, T3, TResult> >())
{
service.RegisterConverter <Func <bool, T1, T2, T3, TResult> >(toJSFunction <T1, T2, T3, TResult>, fromJSFunction <T1, T2, T3, TResult>, false);
}
if (!service.CanConvert <Func <T1, T2, T3, TResult> >())
{
service.RegisterConverter <Func <T1, T2, T3, TResult> >(toJSCallbackFunction <T1, T2, T3, TResult>, fromJSCallbackFunction <T1, T2, T3, TResult>, false);
}
}
public static void RegisterTask <TResult>(this IJSValueConverterService target)
{
if (target.CanConvert <Task <TResult> >())
{
return;
}
//register internal call back types
target.RegisterFunctionConverter <TResult>();
target.RegisterMethodConverter <TResult>();
target.RegisterMethodConverter <string>();
target.RegisterFunctionConverter <JSValue>();
target.RegisterMethodConverter <JavaScriptValue>();
target.RegisterMethodConverter <Action <TResult>, Action <JavaScriptValue> >();
target.RegisterConverter <Task <TResult> >(
(node, value) =>
{
//convert resolve, reject
Action <Action <TResult>, Action <JavaScriptValue> > promiseBody = async(resolve, reject) =>
{
try
{
var result = await value;
resolve(result);
}
catch (PromiseRejectedException ex)
{
reject(ex.Error);
}
catch (Exception)
{
throw;
}
};
var jsValueService = node.GetService <IJSValueService>();
var globalObject = jsValueService.JSGlobalObject;
var jsGlobalObject = new JSValue(node, globalObject);
return(jsGlobalObject.CallFunction <Action <Action <TResult>, Action <JavaScriptValue> >, JavaScriptValue>("Promise", promiseBody, true));
},
(node, value) =>
{
//from a promise
return(Task.Factory.FromAsync(
(callback, state) =>
{
return BeginMethod <TResult>(value, node, callback, state);
}
, EndMethod <TResult>, null
));
}, false
);
}
public static void RegisterProxyConverter <T>(this IJSValueConverterService service, Action <JSValueBinding, T, IServiceNode> createBinding) where T : class
{
toJSValueDelegate <T> tojs = (IServiceNode node, T value) =>
{
var mapService = node.GetService <IProxyMapService>();
return(mapService.Map <T>(value, createBinding));
};
fromJSValueDelegate <T> fromjs = (IServiceNode node, JavaScriptValue value) =>
{
var mapService = node.GetService <IProxyMapService>();
return(mapService.Get <T>(value));
};
service.RegisterConverter <T>(tojs, fromjs);
}
private static void InjectDictionaryConverter(IJSValueConverterService service)
{
service.RegisterArrayConverter <string>();
service.RegisterProxyConverter <IDictionary <string, string> >(
(binding, dict, node) =>
{
DictionaryWrapper wrapper = new DictionaryWrapper(dict);
binding.SetFunction <IEnumerable <string> >("GetKeys", wrapper.GetKeys);
binding.SetMethod <string, string>("SetItem", wrapper.SetItem);
binding.SetFunction <string, string>("GetItem", wrapper.GetItem);
binding.SetFunction <string, bool>("ContainsKey", wrapper.ContainsKey);
}
);
}
private void registerFont(IJSValueConverterService converter)
{
converter.RegisterStructConverter <Font>(
(jsvalue, obj) =>
{
jsvalue.WriteProperty <string>(nameof(obj.Name), obj.Name);
jsvalue.WriteProperty <float>(nameof(obj.Size), obj.Size);
},
(jsvalue) =>
{
return(new Font()
{
Name = jsvalue.ReadProperty <string>(nameof(Font.Name)),
Size = jsvalue.ReadProperty <float>(nameof(Font.Size))
});
});
}
public static void RegisterStructConverter <T>(this IJSValueConverterService service, Action <JSValue, T> toJSValue, Func <JSValue, T> fromJSValue) //where T:struct
{
service.RegisterConverter <T>(
(node, value) =>
{
JavaScriptValue jsObj = node.GetService <IJSValueService>().CreateObject();
JSValue v = new JSValue(node, jsObj);
toJSValue(v, value);
return(jsObj);
},
(node, value) =>
{
JSValue v = new JSValue(node, value);
return(fromJSValue(v));
}
);
}
public static void RegisterArrayConverter <T>(this IJSValueConverterService service)
{
toJSValueDelegate <IEnumerable <T> > tojs = (node, value) =>
{
return(node.WithContext <JavaScriptValue>(() =>
{
var result = node.GetService <IJSValueService>().CreateArray(Convert.ToUInt32(value.Count()));
int index = 0;
foreach (T item in value)
{
result.SetIndexedProperty(service.ToJSValue <int>(index++), service.ToJSValue <T>(item));
}
return result;
}
));
};
fromJSValueDelegate <IEnumerable <T> > fromjs = (node, value) =>
{
return(node.WithContext <IEnumerable <T> >(() =>
{
var jsValueService = node.GetService <IJSValueService>();
var length = service.FromJSValue <int>(value.GetProperty(JavaScriptPropertyId.FromString("length")));
List <T> result = new List <T>(length);//copy the data to avoid context switch in user code
for (int i = 0; i < length; i++)
{
result.Add(
service.FromJSValue <T>(value.GetIndexedProperty(
service.ToJSValue <int>(i))
)
);
}
return result;
}
));
};
service.RegisterConverter <IEnumerable <T> >(tojs, fromjs, false);
}
private void registerTSprintBatch(IJSValueConverterService converter)
{
converter.RegisterProxyConverter <TSpritBatch>(
(binding, obj, node) =>
{
binding.SetMethod <PointF, string, Font, string, int>(nameof(obj.DrawText), obj.DrawText);
binding.SetMethod <IEnumerable <PointF>, string, int>(nameof(obj.DrawLines), obj.DrawLines);
binding.SetMethod <PointF, SizeF, string, int, bool>(nameof(obj.DrawEclipse), obj.DrawEclipse);
binding.SetMethod <PointF, SizeF, TTexture, float>(nameof(obj.DrawImage), obj.DrawImage);
binding.SetMethod <string, RectangleF>(nameof(obj.Fill), obj.Fill);
binding.SetMethod <RectangleF, string, int, bool>(nameof(obj.DrawRectangle), obj.DrawRectangle);
binding.SetMethod <PointF, PointF, PointF, string, int, bool>(nameof(obj.DrawTriangle), obj.DrawTriangle);
binding.SetMethod <PointF>(nameof(obj.Translate), obj.Translate);
binding.SetMethod <PointF>(nameof(obj.Scale), obj.Scale);
binding.SetMethod <float>(nameof(obj.Rotate), obj.Rotate);
binding.SetFunction <int>(nameof(obj.PushMatrix), obj.PushMatrix);
binding.SetFunction <int>(nameof(obj.PopMatrix), obj.PopMatrix);
binding.SetMethod(nameof(obj.ResetMatrix), obj.ResetMatrix);
binding.SetMethod <BlendModeEnum, Effect>(nameof(obj.Begin), obj.Begin);
binding.SetMethod(nameof(obj.End), obj.End);
}
);
}
protected void RegisterCustomValueConverter(IJSValueConverterService converterService)
{
}
private void registerBasicTypes(IJSValueConverterService converter)
{
converter.RegisterStructConverter <PointF>(
(jsvalue, value) =>
{
jsvalue.WriteProperty("X", value.X);
jsvalue.WriteProperty("Y", value.Y);
},
(jsvalue) =>
{
return(new PointF(
jsvalue.ReadProperty <float>("X")
, jsvalue.ReadProperty <float>("Y")));
});
converter.RegisterStructConverter <SizeF>(
(jsvalue, value) =>
{
jsvalue.WriteProperty("Width", value.Width);
jsvalue.WriteProperty("Height", value.Height);
},
(jsvalue) =>
{
return(new SizeF(
jsvalue.ReadProperty <float>("Width")
, jsvalue.ReadProperty <float>("Height")));
});
converter.RegisterStructConverter <RectangleF>(
(jsvalue, value) =>
{
jsvalue.WriteProperty("X", value.X);
jsvalue.WriteProperty("Y", value.Y);
jsvalue.WriteProperty("Width", value.Width);
jsvalue.WriteProperty("Height", value.Height);
},
(jsvalue) =>
{
return(new RectangleF(
jsvalue.ReadProperty <float>("X")
, jsvalue.ReadProperty <float>("Y")
, jsvalue.ReadProperty <float>("Width")
, jsvalue.ReadProperty <float>("Height")));
});
converter.RegisterArrayConverter <PointF>();
converter.RegisterConverter <BlendModeEnum>(
(node, value) =>
{
return(node.GetService <IContextSwitchService>().With(() =>
{
return API.JavaScriptValue.FromInt32((int)value);
}));
},
(node, jsvalue) =>
{
return(node.GetService <IContextSwitchService>().With(() =>
{
return (BlendModeEnum)jsvalue.ToInt32();
}));
}
);
converter.RegisterStructConverter <Effect>(
(jsvalue, value) =>
{
jsvalue.WriteProperty <string>(nameof(value.Name), value.Name);
jsvalue.WriteProperty <string>(nameof(value.ConfigJson), value.ConfigJson);
},
(jsvalue) =>
{
return(new Effect()
{
Name = jsvalue.ReadProperty <string>(nameof(Effect.Name)),
ConfigJson = jsvalue.ReadProperty <string>(nameof(Effect.ConfigJson))
});
}
);
}
