source: trunk/gsdl/src/phind/client/Phind.java@ 1636

/**********************************************************************
 *
 * Phind.java -- the Phind java applet
 *
 * Copyright 1997-2000 Gordon W. Paynter
 * Copyright 2000 The New Zealand Digital Library Project
 *
 * A component of the Greenstone digital library software
 * from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *********************************************************************/


/*********************************************************************

To use the applet, you'll need to embed it in a web page as follows:

<APPLET CODE="Phind.class" WIDTH=500 HEIGHT=500>
  <PARAM NAME=phindcgi    VALUE="http://kowhai/cgi-bin/phindcgi">
  <PARAM NAME=library     VALUE="http://kowhai/cgi-bin/library">
  <PARAM NAME=backdrop    VALUE="http://kowhai/~paynter/transfer/phindtest/green1.jpg">
  <PARAM NAME=collection  VALUE="fao.org">
  <PARAM NAME=orientation VALUE="vertical">
  <PARAM NAME=depth       VALUE="2">
  <PARAM NAME=fontsize    VALUE="12">
  <PARAM NAME=blocksize   VALUE="10">
  The Phind java applet.
</APPLET>

You may have problems with Java applet security.  Java applet's can only
open socket connections (including the HTTP connections the applet uses 
to get data) to the same server the applet was loaded from.  This means
that your phindcgi, library, and (optional) backdrop URLs must be on the
same machine that your web page was loaded from.

**********************************************************************

The applet comprises several classes:

1. Phind (this file) is the applet class, loaded by the browser.
   It also handles network connections.
2. ResultDisplay is a Panel that sits in the applet and displays 
   things; displays are connected in a doubly-linked list.
3. ResultBox holds the results of a query.  Result boxes are shown
   to the user through ResultDisplays.  Another doubly-linked list.
4. ResultTitle acts as a caption to a ResultBox describing its contents.
5. ResultCanvas is what the ResultBox data is drawn on.  It draws the
   words on the screen, and handles user input from the mouse.
6. ResultItem represents a single result object (a phrase or document).
7. PhindTitle is for drawing backdrops in ResultDisplays.

**********************************************************************/


import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextField;

import java.net.URL;
import java.io.DataInputStream;

import java.net.Socket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.io.IOException;

import java.util.Vector;
import java.util.Date;

public class Phind extends java.applet.Applet {
    
    // elements of the page
    Label titleLabel;
    TextField wordField;
    Button searchButton, prevButton, nextButton;

    // Appearance parameters
    public boolean vertical;
    public int depth;
    public int fontSize;
    public Font plainFont, boldFont;

    // Do we want a background image in the applet?
    String backdrop_address;
    public boolean showImage;
    public Image backgroundImage;

    // Holders for the downloaded data
    Panel resultPanel;
    ResultDisplay firstDisplay, lastDisplay;

    // the mode of operation
    int mode;
    final int initMode = 0;
    final int idleMode = 1;
    final int searchMode = 2;

    // what to search for
    String collection;
    int phraseBlockSize;

    //int stopwordLevel = 1;
    //int lowFrequencyCutoff = 0;
    //int stemming = 0;

    // where to search
    Socket connection;
    String library_address, phindcgi_address;
    URL library, phindcgi;

    String search_url;

    // browser details
    String localHost;

    // The time at which the last query finished
    Date lastQueryEndTime;

    // lastQueryEndTime is stored to ensure a 1 second gap between a query
    // returning and a new one beginning.  It is needed because the FAO
    // folks in Rome have a huge lag, and frquently click several times
    // while they wait; these clicks are turned into new queries, which
    // they await again.  It is no elegant solution, but it seems like the
    // easiest, given that I don't know threads.
    // 1. The search button is easy to disable, and is disabled when a
    //    socket connection is in progress.
    // 2. ResutCanvas widgets can'r be similarly disabled because the
    //    browser hides or wipes them, which looks very bad.
    // 3. I cannot just ignore clicks on canvasses because the browser
    //    caches the clicks while the socket connection is going on, and then
    //    sends them through afterwards, when the canvas is accepting clicks
    //    again.
    // 4. Current sequence of events is to record the time the last query
    //    ends, then whenever a click happens make sure a second has past.  if
    //    you double-click the the first query is sent, returns, end-tie is
    //    set, and the second (and any others made during query time) is
    //    *immediately* processed, but since 1 second hasn't past it is
    //    ignored.

  
    public String getAppletInfo() {
    return "Phind by Gordon Paynter ([email protected]). Copyright 1997-2000.";
    }

