source: trunk/gli/src/org/greenstone/gatherer/collection/CollectionManager.java@ 9095

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 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.
 *
 * <BR><BR>
 *
 * 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 java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.filechooser.FileSystemView;
import javax.swing.tree.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.LocalLibraryServer;
import org.greenstone.gatherer.ServletConfiguration;
import org.greenstone.gatherer.cdm.CollectionDesignManager;
import org.greenstone.gatherer.cdm.CollectionMeta;
import org.greenstone.gatherer.cdm.CollectionMetaManager;
import org.greenstone.gatherer.cdm.CommandTokenizer;
import org.greenstone.gatherer.gui.ExternalCollectionPrompt;
import org.greenstone.gatherer.gui.LockFileDialog;
import org.greenstone.gatherer.gui.ModalProgressPopup;
import org.greenstone.gatherer.gui.NewCollectionMetadataPrompt;
import org.greenstone.gatherer.gui.WarningDialog;
import org.greenstone.gatherer.metadata.DocXMLFileManager;
import org.greenstone.gatherer.metadata.MetadataSet;
import org.greenstone.gatherer.metadata.MetadataSetManager;
import org.greenstone.gatherer.metadata.MetadataXMLFileManager;
import org.greenstone.gatherer.metadata.ProfileXMLFileManager;
import org.greenstone.gatherer.shell.GShell;
import org.greenstone.gatherer.shell.GShellEvent;
import org.greenstone.gatherer.shell.GShellListener;
import org.greenstone.gatherer.shell.GShellProgressMonitor;
import org.greenstone.gatherer.util.ArrayTools;
import org.greenstone.gatherer.util.Codec;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.util.XMLTools;
import org.w3c.dom.*;

/** This class manages many aspects of the collection, from its creation via scripts, data access via methods and its importing and building into the final collection. It is also resposible for firing appropriate event when significant changes have occured within the collection, and for creating a new metadata set manager as necessary.
 * @author John Thompson
 * @version 2.3
 */
