<bridgehead renderas="sect2">ClazzLoader.jarClasspath</bridgehead>

<simpara>Makes the J2s compiler to ignore (not load) an array of classes. accepts an array of classnames to ignore. Used when we put set some classes as "Abandoned" in the project Java2Script properties page.</simpara>

ClazzLoader.jarClasspath (base + "util/Collections.js", [

"java.util.Collections",

"java.util.Collections.CheckedCollection",

"java.util.Collections.CheckedList",

"java.util.Collections.CheckedListIterator",

"java.util.Collections.CheckedMap",

......

]);

<para>This document is currently a <emphasis>WORK in PROGRESS</emphasis>. paragraphs and section contains the work <emphasis>TODO</emphasis> mean that the section is to be written or lacks revision.</para>

Java2Script also implements JavaScript's Hotspot technology. It is not complicate, because JavaScript is

<para><indexterm>

<primary>J2SIHS</primary>

</indexterm>

<indexterm>

<primary>Java2Script Inner Hotspot Server</primary>

</indexterm>

To trigger Java2Script class simulator to Hotspot swapping, there is a thread at the plugin side, trying to load an

<para>By using Hotspot, I think it is much more convenient for me to develop JavaScript RIA in Java codes than

before, especially in developing SWT applications. </para>

<para>TODO: talk about j2slib and how swt, junit etc are inside. TODO: talk about .j2x files and package.js files that le definehow alibrary must be loaded.

Also, try and if works to dev a library, put it in other folder that j2slib, with a pacakge.js and lib.j2z file, and show how oackage.js is evaluated, and how to use it for loading one, concatenating several files, etcx</para>

<para>TODO: p/d: future extension packer can be mention here for intelligent generattion of big .js file .</para>

<indexterm> <primary>native exceptions</primary></indexterm>

<indexterm> <primary>Exception</primary></indexterm>

<indexterm> <primary>Throwable</primary></indexterm>

<para>Exceptions are well supported by Java2Script and so exception related statements have a very simple translation. There is only

one special thing we have take care about when programming Java2Script code and is that in Java2Script, besides Java exceptions,

there are also JavaScript native exceptions. For example, as we have seen, using @j2sNative compiler directive we can introduce

native javascript code. And native javascript code

can throw native javascript exceptions, that may have not be related at all with java exceptions (java.lang.Exception class). For example,

the following example will show native javascript code that throws a native DOM exception. </para>

<programlisting>

/**

* native DOM exception siumulation

* @j2sNative

* document.body.appendChild(null);

*/{}

</programlisting>

<para>It is important to understand that these native exceptions, are not java.lang.Exception instances and so,

they cannot be catched with <code>catch(Exception e)</code> expression. So, how we catch native exceptions and how can we diferentiate

them from common java exceptions? The answer is that native exceptions are instance of class java.lang.Throwable (a superclass of

java.lang.Exception) and so, we can catch them using Throwable, as the following example shows: </para>

<programlisting>

try {

/**

* native DOM exception siumulation

* @j2sNative

* document.body.appendChild(null);

*/{}

} catch (Exception e) {

//catching java exceptions

System.out.println("this is NOT printed!!!");

}

catch(Throwable e) {

//catching native exceptions!

System.out.println("this is printed!!!");

}

</programlisting>

<para>The only special case of native exceptions are the null pointer exceptions.

Since both in java and javascript null is the same

object, and in java we spect NullPointerException to be throwed when accessing the null object,

native javascript null pointer exceptions will be objects of the class java.lag.NullPointerException. Let understand this

with a litlle example. In the following listing, we emulate a native null pointer exception and show that is catched with a NullPointerException and not as another native exception with Throwable: </para>

<programlisting>

try {

/**

* This simulates a native null pointer exception

* @j2sNative

* var a = null;

* a.sdf();

*/{}

} catch (NullPointerException e) {

System.out.println("printed!");

}

catch (Throwable e) {

System.out.println("NOT printed!");

}

</programlisting>

<section><title>Concatenating several .js files into one big .js file </title>

<para>TODO: explain the problen of j2s clazzloader that loads several small files. it is fast to load one big file.</para>

<para>TODO: explain how to concatenate (if a extends b, etc).</para>

<para></para>

</section>

<para>Nevertheless, there are some areas that need to be understand if you want to write

native javascript code and need to integrate that native code with your java code.

</para>

<section><title>JavaScript functions</title>

<para>TODO: this sections contains the escense but has a bad english. it should be rewritten more elegantly.</para>

<para>The first problem that we face when working with native javascript is that , in javascript, we work with

functions and the java language doesn't support such a concept or nothing similar. In java, the only beahaviour language concepts we have are

instance methods and static methods. Mixing native javascript functions and java code without realizing what we really are doing,

can cause very nasty bugs and problems, and so in this section we will examine possible problems and advices about how to do it right.

</para>

<para>function context:</para>

<para>what is a function context? In javascript, any function can be evaluated using any object as its context. The context of a

function when evaluated is the object referenced by the "this" keyword.</para>

<important><para>Javascript function can be called with an arbitrary context object while Java instance

methods must always have a fixed context. </para></important>

<para>since in java we always have to use an object, the function in java have a fixed context (the this object).

But in javascript this is not true and we must ensure the context. for example, the following example for registering a

mouse click listener in document.body will work, but it is incorrect! :</para>

<programlisting>

Runnable r = new Runnable(){

public void run() {

System.out.println("clicked");

}

};

/**

* @j2sNative

* document.body.onclick=r.run; //WRONG!

*/{}

</programlisting>

<para>Why this is wrong? When an html document is clicked, and a function is registered for listen to clicks with "element.onclick",

the function will be evaluated using the clicked html element as the function context. This means that any reference to "this" in the function body, will

point to the target html element and not where it should be, to the Runnable instance. Let examine an example that fails because of this:</para>

<programlisting></programlisting>

<para>With java static methods there is no problem because they do no context (no this pointer). But it is not useful to work with

static methods for </para>

</section>