/// <summary>
/// Get the value of a named property.
/// </summary>
/// <param name="name"></param>
/// <param name="returnValue"></param>
/// <param name="exception"></param>
/// <returns></returns>
public bool GetProperty(string name, out CefV8Value returnValue, out string exception)
{
exception = null;
returnValue = null;
if (string.IsNullOrEmpty(name))
{
exception = "No property name specified";
return(false);
}
if (_expandoProperties.TryGetValue(name, out returnValue))
{
return(true);
}
try
{
object val;
if (OnGetProperty(name, out val))
{
returnValue = CefNativeValueConverter.ToCef(val);
return(true);
}
exception = "Property not found: " + name;
returnValue = CefV8Value.CreateUndefined();
return(false);
}
catch (Exception ex)
{
exception = ex.Message;
return(false);
}
}
/// <summary>
/// Convert the parameter values from the caller into native C# objects that match the supplied parameter definitions.
/// </summary>
/// <param name="parameterInfos">The parameter definitions for the method to be invoked.</param>
/// <param name="pluginManager">Plugin Manager instance</param>
/// <returns>Native C# objects matching <param name="parameterInfos"></param></returns>
/// <remarks>
/// The method will be called by <see cref="JavaScriptPlugin.InvokeFunction"/> on the calling thread, *before* dispatching to a background thread for execution.
/// </remarks>
public object[] GetConvertedParameters(ParameterInfo[] parameterInfos, IPluginManager pluginManager)
{
// TODO: handle params method definition
// TODO: ensure sufficient values have been provided (factoring in parameters with default values)
var arguments = new object[parameterInfos.Length];
for (var parameterInfoIndex = 0; parameterInfoIndex < parameterInfos.Length; ++parameterInfoIndex)
{
if (parameterInfoIndex < _parameters.Length)
{
var parameterToken = _parameters[parameterInfoIndex];
arguments[parameterInfoIndex] = CefNativeValueConverter.ToNative(parameterToken, parameterInfos[parameterInfoIndex].ParameterType);
}
else
{
arguments[parameterInfoIndex] = null;
}
}
return(arguments);
}
protected CefV8Value ToCefV8Value(IV8PluginRouter router, object result)
{
if (result == null)
{
return(CefV8Value.CreateNull());
}
// VALUES FROM REMOTE PLUGINS
var remoteResult = result as ResultData;
if (remoteResult != null)
{
switch (remoteResult.DataType)
{
case ResultDataType.Scalar:
if (remoteResult.Items != null && remoteResult.Items.Count != 0)
{
return(ToCefV8Value(router, remoteResult.Items[0]));
}
return(CefV8Value.CreateNull());
case ResultDataType.Array:
{
var cefArray = CefV8Value.CreateArray(remoteResult.Items.Count);
if (remoteResult.Items != null)
{
for (var resultIndex = 0; resultIndex < remoteResult.Items.Count; ++resultIndex)
{
var cefValue = ToCefV8Value(router, remoteResult.Items[resultIndex]);
cefArray.SetValue(resultIndex, cefValue);
}
}
return(cefArray);
}
case ResultDataType.Dictionary:
{
var cefObject = CefV8Value.CreateObject(null);
if (remoteResult.Items != null)
{
foreach (var dictionaryItem in remoteResult.Items)
{
if (string.IsNullOrEmpty(dictionaryItem.Name))
{
continue;
}
var cefValue = ToCefV8Value(router, dictionaryItem);
cefObject.SetValue(dictionaryItem.Name, cefValue, CefV8PropertyAttribute.None);
}
}
return(cefObject);
}
}
}
var resultItem = result as ResultItem;
if (resultItem != null)
{
return(ToCefV8Value(router, (object)resultItem.DynamicPlugin ?? resultItem.PlainData));
}
var pluginObjectDescriptor = result as PluginDescriptor;
if (pluginObjectDescriptor != null)
{
return(V8PluginAdapter.CreateRemote(router, _plugin.PluginContext, pluginObjectDescriptor).V8Object);
}
// VALUES FROM REMOTE OR LOCAL PLUGINS
var plainData = result as JToken;
if (plainData != null)
{
return(CefJsonValueConverter.ToCef(plainData));
}
// VALUES FROM LOCAL PLUGINS
var localArray = result as object[];
if (localArray != null)
{
var cefArray = CefV8Value.CreateArray(localArray.Length);
for (var resultIndex = 0; resultIndex < localArray.Length; ++resultIndex)
{
var cefValue = ToCefV8Value(router, localArray[resultIndex]);
cefArray.SetValue(resultIndex, cefValue);
}
return(cefArray);
}
var localPlugin = result as JavaScriptPlugin;
if (localPlugin != null)
{
return(V8PluginAdapter.CreateLocal(router, _plugin.PluginContext, localPlugin).V8Object);
}
if (JavaScriptPlugin.IsDynamicPlugin(result))
{
var dynPlugin = JavaScriptPlugin.CreateFromObject(PluginProcess.Renderer, result);
_plugin.PluginContext.PluginManager.AddLocalPlugin(dynPlugin);
return(V8PluginAdapter.CreateLocal(router, _plugin.PluginContext, dynPlugin).V8Object);
}
// local C# POCO
return(CefNativeValueConverter.ToCef(result));
}
public object GetConvertedValue(PropertyInfo propertyInfo)
{
return(CefNativeValueConverter.ToNative(_cefValue, propertyInfo.PropertyType));
}
