CA597 Tutorial - Using URLs in Applets

Content:

Network Access
Execute the Applet
Extending the Applet

We are going to implement an applet which takes a URL, accesses it, fetches the specified page and displays it.

Network Access

To access a remote URL we need to establish a network connection. Java offers several ways of doing this, e.g.

URL connectsions
sockets

In any case we need to use the java.net package in addition to applet, GUI-elements and event handling.

	import java.applet.*;
	import java.awt.*;
	import java.awt.event.*;
	import java.net.*;

The applet uses similar constructs as the SimpleApplet discussed earlier on:

buttons and textfields: corresponding objects are declared and created:

	...
        private TextField URLText = null ;
        private Button URLButton = null;

	...

        public void init()
        {
                add(new Label("URL"));
                URLText = new TextField(30);
                add(URLText);
                URLButton = new Button("Go");
                add(URLButton);
		...

We can see that additionally a label, which labels the textfield, is added to the applet panel.

actionListener: as with the SimpleApplet, action events shall be handled. Again, the applet shall react to clicking a button. As usual, we implement the ActionListener class and register with the button object in order to get notified if a user clicks the button.

	public class URLApplet extends Applet
                               implements ActionListener
	...

	      URLButton.addActionListener(this);
        }

        public void actionPerformed(ActionEvent e)
        {
                String actionCommand = e.getActionCommand();
                if (e.getSource() instanceof Button)
                        if (actionCommand.equals("Go"))
                        {

The sequence of tests within the event handler actionPerformed is also the same.

The new bit in this applet is the following:

	System.out.println("Go");
        try
        {
       	          AppletContext context = getAppletContext();
                  URL url = new URL(URLText.getText());
                  context.showDocument(url);
        }
        catch(Exception ex)
        {
                  showStatus("Error "+ex);
        }

The first line is only a test output (you can delete it if you want).

getAppletContext is a method of the Applet class which determines the applet context - information about the environment it is running in. AppletContext is an interface which can be used by an applet to determine concrete information about the context (are there other applets: getApplets() ) or to affect the context. The showDocument(..) method is an example of the latter class.

It requests the browser to show the Web page specified by the URL. URLText is a textfield object. Applying the getText() method gives us the string typed in by the user. If this is actually a valid URL, then a URL object url is created.

Execute the Applet

Here is the applet. Note that the applet is not smart (as most browsers are). You have to give a full URL including the protocol specification, e.g. http: . Most browsers would insert that for you.

Here is the full text of the applet:

//
//      an Applet showing a Web page
//      Claus Pahl
//      Feb 2000
//

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;

public class URLApplet extends Applet
                          implements ActionListener
{
        private TextField URLText = null ;
        private Button URLButton = null;

        public URLApplet()
        {
        }

        public void init()
        {
                add(new Label("URL"));
                URLText = new TextField(30);
                add(URLText);
                URLButton = new Button("Go");
                add(URLButton);

                URLButton.addActionListener(this);
        }

        public void actionPerformed(ActionEvent e)
        {
                String actionCommand = e.getActionCommand();
                if (e.getSource() instanceof Button)
                        if (actionCommand.equals("Go"))
                        {
                                System.out.println("Go");
                                try
                                {
                                        AppletContext context = getAppletContext();
                                        URL url = new URL(URLText.getText());
                                        context.showDocument(url);
                                }
                                catch(Exception ex)
                                {
                                        showStatus("Error "+ex);
                                }
                        }
        }
}

How to Extend Your Applet

A warning: the first couple of ideas are about making connections from an applet. Since applets are usually subject to some security restrictions, use the appletviewer in case you experience problems with the browser.

URLs are an important concept. Java allows to establish connections with a URL and to read from and write to it.
- open a connection:
```
	URL url = new URL(URLText.getText());
	URLConnection connection = url.openConnection();
```
- read from a URL connection:
```
	DataInputStream dis = 
		new DataInputStream(connection.getInputStream());
```
  This input stream can then be used to write the file to the terminal or to a file, or to do something else with it.
- write to a URL connection:
  Writing to a URL connection makes sense if the URL specifies a CGI-script which could process our input, and which might send data back.
  Instead of getting the input stream, we do the same with the output stream:
```
	DataOutputStream dos = 
		new DataOutputStream(connection.getOutputStream());
```
  An application of this idea might establish an output connection to the URL, close it, and then open an input stream handling data send back from the contacted server.
Certainly, other networking mechanisms can be used. That will be dealt with later on.
As for the SimpleApplet, other GUI-components or event handlers can be used.

What to do??
Continue working on the interface.

Use other layout managers if you want to use the border layout, you need to do the following: choose a layout manager:
```
setLayout(new BorderLayout());
```
This defines a layout with a Center field and 4 fields around it (called North, East, South and West). Now you can add GUI components at specific places, e.g.
```
add("Center", URLButton);
```
or
```
add("North",URLText);
```
add a button which analyses the input in the text field (is it a string, is it a URL?)
Within the init method, create the button object:
```
CheckButton = new Button("Check");
add(CheckButton);
```
Then you need to implement the action handling. As for the URLbutton, the event type is action and the event generating object is of type button. So within the
```
if (e.getSource() instanceof Button) { ... }
```
statement, add an event handler for the check button:
```
if (actionCommand.equals("Check"))
{ 
    ...
}
```
The content of the textfield shall be checked. The first step is to get the content of the textfield. We could require that the URL connection uses HTTP as the protocol. So we can compare the first four letter of the textfield content with 'http'. If there is something wrong we will print an error message.
```
String s;
s = URLText.getText();
s = s.substring(1,4);
if ( !s.equalIngnoreCase("http") ) {
	errorMsg = new label("ERROR: not HTTP");
	add(errorMsg);
	validate();
}
```
You need to declare 'errorMsg' as a 'Label'. 'validate()' forces the applet to redraw the panel. If you are using the graphics package, then use 'repaint()'.
try to react on ENTER in the textfield.
As explained earlier on, ENTER (return) in a textfield causes an action event. This can be dealt with in the same way as action events caused by buttons - only the instanceOf operation should test 'TextField' and not 'Button'.