    public void init() {

    // default search variable values 
    mode = initMode;
    lastQueryEndTime = new Date();

    // What is this collection called?
    try { 
        collection = new String(getParameter("collection"));
    } catch (Exception e) { 
        System.err.println("Phind: You must specify a collection.");
        stop();
    }
    System.out.println("Phind collection: " + collection);

    // Where do we get the phind data
    try { 
        phindcgi_address = new String(getParameter("phindcgi"));
    } catch (Exception e) { 
        System.err.println("Phind: You must specify a URL for phindcgi.");
        stop();
    }
    System.out.println("Phind phindcgi: " + phindcgi_address);

    // Where is the collection served from
    try { 
        library_address = new String(getParameter("library"));
    } catch (Exception e) { 
        System.err.println("Phind: You must specify a URL for library.");
        stop();
    }
    System.out.println("Phind library: " + library_address);

    // Should we display a background image?
    showImage = false;
    try { 
        backdrop_address = new String(getParameter("backdrop"));
        URL backdrop_url = new URL(backdrop_address);
        backgroundImage = getImage(backdrop_url);
        showImage = true;
        System.out.println("Phind backdrop: " + backdrop_address);
    } catch (Exception e) { 
        System.out.println("Phind backdrop not set");
    }

    // Is there a search URL for this collection?
    try {
        search_url = new String(getParameter("search_url"));
        System.out.println("Phind search URL: " + search_url);
    } catch (Exception e) { 
        System.out.println("Phind search_url not set.");
    }

    // Are the windows arranged vertically or horizontally
    vertical = true;
    try {
        if (getParameter("orientation").toLowerCase().startsWith("h")) {
        vertical = false;
        System.out.println("Phind orientation: horizontal");
        }
    } catch (Exception e) { 
        System.out.println("Phind orientation: vertical");
    }

    // How many phind windows are there?
    Integer temp;
    try { 
        temp = Integer.valueOf(getParameter("depth"));
        depth = temp.intValue();
    } catch (Exception e) { 
        temp = null;
        depth = 3;
    }
    System.out.println("Phind depth: " + depth);

    // How many phrases should we fetch at any given time?
    try { 
        temp = Integer.valueOf(getParameter("blocksize"));
        phraseBlockSize = temp.intValue();
    } catch (Exception e) { 
        temp = null;
        phraseBlockSize = 10;
    }
    System.out.println("Phind phrase block size: " + phraseBlockSize);

    // How large should the font be?
    try { 
        temp = Integer.valueOf(getParameter("fontsize"));
        fontSize = temp.intValue();
    } catch (Exception e) { 
        temp = null;
        fontSize = 12;
    }
    System.out.println("Phind font size: " + fontSize);

    // browser details
    try {
        localHost = InetAddress.getLocalHost().toString();
    } catch (Exception e) {
        localHost = "Can't get client host.";
    }
    System.out.println("Phind client: " + localHost);
    System.out.println("");

    // The phind applet layout manager
    setLayout(new BorderLayout());

    // initialise the user interface
    setBackground(Color.white);
    plainFont = new Font("Helvetica", Font.PLAIN, fontSize);
    boldFont  = new Font("Helvetica", Font.BOLD, fontSize);

    // the main Result area

    // the Panel containing the displays is in the center of the display
    resultPanel = new Panel();
    if (vertical) {
        resultPanel.setLayout(new GridLayout(depth,1,0,2));
    } else {
        System.out.println("horizontal");
        resultPanel.setLayout(new GridLayout(1,depth,2,0));
    }
    add("Center", resultPanel);

    // Create ResultDisplays and place in the interface
    ResultDisplay d1, d2 = null;
    firstDisplay = new ResultDisplay(this, null);
    resultPanel.add(firstDisplay);

    d1 = firstDisplay;
    for (int i = 2; i <= depth; i++) {
        d2 = new ResultDisplay(this, d1);
        resultPanel.add(d2);
        d1 = d2;
    }
      
    lastDisplay = d2;


    // The "control panel" 
    Panel p1 = new Panel();
    add("North", p1);
    p1.setLayout(new FlowLayout(FlowLayout.CENTER, 0, 0));

    searchButton = new Button("Search");
    searchButton.setFont(boldFont);
    p1.add(searchButton);

    Label tempLabel = new Label("  for");
    tempLabel.setFont(boldFont);
    p1.add(tempLabel);

    wordField = new TextField(12);
    wordField.setFont(boldFont);
    p1.add(wordField);

    Label temp2 = new Label("          ");
    p1.add(temp2);

    prevButton = new Button("Previous");
    prevButton.setFont(boldFont);
    prevButton.disable();
    p1.add(prevButton);

    nextButton = new Button("  Next  ");
    nextButton.setFont(boldFont);
    nextButton.disable();
    p1.add(nextButton);

    // lets get started then
    setStatus("Welcome to Phind.");
    mode = idleMode;
    }


