public JsNode VisitNamedExpression(NamedExpression node)
{
var name = new JsJsonMember {
Name = node.Name
};
if (name.Name.IsNullOrEmpty())
{
throw new NotImplementedException();
//if (d.expression.e == cs_node.n_simple_name)
// name.Name = ((CsSimpleName)d.expression).identifier.identifier;
//else if (d.expression.e == cs_node.n_primary_expression_member_access)
// name.Name = ((CsPrimaryExpressionMemberAccess)d.expression).identifier.identifier;
}
var value = VisitExpression(node.Expression);
var ce = node.GetParentType();
var nativeJson = Sk.UseNativeJsons(ce.GetDefinitionOrArrayType());
if (!nativeJson)
{
name.Name = "get_" + name.Name;
value = new JsFunction {
Block = new JsBlock {
Statements = new List <JsStatement> {
new JsReturnStatement {
Expression = value
}
}
}
};
}
return(new JsJsonNameValue {
Name = name, Value = value
});
}
public JsFunctionDelegate(
IJintVisitor visitor,
JsFunction function,
JsDictionaryObject that,
Type delegateType)
{
if (visitor == null)
{
throw new ArgumentNullException(nameof(visitor));
}
if (function == null)
{
throw new ArgumentNullException(nameof(function));
}
if (delegateType == null)
{
throw new ArgumentNullException(nameof(delegateType));
}
if (!typeof(Delegate).IsAssignableFrom(delegateType))
{
throw new ArgumentException("A delegate type is required", nameof(delegateType));
}
this.m_visitor = visitor;
this.m_function = function;
this.m_delegateType = delegateType;
this.m_that = that;
this.m_marshaller = visitor.Global.Marshaller;
}
private object MarshalJsFunctionHelper(JsFunction func, Type delegateType)
{
return((object)new JsFunctionDelegate((IJintVisitor) new ExecutionVisitor(this.m_global, new JsScope((JsDictionaryObject)this.m_global))
{
PermissionSet = ((ExecutionVisitor)this.m_global.Visitor).PermissionSet
}, func, (JsDictionaryObject)JsNull.Instance, delegateType).GetDelegate());
}
public JsNode VisitLambdaResolveResult(LambdaResolveResult res)
{
//var prmTypes = res.Parameters.Select(t => t.Type).ToArray();
//var retType = res.GetInferredReturnType(prmTypes);
//var conv = res.IsValid(prmTypes, retType, CSharpConversions.Get(Project.Compilation));
//return Visit(conv);
var func = new JsFunction {
Parameters = res.Parameters.Select(t => JsIdentifier(t.Name)).ToList()
};
var body = res.Body;
JsNode body2;
var info = res.GetInfo();
if (body.GetType() == typeof(ResolveResult) && body.Type.IsVoid())
{
var x = res.GetType().GetProperty("BodyExpression", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(res, null);
var astNode = (AstNode)x;
body2 = Visit(astNode);
}
else
{
body2 = Visit(res.Body);
}
var currentMember = res.GetCurrentMember();
var delType = info.ConversionTargetType;
if (body2 is JsExpression)
{
var delMethod = delType.GetDelegateInvokeMethod();
JsStatement st = new JsReturnStatement {
Expression = (JsExpression)body2
};
if (delMethod != null && delMethod.ReturnType.IsVoid())
{
st = new JsExpressionStatement {
Expression = (JsExpression)body2
}
}
;
func.Block = new JsBlock {
Statements = new List <JsStatement> {
st
}
};
}
else if (body2 is JsBlock)
{
func.Block = (JsBlock)body2;
}
if (delType == null || currentMember == null)
{
Log.Warn(res.GetFirstNode(), "Cannot resolve delegate type / parent method");
return(func);
}
else
{
return(CreateJsDelegateIfNeeded(func, currentMember, delType, true));
}
}
public object CallFunction(JsFunction function, params object[] args)
{
try
{
visitor.ExecuteFunction(function, null, JsClr.ConvertParametersBack(visitor, args));
return(JsClr.ConvertParameter(visitor.Returned));
}
catch (TargetInvocationException e)
{
string message = String.Format("{0}\n{1}: {2} in {3}"
, e.InnerException.Message, moduleName, CurrentString, CurrentLine);
throw new BitMobile.Utilities.Exceptions.JSException(message, e);
}
catch (BitMobile.Utilities.Exceptions.JsGlobalException e)
{
string message = String.Format("Error occured in script function:\n{0}\n{1}: {2} in {3}"
, e.Message, moduleName, CurrentString, CurrentLine);
throw new BitMobile.Utilities.Exceptions.JSException(message, e);
}
catch (Exception e)
{
string message = String.Format("{0}\n{1}: {2} in {3}"
, e.Message, moduleName, CurrentString, CurrentLine);
throw new BitMobile.Utilities.Exceptions.JSException(message, e);
}
}
public JavaScriptHandle(JsContext jsc, string init, ICollection <int> providers, DictionaryCache cache)
{
this.jsc = jsc;
this.cache = cache;
jsc.sync(js =>
{
js.name("limax.js").eval(limax.script.codes.js.limax);
js.name("cache").eval("var cache=<0>", cache);
js.name("initscript").eval(init);
if (providers == null || providers.Count == 0)
{
foreach (object pvid in (JsArray)js.eval("providers"))
{
this.providers.Add((int)pvid);
}
}
else
{
foreach (var pvid in providers)
{
this.providers.Add(pvid);
}
}
this.instance = (JsFunction)js.name("").eval("limax");
});
}
public override JsNode _VisitDelegate(ITypeDefinition ce)
{
var CurrentType = new JsClrType {
Kind = JsClrTypeKind.Delegate
};
CurrentType.fullname = GetJsTypeName(ce);
//Generate constructor
var genericParams = new List <ITypeParameter>(ce.GetGenericArguments());
var func = new JsFunction();
func.Parameters = genericParams.Select(t => t.Name).ToList();
func.Parameters.Add("obj");
func.Parameters.Add("func");
func.Block = Js.Block();
foreach (var ga in genericParams)
{
func.Block.Add(Js.This().Member(ga.Name).Assign(Js.Member(ga.Name)).Statement());
}
func.Block.Add(Js.Members("System.MulticastDelegate.ctor.call").Invoke(Js.This(), Js.Member("obj"), Js.Member("func")).Statement());
CurrentType.GetDefinition(false)["ctor"] = func;
return(OnAfterExportType(ce, CurrentType));
//return func;
//FullName',{ ShortName:function(T1,T2,T3,...,obj,func){this.T1=T1;....;this.construct(obj,func);}, })");
}
public object CallFunction(JsFunction function, params object[] args)
{
Visitor.ExecuteFunction(function, null,
args.Select(x => Visitor.Global.Marshaller.MarshalClrValue <object>(x)).ToArray()
//Array.ConvertAll<object,JsInstance>( args, x => Visitor.Global.Marshaller.MarshalClrValue<object>(x) )
);
return(Visitor.Global.Marshaller.MarshalJsValue <object>(Visitor.Returned));
}
public static void CreateInstanceImpl(JsClass klass)
{
var func = new JsFunction(null);
func.Body.Add(klass.Type.New().Return());
klass.ExtendPrototype(func, "CreateInstance");
}
public void AddSamples(SampleArray samples)
{
var uint8 = new Uint8Array(samples.Buffer);
JsFunction fromCharCode = JsCode("String.fromCharCode").As <JsFunction>();
var b64 = window.btoa(fromCharCode.apply(null, uint8.As <object[]>()).As <string>());
document.getElementById(_swfId).As <IFlashSynthOutput>().AlphaSynthAddSamples(b64);
}
public static void ExtendPrototype(this JsClass klass, JsFunction func, string name)
{
var type = klass.Type;
var typeName = type.IsString() ? "String" : type.JsFullName();
var fullName = typeName + ".prototype." + name;
klass.Add(new JsGeneratedMethod(fullName, func));
}
public virtual void Visit(JsFunction node)
{
DefaultVisit(node);
foreach (var parameter in node.Parameters)
{
VisitDeclaration(parameter);
}
node.Body.Accept(this);
}
object MarshalJsFunctionHelper(JsFunction func, Type delegateType)
{
// create independent visitor
ExecutionVisitor visitor = new ExecutionVisitor(m_global, new JsScope((JsObject)m_global));
visitor.PermissionSet = ((ExecutionVisitor)m_global.Visitor).PermissionSet;
JsFunctionDelegate wrapper = new JsFunctionDelegate(visitor, func, JsNull.Instance, delegateType);
return(wrapper.GetDelegate());
}
public virtual JsNode ExportConstructor(IMethod ctor)
{
var ctorName = SkJs.GetEntityJsName(ctor);
var func = new JsFunction {
Parameters = new List <string>()
};
func.Block = ExportConstructorBody(ctor);
ExportConstructorParameters(ctor, func);
return(func);
}
public JsFunction DefineFunctionMessage(MethodBase method)
{
JsFunction function = new JsFunction(method);
DefineFunctionMessage msgDef = new DefineFunctionMessage {
Name = function.Name,
Parameters = function.Parameters,
Body = function.Body
};
SendMessage(msgDef);
return function;
}
public virtual JsNode Visit(JsFunction node)
{
return(DefaultVisit(node, x =>
{
for (var i = 0; i < x.Parameters.Count; i++)
{
x.Parameters[i] = (IJsDeclaration)VisitDeclaration(x.Parameters[i]);
}
x.Body = (JsBlockStatement)x.Body.Accept(this);
return x;
}));
}
protected JsFunction ApplyYield(JsFunction func)
{
if (AstNodeConverter.SupportClrYield && func.Block.Descendants().OfType <JsYieldStatement>().FirstOrDefault() != null)
{
var yielder = new YieldRefactorer {
BeforeFunction = func
};
yielder.Process();
return(yielder.AfterFunction);
}
return(func);
}
private string PromiseRequire(JsFunction func)
{
return
(@"function(extraArgs){
return new Promise(function(resolve){
require(['{moduleNames}'], function({moduleVars}){
{moduleVars}.{functionName}({arguments}).then(function(args) { resolve(args); });
});
});
}".Replace("{moduleNames}", func.Module.Name)
.Replace("{moduleVars}", JsFunction.VarName(func.Module))
.Replace("{functionName}", func.FunctionName)
.Replace("{arguments}", func.Arguments.ToString(a => a == ClientConstructorManager.ExtraJsonParams ? "extraArgs" : JsonConvert.SerializeObject(a, func.JsonSerializerSettings), ", ")));
}
public static void OnLoad()
{
jQuery.ajax(new AjaxSettings
{
url = "Handler.ashx",
dataType = "text",
success = (js, b, cc) =>
{
var func = new JsFunction(js.As <JsString>());
var x = func.call();
var c = x.As <Contact>();
HtmlContext.alert(c.GetType().FullName + "," + c.Name);
}
});
}
public static void OnLoad()
{
jQuery.ajax(new AjaxSettings
{
url = "Handler.ashx",
dataType = "text",
success = (js, b, cc) =>
{
var func = new JsFunction(js.As<JsString>());
var x = func.call();
var c = x.As<Contact>();
HtmlContext.alert(c.GetType().FullName+","+c.Name);
}
});
}
private static JsFunction GetImpl(MethodContext context, IEnumerable <KeyValuePair <Func <IMethod, bool>, Action <MethodContext, JsBlock> > > list)
{
var method = context.Method;
foreach (var pair in list)
{
if (pair.Key(method))
{
var parameters = method.Parameters.Select(x => x.Name).ToArray();
var func = new JsFunction(null, parameters);
pair.Value(context, func.Body);
return(func);
}
}
return(null);
}
public virtual JsNode ExportMethod(IMethod me)
{
var jma = Sk.GetJsMethodAttribute(me);
if (jma != null && jma.GlobalCode)
{
var block = ExportMethodBody(me);
return(new JsUnit {
Statements = block.Statements
});
}
var func = new JsFunction();
func.Parameters = ExportMethodParameters(me);
func.Name = SkJs.GetEntityJsName(me);
func.Block = ExportMethodBody(me);
func = ApplyYield(func);
return(func);
}
public void Process()
{
AfterFunction = BeforeFunction;
SetParents(BeforeFunction.Block);
foreach (var me in BeforeFunction.Block.Descendants <JsMemberExpression>().ToList())
{
if (me.PreviousMember == null && me.NodeType == JsNodeType.MemberExpression)
{
me.PreviousMember = Js.This();
}
}
BeginNewStep();
ProcessStatement(BeforeFunction.Block);
BeforeFunction.Block.Statements.Clear();
var func = new JsFunction {
Block = new JsBlock {
Statements = new List <JsStatement>()
}
};
var i = 0;
func.Block.Statements.Add(Js.Var("result").Statement());
var stSwitch = Js.Switch(_state());
var lastStep = Js.Block().Add(_state().Assign(Js.Value(Steps.Count)).Statement()).Add(new JsBreakStatement());
Steps.Add(new YieldStep {
Statements = { lastStep }
});
foreach (var step in Steps)
{
stSwitch.Case(Js.Value(i), step.Statements);
i++;
}
func.Block.Statements.Add(stSwitch);
func.Block.Statements.Add(Js.Member("result").Assign(Js.Value(false)).Statement());
func.Block.Statements.Add(Js.Return(Js.Member("result")));
BeforeFunction.Block.Statements.Add(Js.Return(Js.New(Js.Member("CustomEnumerable"), func)));
return;
}
public JavaScriptHandle(JsContext jsc, string init, ICollection <int> providers, DictionaryCache cache, TunnelReceivier ontunnel)
{
this.jsc = jsc;
this.cache = cache != null ? cache : new SimpleDictionaryCache();
TunnelReceivier _ontunnel = (providerid, label, data) =>
{
if (providerid == AuanyService.providerId)
{
if (lmkDataReceiver != null)
{
lmkDataReceiver.onLmkData(data, () => tunnel(AuanyService.providerId, -1, ""));
}
}
else if (ontunnel != null)
{
ontunnel(providerid, label, data);
}
};
jsc.sync(js =>
{
js.name("limax.js").eval(limax.script.codes.js.limax);
js.name("cache").eval("var cache=<0>", this.cache);
js.name("ontunnel").eval("var ontunnel=<0>", _ontunnel);
js.name("initscript").eval(init);
if (providers == null || providers.Count == 0)
{
foreach (object pvid in (JsArray)js.eval("providers"))
{
this.providers.Add((int)pvid);
}
}
else
{
foreach (var pvid in providers)
{
this.providers.Add(pvid);
}
}
this.instance = (JsFunction)js.name("").eval("limax");
});
}
void VerifyConstructors()
{
if (_Constructors == null)
{
VerifyMethods();
_Constructors = new JsExtendedArray();
for (int i = 0; i < _JsType.ctors.As <JsArray>().length; i++)
{
JsObject ctorMeta = _JsType.ctors[i.As <string>()].As <JsObject>();
string ctorName = ctorMeta["name"].As <string>();
JsArray <string> ctorParams = ctorMeta["parameters"].As <JsArray <string> >();
JsFunction ctorFunc = ctorMeta["_type"].As <JsObject>()[ctorName].As <JsFunction>();
var method = new JsImplConstructorInfo(ctorName, ctorFunc, ctorParams);
method._DeclaringType = this;
//method.JsName = funcName;
//method.JsFunction = func;
_Constructors.push(method);
}
}
}
JsNode CreateJsDelegateIfNeeded(JsFunction func, IMember currentMember, IType delType, bool isAnonymous)
{
if (currentMember != null && !currentMember.IsStatic && !UseNativeFunctions(delType) && !Sk.ForceDelegatesAsNativeFunctions(currentMember))
{
var instanceContext = new JsThis();
JsExpression wrapper;
if (isAnonymous)
{
wrapper = CreateAnonymousJsDelegate(instanceContext, func);
}
else
{
wrapper = CreateJsDelegate(instanceContext, func);
}
return(wrapper);
}
else
{
return(func);
}
}
public override void VisitFunction(JsFunction node)
{
output.Append("function");
if (node.Name != null)
{
output.Append(" ");
output.Append(node.Name);
}
output.Append("(");
for (var i = 0; i < node.Parameters.Count; i++)
{
var argument = node.Parameters[i];
output.Append(argument.Name);
if (i < node.Parameters.Count - 1)
{
output.Append(", ");
}
}
output.Append(") ");
node.Body.Accept(this);
}
public object CallFunction(JsFunction function, params object[] args)
{
visitor.ExecuteFunction(function, null, Array.ConvertAll <object, JsInstance>(args, (x) => {
TypeCode t = Type.GetTypeCode(x.GetType());
switch (t)
{
case TypeCode.Boolean:
return(visitor.Global.BooleanClass.New((bool)x));
case TypeCode.Char:
case TypeCode.String:
case TypeCode.Object:
return(visitor.Global.StringClass.New(x.ToString()));
case TypeCode.DateTime:
return(visitor.Global.DateClass.New((DateTime)x));
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.SByte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Single:
return(visitor.Global.NumberClass.New(
Convert.ToDouble(x)));
case TypeCode.DBNull:
case TypeCode.Empty:
return(JsNull.Instance);
}
throw new NotSupportedException();
}));
return(visitor.Returned);
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
try
{
var js = new FileInfo(@"test.js");
using (var runtime = JsRuntime.Create())
{
runtime.AllocatingMemory += this.Runtime_MemoryEvent;
runtime.CollectingGarbage += this.Runtime_CollectingGarbage;
using (runtime.CreateContext().Use(true))
{
try
{
var obj = JsExternalObject.Create(this);
obj.ExternalData = 12;
obj.ExternalData = 100;
JsContext.StartDebugging();
var func = JsFunction.Create(saf);
var console = Opportunity.ChakraBridge.WinRT.Browser.Console.GetOrCreate();
console.Logging += Con_Logging;
var c2 = Opportunity.ChakraBridge.WinRT.Browser.Console.GetOrCreate();
JsValue.GlobalObject["func"] = func;
JsContext.RunScript("console.log(1,'2',{});func(1,'2',{});new func();", js.Name);
}
catch (Exception)
{
var error = JsContext.LastError;
}
}
}
}
catch (Exception)
{
}
}
public static JsFunction GetDelegate(object obj, JsFunction func)
{
var target = obj.As <JsCompilerObject>();
if (target == null)
{
return(func);
}
if (JsContext.@typeof(func) == "string")
{
func = target.As <JsObject>()[func.As <JsString>()].As <JsFunction>();
}
var cache = target.__delegateCache;
if (cache == null)
{
cache = new JsObject <JsDelegateFunction>();
target.__delegateCache = cache;
}
var key = JsCompiler.GetHashKey(func);
var del = cache[key];
if (del == null)
{
del = new JsNativeFunc <object>(delegate()
{
var del2 = JsContext.arguments.callee.As <JsDelegateFunction>();
return(del2.func.apply(del.target, JsContext.arguments.As <object[]>()));
}).As <JsDelegateFunction>();
del.func = func;
del.target = target;
del.isDelegate = true;
cache[key] = del;
}
return(del);
}
public object CallFunction(JsFunction function, params object[] args)
{
visitor.ExecuteFunction(function, null, Array.ConvertAll<object,JsInstance>( args, x => visitor.Global.Marshaller.MarshalClrValue<object>(x) ));
return visitor.Global.Marshaller.MarshalJsValue<object>(visitor.Returned);
}
public JintEngine SetFunction(string name, JsFunction function)
{
visitor.GlobalScope[name] = function;
return this;
}
///// <summary>
///// Could be used inside event handler to figure out actual name of the eve
///// </summary>
///// <param name="subname">subname of the event</param>
///// <returns>name of the event, if subname is not specified</returns>
//public JsString nt(JsString subname) { return null; }
/// <summary>
/// Removes given function from the list of event listeners assigned to given name.
/// </summary>
/// <param name="name">name of the event, dot (.) or slash (/) separated, with optional wildcard</param>
/// <param name="f">event handler function</param>
public void off(JsString name, JsFunction f) { }
/// <summary>
/// set draw function
/// </summary>
/// <param name="drawFunc">drawing function</param>
public void setDrawFunc(JsFunction drawFunc) { }
public object CallFunction(JsFunction function, params object[] args)
{
visitor.ExecuteFunction(function, null, Array.ConvertAll<object,JsInstance>(args, (x) => {
TypeCode t = Type.GetTypeCode(x.GetType());
switch (t) {
case TypeCode.Boolean:
return visitor.Global.BooleanClass.New((bool)x);
case TypeCode.Char:
case TypeCode.String:
case TypeCode.Object:
return visitor.Global.StringClass.New(x.ToString());
case TypeCode.DateTime:
return visitor.Global.DateClass.New((DateTime)x);
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.SByte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Single:
return visitor.Global.NumberClass.New(
Convert.ToDouble(x));
case TypeCode.DBNull:
case TypeCode.Empty:
return JsNull.Instance;
}
throw new NotSupportedException();
}));
return visitor.Returned;
}
internal static object NewByFunc(JsFunction ctor)
{
return null;
}
public extern JsString replace(JsRegExp regexp, JsFunction replaceWith);
/// <summary>
/// Returns the current position within an audio file.
/// </summary>
/// <param name="mediaSuccess">The callback that is called with the current position in seconds.</param>
/// <example>
/// usage
/// <code>
/// // Audio player
/// //
///var my_media = new Media(src, onSuccess, onError);
/// // Update media position every second
///var mediaTimer = setInterval(function() {
/// // get media position
/// my_media.getCurrentPosition(
/// // success callback
/// function(position) {
/// if (position > -1) {
/// console.log((position) + " sec");
/// }
/// },
/// // error callback
/// function(e) {
/// console.log("Error getting pos=" + e);
/// }
/// );
///}, 1000);
/// </code>
/// </example>
public void getCurrentPosition(JsFunction mediaSuccess) { }
internal static object NewByFuncArgs(JsFunction ctor, JsArray args)
{
return(null);
}
public static JsFunction FunctionInline(JsList parameters, JsMultiLine commands)
{
JsFunction f = new JsFunction(parameters, commands);
f.MultiLine = false;
return f;
}
/// <summary>
/// Matches when the observable sequence has an available value and projects the value.
/// </summary>
public Plan Then(JsFunction selector) { return default(Plan); }
public virtual AbstractBehavior createExternalBehavior( HtmlElement element, JsString behaviorClassName, JsFunction constructorFunction )
{
return null;
}
/// <summary>
/// Binds given event handler with a given name to only run once then unbind itself.
/// eve.once("login", f);
/// eve("login"); // triggers f
/// eve("login"); // no listeners
/// Use eve to trigger the listener.
/// </summary>
/// <param name="name">name of the event, dot (.) or slash (/) separated, with optional wildcards</param>
/// <param name="f">event handler function</param>
/// <returns>same return function as eve.on</returns>
public JsFunction once(JsString name, JsFunction f) { return null; }
public JsFunction CreateFunction(JsFormat format, JsMultiLine commands)
{
JsFunction f = new JsFunction(this, commands);
f.SetFormat(format);
return f;
}
[JsMethod(Code="if(prms==null || prms.length==0) return new jsCtor(); return new jsCtor(prms[0], prms[1], prms[2], prms[3], prms[4], prms[5], prms[6], prms[7], prms[8]);")]//TODO: switch by prm number
internal static object ApplyNew(JsFunction jsCtor, JsArray prms)
{
throw new NotImplementedException();
}
internal static JsDelegateFunction CreateClrDelegate(JsType type, JsArray<JsType> genericArgs, object target, JsFunction func)
{
return JsTypeHelper.GetDelegate(target, func).As<JsDelegateFunction>(); //TODO: support delegate.getType()
}
/// <summary>
/// set after frame event handler
/// </summary>
/// <param name="index">frame index</param>
/// <param name="func">function to be executed after frame has been drawn</param>
public void afterFrame(JsArray index, JsFunction func) { }
/// <summary>
/// Returns the current position within an audio file.
/// </summary>
/// <param name="mediaSuccess">The callback that is called with the current position in seconds.</param>
/// <param name="mediaError">The callback that is called if there was an error.</param>
/// <example>
/// usage
/// <code>
/// // Audio player
/// //
///var my_media = new Media(src, onSuccess, onError);
/// // Update media position every second
///var mediaTimer = setInterval(function() {
/// // get media position
/// my_media.getCurrentPosition(
/// // success callback
/// function(position) {
/// if (position > -1) {
/// console.log((position) + " sec");
/// }
/// },
/// // error callback
/// function(e) {
/// console.log("Error getting pos=" + e);
/// }
/// );
///}, 1000);
/// </code>
/// </example>
public void getCurrentPosition(JsFunction mediaSuccess, MediaError mediaError) { }
/// <summary>
/// sets onFrameFunc for animation
/// </summary>
/// <param name="func"></param>
public void onFrame(JsFunction func) { }
internal static object NewByFuncArgs(JsFunction ctor, JsArray args)
{
return null;
}
/// <summary>
/// bind events to the node. KineticJS supports mouseover, mousemove,mouseout, mousedown, mouseup, click, dblclick, touchstart, touchmove,touchend, tap, dbltap, dragstart, dragmove, and dragend. Pass in a stringof event types delimmited by a space to bind multiple events at oncesuch as 'mousedown mouseup mousemove'.
/// include a namespace to bind anevent by name such as 'click.foobar'.
/// </summary>
/// <param name="typesStr"></param>
/// <param name="handler"></param>
public void on(JsString typesStr, JsFunction handler) { }
private void AssertJsFunction(JsFunction function, string name, string parameters, string body)
{
Assert.AreEqual(name, function.Name);
Assert.AreEqual(parameters, function.Parameters);
Assert.AreEqual(body, function.Body);
}
/// <summary>
/// Executes given function for each element in the set.
/// If function returns false it will stop loop running.
/// </summary>
/// <param name="callback">function to run</param>
/// <param name="thisArg">context object for the callback</param>
/// <returns>Set object</returns>
public object forEach(JsFunction callback, object thisArg) { return null; }
internal static object NewByFunc(JsFunction ctor)
{
return(null);
}
private void RunTest(MethodBase method, string name, string parameters, string body)
{
var function = new JsFunction(method);
AssertJsFunction(function, name, parameters, body);
}
public static JsFunction GetDelegate(object obj, JsFunction func)
{
var target = obj.As<JsCompilerObject>();
if (target == null)
return func;
if (JsContext.@typeof(func) == "string")
func = target.As<JsObject>()[func.As<JsString>()].As<JsFunction>();
var cache = target.__delegateCache;
if (cache == null)
{
cache = new JsObject<JsDelegateFunction>();
target.__delegateCache = cache;
}
var key = JsCompiler.GetHashKey(func);
var del = cache[key];
if (del == null)
{
del = new JsNativeFunc<object>(delegate()
{
var del2 = JsContext.arguments.callee.As<JsDelegateFunction>();
return del2.func.apply(del.target, JsContext.arguments.As<object[]>());
}).As<JsDelegateFunction>();
del.func = func;
del.target = target;
del.isDelegate = true;
cache[key] = del;
}
return del;
}
public static void tap(this jQueryFn jqfn, JsFunction fn)
{
throw new NotImplementedException();
}
public static void enable(string eventName, object target, JsFunction isEnabled) { }
public extern JsString replace(JsString substring, JsFunction replaceWith);
