iveConnect enables communication between JavaScript and Java applets in a
page and between JavaScript and plug-ins loaded on a page.
-
-
Use JavaScript to access Java variables, methods, classes, and packages directly.
-
Control Java applets or plug-ins with JavaScript.
-
Use Java code to access JavaScript methods and properties.
For the Netscape packages reference, see
Chapter 12, "The Netscape packages."
This chapter explains how to use LiveConnect in Netscape
Navigator. It assumes you are familiar with Java programming.
For the HTML syntax required to
add applets and plug-ins to your web page, see
"Applet" and
"Plugin".
LiveConnect is enabled by default in Navigator 3.0. For
LiveConnect to work, both Java and JavaScript must be enabled. To confirm
they are enabled, choose Network Preferences from the Options menu, then
choose the Languages tab.
-
-
Make sure Enable Java is checked.
-
Make sure Enable JavaScript is checked.
To disable either Java or JavaScript, uncheck the checkboxes;
if you do this, LiveConnect will not work.
The Java Console is a Navigator window that displays Java
messages. When you use the class variables out or err in
java.lang.System to output a message, the message appears in the Console.
To display the Java Console, choose Show Java Console from the Options
menu.
You can use the Java Console to present messages to users,
or to trace the values of variables at different places in a program's
execution.
For example, the following Java
code displays the message "Hello, world!" in the Java Console:
public void init() {
System.out.println("Hello, world!")
}
You can use the Java Console to present messages to users,
or to trace the values of variables at different places in a program's execution.
To display the Java Console, the user chooses Show Java Console from the
Options menu. Note that most users probably do not display the Java
Console.
Navigator 3.0 contains a java_30 file that
includes the following Java packages:
-
-
netscape packages to enable JavaScript and Java communication.
-
java and sun packages to provide security enhancements for
LiveConnect.
The new java and sun packages replace packages
in the Sun 1.0.2 Java Development Kit (JDK) classes.zip. These
packages have been tested by Sun, and similar security enhancements will
be implemented in future releases of the Sun JDK. Use these packages until
the Sun JDK provides these security enhancements.
The file java_30 contains the following
netscape packages:
-
-
netscape.javascript implements the JSObject class to allow
your Java applet to access JavaScript methods and properties. It also implements
JSException to throw an exception when JavaScript code returns an
error.
-
netscape.plugin implements the Plugin class to enable JavaScript
and Java plug-in communication. Compile your Java plug-in with this class
to allow applets and JavaScript code to manipulate the plug-in.
These packages are documented in
Chapter 12, "The Netscape
packages."
In addition, java_30 contains some other
netscape packages:
-
-
netscape.applet is a replacement for the Sun JDK package
sun.applet.
-
netscape.net is a replacement for the Sun JDK package sun.net.
These packages are not documented because they are implemented
in the same way as the original Sun packages.
To access the packages in java_30, place
the file in the classpath of the JDK compiler in either of the following
ways:
-
-
Create a
CLASSPATH environment variable to specify the paths
and names of java_30 and classes.zip.
-
Specify the location of
java_30 when you compile by using the
-classpath command line parameter.
For example, on Windows, the java_30 file
is delivered in the Program\Java\classes directory beneath the
Navigator directory. You can specify an environment variable in Windows NT
by double-clicking the System icon in the Control Panel and creating a user
environment variable called CLASSPATH with a value similar to the
following:
D:\JDK\java\lib\classes.zip;D:\Navigator\Program\java\classes\java_30
See the Sun JDK documentation for more information about
CLASSPATH.
LiveConnect provides three ways for JavaScript to communicate
with Java:
-
-
Call Java methods directly.
-
Control Java applets.
-
Control Java plug-ins.
When LiveConnect is enabled, JavaScript can make direct
calls to Java methods. For example, you can call
System.out.println to display a message on the Java Console.
In JavaScript, Java packages and classes are properties
of the Packages object. Use Java syntax to reference Java objects
in JavaScript, with the name of the Packages object optionally
prepended:
[Packages.]packageName.className.methodName
The name Packages is optional for
java, sun, and netscape packages; in code,
java, sun, and netscape are aliases
for Packages.java, Packages.sun, and
Packages.netscape. For example, you can refer to the Java class
java.lang.System as either Packages.java.lang.System
or as java.lang.System in your code. The name
Packages is required for other packages.
Access fields and methods in a class with the same syntax
that you use in Java. For example, the following JavaScript code prints a
message to the Java Console:
var System = java.lang.System
System.err.println("Greetings from JavaScript")
The first line in this example makes the JavaScript variable
System refer to the class java.lang.System. The second line
invokes the println method of the static variable err in the
Java System class. Because println expects a
java.lang.String argument, the JavaScript string is automatically
converted to a java.lang.String.
You can even use Java class constructors in JavaScript.
For example, the following JavaScript code creates a Java Date object
and prints it to the Java Console.
var mydate = new java.util.Date()
System.out.println(myDate)
You can use JavaScript to control the behavior of a Java
applet without knowing much about the internal construction of the applet.
All public variables, methods, and properties of an applet are available
for JavaScript access. For example, you can use buttons on an HTML form to
start and stop a Java applet that appears elsewhere in the document.
Each applet in a document is reflected in JavaScript by
document.appletName, where appletName is the value of
the NAME attribute of the <APPLET> tag. The applets array also
contains all the applets in a page; you can reference elements of the array
through the applet name (as in an associative array) or by the ordinal number
of the applet on the page (starting from zero).
For example, consider the basic "Hello World" applet in
Java:
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
The following HTML runs and displays the applet, and names
it "HelloWorld" (with the NAME attribute):
<APPLET CODE="HelloWorld.class" NAME="HelloWorld" WIDTH=150 HEIGHT=25>
</APPLET>
You can reference this applet in JavaScript in either
of the following ways:
document.HelloWorld
document.applets["HelloWorld"]
If this is the first applet in the document (topmost on
the page), you could also reference it as:
document.applets[0]
The applets array has a length property,
document.applets.length, that indicates the number of applets
in the document.
All public variables declared in an applet, and its ancestor
classes and packages are available in JavaScript. Static methods and properties
declared in an applet are available to JavaScript as methods and properties
of the Applet object. You can get and set property values, and you
can call methods that return string, numeric, and boolean values.
So for example, modify the HelloWorld applet shown above,
and make the following changes:
-
-
Override its init method so that it declares and initializes a string
called myString.
-
Define a setString method that accepts a string argument, assigns
it to myString, and calls the repaint method. (The paint
and repaint methods are inherited from
java.awt.Component).
The Java source code then looks as follows:
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
String myString;
public void init() {
myString = new String("Hello, world!");
}
public void paint(Graphics g) {
g.drawString(myString, 25, 20);
}
public void setString(String aString) {
myString = aString;
repaint();
}
}
Making the message string a variable allows you to modify
it from JavaScript. Now modify the HTML file as follows:
-
-
Add a form with a button and a text field.
-
Make the onClick event handler for the button call the setString method
of HelloWorld with the string from the text field as its argument.
The HTML file now looks like this:
<APPLET CODE="HelloWorld1.class" NAME="Hello" WIDTH=150 HEIGHT=25>
</APPLET>
<FORM NAME="form1">
<INPUT TYPE="button" VALUE="Set String"
onClick="document.HelloWorld.setString(document.form1.str.value)">
<BR>
<INPUT TYPE="text" SIZE="20" NAME="str">
</FORM>
When you compile the HelloWorld applet, and load the HTML
page into Navigator, you initially see "Hello, World!" displayed in the gray
applet panel. However, you can now change it by entering text in the text
field and clicking on the button. This demonstrates controlling an applet
from JavaScript.
As another slightly more complex example, consider an
applet that displays text that flashes in different colors. Two buttons start
and stop this applet, and another pushbutton changes the flashing text that
it displays.
The HTML source for this example
is as follows:
<APPLET CODE="colors.class" WIDTH=500 HEIGHT=60 NAME="colorApp">
</APPLET>
<FORM NAME=colorText>
<P>Enter new text for the flashing display:
<INPUT TYPE="text"
NAME="textBox"
LENGTH=50>
<P>Click the button to change the display:
<INPUT TYPE="button"
VALUE="Change Text"
onClick="document.colorApp.setString(document.colorText.textBox.value)">
</FORM>
This applet uses the public method setString to
specify the text for the flashing string that appears. In the HTML form,
the onClick event handler of the button lets a user change the "Hello, world!"
string that the applet initially displays by calling the setString
method as follows:
<INPUT TYPE="button"
VALUE="Change Text"
onClick="document.colorApp.setString(document.colorText.textBox.value)">
In this code, colorText is the name of the HTML
form and textBox is the name of the text field. The event handler
passes the value that a user enters in the text field to the setString
method in the Java applet.
Each plug-in in a document is reflected in JavaScript
as an element in the embeds array. For example, the following HTML
code includes an AVI plug-in in a document:
<EMBED SRC=myavi.avi NAME="myEmbed" WIDTH=320 HEIGHT=200>
If this HTML defines the first plug-in in a document,
you can access it in any of the following ways:
document.embeds[0]
document.embeds["myEmbed"]
document.myEmbed
If the plug-in is associated with the Java class
netscape.plugin.Plugin, you can access its static variables and methods
the way you access an applet's variables and methods.
The embeds array has a length property,
document.embeds.length, that indicates the number of plug-ins
embedded in the document. See "Determining
installed plug-ins" for more information about plug-ins.
The
Plug-in
Developer's Guide contains information on:
-
-
Calling Java methods from plug-ins
-
Calling a plug-in's native methods from Java
Values passed from JavaScript to Java are converted as
follows:
-
-
Strings, numbers and booleans are converted to Java String,
Float, and Boolean objects respectively.
-
Objects that are wrappers around Java objects are unwrapped.
-
Other objects are wrapped with a JSObject.
This means that all JavaScript values appear in Java as
objects of class java.lang.Object. To use them, you generally will
have to cast them to the appropriate subclass of Object, for
example:
(String) window.getMember("name");
(JSObject) window.getMember("document");.
To access JavaScript methods, properties, and data structures
from your Java applet, import the Netscape javascript package:
import netscape.javascript.*
The package netscape.javascript defines the
JSObject class and the JSException exception object.
The author of an HTML page must permit an applet to access
JavaScript by specifying the MAYSCRIPT attribute of the <APPLET> tag.
This prevents an applet from accessing JavaScript on a page without the knowledge
of the page author. Attempting to access JavaScript from an applet that does
not have the MAYSCRIPT attribute generates an exception. The MAYSCRIPT tag
is needed only for Java to access JavaScript; it is not needed for JavaScript
to access Java.
Before you can access JavaScript, you must get a handle
for the Navigator window. Use the getWindow method in the class
netscape.javascript.JSObject to get a window handle, passing it the
Applet object.
For example, if win is a previously-declared variable
of type JSObject, the following Java code assigns a window handle
to win:
public class myApplet extends Applet {
public void init() {
JSObject win = JSObject.getWindow(this);
}
}
The getMember method in the class
netscape.javascript.JSObject lets you access JavaScript objects and
properties. Call getWindow to get a handle for the JavaScript window,
then call getMember to access each JavaScript object in a containership
path in turn.
For example, the following Java code allows you to access
the JavaScript object document.testForm through the variable
myForm:
public void init() {
win = JSObject.getWindow(this);
myForm=win.eval("document.testForm")
}
Note that you could use the following lines in place of
myForm=win.eval("document.testForm"):
JSObject doc = (JSObject) win.getMember("document");
JSObject myForm = (JSObject) doc.getMember("testForm");
Notice that JavaScript objects appear as instances of
the class netscape.javascript.JSObject in Java. Values passed between
Java and JavaScript are converted as described in
"netscape.javascript.JSObject".
If the JavaScript object document.testForm.jazz
is a checkbox, the following Java code allows you to access its
checked property:
public void init() {
win = JSObject.getWindow(this);
JSObject doc = (JSObject) win.getMember("document");
JSObject myForm = (JSObject) doc.getMember("testForm");
JSObject check = (JSObject) myForm.getMember("jazz");
Boolean isChecked = (Boolean) check.getMember("checked");
}
The eval method in the class
netscape.javascript.JSObject let you evaluate an arbitrary JavaScript
expression. Use getWindow to get a handle for the JavaScript window,
then use eval to access a JavaScript method.
Use the following syntax to call JavaScript methods:
JSObject.getWindow().eval("expression")
expression is a JavaScript expression that evaluates
to a JavaScript method call.
For example, the following Java code uses eval
to call the JavaScript alert method when a mouseUp event occurs:
public void init() {
JSObject win = JSObject.getWindow(this);
}
public boolean mouseUp(Event e, int x, int y) {
win.eval("alert(\"Hello world!\");");
return true;
}
Another way to call JavaScript methods is with the
call method of JSObject. Use the following to call a JavaScript
method from Java when you want to pass Java objects as arguments:
JSObject.call(methodName, argArray)
where argArray is an Array of Java objects used
to pass arguments to the JavaScript method.
If you want to pass primitive values to a JavaScript method,
you must use the Java object wrappers (such as Integer, Float, and Boolean),
and then populate an Array with such objects.
Returning to the HelloWorld example, modify the
paint method in the Java code so that it calls the JavaScript
alert method (with the message "Painting!") as follows:
public void paint(Graphics g) {
g.drawString(myString, 25, 20);
JSObject win = JSObject.getWindow(this);
String args[] = {"Painting!"};
win.call("alert", args);
}
Then add the MAYSCRIPT attribute to the <APPLET>
tag in the HTML page, recompile the applet, and try it. Each time the applet
is painted (when it is initalized, when you enter a new text value, and when
the page is reloaded) a JavaScript alert box is displayed. This is a simple
illustration of calling JavaScript from Java.
This same effect could be achieved
with the following:
public void paint(Graphics g) {
g.drawString(myString, 25, 20);
JSObject win = JSObject.getWindow(this);
win.eval("alert(`Painting')");
}
Note
You may have to reload the HTML page by choosing Open File
from the File menu instead of clicking the Reload button, to ensure that
the applet is re-initialized.
You can also call user-defined functions from a Java applet.
For example, add the following function to the <HEAD> of the HTML page
with the HelloWorld applet:
<SCRIPT>
function test() {
alert("You are using " + navigator.appName + " " +
navigator.appVersion)
}
</SCRIPT>
This simple function displays an alert dialog box containing
the name and version of the client software being used. Then modify the
init method in your Java code similarly to the way you modified
paint:
public void init() {
myString = new String("Hello, world!")
JSObject win = JSObject.getWindow(this)
String args2[] = {""}
win.call("test", args2)
}
Notice that args2 is declared as an array with
no elements, even though the method does not take any arguments. When you
recompile the applet and reload the HTML page (and re-initialize the applet),
a JavaScript alert dialog box will display the version of Navigator you are
running. This is a simple illustration of calling a user-defined function
from Java.
Values passed from Java to JavaScript are converted as
follows:
-
-
Java byte, char, short, int, long, float, and double are converted to JavaScript
numbers.
-
A Java boolean is converted to a JavaScript boolean.
-
An object of class JSObject is converted to the original JavaScript
object.
-
An object of any other class is converted to a JavaScript wrapper, which
can be used to access methods and fields of the Java object. Converting this
wrapper to a string will call the toString method on the original
object; converting to a number will call the floatValue method if
possible and fail otherwise. Converting to a boolean will attempt to call
the booleanValue method in the same way.
-
Java arrays are converted to a JavaScript pseudo-Array object; this object
behaves just like a JavaScript Array object: you can access it with
the syntax
arrayName[index] (where index is an integer),
and determine its length with arrayName.length.
| file: /Techref/language/JAVA/SCRIPT/livecon.htm, 30KB, , updated: 2009/2/2 13:27, local time: 2024/11/22 18:29,
|
| | ©2024 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?
<A HREF="http://sxlist.com/techref/language/JAVA/SCRIPT/livecon.htm"> LiveConnect </A> |
| Did you find what you needed?
|
.