    void setStatus(String status) {
    showStatus(status);
    }

    public boolean action(Event evt, Object arg) {

    if (evt.target == searchButton) {
        searchForWord();
    } else if (evt.target == wordField) {
        searchForWord();
    } else if (evt.target == prevButton) {
        shiftPrevious();
    } else if (evt.target == nextButton) {
        shiftNext();
    } else {
        System.out.println("unknown action: " + evt.toString() + ", object: " + arg.toString());
    }
    return true;
    }


    // Search for a word 
    //
    // called when the "Search" Button is pressed
    void searchForWord() {

    if (mode == idleMode) {

        // transform the word to an appropriate search key
        String searchWord = wordField.getText().trim().toLowerCase();
        for (int i = 0; i < searchWord.length(); i++) {
        if ((searchWord.charAt(i) < 'a') || (searchWord.charAt(i) > 'z')) {
            searchWord = searchWord.substring(0, i);
        }
        }
        wordField.setText(searchWord);

        // look up the word
        if (searchWord.length() > 1) {
        setStatus("searching for \"" + searchWord + "\""); 
        firstDisplay.emptyContents();
        ResultBox result = lookupPhraseOnServer(null, false, searchWord, searchWord, 2);

        // if there is an error, return
        if (result == null) {
            setStatus("No results for \"" + searchWord + "\""); 
            return;
        }

        // display the result
        result.display = firstDisplay.display(result);
        result.resize(result.display.size());
        result.paintAll(result.getGraphics());
        }

        enablePreviousAndNext();
    }
    }
  

    // Search for a phrase
    //
    // If querymode is 2, the user has clicked on a phrase.
    // If querymode is 3, the user has requested more phrases.
    // If querymode is 4, the user has requested more documents.
    void searchForPhrase(ResultBox source, String key, String phrase, int queryMode) {

    // System.out.println("searchForPhrase: " + key + " " + phrase + " " + queryMode);

    if (mode == idleMode) {

        // If we are going to replace the next ResultDisplay, then empty it
        if (queryMode <= 2) {
        if (source.display.next != null) source.display.next.emptyContents();
        }

        // look up the word
        setStatus("Searching for \"" + phrase + "\""); 
        ResultBox result = lookupPhraseOnServer(source, true, key, phrase, queryMode);
        if (result == null) {
        setStatus("No result for \"" + phrase + "\""); 
        return;
        }

        // If this is not already displayed, display it in the last free spot
        if (queryMode <= 2) {
        result.display = lastDisplay.display(result);
        result.resize(result.display.size());
        result.paintAll(result.getGraphics());
        }

        enablePreviousAndNext();
    }
    }


    // Look up a phrase (or symbol) on the server
    //
    // Arguments are the source of the query (a ResultBox, or null if the
    // query comes from hitting the search button), the key to search for
    // (the text of a phrase or a symbol number), the phrase as a string, 
    // and the query mode.
    // Query modes are: 
    //   0 = obsolete
    //   1 = obsolete
    //   2 = get first N phrases and URLs,
    //   3 = get another N phrases into same window
    //   4 = get another N documents into same window

    ResultBox lookupPhraseOnServer(ResultBox source, 
                   boolean keyKnown, String key, String phrase, 
                   int queryMode) { 
        searchButton.disable();
    mode = searchMode;
    ResultBox r = null;

    if (queryMode <= 2) {
        r = new ResultBox(this, collection, key, phrase, source);
    } else if ((queryMode == 3) || (queryMode == 4)) {
        r = source;
    }

    try { 
        queryServer(keyKnown, key, queryMode, r);
    } catch (Exception e) { 
        System.out.println("Phind query error: " + e.toString());
        setStatus("Query error: " + e.toString());
        mode = idleMode;
        searchButton.enable();
        return null;
    }
      
    // The query is finished
    setStatus(r.c.numberOfPhrases + " results containing \"" + phrase + "\""); 
    mode = idleMode;
    searchButton.enable();
    lastQueryEndTime = new Date();

    return r;
    }


