source: main/trunk/gli/src/org/greenstone/gatherer/collection/CollectionTreeNode.java@ 23433

/**
 *############################################################################
 * A component of the Greenstone Librarian Interface, part of the Greenstone
 * digital library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * Author: Michael Dewsnip, NZDL Project, University of Waikato, NZ
 *
 * Copyright (C) 2004 New Zealand Digital Library Project
 *
 * 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.
 *############################################################################
 */

package org.greenstone.gatherer.collection;


import java.io.*;
import javax.swing.*;
import org.greenstone.gatherer.cdm.CollectionDesignManager;
import org.greenstone.gatherer.file.FileNode;
import org.greenstone.gatherer.metadata.FilenameEncoding;
import org.greenstone.gatherer.util.JarTools;
import java.util.Set;
import java.util.Iterator;


/** This class represents one node in the collection tree. */
public class CollectionTreeNode
    extends FileNode
{
    static final public ImageIcon GREEN_FILE_ICON = JarTools.getImage("greenfile.gif", true);
    
    /** Is this file a metadata database that is explodable with the explode_metadata_databases.pl script? */
    private boolean is_explodable = false;

    /** Keeps track of whether this file can be replaced with a Greenstone-generated html file.
     * To work with replace_srcdoc_with_html.pl */
    private boolean is_srcreplaceable = false;

    public CollectionTreeNode(File file)
    {
    super(file);
        // the super call will additionally call calcDisplayString() which will get any
        // applicable the filename encoding and apply it to the file's name for display.

    this.is_explodable = CollectionDesignManager.plugin_manager.isFileExplodable(file);
    // To work with replace_srcdoc_with_html.pl
    this.is_srcreplaceable = CollectionDesignManager.plugin_manager.isFileSrcReplaceable(file);
    
    }


    public FileNode addChildNode(File file)
    {
    CollectionTreeNode child_node = new CollectionTreeNode(file);
    child_node.setModel(model);
    child_node.setParent(this);
    return child_node;
    }


    public boolean isExplodable()
    {
    return is_explodable;
    }

    // To work with replace_srcdoc_with_html.pl
    public boolean isSrcReplaceable()
    {
    return is_srcreplaceable;
    }

    /** This method returns a string representation of the filenodes in the 
    * <i>Collection</i> Tree, that can then be displayed in the tree. If the 
    * filename encoding is specified as metadata with the file, then this
    * method will apply that to the filename's bytes to get the displayName.
    */
    protected String calcDisplayString() {      
        // metadata.xml files in collections don't get displayed anyway
        if(file.getName().equals("metadata.xml")) { 
            return super.calcDisplayString();
        }
        
        if(!FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED) {
            return super.calcDisplayString();
        }

        // Else: try to encode the display string from the 
        // file_to_encoding map. If that fails, just use the locale 
        String displayName = null;
        String urlEncodedPath = getURLEncodedFilePath();
        String encoding = FilenameEncoding.findFilenameEncoding(file, urlEncodedPath, false);

        // if it isn't the same as the current encoding already applied, reapply
        // it which will set the filenameEncoding again as well
        if(!encoding.equals(getFilenameEncoding())) {
            displayName = reencodeDisplayName(encoding); // may return null
        }
        
        if(displayName == null) {
            if(FilenameEncoding.DEBUGGING) {
                displayName = getURLEncodedFileName(); 
            } else {
                displayName = super.calcDisplayString();
            }
        }
        
        return displayName;
    }

    /** Call this if the filename encoding has changed and needs to be 
    * recalculated and re-applied to the filename. This is only for display,
    * so it only gets applied to the urlEncodedFileName (not urlEncodedFilePath). 
    * Note that the filenameEncoding may not be the same as the given encoding
    * at the end of this method (in case it was a charset alias of the encoding). 
    * This method both sets and returns the displayFileName member variable. 
    * @return the reencoded display name, if the encoding was a recognised alias
    * in which case the filenameEncoding will store the canonical name.  */
    public String reencodeDisplayName(String encoding) {
        if(!FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED) {
            return displayFileName; // may still be null
        }

        filenameEncoding = encoding; // clear previous value

        if(filenameEncoding.equals("")) {
            displayFileName = super.calcDisplayString(); // *FileNode* calcDisplayString
            return displayFileName;
        }

        try{
            displayFileName = new String(file.getName().getBytes(), filenameEncoding);
        } catch(Exception e) { 
            // IllegalCharsetName-, UnsupportedCharset- or UnsupportedEncoding-Exception
            // Store the unsupported encoding, but display with filesystem (or URL) encoding
            filenameEncoding = encoding;
            
            if(FilenameEncoding.DEBUGGING) {
                displayFileName = getURLEncodedFileName();
            } else {
                displayFileName = super.calcDisplayString(); 
            }
        } 
        return displayFileName;
    }
        
    /** Can call this upon refreshing a FileNode (this CollectionTreeNode). It makes
    * sure the display names of the visible nodes in the CollectionTree aren't stale */
    public void refreshDescendantEncodings() {
        // now recalculate encodings for all visible children
        
        // Don't bother with the encoding stuff when multiple filename encodings 
        // are not supported because the system is UTF-8 (not Native-Latin-1) and 
        // Java interprets all filename bytes as UTF-8, which destructively 
        // converts unrecognised characters (for UTF-8) into the invalid character. 

        if(!FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED 
                || child_nodes == null) 
        {
            return;
        }       
        
        // get and apply the filename encoding, if any
        for(int i = 0; i < child_nodes.size(); i++) {
            CollectionTreeNode child_node = (CollectionTreeNode) child_nodes.get(i);            
            String urlEncodedPath = child_node.getURLEncodedFilePath();     
            
            String encoding = FilenameEncoding.findFilenameEncoding(
                    child_node.getFile(), urlEncodedPath, false);
            
            // if current encoding is different from the existing one, re-apply encoding
            if(!child_node.getFilenameEncoding().equals(encoding)) {
            child_node.reencodeDisplayName(encoding);
            }
        }
    }
    
    // Unused at present
    /** Call when the filename encoding of this folder level fileNode has changed
    * and therefore the filename encodings of the descendant fileNodes have to be
    * reset (their entries in the file_to_encoding hashmap cleared), so that we know
    * to recalculate these later.  Call when deleting, moving or renaming col nodes */
    public void resetDescendantEncodings() {
        if(FilenameEncoding.MULTIPLE_FILENAME_ENCODINGS_SUPPORTED) {
            resetDescendantEncodings(this.file, this.getURLEncodedFilePath());
            
            // for an actual file/folder delete, want to remove all corresponding 
            // entries from the hashtable without recalculating any encodings 
            // (files have been deleted, so no there will be no filenames to display).
            // So don't do this here: refreshDescendantEncodings();
            // It's done near the end of FileNode.map().
        }
    }
    
    // Together with the above, unused at present
    private static void resetDescendantEncodings(File f, String urlEncodedPath) 
    {
        // remove this file f's urlencoded path name from the file_to_encoding Map
        FilenameEncoding.map.remove(urlEncodedPath);
            
        if(f.isDirectory()) {
            File[] children = f.listFiles();        
            for(int i = 0; i < children.length; i++) {
                urlEncodedPath = FilenameEncoding.fileToURLEncoding(children[i]);
                resetDescendantEncodings(children[i], urlEncodedPath); 
                        // sets filenameEncoding var
            }
        }
    }

}