public class CollectionManager
    implements GShellListener {

    /** Are we currently in the process of building? */
    private boolean building = false;
    /** Are we currently in the process of importing? */
    private boolean importing = false;
    /** The objects listening for CollectionContentsChanged events. */
    private ArrayList collection_contents_changed_listeners = new ArrayList();
    /** The collection this manager is managing! */
    static private Collection collection = null;
    /** The collection_model. */
    private CollectionTreeModel collection_model = null;
    /** An inner class listener responsible for noting tree changes and resetting saved when they occur. */
    private FMTreeModelListener fm_tree_model_listener = null;
    /** The monitor resposible for parsing the build process. */
    private GShellProgressMonitor build_monitor = null;
    /** The monitor resposible for parsing the import process. */
    private GShellProgressMonitor import_monitor = null;

    /** The name of the standard lock file. */
    static final public String LOCK_FILE = "gli.lck";

    /** Used to indicate the source of the message is the file collection methods. */
    static final public int COLLECT   = 3;
    /** Used to indicate the source of the message is the building methods. */
    static final public int BUILDING  = 5;

    /** Constructor. */
    public CollectionManager() {
    // Initialisation.
    this.building = false;
    this.importing = false;
    this.collection = null;
    }


    public void addCollectionContentsChangedListener(CollectionContentsChangedListener listener)
    {
    collection_contents_changed_listeners.add(listener);
    }


    /** This method calls the builcol.pl scripts via a GShell so as to not lock up the processor.
     * @see org.greenstone.gatherer.Configuration
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.collection.Collection
     * @see org.greenstone.gatherer.gui.BuildOptions
     * @see org.greenstone.gatherer.shell.GShell
     * @see org.greenstone.gatherer.shell.GShellListener
     * @see org.greenstone.gatherer.shell.GShellProgressMonitor
     * @see org.greenstone.gatherer.util.Utility
     */
    private void buildCollection() {
    DebugStream.println("CollectionManager.buildCollection()");
    building = true;
    String lang = Configuration.getLanguage();
    String collect_dir = getCollectDirectory();

    String args[];
    if((Utility.isWindows()) && (!Gatherer.isGsdlRemote)) {
        args = new String[8];
        args[0] = Configuration.perl_path;
        args[1] = "-S";
        args[2] = Configuration.getScriptPath() + "buildcol.pl";
        args[3] = "-gli";
        args[4] = "-language";
        args[5] = lang;
        args[6] = "-collectdir";
        args[7] = collect_dir;
    }
    else {
        args = new String[6];
        args[0] = Configuration.getScriptPath() + "buildcol.pl";
        args[1] = "-gli";
        args[2] = "-language";
        args[3] = lang;
        args[4] = "-collectdir";
        args[5] = collect_dir;
    }
    args = ArrayTools.add(args, collection.build_options.getBuildValues());
    args = ArrayTools.add(args, collection.getName());
    GShell shell = new GShell(args, GShell.BUILD, BUILDING, this, build_monitor, GShell.GSHELL_BUILD);
    shell.addGShellListener(Gatherer.g_man.create_pane);
    shell.start();
    DebugStream.println("CollectionManager.buildCollection().return");
    }

    /** Used to determine whether the currently active collection has been built.
     * @return A boolean indicating the built status of the collection.
     */
    public boolean built() {
    if(collection != null) {
        // Determine if the collection has been built by looking for the build.cfg file
        File build_cfg_file = new File(getCollectionIndexDirectoryPath() + Utility.BUILD_CFG_FILENAME);
        return build_cfg_file.exists();
    }
    return false;
    }

    /** a test method to see if we can delete a directory/file - returns false is the file or any of the contents of a directory cannot be deleted */
    public boolean canDelete(File file) {
    if (!file.isDirectory()) {
        return file.canWrite();
    }
    File [] file_list = file.listFiles();
    for (int i=0; i<file_list.length; i++) {
        if (!canDelete(file_list[i])) {
        return false;
        }
    }
    return true;
    }
    /** Called to close the current collection and remove its lock file.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.collection.Collection
     * @see org.greenstone.gatherer.util.Utility
     */
    public void closeCollection() {
    DebugStream.println("Close collection: " + collection.getName());

    // Remove the lock on this file, then remove the collection.
    String collection_directory_path = getCollectionDirectoryPath(collection.getName());
    File lock_file = new File(collection_directory_path + LOCK_FILE);
    lock_file.delete();
    if (lock_file.exists()) {
        System.err.println("Warning: Lockfile was not successfully deleted.");
    }

    MetadataSetManager.clearMetadataSets();
    MetadataXMLFileManager.clearMetadataXMLFiles();
    DocXMLFileManager.clearDocXMLFiles();
    ProfileXMLFileManager.clearProfileXMLFile();

    collection = null;
    collection_model = null;
    Configuration.setCollectionConfiguration(null);
    Gatherer.refresh(Gatherer.COLLECTION_CLOSED);
    if (Gatherer.g_man != null) {
        Gatherer.g_man.updateUI();  // !!! Necessary?
    }
    }

    /** Method that is called whenever something has changed in the configuration of this collection. */
    public void configurationChanged() {
    if(collection != null) {
        collection.setSaved(false);
    }
    }

    public void convertToGS3Collection() {
    // Run the mkcol command.
    String command[];
    String collect_dir = getCollectDirectory();
    
    if((Utility.isWindows()) && (!Gatherer.isGsdlRemote)) {
        command = new String[6];
        command[0] = Configuration.perl_path;
        command[1] = "-S";
        command[2] = Configuration.getGS3ScriptPath() + "convert_coll_from_gs2.pl";
        command[3] = "-collectdir";
        command[4] = collect_dir;
        command[5] = collection.getName();
    } else {
        command = new String[4];
        command[0] = Configuration.getGS3ScriptPath() + "convert_coll_from_gs2.pl";
        command[1] = "-collectdir";
        command[2] = collect_dir;
        command[3] = collection.getName();
    }
    DebugStream.println("running command "+command);
    GShell process = new GShell(command, GShell.CONVERT, COLLECT, this, null, GShell.GSHELL_CONVERT);
    process.addGShellListener(this);
    process.run(); // Don't bother threading this... yet
       
    }

    /** When basing a new collection on an existing one, we need to copy 
     *  over some extra directories: images and macros  
     */
    private boolean copyExtraBaseCollStuff(File new_coll_dir, File base_coll_dir) {
    if (!new_coll_dir.isDirectory() || !base_coll_dir.isDirectory()) {
        return false;
    }
    DebugStream.println("Copying images and macros dirs from the base collection");
    try {
        // do the images dir
        File base_coll_images = new File(base_coll_dir, Utility.IMAGES_DIR);
        if (base_coll_images.isDirectory()) {
        // copy all the images over
        File new_coll_images = new File(new_coll_dir, Utility.IMAGES_DIR);
        new_coll_images.mkdirs();
        
        // copy the contents over
        Gatherer.f_man.getQueue().copyDirectoryContents(base_coll_images, new_coll_images, null);
        }
    }
    catch (Exception e) {
        DebugStream.println("Couldn't copy over the images dir from the base collection: "+e.toString());
    }
    try {
        // do the macros dir
        File base_coll_macros = new File(base_coll_dir, Utility.MACROS_DIR);
        if (base_coll_macros.isDirectory()) {
        // copy all the macros over
        File new_coll_macros = new File(new_coll_dir, Utility.MACROS_DIR);
        new_coll_macros.mkdirs();
        
        // copy the contents over
        Gatherer.f_man.getQueue().copyDirectoryContents(base_coll_macros, new_coll_macros, null);
        } 
    }
    catch (Exception e) {
        DebugStream.println("Couldn't copy over the macros dir from the base collection: "+e.toString());
    }
    return true;
    }

    /** Used to set the current collection to the given collection. Note that this call should -always- be proceeded by a ready call, and if the colection is ready and the saved flag is unset then the user should be prompted to save. Also note that this method creates yet another GShell to run buildcol.pl.
     * @param description a description of the collection as a String
     * @param email the email address of the author/maintainer as a String
     * @param name the short name of the collection, which will subsequently be used to refer to this particular collection, as a String
     * @param title the longer title of the collection as a String
     * @param base_collection_directory if the user has chosen to base their new collection on an existing one, this is the directory where this base collection can be found, as a File, otherwise its null
     * @param metadata_sets if the user has decided to select several metadata sets with which to initially populate the GLI then this is an ArrayList of metadata set file names, otherwise its null
     */
    public void createCollection(String description, String email, String name, String title, File base_collection_directory, ArrayList metadata_sets)
    {
    try {
        // first make sure that the collect directory exists
        File collect_dir = new File(getCollectDirectory());
        if (!collect_dir.exists()) {
        collect_dir.mkdirs();
        }

        // Create a progress monitor
        ProgressMonitor progress = new ProgressMonitor(Gatherer.g_man, Dictionary.get("CollectionManager.Creating_New"), "mkcol.pl", 0, 4);

        // Create the new collection.
        makeCollection(description, email, name, title);
        progress.setProgress(1);
        
        // *******************
        //check that this creation has worked - simply by checking for the existence of the collect.cfg file
        String collection_directory_path = getCollectionDirectoryPath(name);
        File config_file = new File(Utility.getConfigFile(collection_directory_path));
        if (!config_file.exists()) {
        // no point continuing
        DebugStream.println("The collection could not be created");
        progress.close();
        return;
        }
        
        // ACTIVE_DIR/log/
        File log_dir_temp = new File(Utility.getLogDir(collection_directory_path)+"temp.dat");
        File log_dir = log_dir_temp.getParentFile();
        log_dir.mkdirs();
        progress.setNote(Dictionary.get("CollectionManager.Log_Created"));

        // Make sure an import folder exists
        File import_directory = new File(Utility.getImportDir(collection_directory_path));
        if (!import_directory.exists()) {
        import_directory.mkdirs();
        }

        progress.setProgress(2);

        // Now create the collection object around the directory.
        collection = new Collection(new File(collection_directory_path, name + ".col"));

        MetadataSetManager.clearMetadataSets();
        MetadataXMLFileManager.clearMetadataXMLFiles();
        DocXMLFileManager.clearDocXMLFiles();

        // Import default metadata sets, if any
        for (int i = 0; metadata_sets != null && i < metadata_sets.size(); i++) {
        importMetadataSet((MetadataSet) metadata_sets.get(i));
        }

        ProfileXMLFileManager.loadProfileXMLFile(new File(collection_directory_path, Utility.META_DIR));

        // Before creating the CollectionDesignManager check if we are basing it upon some other collection
        if (base_collection_directory != null) {
        DebugStream.println("Basing new collection on existing one: " + base_collection_directory);
        collection.setBaseCollection(base_collection_directory.getAbsolutePath());
        // copy over other needed directories
        copyExtraBaseCollStuff(new File(collection_directory_path), base_collection_directory);
        // Try to import any existing metadata sets for this collection
        // Look in base_collection_directory/metadata and import any metadata sets found.
        File base_metadata_directory = new File(base_collection_directory, Utility.META_DIR);
        ArrayList base_metadata_sets = MetadataSetManager.listMetadataSets(base_metadata_directory);
        if (base_metadata_sets != null) {
            for (int i = 0; i < base_metadata_sets.size(); i++) {
            importMetadataSet((MetadataSet) base_metadata_sets.get(i));
            }
        }
        else {
            DebugStream.println("This base collection has no metadata directory.");
        }

        // If no sets were imported...
        if (MetadataSetManager.getMetadataSets().size() == 0) {
            // Prompt the user so that they can choose at least one initial metadata set. We're sneaky here and just create a ncm_prompt
            DebugStream.println("This collection has no metadata sets. Present the user with the metadata set selection prompt.");
            NewCollectionMetadataPrompt ncm_prompt = new NewCollectionMetadataPrompt();
            // If cancelled then they really do mean to start a collection with no metadata sets.
            if (!ncm_prompt.isCancelled()) {
            ArrayList initial_sets = ncm_prompt.getSets();
            for (int i = 0; initial_sets != null && i < initial_sets.size(); i++) {
                importMetadataSet((MetadataSet) initial_sets.get(i));
            }
            }
            ncm_prompt.dispose();
            ncm_prompt = null;
        }

        // Now we update our collect.cfg
        DebugStream.println("Copy and update collect.cfg from base collection.");
        updateCollectionCFG(new File(base_collection_directory, Utility.CONFIG_FILE), new File(collection_directory_path, Utility.CONFIG_FILE), description, email, title);
        }

        // Always import the extracted metadata set if we didn't already
        if (MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE) == null) {
        File extracted_metadata_set_file = new File(Utility.METADATA_DIR + Utility.EXTRACTED_METADATA_NAMESPACE + StaticStrings.METADATA_SET_EXTENSION);
        importMetadataSet(new MetadataSet(extracted_metadata_set_file));
        }

        collection.cdm = new CollectionDesignManager(new File(getCollectionConfigFilePath()));

        // Now that we have a CDM, update several settings, such as if we created this collection by basing it on another, set it as public automatically
        if (base_collection_directory != null) {
        // Update the creator and maintainer
        CollectionMeta creator_collectionmeta = new CollectionMeta(collection.cdm.collect_config.getCreator());
        creator_collectionmeta.setValue(email);
        creator_collectionmeta = null;
        CollectionMeta maintainer_collectionmeta = new CollectionMeta(collection.cdm.collect_config.getMaintainer());
        maintainer_collectionmeta.setValue(email);
        maintainer_collectionmeta = null;

        // Update the collection title
        CollectionMeta collection_name_collectionmeta = collection.cdm.collectionmeta_manager.getMetadatum(StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR);
        collection_name_collectionmeta.setValue(title);
        collection_name_collectionmeta = null;

        // And now the description
        CollectionMeta collection_extra_collectionmeta = collection.cdm.collectionmeta_manager.getMetadatum(StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR);
        collection_extra_collectionmeta.setValue(description);
        collection_extra_collectionmeta = null;

        // All collections based on others are automatically public
        CollectionMeta public_collectionmeta = new CollectionMeta(collection.cdm.collect_config.getPublic());
        public_collectionmeta.setValue(StaticStrings.TRUE_STR);
        public_collectionmeta = null;

        // Finally reset the icons
        CollectionMeta icon_collection_collectionmeta = collection.cdm.collectionmeta_manager.getMetadatum(StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR);
        icon_collection_collectionmeta.setValue(StaticStrings.EMPTY_STR);
        icon_collection_collectionmeta = null;
        CollectionMeta icon_collection_small_collectionmeta = collection.cdm.collectionmeta_manager.getMetadatum(StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR);
        icon_collection_small_collectionmeta.setValue(StaticStrings.EMPTY_STR);
        icon_collection_small_collectionmeta = null;
        }

        progress.setProgress(3);

        // Create a lock file
        createLockFile(new File(collection_directory_path, LOCK_FILE));

        progress.setProgress(4);
        progress.setNote(Dictionary.get("CollectionManager.Session_Ready", name));
        progress.close();
    }
    catch (Exception error) {
        DebugStream.printStackTrace(error);
    }
    }


    private void createLockFile(File lock_file)
    {
    try {
        Document default_lockfile = Utility.parse("xml/" + LOCK_FILE, true);
        String user_name = System.getProperty("user.name");
        Element person_element = (Element) XMLTools.getNodeFromNamed(default_lockfile.getDocumentElement(), "User");
        person_element.appendChild(default_lockfile.createTextNode(user_name));
        person_element = null;
        user_name = null;
        String machine_name = Utility.getMachineName();
        Element machine_element = (Element) XMLTools.getNodeFromNamed(default_lockfile.getDocumentElement(), "Machine");
        machine_element.appendChild(default_lockfile.createTextNode(machine_name));
        machine_element = null;
        machine_name = null;
        String date_time = Utility.getDateString();
        Element date_element = (Element) XMLTools.getNodeFromNamed(default_lockfile.getDocumentElement(), "Date");
        date_element.appendChild(default_lockfile.createTextNode(date_time));
        date_element = null;
        date_time = null;
        XMLTools.writeXMLFile(lock_file, default_lockfile);
    }
    catch (Exception exception) {
        DebugStream.printStackTrace(exception);
    }
    }


    public boolean deleteCollection(String collection_name)
    {
    return Utility.delete(new File(getCollectionDirectoryPath(collection_name)));
    }


    public void fireFileAddedToCollection(File file)
    {
    // Send the event off to all the CollectionContentsChangedListeners
    for (int i = 0; i < collection_contents_changed_listeners.size(); i++) {
        ((CollectionContentsChangedListener) collection_contents_changed_listeners.get(i)).fileAddedToCollection(file);
    }
    }


    /** Retrieve the current collection.
     * @return The <strong>Collection</strong> itself.
     */
    public Collection getCollection() {
    return collection;
    }


    /** Constructs the absolute filename of the collection's directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;"
     * @return A <strong>String</strong> containing the directory name.
     */
    static public String getCollectionDirectoryPath(String collection_name)
    {
    return Gatherer.getCollectDirectoryPath() + collection_name + File.separator;
    }


    /** Constructs the absolute filename of the collection's .col file, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/&lt;col_name&gt;.col"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionFilePath()
    {
    return getCollectionDirectoryPath(collection.getName()) + collection.getName() + ".col";
    }


    /** Constructs the absolute filename of the collection's archives directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/archives/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionArchivesDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "archives" + File.separator;
    }


    /** Constructs the absolute filename of the collection's building directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/building/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionBuildingDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "building" + File.separator;
    }


    /** Constructs the absolute filename of the collection's collect.cfg file, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/etc/collect.cfg"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionConfigFilePath()
    {
    return getCollectionEtcDirectoryPath() + "collect.cfg";
    }


    /** Constructs the absolute filename of the collection's etc directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/etc/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionEtcDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "etc" + File.separator;
    }


    /** Constructs the absolute filename of the collection's images directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/images/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionImagesDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "images" + File.separator;
    }


    /** Constructs the absolute filename of the collection's import directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/import/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionImportDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "import" + File.separator;
    }


    /** Constructs the absolute filename of the collection's index directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/index/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionIndexDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "index" + File.separator;
    }


    /** Constructs the absolute filename of the collection's log directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/log/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionLogDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "log" + File.separator;
    }


    /** Constructs the absolute filename of the collection's metadata directory, which should resemble "$GSDLHOME/collect/&lt;col_name&gt;/metadata/"
     * @return A <strong>String</strong> containing the filename.
     */
    public String getCollectionMetadataDirectoryPath()
    {
    return getCollectionDirectoryPath(collection.getName()) + "metadata" + File.separator;
    }


    /** Retrieve the tree model associated with the current collection. */
    public CollectionTreeModel getCollectionTreeModel()
    {
    if (collection_model == null && collection != null) {
        // Use the import directory to generate a new CollectionTreeModel
        collection_model = new CollectionTreeModel(new CollectionTreeNode(new File(getCollectionImportDirectoryPath())));
        // Ensure that the manager is a change listener for the tree.
        if (fm_tree_model_listener == null) {
        fm_tree_model_listener = new FMTreeModelListener();
        }
        collection_model.addTreeModelListener(fm_tree_model_listener);
    }
    return collection_model;
    }


    /** This method when called, creates a new GShell in order to run the import.pl script.
     * @see org.greenstone.gatherer.Configuration
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.gui.BuildOptions
     * @see org.greenstone.gatherer.shell.GShell
     * @see org.greenstone.gatherer.shell.GShellListener
     * @see org.greenstone.gatherer.shell.GShellProgressMonitor
     * @see org.greenstone.gatherer.util.Utility
     */
    public void importCollection() {
    importing = true;

    if (!saved()) {
        DebugStream.println("CollectionManager.importCollection().forcesave");
        import_monitor.saving();
        saveCollection();
    }

    DebugStream.println("CollectionManager.importCollection()");
    //check that we can remove the old index before starting import
    File index_dir = new File(getCollectionIndexDirectoryPath());
    if (index_dir.exists()) {
        DebugStream.println("Old Index = " + index_dir.getAbsolutePath()+", testing for deletability");
        if (!canDelete(index_dir)) {
        // tell the user
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Cannot_Delete_Index"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE); 
        // tell the gui manager
        // a message for the building log 
        GShellEvent event = new GShellEvent(this, 0, GShell.IMPORT, Dictionary.get("CollectionManager.Cannot_Delete_Index_Log"), GShell.ERROR);
        Gatherer.g_man.create_pane.message(event);
        event = new GShellEvent(this, 0, GShell.IMPORT, "", GShell.ERROR);
        Gatherer.g_man.create_pane.processComplete(event);
        importing = false;
        return;
        }
    }

    String collect_dir = getCollectDirectory();

    String args[];
    String lang = Configuration.getLanguage();
    if((Utility.isWindows()) && (!Gatherer.isGsdlRemote)) {
        args = new String[8];
        args[0] = Configuration.perl_path;
        args[1] = "-S";
        args[2] = Configuration.getScriptPath() + "import.pl";
        args[3] = "-gli";
        args[4] = "-language";
        args[5] = lang;
        args[6] = "-collectdir";
        args[7] = collect_dir;
    }
    else {
        args = new String[6];
        args[0] = Configuration.getScriptPath() + "import.pl";
        args[1] = "-gli";
        args[2] = "-language";
        args[3] = lang;
        args[4] = "-collectdir";
        args[5] = collect_dir;
    }
    collect_dir = null;
    args = ArrayTools.add(args, collection.build_options.getImportValues());
    args = ArrayTools.add(args, collection.getName());

    GShell shell = new GShell(args, GShell.IMPORT, BUILDING, this, import_monitor, GShell.GSHELL_IMPORT);
    shell.addGShellListener(Gatherer.g_man.create_pane);
    shell.start();
    DebugStream.println("CollectionManager.importCollection().return");

    importing = false;
    }


    public void importMetadataSet(MetadataSet external_metadata_set)
    {
    // Copy the .mds file into the collection's "metadata" folder...
    File external_metadata_set_file = external_metadata_set.getMetadataSetFile();

    // ...but not if it is the redundant "hidden.mds" file
    if (external_metadata_set_file.getName().equals("hidden.mds")) {
        return;
    }

    // ...and only if it doesn't already exist
    File metadata_set_file = new File(getCollectionMetadataDirectoryPath(), external_metadata_set_file.getName());
    if (!metadata_set_file.exists()) {
        try {
        Gatherer.f_man.getQueue().copyFile(external_metadata_set_file, metadata_set_file, null);
        }
        catch (Exception ex) {
        ex.printStackTrace();
        }

        // Load it into the MetadataSetManager
        MetadataSetManager.loadMetadataSet(metadata_set_file);
    }
    }


    /** Determine if we are currently in the middle of importing (and thus, in this case, we can't allow the log writer to exit). Boy was this a mission to track down. The cascade of crap rolls out something like this: Joe Schmo clicks 'Build Collection', which calls the importCollection() method above, which in turn saves the collection with a saveTask, which fires a collectionChanged message once its finished, which drives the list of logs shown on the create pane to update, which fires a itemChanged() event to the OptionsPane who dutifully tells the current log writer thread to finish up writing (all zero lines its been asked to write) and then die. Wereapon Joe Schmo gets a pretty log to look at, but it isn't actually being written to file so the next time he tries to view it faeces hits the air motion cooling device. Joy.
     * @return true if the gli is currently importing
     */
    public boolean isImporting() {
    return importing;
    }


    public void loadCollection(String collection_file_path)
    {
    ModalProgressPopup load_collection_progress_popup = new ModalProgressPopup(Dictionary.get("CollectionManager.Loading_Collection"));
    LoadCollectionTask load_collection_task = new LoadCollectionTask(collection_file_path, load_collection_progress_popup);
    load_collection_task.start();
    load_collection_progress_popup.display();  // Blocks, so must go *after* starting the task!
    }


    private class LoadCollectionTask
    extends Thread
    {
    private String collection_file_path = null;
    private ModalProgressPopup load_collection_progress_popup = null;

    public LoadCollectionTask(String collection_file_path, ModalProgressPopup load_collection_progress_popup)
    {
        this.collection_file_path = collection_file_path;
        this.load_collection_progress_popup = load_collection_progress_popup;
    }

    public void run()
    {
        loadCollectionInternal(collection_file_path);
        load_collection_progress_popup.setVisible(false);
    }
    }


    /** Attempts to load the given collection. Currently uses simple serialization of the collection class.
     * @param location The path to the collection as a <strong>String</strong>.
     * @see org.greenstone.gatherer.Configuration
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.collection.Collection
     * @see org.greenstone.gatherer.util.Utility
     */
    private void loadCollectionInternal(String location)
    {
    DebugStream.println("Loading collection " + location + "...");
    boolean non_gli_collection = false;

    // Check we have actually been given a .col file.
    if (!location.endsWith(".col")) {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Not_Col_File", location), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        DebugStream.println("CollectionManager.loadCollection: Haven't been given a .col file.");
        return;
    }

    // Check that there is the collection configuration file available
    File collection_file = new File(location);
    // Ensure that the directory exists.
    File collection_directory = collection_file.getParentFile();
    if (!collection_directory.exists()) {
        // we cant open this
        collection_directory = null;
        return;
    }
    File collection_config_file = new File(collection_directory, Utility.CONFIG_FILE);
    if (!collection_config_file.exists()) {
        DebugStream.println("CollectionManager.loadCollection: No config file");
        collection_directory = null;
        collection_config_file = null;
        return;
    }

    // Special case of a user trying to open an old greenstone collection.
    File collection_metadata_directory = new File(collection_directory, Utility.META_DIR);
    if (!collection_metadata_directory.exists()) {
        DebugStream.println("Loading non-gatherer collection...");
        non_gli_collection = true;
    }

    // Now determine if a lock already exists on this collection.
    String name = collection_directory.getName();
    File lock_file = new File(collection_file.getParentFile(), LOCK_FILE);
    if (lock_file.exists()) {
        LockFileDialog dialog = new LockFileDialog(Gatherer.g_man, name, lock_file);
        int choice = dialog.getChoice();
        dialog.dispose();
        dialog = null;

        if (choice != LockFileDialog.YES_OPTION) {
        // user has cancelled
        lock_file = null;
        collection_directory = null;
        collection_config_file = null;
        return;
        }

        lock_file.delete();
    }

    try {
        // Create a lock file.
        createLockFile(lock_file);
        // This lock file may not have been created so check
        if(!lock_file.canWrite()) {
        // The lock file cannot be written to. Most likely cause incorrect file permissions.
        System.err.println("Cannot write lock file!");
        String args[] = new String[2];
        args[0] = location;
        args[1] = Dictionary.get("FileActions.Write_Not_Permitted_Title");
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Cannot_Open_With_Reason", args), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        args = null;
        return;
        }

        // Open the collection file
        this.collection = new Collection(collection_file);
        if (collection.error) {
        collection = null;
        // Remove lock file
        if (lock_file.exists()) {
            lock_file.delete();
        }
        throw(new Exception(Dictionary.get("CollectionManager.Missing_Config"))); // this error message does not agree with the error
        }

        MetadataSetManager.clearMetadataSets();
        MetadataSetManager.loadMetadataSets(collection_metadata_directory);

        ProfileXMLFileManager.loadProfileXMLFile(collection_metadata_directory);
 
        // If this is a non-GLI (legacy) collection, ask the user to choose some metadata sets
        if (non_gli_collection) {
        if (!addSomeMetadataSets(collection_directory)) {
            lock_file = null;
            collection_directory = null;
            closeCollection();
            return;
        }

        // Recurse the import folder tree, backing up the metadata.xml files before they are edited
        LegacyCollectionImporter.backupMetadataXMLFiles(collection_directory);
        }

        // Read through the metadata.xml files in the import directory, building up the metadata value trees
        File collection_import_directory = new File(collection_directory, Utility.IMPORT_DIR);
        MetadataXMLFileManager.clearMetadataXMLFiles();
        MetadataXMLFileManager.loadMetadataXMLFiles(collection_import_directory);

        // Read through the doc.xml files in the archives directory
        File collection_archives_directory = new File(getCollectionArchivesDirectoryPath());
        DocXMLFileManager.clearDocXMLFiles();
        DocXMLFileManager.loadDocXMLFiles(collection_archives_directory);

        collection.cdm = new CollectionDesignManager(collection_config_file);
        if (non_gli_collection) {
        // Change the classifiers to use the namespaced element names
        LegacyCollectionImporter.updateClassifiers(collection.cdm);
        }

        // We're done. Let everyone know.
        DebugStream.println(Dictionary.get("CollectionManager.Loading_Successful", name));
        Gatherer.refresh(Gatherer.COLLECTION_OPENED);
    }
    catch (Exception error) {
        // There is obviously no existing collection present.
        DebugStream.printStackTrace(error);
        if(error.getMessage() != null) {
        String[] args = new String[2];
        args[0] = location;
        args[1] = error.getMessage();
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Cannot_Open_With_Reason", args), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        }
        else {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Cannot_Open", location), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        }
    }

    lock_file = null;
    collection_directory = null;
    collection_config_file = null;
    }


    private void makeCollection(String description, String email, String name, String title) {
    // Encode the description so it is safe to write to shell
    if(Utility.isWindows()) {
        description = Codec.transform(description, Codec.TEXT_TO_SHELL_WINDOWS);
    }
    else {
        description = Codec.transform(description, Codec.TEXT_TO_SHELL_UNIX);
    }
    String collect_dir = getCollectDirectory();
    // Run the mkcol command.
    String command[];
    if((Utility.isWindows()) && (!Gatherer.isGsdlRemote)) {
        if(description == null || title == null) {
        command = new String[8];
        command[0] = Configuration.perl_path;
        command[1] = "-S";
        command[2] = Configuration.getScriptPath() + "mkcol.pl";
        command[3] = "-collectdir";
        command[4] = collect_dir;
        command[5] = "-win31compat";
        command[6] = (Gatherer.isGsdlRemote) ? "false" : "true";
        command[7] = name;
        }
        // Users are no longer required to supply an email
        else if(email == null) {
        command = new String[12];
        command[0] = Configuration.perl_path;
        command[1] = "-S";
        command[2] = Configuration.getScriptPath() + "mkcol.pl";
        command[3] = "-collectdir";
        command[4] = collect_dir;
        command[5] = "-win31compat";
        command[6] = (Gatherer.isGsdlRemote) ? "false" : "true";
        command[7] = "-title";
        command[8] = title;
        command[9] = "-about";
        command[10] = description;
        command[11] = name;
        }
        else {
        command = new String[14];
        command[0] = Configuration.perl_path;
        command[1] = "-S";
        command[2] = Configuration.getScriptPath() + "mkcol.pl";
        command[3] = "-collectdir";
        command[4] = collect_dir;
        command[5] = "-win31compat";
        command[6] = (Gatherer.isGsdlRemote) ? "false" : "true";
        command[7] = "-title";
        command[8] = title;
        command[9] = "-creator";
        command[10] = email;
        command[11] = "-about";
        command[12] = description;
        command[13] = name;
        }
    }
    else {
        if(description == null || title == null) {
        command = new String[6];
        command[0] = "mkcol.pl";
        command[1] = "-collectdir";
        command[2] = collect_dir;
        command[3] = "-win31compat";
        command[4] = (Gatherer.isGsdlRemote) ? "false" : "true";
        command[5] = name;
        }
        else if(email == null) {
        command = new String[10];
        command[0] = "mkcol.pl";
        command[1] = "-collectdir";
        command[2] = collect_dir;
        command[3] = "-win31compat";
        command[4] = (Gatherer.isGsdlRemote) ? "false" : "true";
        command[5] = "-title";
        command[6] = title;
        command[7] = "-about";
        command[8] = description;
        command[9] = name;
        }
        else {
        command = new String[12];
        command[0] = "mkcol.pl";
        command[1] = "-collectdir";
        command[2] = collect_dir;
        command[3] = "-win31compat";
        command[4] = (Gatherer.isGsdlRemote) ? "false" : "true";
        command[5] = "-title";
        command[6] = title;
        command[7] = "-creator";
        command[8] = email;
        command[9] = "-about";
        command[10] = description;
        command[11] = name;
        }
    }
    GShell process = new GShell(command, GShell.NEW, COLLECT, this, null, GShell.GSHELL_NEW);
    process.run(); // Don't bother threading this... yet
    }

    /** Any implementation of GShellListener must include this method to allow the GShell to send messages to listeners. However in this case the CollectionManager is in no way interested in what the messages are, just the import events which have a specific type and are handled elsewhere. Thus we can safely ignore this event.
     * @param event A <strong>GShellEvent</strong> which contains a the message.
     */
    public synchronized void message(GShellEvent event) {
    }

    /** This call is fired whenever a process within a GShell created by this class begins.
     * @param event A <strong>GShellEvent</strong> containing information about the GShell process.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.gui.GUIManager
     * @see org.greenstone.gatherer.shell.GShell
     */
    public synchronized void processBegun(GShellEvent event) {
    DebugStream.println("CollectionManager.processBegun(" + event.getType() + ")");
    ///ystem.err.println("ProcessBegun " + event.getType());
    // If this is one of the types where we wish to lock user control
    Gatherer.g_man.lockCollection((event.getType() == GShell.IMPORT), true);
    }
    /** This call is fired whenever a process within a GShell created by this class ends.
     * @param event A <strong>GShellEvent</strong> containing information about the GShell process.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.gui.GUIManager
     * @see org.greenstone.gatherer.shell.GShell
     */
    public synchronized void processComplete(GShellEvent event) {
    DebugStream.println("CollectionManager.processComplete(" + event.getType() + ")");
    Gatherer.g_man.lockCollection((event.getType() == GShell.IMPORT), false);
    ///ystem.err.println("Recieved process complete event - " + event);
    // If we were running an import, now run a build.
    if(event.getType() == GShell.IMPORT && event.getStatus() == GShell.OK) {
        // Finish import.
        collection.setImported(true);
        buildCollection();
    }
    // If we were running a build, now is when we move files across.
    else if(event.getType() == GShell.BUILD && event.getStatus() == GShell.OK) {
        if(installCollection()) {
        // If we have a local library running then ask it to add our newly create collection
        if (LocalLibraryServer.isRunning() == true) {
            LocalLibraryServer.addCollection(collection.getName());
        }
        else if (Gatherer.GS3) {
            convertToGS3Collection();
            Gatherer.configGS3Server(Configuration.site_name, ServletConfiguration.ADD_COMMAND + collection.getName());
        }  

        // Fire a collection changed first to update the preview etc buttons
        Gatherer.refresh(Gatherer.COLLECTION_REBUILT);

        // Now display a message dialog saying its all built
        WarningDialog collection_built_warning_dialog = new WarningDialog("warning.CollectionBuilt", null, false);
        collection_built_warning_dialog.setMessageOnly(true); // Not a warning
        collection_built_warning_dialog.display();
        collection_built_warning_dialog.dispose();
        collection_built_warning_dialog = null;
        }
        else {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Preview_Ready_Failed"), Dictionary.get("CollectionManager.Preview_Ready_Title"), JOptionPane.ERROR_MESSAGE);
        Gatherer.refresh(Gatherer.COLLECTION_REBUILT);
        }
    }
    else if (event.getStatus() == GShell.CANCELLED) {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Build_Cancelled"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        Gatherer.g_man.repaint();
    }
    else if (event.getStatus() == GShell.ERROR) {
        DebugStream.println("There was an error in the gshell:"+ event.getMessage());
        if (event.getType() == GShell.NEW) {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Cannot_Create_Collection"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        } else {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CollectionManager.Preview_Ready_Failed"), Dictionary.get("CollectionManager.Preview_Ready_Title"), JOptionPane.ERROR_MESSAGE);
        Gatherer.refresh(Gatherer.COLLECTION_REBUILT);
        }
        
        Gatherer.g_man.repaint(); // It appears Java's own dialogs have the same not always painting correct area bug that I suffer from. Well I don't suffer from it personally, but my ModalDialog components do.
    }
    }


    /** Determine if the manager is ready for actions apon its collection.
     * @return A <i>boolean</i> which is <i>true</i> to indicate a collection has been loaded and thus the collection is ready for editing, <i>false</i> otherwise.
     */
    static public synchronized boolean ready() {
    if(collection != null) {
        return true;
    }
    else {
        return false;
    }
    }


    /** This method associates the collection build monitor with the build monitor created in CreatePane.
     * @param monitor A <strong>GShellProgressMonitor</strong> which we will use as the build monitor.
     */
    public void registerBuildMonitor(GShellProgressMonitor monitor) {
    build_monitor = monitor;
    }
    /** This method associates the collection import monitor with the import monitor created in CreatePane.
     * @param monitor A <strong>GShellProgressMonitor</strong> which we will use as the import monitor.
     */
    public void registerImportMonitor(GShellProgressMonitor monitor) {
    import_monitor = monitor;
    }


    public void removeCollectionContentsChangedListener(CollectionContentsChangedListener listener)
    {
    collection_contents_changed_listeners.remove(listener);
    }


    public void removeMetadataSet(MetadataSet metadata_set)
    {
    System.err.println("Removing metadata set...");

    // Delete the .mds file from the collection's "metadata" folder...
    File metadata_set_file = metadata_set.getMetadataSetFile();

    // ...but not if it is the "ex.mds" file
    if (metadata_set_file.getName().equals("ex.mds")) {
        return;
    }

    // ...and only if it exists
    if (metadata_set_file.exists()) {
        metadata_set_file.delete();

        // Unload it from the MetadataSetManager
        MetadataSetManager.unloadMetadataSet(metadata_set);
    }
    }


    /** Used to check whether all open collections have a 'saved' state.
     * @return A <i>boolean</i> which is <i>true</i> if the collection has been saved.
     * @see org.greenstone.gatherer.collection.Collection
     */
    public boolean saved() {
    boolean result = true;
    if(collection != null) {
        result = collection.getSaved();
    }
    return result;
    }


    /** Saves the currently loaded collection. */
    public void saveCollection()
    {
    DebugStream.println("Saving collection " + collection.getName() + "...");

    // Change cursor to hourglass
    Gatherer.g_man.wait(true);

    // Create a backup of the collection file, just in case anything goes wrong
    File collection_file = new File(getCollectionFilePath());
    if (collection_file.exists()) {
        File collection_file_backup = new File(collection_file.getAbsolutePath() + "~");
        if (!collection_file.renameTo(collection_file_backup)) {
        DebugStream.println("Error in CollectionManager.saveCollection(): could not create backup file.");
        }
        collection_file_backup.deleteOnExit();
    }

    // Write out the collection file
    collection.save();

    // Write out the collection configuration file
    Gatherer.g_man.design_pane.saveConfiguration();

    // Write hfiles for the loaded metadata elements into the collection "etc" directory
    MetadataSetManager.writeHierarchyFiles(new File(getCollectionEtcDirectoryPath()));

    // Change cursor back to normal
    Gatherer.g_man.wait(false);
    }


    /** I started giving the user the choice of using an existing meta set or creating a new one. The second option being so that they didn't have to add/merge/ignore each element, they could all be added automatically. However, I am not sure where the merge prompt gets called from, and it is not essential, so I am leaving it for now - it should be added back in and finished. [kjdon] */
    private boolean addSomeMetadataSets(File collection_dir) {


    ExternalCollectionPrompt external_prompt = new ExternalCollectionPrompt();
    int meta_choice = external_prompt.getMetadataChoice();
    boolean cancelled = external_prompt.isCancelled();
    if (cancelled) {
        return false;
    }

    // now we reuse the newcoll metadata prompt for the user to select metadata sets
    NewCollectionMetadataPrompt ncm_prompt = new NewCollectionMetadataPrompt(true);
    if (ncm_prompt.isCancelled()) {
        return false;
    }
    ArrayList metadata_sets = ncm_prompt.getSets();
    // Import default metadata sets if any.
    for(int i = 0; metadata_sets != null && i < metadata_sets.size(); i++) {
        importMetadataSet((MetadataSet) metadata_sets.get(i));
    }

    // Always import the extracted metadata set
    File extracted_metadata_set_file = new File(Utility.METADATA_DIR + Utility.EXTRACTED_METADATA_NAMESPACE + StaticStrings.METADATA_SET_EXTENSION);
    importMetadataSet(new MetadataSet(extracted_metadata_set_file));

    return true;
    }


    // used as arg in the perl scripts
    private String getCollectDirectory() {
    String collect_dir = Gatherer.getCollectDirectoryPath();

    // Remove erroneous file windows file separator as it causes problems when running import.pl
    if(collect_dir.length() > 2 && collect_dir.endsWith("\\")) {
        collect_dir = collect_dir.substring(0, collect_dir.length() - 1);
    }

    return collect_dir;
    }


    /** Install collection by moving its files from building to index after a successful build.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.util.Utility
     */
    private boolean installCollection()
    {
    DebugStream.println("Build complete. Moving files.");

    try {
        // Ensure that the local library has released this collection so we can delete the index directory
        if (LocalLibraryServer.isRunning() == true) {
        LocalLibraryServer.releaseCollection(collection.getName());
        }

        File index_dir = new File(getCollectionIndexDirectoryPath());
        DebugStream.println("Index = " + index_dir.getAbsolutePath());

        File building_dir = new File(getCollectionBuildingDirectoryPath());
        DebugStream.println("Building = " + building_dir.getAbsolutePath());

        // Get the build mode from the build options
        String build_mode = collection.build_options.getBuildValue("mode");

        // Special case for build mode "all": replace index dir with building dir
        if (build_mode == null || build_mode.equals(Dictionary.get("CreatePane.Mode_All"))) {
        // Remove the old index directory
        if (index_dir.exists()) {
            Utility.delete(index_dir);

            // Wait for a couple of seconds, just for luck
            wait(2000);

            // Check the delete worked
            if (index_dir.exists()) {
            throw new Exception("Index directory could not be removed.");
            }
        }

        // Move the building directory to become the new index directory
        if (building_dir.renameTo(index_dir) == false) {
            throw new Exception("Build directory could not be moved.");
        }
        }

        // Otherwise copy everything in the building dir into the index dir
        else {
        moveContentsInto(building_dir, index_dir);
        }
    }
    catch (Exception exception) {
        JOptionPane.showMessageDialog(Gatherer.g_man, "Exception detected during collection install.\nMost likely caused by Windows or Local Library holding locks on files:\n" + exception.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
        return false;
    }
    return true;
    }


    /** Moves all the files in one directory into another, overwriting existing files */
    private void moveContentsInto(File source_directory, File target_directory)
    {
    File[] source_files = source_directory.listFiles();
    for (int i = 0; i < source_files.length; i++) {
        File source_file = source_files[i];
        File target_file = new File(target_directory, source_file.getName());

        if (source_file.isDirectory()) {
        moveContentsInto(source_file, target_file);
        source_file.delete();
        }
        else {
        if (target_file.exists()) {
            target_file.delete();
        }

        source_file.renameTo(target_file);
        }
    }
    }


    private void updateCollectionCFG(File base_cfg, File new_cfg, String description, String email, String title)
    {
    boolean first_name = true;
    boolean first_extra = true;
    String collection_path = (base_cfg.getParentFile().getParentFile()).getAbsolutePath();

    // Now read in base_cfg line by line, parsing important onces and/or replacing them with information pertinent to our collection. Each line is then written back out to the new collect.cfg file.
    try {
        BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(base_cfg), "UTF-8"));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new_cfg), "UTF-8"));
        String command = null;
        while((command = in.readLine()) != null) {
        if (command.length()==0) {
            // output a new line
            out.newLine();
            continue;
        }
        // We have to test the end of command for the special character '\'. If found, remove it and append the next line, then repeat.
        while(command.trim().endsWith("\\")) {
            command = command.substring(0, command.lastIndexOf("\\"));
            String next_line = in.readLine();
            if(next_line != null) {
            command = command + next_line;
            }
        }
        // commands can extend over more than one line so use the CommandTokenizer which takes care of that
        CommandTokenizer tokenizer = new CommandTokenizer(command, in, false);
        String command_type_str = tokenizer.nextToken().toLowerCase();

        if (command_type_str.equals(StaticStrings.COLLECTIONMETADATA_STR)) {
            // read the whole thing in, but for collectionname, collectionextra, iconcollection, iconcollectionsmall we will ignore them
            StringBuffer new_command = new StringBuffer(command_type_str);
            String meta_name = tokenizer.nextToken();
            new_command.append(' ');
            new_command.append(meta_name);
            while (tokenizer.hasMoreTokens()) {
            new_command.append(' ');
            new_command.append(tokenizer.nextToken());
            }
            if (meta_name.equals(StaticStrings.COLLECTIONMETADATA_COLLECTIONNAME_STR) || meta_name.equals(StaticStrings.COLLECTIONMETADATA_COLLECTIONEXTRA_STR) || meta_name.equals(StaticStrings.COLLECTIONMETADATA_ICONCOLLECTION_STR) || meta_name.equals(StaticStrings.COLLECTIONMETADATA_ICONCOLLECTIONSMALL_STR)) {
            // dont save
            } else {
            write(out, new_command.toString());
            }
            new_command = null;
            continue;
        } // if collectionmeta

        if(command_type_str.equals(Utility.CFG_CLASSIFY)) {
            StringBuffer text = new StringBuffer(command_type_str);
            // Read in the classifier command watching for hfile, metadata and sort arguments.
            String buttonname = null;
            String hfile = null;
            String new_metadata = null;
            String old_metadata = null;
        
            while(tokenizer.hasMoreTokens()) {
            String token = tokenizer.nextToken();
            if(token.equals(Utility.CFG_CLASSIFY_HFILE)) {
                if(tokenizer.hasMoreTokens()) {
                text.append(" ");
                text.append(token);
                token = tokenizer.nextToken();
                hfile = token;
                }
            }
            else if(token.equals(Utility.CFG_CLASSIFY_METADATA)) {
                if(tokenizer.hasMoreTokens()) {
                text.append(" ");
                text.append(token);
                String temp_metadata = tokenizer.nextToken();
                String replacement = ProfileXMLFileManager.getMetadataElementFor(temp_metadata);
                if (replacement != null && !replacement.equals("")) {
                    token = replacement;
                    old_metadata = temp_metadata;
                    new_metadata = replacement;
                }
                else {
                    token = temp_metadata;
                }
                temp_metadata = null;
                replacement = null;
                }
            }
            else if(token.equals(Utility.CFG_CLASSIFY_SORT)) {
                if(tokenizer.hasMoreTokens()) {
                text.append(" ");
                text.append(token);
                String temp_metadata = tokenizer.nextToken();
                String replacement = ProfileXMLFileManager.getMetadataElementFor(temp_metadata);
                if (replacement != null && !replacement.equals("")) {
                    token = replacement;
                }
                else {
                    token = temp_metadata;
                }
                temp_metadata = null;
                replacement = null;
                }
            }
            else if(token.equals(Utility.CFG_CLASSIFY_BUTTONNAME)) {
                buttonname = token;
            }
            text.append(' ');
            text.append(token);
            token = null;
            }
           
            // If we replaced the metadata argument and didn't encounter a buttonname, then add one now pointing back to the old metadata name in order to accomodate macro files which required such names (buttonname is metadata name by default)!
            if(old_metadata != null && new_metadata != null && buttonname == null) {
            text.append(' ');
            text.append(Utility.CFG_CLASSIFY_BUTTONNAME);
            text.append(' ');
            text.append(old_metadata);
            }
            command = text.toString();
            // Replace the hfile if we found it
            if(hfile != null && new_metadata != null) {
            command = command.replaceAll(hfile, new_metadata + ".txt");
            }
        
            buttonname = null;
            hfile = null;
            new_metadata = null;
            old_metadata = null;
            write(out, command);
        } else {
            // the rest of the commands just want a string - we read in all the tokens from the tokeniser and get rid of it.
            StringBuffer new_command = new StringBuffer(command_type_str);
            while (tokenizer.hasMoreTokens()) {
            new_command.append(' ');
            new_command.append(tokenizer.nextToken());
            }

            command = new_command.toString();
            
            // There is still one special case, that of the format command. In such a command we have to search for [<target>] to ensure we don't change parts of the format which have nothing to do with the metadata elements.
            // we really want to build up the whole command here
            boolean format_command = command_type_str.equals(Utility.CFG_FORMAT);
            HashMap metadata_mapping = ProfileXMLFileManager.getMetadataMapping();
            if (metadata_mapping != null) {
            Iterator keys = metadata_mapping.keySet().iterator();
            while (keys.hasNext()) {
                String target = (String) keys.next();
                String replacement = (String) metadata_mapping.get(target);
                if (replacement != null && !replacement.equals("")) {
                if (format_command) {
                    target = "\\[" + target + "\\]";
                    replacement = "{Or}{[" + replacement + "]," + target + "}";
                }
                command = command.replaceAll(target, replacement);
                }
            }
            }

            write(out, command);
        }
        tokenizer = null;
        }
        in.close();
        in = null;
        out.flush();
        out.close();
        out = null;
    }
    catch(Exception error) {
        DebugStream.printStackTrace(error);
    }
    // All done, I hope.
    }
    
    private void write(BufferedWriter out, String message)
    throws Exception {
    out.write(message, 0, message.length());
    out.newLine();
    }


    /** The CollectionManager class is getting too confusing by half so I'll implement this TreeModelListener in a private class to make responsibility clear. */
    private class FMTreeModelListener
    implements TreeModelListener {
    /** Any action that changes one of the tree models within a collection, which are the only models we listen to, mean the collections contents have changed and so saved should be set to false.
     * @param event A <strong>TreeModelEvent</strong> encompassing all the information about the event which has changed the tree.
     */
    public void treeNodesChanged(TreeModelEvent event) {
        if(collection != null) {
        collection.setSaved(false);
        }
    }
    /** Any action that changes one of the tree models within a collection, which are the only models we listen to, mean the collections contents have changed and so saved should be set to false.
     * @param event A <strong>TreeModelEvent</strong> encompassing all the information about the event which has changed the tree.
     */
    public void treeNodesInserted(TreeModelEvent event) {
        if(collection != null) {
        collection.setSaved(false);
        }
    }
    /** Any action that changes one of the tree models within a collection, which are the only models we listen to, mean the collections contents have changed and so saved should be set to false.
     * @param event A <strong>TreeModelEvent</strong> encompassing all the information about the event which has changed the tree.
     */
    public void treeNodesRemoved(TreeModelEvent event) {
        if(collection != null) {
        collection.setSaved(false);
        }
    }
    /** Any action that changes one of the tree models within a collection, which are the only models we listen to, mean the collections contents have changed and so saved should be set to false.
     * @param event A <strong>TreeModelEvent</strong> encompassing all the information about the event which has changed the tree.
     */
    public void treeStructureChanged(TreeModelEvent event) {
        if(collection != null) {
        collection.setSaved(false);
        }
    }
    }
}