    // Query the phindcgi program
    //
    // Send a query (a word or symbol number) to the server
    // Open a socket connection to the server, send it a query,
    // and pass the result to a ResultBox.

    void queryServer(boolean keyKnown, String word, int queryMode, ResultBox area) 
    throws IOException {

    // Build the query
    String query = phindcgi_address + "?x=1&c=" + collection;

    if (keyKnown) {
      query = query + "&n=" + word;
    } else {
      query = query + "&p=" + word;
    }

    
    // Specify the set of results to return 
    int first_e = 0;
    int last_e = 0;
    int first_d = 0;
    int last_d = 0;

    // the initial query
    if (queryMode <= 2) {
      last_e = phraseBlockSize;
      last_d = phraseBlockSize;
    }
 
    // add phrases to an existing result set
    else if (queryMode == 3) {
      first_e = area.nextPhraseBlock * phraseBlockSize;
      area.nextPhraseBlock++;
      last_e = area.nextPhraseBlock * phraseBlockSize;
    } 
    
    // add documents to existing result set
    else if (queryMode == 4) {
      first_d = area.nextDocumentBlock * phraseBlockSize;
      area.nextDocumentBlock++;
      last_d = area.nextDocumentBlock * phraseBlockSize;
    }

    query = query + "&f=" + first_d + "&d=" + last_d 
                  + "&g=" + first_e + "&e=" + last_e;

    // Send the query to the phindcgi program 
    System.out.println("sending query: " + query);
    try {
        phindcgi = new URL(query);
        DataInputStream in = new DataInputStream(phindcgi.openStream());
        byte[] buffer;
        int availableBytes = 0;

        while (!area.finished) {
        availableBytes = in.available();
        if (availableBytes == 0) {
            // if i had threads i'd do a wait here for 1 second
        } else {
            buffer = new byte[availableBytes];
            in.read(buffer);
            area.parseBytes(buffer);
        }
        }
        
        in.close();
    } catch (Exception e) {
        System.err.println( "Error sending query to phindcgi: " + e);
    }
    area.repaint();
    }
    

    // Previous and Next button functionality

    // enable or disable the "Previous" and "Next" buttons
    void enablePreviousAndNext() {

    Component c = firstDisplay.current;
    if (c.getClass().getName().equals("ResultBox")) {
        if (((ResultBox) c).prevBoxExists()) {
        prevButton.enable();
        } else {
        prevButton.disable();
        }
    }

    c = lastDisplay.current;
    if (c.getClass().getName().equals("ResultBox")) {
        if (((ResultBox) c).nextBoxExists()) {
        nextButton.enable();
        } else {
        nextButton.disable();
        }
    }
    }

    // Shift to previous box
    //
    // If the user clicks "Previous" then scroll up.
    void shiftPrevious() {

    Component c = firstDisplay.current;
    if (c.getClass().getName().equals("ResultBox")) {

        ResultBox b = (ResultBox) c;
        if (b.prevBoxExists()) {
        b = b.prev;

        // empty all the displays
        firstDisplay.emptyContents();

        // add as many result boxes as there are displays
        for (int i = 1 ; ((i <= depth) && (b != null)); i++) {
            lastDisplay.display(b);
            b.resize(b.display.size());
            b.paintAll(b.getGraphics());
            b = b.next;
        }
        }
    }
    enablePreviousAndNext();
    }


    // Shift to next box
    //
    // If the user clicks "Next" then scroll down if possible
    void shiftNext() {

    Component c = lastDisplay.current;
    if (c.getClass().getName().equals("ResultBox")) {

        ResultBox b = (ResultBox) c;
        if (b.nextBoxExists()) {

        // find the new "first" displayed box
        c = firstDisplay.current;
        b = (ResultBox) c;
        b = b.next;

        // empty all the displays
        firstDisplay.emptyContents();

        // add as many result boxes as there are displays
        for (int i = 1 ; ((i <= depth) && (b != null)); i++) {
            lastDisplay.display(b);
            b.resize(b.display.size());
            b.paintAll(b.getGraphics());
            b = b.next;
        }
        }
    }
    enablePreviousAndNext();
    }

}