README.html

<h1>Jint.Ex - Alpha</h1>

<h2>Overview</h2>

<p>The Jint.Ex framework extends <strong><em><a href="https://github.com/sebastienros/jint">Jint</a></em></strong> with features that are not part of the ECMAScript standard, but use full when mixing C# and JavaScript in the same application. </p>

<p>Jint.Ex intend to be as portable as Jint and therefore should work on Windows, MacOS, iOS, Android and Linux. My current focus is Windows WinForm and iOS UIKit with the Xamarin tools.</p>

<ul>
<li><p><strong><em>Event-driven interaction</em></strong>: Jint.Ex.AsyncronousEngine is an event-driven interaction run time for Jint to build non blocking UI and creating asynchronous API with a focus on Windows and iOS.</p></li>
<li><p><strong><em>setTimeOut() and setInterval()</em></strong>: The methods setTimeOut() and setInterval() are part of Browser DOM standard and not part on Jint. 
Jint.Ex.AsyncronousEngine offer the methods as well as the clearTimeOut() and clearInterval() methods.</p></li>
<li><p><strong><em>localeStorage</em></strong>: A singleton object compatible with the HTML5 storage standard. Not available yet.</p></li>
</ul>

<h2>Features</h2>

<h3>setTimeout and clearTimeOut</h3>

<p>The methods setTimeout() and clearTimeOut() are not part of the JavaScript language,
but part of the DOM. Nevertheless they can be usefull and sometime necessary
to run some JavaScript libraries written for the browser.
These methods are also present in NodeJs.</p>

<h4>Javascript</h4>

<p>```javascript
function f3() {
    print('Hi 3');
}
var timeout3 = setTimeout(f3, 3000);</p>

<p>function f1() {
    print('Hi 1');
}
var timeout1 = setTimeout(f1, 1000);</p>

<p>clearTimeout(timeout3);
print('timeout3 cleared');
```</p>

<h4>CSharp</h4>

<p>```csharp
static void SetIntervalDemo()
{
    Console.WriteLine("Jint setInterval() demo");</p>

<pre><code>AsyncronousEngine.EmbedScriptAssembly = Assembly.GetExecutingAssembly();
AsyncronousEngine.RequestExecution("setIntervalSetTimeout.js");   
AsyncronousEngine.Wait(); // Wait util all events are processed
AsyncronousEngine.Stop(); // Stop the event loop

Console.ReadKey();
</code></pre>

<p>}
```</p>

<h3>setInterval and clearInterval</h3>

<h4>Javascript</h4>

<p>```javascript
function f1() {
    print('Hi 1 '+(new Date()));
}
var timeout1 = setInterval(f1, 1000);</p>

<p>function f2() {
    print('Hi 2 '+(new Date()));
}
var timeout2 = setInterval(f2, 3000);
```</p>

<h3>Implementing Custom Asynchronous Api</h3>

<p>Jint allows to expose C# methods, class and singleton object to the JavaScript world. With Jint.Ex
you can implement true asynchronous method, like the method read() of the singleton object storage in sample below.</p>

<p><code>javascript
var s = null;
storage.read(function(data) {
    s = data;
});
</code></p>

<p>The method read() starts a background thread and returns right away. The thread will execute the read
operation and then request the execution of the call back function using the Jint.Ex event loop.
when the Jint.Ex event loop will reach the event it will execute the call back function.</p>

<p>For more information see blog: xxxxxxxxxxxxxxxxx.</p>

<h3>Jint.Ex Api</h3>

<h4>The AsyncronousEngine class.</h4>

<p>The class AsyncronousEngine allows to run JavaScript script in a background thread
and supports interaction with UI and the execution of the asynchronous events.</p>

<p>```csharp</p>

<p>public static AsyncronousEngine {</p>

<pre><code>/// &lt;summary&gt;
/// The instance of Jint
/// &lt;/summary&gt;
public Jint.Engine Engine = null;

/// &lt;summary&gt;
/// Reference the assembly that embed the JavaScript scripts.
/// &lt;/summary&gt;
public Assembly EmbedScriptAssembly = null;

/// &lt;summary&gt;
/// Load a file from the file system or as an embed resource
/// &lt;/summary&gt;
/// &lt;param name="name"&gt;&lt;/param&gt;
/// &lt;param name="source"&gt;&lt;/param&gt;
public void LoadScript(string name, StringBuilder source);

/// &lt;summary&gt;
/// Start the event loop
/// &lt;/summary&gt;
/// &lt;returns&gt;&lt;/returns&gt;
public bool Start();

/// &lt;summary&gt;
/// Request the execution of one javaScript script file by the event loop. 
/// The method returns right away. 
/// Start the AsyncronousEngine if needed.
/// &lt;/summary&gt;
/// &lt;param name="fileName"&gt;The filename or resource name to load and execute&lt;/param&gt;
/// &lt;param name="block"&gt;If true after the execution, block until the event queue is empty&lt;/param&gt;
public bool RequestFileExecution(string fileName, bool block = false);

/// &lt;summary&gt;
/// Request the execution of one javaScript source by the event loop. 
/// The method returns right away. 
/// Start the AsyncronousEngine if needed.
/// &lt;/summary&gt;
/// &lt;param name="fileName"&gt;The filename or resource name to load and execute&lt;/param&gt;
/// &lt;param name="block"&gt;If true after the execution, block until the event queue is empty&lt;/param&gt;
public bool RequestScriptExecution(string source, bool block = false);

/// &lt;summary&gt;
/// Kill the event loop
/// &lt;/summary&gt;
public void Kill();

/// &lt;summary&gt;
/// Stop the event loop
/// &lt;/summary&gt;
public void Stop();

/// &lt;summary&gt;
/// Wait until the event queue is empty
/// &lt;/summary&gt;
public void Wait();

/// &lt;summary&gt;
/// Clear the event queue
/// &lt;/summary&gt;
public void RequestClearQueue();

/// &lt;summary&gt;
/// Request the execution of a JavaScript callback function. This method should be called by 
/// C# custom object that want to implement asynchronous api.
/// &lt;/summary&gt;
/// &lt;param name="callBackFunction"&gt;&lt;/param&gt;
/// &lt;param name="parameters"&gt;&lt;/param&gt;
public void RequestCallbackExecution(Func&lt;Jint.Native.JsValue, Jint.Native.JsValue[], Jint.Native.JsValue&gt; callBackFunction, List&lt;JsValue&gt;  parameters);
</code></pre>

<p>}</p>

<p>```</p>