source: other-projects/gs3-webservices-java-client/trunk/src/GS3DemoClient/org/greenstone/gs3client/SearchResultsDisplay.java@ 26180

/**
 *#########################################################################
 * SearchResultsDisplay.java - part of the demo-client for Greenstone 3, 
 * of the Greenstone digital library suite from the New Zealand Digital 
 * Library Project at the  * University of Waikato, New Zealand.
 * <BR><BR>
 * Copyright (C) 2008 New Zealand Digital Library Project
 * <BR><BR>
 * 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.
 * <BR><BR>
 * 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.
 *########################################################################
 */

package org.greenstone.gs3client;

import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.BorderLayout;
import java.awt.FlowLayout;

import javax.swing.JPopupMenu;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JEditorPane;
import javax.swing.JList;
import javax.swing.JLabel;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeSelectionModel;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;

import javax.swing.text.html.HTMLDocument;

import org.apache.log4j.Logger;
import org.greenstone.gs3client.data.DocumentNodeData;

import java.net.URL;
import java.net.MalformedURLException;

/** 
 * The Search panel inside the Java-client's tab pane that's labelled 
 * "Search Results". This panel contains two tree views: 
 * - one for displaying the list of search results (top-level documents or document
 * - one for displaying the structure of document nodes selected in the list of
 * search results.  
 * This panel also contains an area where the selected documentNode's metadata is 
 * displayed, and a text area where the textual or image content of a selected 
 * documentNode is displayed. 
 * @author ak19
*/
public class SearchResultsDisplay 
    extends JPanel implements TreeSelectionListener, ColourCombo.ColourChangeable
{   
    /** The Logger for this class */
    static Logger LOG = Logger.getLogger(SearchResultsDisplay.class);
    
    /** Access to the running instance of GS3JavaClient */
    protected GS3JavaClient client;
    
    /* GUI items of this SearchResults Panel */
    protected JTree searchResultsTree, docStructureTree;
    protected JSplitPane docInfoPane, docInfoWithContent, treeviewSplitPane;
    protected JEditorPane docContentEditPane;
    protected JList metanames, metavalues;
    /** Context menu that pops up when users right click in the browse tree area */
    protected JPopupMenu popup;
    
    /** Constructor that creates the Search Panel and its internal GUI items.
     * @param client is the running instance of the client application through 
     * which its methods can be accessed. */
    public SearchResultsDisplay(GS3JavaClient client) 
    {
        super(new FlowLayout(FlowLayout.LEFT)); 
            // so the contents of this panel are not centred
        this.client = client;
        
        // The panels: searchresults (with a tree), docStructure (also 
        // contains a tree), metadataPanel (with 2 lists for metanames 
        // and metavalues and docContentEditor to show a selected html  
        // document's contents
        JPanel searchResultsPanel, docStructurePanel, metadataPanel;
        
        this.docContentEditPane = new JEditorPane();
        this.docContentEditPane.setEditable(false);
        this.docContentEditPane.setContentType("text/html"); 
                //"text/plain" to view the html markup
        
        searchResultsPanel = new JPanel(new BorderLayout()); 
        docStructurePanel = new JPanel(new BorderLayout());
        searchResultsPanel.add(
                new JLabel("Documents returned"), BorderLayout.NORTH);
        docStructurePanel.add(
                new JLabel("Document structure"), BorderLayout.NORTH);
        
        metadataPanel = new JPanel(new BorderLayout());
        this.metanames = new JList();
        this.metavalues = new JList();
        metadataPanel.add(metanames, BorderLayout.WEST);
        metadataPanel.add(metavalues, BorderLayout.CENTER);
        
        JPanel metaSuperPanel = new JPanel(new BorderLayout());
        metaSuperPanel.add(new JLabel("Metadata"), BorderLayout.NORTH);
        metaSuperPanel.add(
                new JScrollPane(metadataPanel), BorderLayout.CENTER);
        
        // Create the searchresults tree and the docStructure tree
        // (neither of them initialised to any meaningful nodes at present).
        // Both trees allow only one selection at a time.
        // Add a listener to both for when their treenode selections change.
        // Finally add them to their respective JPanels.
        searchResultsTree = new JTree(new DefaultMutableTreeNode(null)); 
        searchResultsTree.getSelectionModel().setSelectionMode(
                TreeSelectionModel.SINGLE_TREE_SELECTION);
        searchResultsTree.addTreeSelectionListener(this);
        searchResultsPanel.add(new JScrollPane(searchResultsTree), 
                BorderLayout.CENTER);
        
        docStructureTree = new JTree(new DefaultMutableTreeNode(null));
        docStructureTree.getSelectionModel().setSelectionMode(
                TreeSelectionModel.SINGLE_TREE_SELECTION);
        docStructureTree.addTreeSelectionListener(this);
        docStructurePanel.add(new JScrollPane(docStructureTree),
                BorderLayout.CENTER);
        // add a (rightclick) popup menu to the document structure tree:
        popup = new JPopupMenu();
        docStructureTree.setComponentPopupMenu(popup);
        docStructureTree.addMouseListener(new Displays.PopupListener(
            popup, docStructureTree, client, this.docContentEditPane));
        
        // Add the docStructure and metadata panels next to each 
        // other within a split pane
        docInfoPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
        docInfoPane.setLeftComponent(docStructurePanel);
        docInfoPane.setRightComponent(metaSuperPanel);
        docInfoPane.setOneTouchExpandable(true);
                
        // Add that to the top of the editorpanel showing the contents of
        // any selected document nodes
        docInfoWithContent = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
        docInfoWithContent.setTopComponent(docInfoPane);
        docInfoWithContent.setBottomComponent(
                new JScrollPane(this.docContentEditPane));
        docInfoWithContent.setOneTouchExpandable(true);
        
        // Add that splitpane to the right of the search results panel
        // in a new splitpane (horizontal)
        treeviewSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
        treeviewSplitPane.setLeftComponent(searchResultsPanel);
        treeviewSplitPane.setRightComponent(this.docInfoWithContent);
        treeviewSplitPane.setOneTouchExpandable(true);
        this.add(treeviewSplitPane);
        
        // All the scrollviews and the splitpanes will be sized
        // when getPreferredSize() is called on show()/setVisible()
    }
    
    /** Overrode this method to resize the splitpanes within, upon resize. 
     * It calculates the size of this panel, as well as setting those of  
     * the splitpanes it contains based on the size of the parent container.
     * @return the preferred dimensions of this JPanel. */
    public Dimension getPreferredSize() {
        Dimension size = this.getParent().getSize(); //900, 500
        int x = (int)size.getWidth() / 3;
        int y = (int)(size.getHeight() / 5 * 2);
        docInfoPane.setDividerLocation(x);
        docInfoWithContent.setDividerLocation(y);
        treeviewSplitPane.setDividerLocation(x);
        docInfoPane.setPreferredSize(size);
        docInfoWithContent.setPreferredSize(size);
        treeviewSplitPane.setPreferredSize(size);
        return size;
    }
    
    /** Changes the colour of the query form and its controls to the
     *  current colours set in class ColourCombo. Specified by
     *  the ColourCombo.ColourChangeable interface. */
    public void changeUIColour() {
        Component[] comps = { this, this.docStructureTree, 
            this.searchResultsTree, metanames, metavalues, popup };
        ColourCombo.changeColor(comps);
        
        // ensures that the JLabel for "metadata" and the trees
        // are coloured properly:
        ColourCombo.changeAncestorColor(metanames); 
        ColourCombo.changeAncestorColor(this.docStructureTree);
        ColourCombo.changeAncestorColor(this.searchResultsTree);
    }
    
    /** Clears the service-specific buttons in the browseBar and the 
     * service-specific display-data. The rest of the GUI (split panes, panels) 
     * remain as they are. Resets the contents of the widgets in this panel. */
    public void clear() {
        //searchResultsTree.removeAll();
        //docStructureTree.removeAll(); // doesn't seem to emtpy tree
        //this.metanames.removeAll(); //doesn't seem to empty the list values
        //this.metavalues.removeAll(); //doesn't seem to empty the list values
        
        // empty the docStructureTree's popup menu too
        popup.removeAll();
                
        // empty the trees
        ((DefaultTreeModel)searchResultsTree.getModel()).setRoot(null);
        ((DefaultTreeModel)docStructureTree.getModel()).setRoot(null);
        // empty the metadatalists
        final String[] empty = {""};
        this.metanames.setListData(empty);
        this.metavalues.setListData(empty);
        // empty the html view area
        this.docContentEditPane.setText("");
    }
    
    /** Restructures the searchResultsTree when another search has been made, so 
     * that the search results contain a new list of documentNodeData objects.
     * @param resultDocs - the list of (new) DocumentNodeData objects that have
     * been returned as the results of a query/search operation. */
    public void setResults(DocumentNodeData[] resultDocs) {
        // Empty out whatever was in our searchResultsTree and in the
        // other displays
        clear();
        
        // Populate the searchresults tree with each node being a document
        // that represents a different search result
        DefaultMutableTreeNode newRoot 
            = new DefaultMutableTreeNode();
        for(int i = 0; i < resultDocs.length; i++)
            newRoot.add(new DefaultMutableTreeNode(resultDocs[i]));
        
        DefaultTreeModel model 
            = (DefaultTreeModel)searchResultsTree.getModel();
        model.setRoot(newRoot);
        // We do not want a root, without a root it is perfect for linear  
        // display of search results (a.o.t. hierarchical display)
        searchResultsTree.setRootVisible(false);
        // hierarchical display of the first search result (if its root is set)
        if(resultDocs.length > 0) 
            // array may be empty if there were no resultdocs
            this.restructureWithNewRoot(resultDocs[0].getRoot());
    }
    
    /** Restructures the docStructureTree with a new rootNode when a different   
     * search result has been clicked.
     * @param rootDocNode - the new root DocumentNodeData whose structure is  
     * to be displayed in the docStructureTree. */
    protected void restructureWithNewRoot(DocumentNodeData rootDocNode)
    {
        DefaultMutableTreeNode root = null;
        if(rootDocNode != null) {
            // Create the nodes.
            root = new DefaultMutableTreeNode(rootDocNode);
            Displays.createNodesForChildren(rootDocNode, root);
        }
        DefaultTreeModel model = (DefaultTreeModel)docStructureTree.getModel();
            
        docStructureTree.removeAll();
        model.setRoot(root);
        
        // empty the contentpane
        this.docContentEditPane.setText("");
    }
    
    /** Part of the TreeSelectionListener interface. When this is called, an item  
     * has been clicked in either the searchResultsTree or the docStructureTree.  
     * This method displays the metadata and textual contents accordingly
     * of the selected documentNodeData object. */
    public void valueChanged(TreeSelectionEvent e) {
        // remove any menuItems in the popup from the previously 
        // selected docNode
        popup.removeAll();
                
        DefaultMutableTreeNode node = null;
        if(e.getSource() == searchResultsTree)
            node = (DefaultMutableTreeNode)
                searchResultsTree.getLastSelectedPathComponent();
        else if(e.getSource() == docStructureTree)
            node = (DefaultMutableTreeNode)
                docStructureTree.getLastSelectedPathComponent();
        
        if(node == null) return;
        Object nodeInfo = node.getUserObject();
        // after construction there's nothing in the trees, so check for that:
        if(nodeInfo == null) return; 
        
        // We need to change to a Wait cursor while we load the documentNode
        Container c = client.getContentPane();
        c.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
        
        DocumentNodeData docNode = (DocumentNodeData)nodeInfo;
        
        // If user had clicked on a searchResult:
        if(e.getSource() == this.searchResultsTree && node.isLeaf()) {
            this.client.retrieveTitledStructureFor(docNode);
            // Now it has set the root and descendents for the 
            // selected docNode
            DocumentNodeData root = docNode.getRoot();
            // get the nodestructuredisplay from the client
            // nodestructure.restructureWithNewRoot(root, docNode);
            this.restructureWithNewRoot(root);
            
            // First ensure the metadata for the docNode is set
            client.retrieveAllMetadataFor(docNode); 
                // now metadata for the document is set
            // Now, if metadata viewable, then display the metadata
            // for the root document node:
            Displays.showMeta(docNode, metanames, metavalues);
            
            // make the client retrieve the content for the docNode
            // that's clicked on, and display it in the docContentEditPane 
            client.retrieveContentFor(docNode);
            // JEditorPane can't handle Justify, it centers such paras
            // Therefore, left align them instead.
            String docContent = docNode.getContent();
            if(docContent != null) {
                docContent = docContent.replaceAll(
                    "ALIGN=\"JUSTIFY\"", "ALIGN=\"LEFT\"");
            }

        this.docContentEditPane.setText(docContent);
            this.docContentEditPane.setCaretPosition(0); // set 'cursor' at top
        }
        
        // If the user had clicked on any docNode - leaf or otherwise
        // - in the docStructureTree panel:
        else if(e.getSource() == this.docStructureTree) {
            // First ensure the metadata for the docNode is set
            client.retrieveAllMetadataFor(docNode); 
                // now metadata for the document is set
            
            // Display the metadata for this document node:
            Displays.showMeta(docNode, metanames, metavalues);
            
            // if the document has NoText set to 1 (doc has no text), then it
            // has an image - display this by default
            if(docNode.hasNoText() && node.isLeaf() /*&& docNode.canBeImage()*/) {
                this.docContentEditPane.setText(
                        Displays.getImgUrlEnclosedInHtml(client.getBaseURL(), docNode.getImgURL()));
                this.docContentEditPane.setCaretPosition(0);
            }
            else { // now we know that the document must have text:
                // make the client retrieve the content for the docNode
                // that's clicked on, and display it in the docContentEditPane 
                client.retrieveContentFor(docNode);
                // Java's htmlpane does not recognise justified alignment.
                // It displays them all centred. So replace all ALIGN="JUSTIFY" 
                // with ALIGN="LEFT" here. (Not in the DocumentNodeData class,
                // because our nodeContent should not be transformed: it will
                // display properly in browsers and other html displays).
                String docContent = docNode.getContent();
                if(docContent != null) {
                    docContent = docContent.replaceAll(
                            "ALIGN=\"JUSTIFY\"", "ALIGN=\"LEFT\"");
                }
                    
                // set the baseURL for digital libraries that use relative paths
                // to images and don't take care of base paths themselves
                // (GS3 uses the _httpdocimg_ macro to resolve relative urls)
                String baseURL = client.getBaseURL();
                // TODO: make the docNode itself workout its URL by passing
                // baseURL to the docNode?
                if(!baseURL.equals("") && docNode.getRoot() != null) { 
                        // "" is the case where dlAPIA = gs3
                        // where the _httpdocimg_ macro will deal with
                        // resolving the relative urls into their full ones
                        // We don't want to set the base and meddle with macro
                        // for those cases.
                    // For Fedora's case:
                    HTMLDocument doc 
                        = (HTMLDocument)this.docContentEditPane.getDocument();
                    try{
                        URL url = new URL(baseURL+docNode.getRoot().nodeID+"/");
                        //System.err.println("url: " + url.toString());
                        doc.setBase(url);
                        //docContent = docContent.replaceAll("_httpdocimg_/", "");
                        LOG.debug(docContent);
                    }catch(MalformedURLException mex) {
                        ; //nothing to be done, leave the base as it is
                    }
                }
                this.docContentEditPane.setText(docContent);
                // make sure 'cursor' (actually caret) is at the top
                // Don't want it to autoscroll to the bottom of the contentPane
                this.docContentEditPane.setCaretPosition(0);
            }
        }
        c.setCursor(Cursor.getDefaultCursor());
    }   
}