Changeset 6051 for trunk/gli/src/org/greenstone/gatherer/cdm

Timestamp:

2003-11-30T21:43:23+13:00 (21 years ago)

Author:

jmt12

Message:

Here is the result of sixteen hours work over the weekend. I'm too tired to comment them all separately, but here are some of the highlights:
Rewrote how the 'base on collection' method actually retrieves and updates the collection configuration - ensuring the CDM.CollectionConfiguration class is used instead of the retarded Collection.CollectionConfiguration (which coincidently has had a name change to BasicCollectionConfiguration). Went through code search for places where the two versions had been confused. Rewrote large swathes of GDMDocument so as to differentiate between normal and extracted metadata - an attempt to prevent the snowballing extracted metadata problem. Fixed problem where GLI was correctly recieving the last few lines of an external process. The collection shortname is no longer visible, nor is the confusing double name for metadata elements. Also coloured folders in the trees are kaput. The users email is now saved as part of the GLI configuration and is used as appropriate to fill out collection fields. There are new options on the right click menus over trees to allow the expansion and collapsing of folders. 'Show Files' now shows all types (or at least 6 types) of image properly (arg, the plagues of copy and paste). 'Based On' collections are public, plugin list automatically moves to next entry if plugin removed (I guess we should do the same in every other screen?) and metadata arguments in plugins/classifiers are no longer editable. There are about a dozen other small things, but I can't remember them. Hope I remembered to set all of the files to UNIX line-endings.

Location:

trunk/gli/src/org/greenstone/gatherer/cdm

Files:

• ArgumentConfiguration.java (modified) (1 diff)
• CollectionConfiguration.java (modified) (42 diffs)
• CollectionDesignManager.java (modified) (7 diffs)
• CommandTokenizer.java (modified) (2 diffs)
• GeneralManager.java (modified) (7 diffs)
• IndexManager.java (modified) (21 diffs)
• MetadataSetView.java (modified) (2 diffs)
• PlugInManager.java (modified) (1 diff)
• SearchTypeManager.java (modified) (9 diffs)
• SuperCollectionManager.java (modified) (7 diffs)

trunk/gli/src/org/greenstone/gatherer/cdm/ArgumentConfiguration.java

@@ -400 +400 @@
         case Argument.METADATUM:
         value = new JComboBox(Gatherer.c_man.getCollection().msm.getAssignedElements());
-        ((JComboBox)value).setEditable(true);
+        //((JComboBox)value).setEditable(true);
         // Now ensure we have the existing value or default value selected if either exist.
         if(existing_value != null) {

trunk/gli/src/org/greenstone/gatherer/cdm/CollectionConfiguration.java

@@ -46 +46 @@
  */
 public class CollectionConfiguration
-    extends StaticStrings {
-
-    static public Document document;
-
-    static public void main(String[] args) {
+    extends StaticStrings {
+
+    static public Document document;
+
+    static public void main(String[] args) {
     if(args.length >= 1) {
-        File file = new File(args[0]);
-        CollectionConfiguration collect_cfg = new CollectionConfiguration(file);
-        collect_cfg.save(true);
-        collect_cfg.save(false);
-        collect_cfg = null;
+        File file = new File(args[0]);
+        CollectionConfiguration collect_cfg = new CollectionConfiguration(file);
+        collect_cfg.save(true);
+        collect_cfg.save(false);
+        collect_cfg = null;
     }
     else {
-        System.out.println("Usage: CollectionConfiguration <filename>");
-    }
-    }
-
-    /** Find the best insertion position for the given DOM Element. This should try to match command tag, and if found should then try to group by name or type (eg CollectionMeta), or append to end is no such grouping exists (eg PlugIns). Failing a command match it will check against the command order for the best insertion location.
-     * @param element the command Element to be inserted
-     * @return the Element which the given command should be inserted before, or null to append to end of list
-     */
-    static public Node findInsertionPoint(Element target_element) {
+        System.out.println("Usage: CollectionConfiguration <filename>");
+    }
+    }
+
+    /** Find the best insertion position for the given DOM Element. This should try to match command tag, and if found should then try to group by name or type (eg CollectionMeta), or append to end is no such grouping exists (eg PlugIns). Failing a command match it will check against the command order for the best insertion location.
+     * @param element the command Element to be inserted
+     * @return the Element which the given command should be inserted before, or null to append to end of list
+     */
+    static public Node findInsertionPoint(Element target_element) {
     ///ystem.err.println("Find insertion point: " + target_element.getNodeName());
     String target_element_name = target_element.getNodeName();
@@ -75 +75 @@
     // If we found matching elements, then we have our most likely insertion location, so check within for groupings
     if(matching_elements.getLength() != 0) {
-        ///ystem.err.println("Found matching elements.");
-        // Only CollectionMeta are grouped.
-        if(target_element_name.equals(COLLECTIONMETADATA_ELEMENT)) {
+        ///ystem.err.println("Found matching elements.");
+        // Only CollectionMeta are grouped.
+        if(target_element_name.equals(COLLECTIONMETADATA_ELEMENT)) {
         ///ystem.err.println("Dealing with collection metadata");
         // Special case: CollectionMeta can be added at either the start or end of a collection configuration file. However the start position is reserved for special metadata, so if no non-special metadata can be found we must append to the end.
         // So if the command to be added is special add it immediately after any other special command
         if(target_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
-            int index = 0;
-            Element matched_element = (Element) matching_elements.item(index);
-            Element sibling_element = (Element) matched_element.getNextSibling();
-            while(sibling_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
+            int index = 0;
+            Element matched_element = (Element) matching_elements.item(index);
+            Element sibling_element = (Element) matched_element.getNextSibling();
+            while(sibling_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
             index++;
             matched_element = (Element) matching_elements.item(index);
             sibling_element = (Element) matched_element.getNextSibling();
-            }
-            if(sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) {
+            }
+            if(sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) {
             Element newline_element = document.createElement(NEWLINE_ELEMENT);
             document_element.insertBefore(newline_element, sibling_element);
-            }
-            return sibling_element;
+            }
+            return sibling_element;
         }
         // Otherwise try to find a matching 'name' and add after the last one in that group.
         else {
-            int index = 0;
-            target_element_name = target_element.getAttribute(NAME_ATTRIBUTE);
-            boolean found = false;
-            // Skip all of the special metadata
-            Element matched_element = (Element) matching_elements.item(index);
-            while(matched_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
+            int index = 0;
+            target_element_name = target_element.getAttribute(NAME_ATTRIBUTE);
+            boolean found = false;
+            // Skip all of the special metadata
+            Element matched_element = (Element) matching_elements.item(index);
+            while(matched_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
             index++;
             matched_element = (Element) matching_elements.item(index);
-            }
-            // Begin search
-            while(!found && matched_element != null) {
+            }
+            // Begin search
+            while(!found && matched_element != null) {
             if(matched_element.getAttribute(NAME_ATTRIBUTE).equals(target_element_name)) {
-                found = true;
+                found = true;
             }
             else {
-                index++;
-                matched_element = (Element) matching_elements.item(index);
-            }
-            }
-            // If we found a match, we need to continue checking until we find the last name match.
-            if(found) {
+                index++;
+                matched_element = (Element) matching_elements.item(index);
+            }
+            }
+            // If we found a match, we need to continue checking until we find the last name match.
+            if(found) {
             index++;
             Element previous_sibling = matched_element;
             Element sibling_element = (Element) matching_elements.item(index);
             while(sibling_element != null && sibling_element.getAttribute(NAME_ATTRIBUTE).equals(target_element_name)) {
-                previous_sibling = sibling_element;
-                index++;
-                sibling_element = (Element) matching_elements.item(index);
+                previous_sibling = sibling_element;
+                index++;
+                sibling_element = (Element) matching_elements.item(index);
             }
             // Previous sibling now holds the command immediately before where we want to add, so find its next sibling and add to that. In this one case we can ignore new lines!
             return previous_sibling.getNextSibling();
-            }
-            // If not found we just add after last metadata element
-            else {
+            }
+            // If not found we just add after last metadata element
+            else {
             Element last_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
             return last_element.getNextSibling();
-            }
-        }
-
-        }
-        else {
+            }
+        }
+
+        }
+        else {
         ///ystem.err.println("Not dealing with collection meta.");
         Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
@@ -144 +144 @@
         Node sibling_element = matched_element.getNextSibling();
         if(sibling_element != null && sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) {
-            Element newline_element = document.createElement(NEWLINE_ELEMENT);
-            document_element.insertBefore(newline_element, sibling_element);
+            Element newline_element = document.createElement(NEWLINE_ELEMENT);
+            document_element.insertBefore(newline_element, sibling_element);
         }
         return sibling_element; // Note that this may be null
-        }
+        }
     }
     ///ystem.err.println("No matching elements found.");
@@ -154 +154 @@
     int command_index = -1;
     for(int i = 0; command_index == -1 && i < COMMAND_ORDER.length; i++) {
-        if(COMMAND_ORDER[i].equals(target_element_name)) {
+        if(COMMAND_ORDER[i].equals(target_element_name)) {
         command_index = i;
-        }
+        }
     }
     ///ystem.err.println("Command index is: " + command_index);
@@ -163 +163 @@
     ///ystem.err.println("Searching before the target command.");
     while(preceeding_index >= 0) {
-        matching_elements = document_element.getElementsByTagName(COMMAND_ORDER[preceeding_index]);
-        // If we've found a match
-        if(matching_elements.getLength() > 0) {
+        matching_elements = document_element.getElementsByTagName(COMMAND_ORDER[preceeding_index]);
+        // If we've found a match
+        if(matching_elements.getLength() > 0) {
         // We add after the last element
         Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1);
@@ -171 +171 @@
         Node sibling_element = matched_element.getNextSibling();
         if(sibling_element != null && sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) {
-            Element newline_element = document.createElement(NEWLINE_ELEMENT);
-            document_element.insertBefore(newline_element, sibling_element);
+            Element newline_element = document.createElement(NEWLINE_ELEMENT);
+            document_element.insertBefore(newline_element, sibling_element);
         }
         return sibling_element; // Note that this may be null
-        }
-        preceeding_index--;
+        }
+        preceeding_index--;
     }
     // If all that fails, we now move backwards through the commands
@@ -182 +182 @@
     ///ystem.err.println("Searching after the target command.");
     while(susceeding_index < COMMAND_ORDER.length) {
-        matching_elements = document_element.getElementsByTagName(COMMAND_ORDER[susceeding_index]);
-        // If we've found a match
-        if(matching_elements.getLength() > 0) {
+        matching_elements = document_element.getElementsByTagName(COMMAND_ORDER[susceeding_index]);
+        // If we've found a match
+        if(matching_elements.getLength() > 0) {
         // We add before the first element
         Element matched_element = (Element) matching_elements.item(0);
@@ -190 +190 @@
         Node sibling_element = matched_element.getPreviousSibling();
         if(sibling_element != null && sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) {
-            Element newline_element = document.createElement(NEWLINE_ELEMENT);
-            document_element.insertBefore(newline_element, sibling_element);
+            Element newline_element = document.createElement(NEWLINE_ELEMENT);
+            document_element.insertBefore(newline_element, sibling_element);
         }
         return sibling_element; // Note that this may be null
-        }
-        susceeding_index++;
+        }
+        susceeding_index++;
     }
     // Well. Apparently there are no other commands in this collection configuration. So append away...
     return null;
-    }
-
-    static public String toString(Element command_element, boolean show_extracted_namespace) {
+    }
+
+    static public String toString(Element command_element, boolean show_extracted_namespace) {
     String command_element_name = command_element.getNodeName();
     if(command_element_name.equals(CLASSIFY_ELEMENT)) {
-        return self.classifyToString(command_element, show_extracted_namespace);
+        return self.classifyToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(FORMAT_ELEMENT)) {
-        return self.formatToString(command_element, show_extracted_namespace);
+        return self.formatToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(INDEXES_ELEMENT)) {
-        return self.indexesToString(command_element, show_extracted_namespace);
+        return self.indexesToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(INDEX_DEFAULT_ELEMENT)) {
-        return self.indexDefaultToString(command_element, show_extracted_namespace);
+        return self.indexDefaultToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(LANGUAGES_ELEMENT)) {
-        return self.languagesToString(command_element);
+        return self.languagesToString(command_element);
     }
     else if(command_element_name.equals(LANGUAGE_DEFAULT_ELEMENT)) {
-        return self.languageDefaultToString(command_element);
+        return self.languageDefaultToString(command_element);
     }
     else if(command_element_name.equals(LEVELS_ELEMENT)) {
-        return self.levelsToString(command_element);
+        return self.levelsToString(command_element);
     }
     else if(command_element_name.equals(COLLECTIONMETADATA_ELEMENT)) {
-        return self.metadataToString(command_element, show_extracted_namespace);
+        return self.metadataToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(COLLECTIONMETADATA_CREATOR_ELEMENT)) {
-        return self.metadataToString(command_element, show_extracted_namespace);
+        return self.metadataToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(COLLECTIONMETADATA_MAINTAINER_ELEMENT)) {
-        return self.metadataToString(command_element, show_extracted_namespace);
+        return self.metadataToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(COLLECTIONMETADATA_PUBLIC_ELEMENT)) {
-        return self.metadataToString(command_element, show_extracted_namespace);
+        return self.metadataToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(COLLECTIONMETADATA_BETA_ELEMENT)) {
-        return self.metadataToString(command_element, show_extracted_namespace);
+        return self.metadataToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(PLUGIN_ELEMENT)) {
-        return self.pluginToString(command_element, show_extracted_namespace);
+        return self.pluginToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(SEARCHTYPE_ELEMENT)) {
-        return self.searchtypeToString(command_element);
+        return self.searchtypeToString(command_element);
     }
     else if(command_element_name.equals(SUBCOLLECTION_ELEMENT)) {
-        return self.subcollectionToString(command_element, show_extracted_namespace);
+        return self.subcollectionToString(command_element, show_extracted_namespace);
     }
     else if(command_element_name.equals(SUBCOLLECTION_DEFAULT_INDEX_ELEMENT)) {
-        return self.subcollectionDefaultIndexToString(command_element);
+        return self.subcollectionDefaultIndexToString(command_element);
     }
     else if(command_element_name.equals(SUBCOLLECTION_INDEXES_ELEMENT)) {
-        return self.subcollectionIndexesToString(command_element);
+        return self.subcollectionIndexesToString(command_element);
     }
     else if(command_element_name.equals(SUPERCOLLECTION_ELEMENT)) {
-        return self.supercollectionToString(command_element);
+        return self.supercollectionToString(command_element);
     }
     else if(command_element_name.equals(UNKNOWN_ELEMENT)) {
-        return self.unknownToString(command_element);
+        return self.unknownToString(command_element);
     }
     return "";
-    }
-
-    /** Parses arguments from a tokenizer and returns a HashMap of mappings. The tricky bit here is that not all entries in the HashMap are name->value pairs, as some arguments are boolean and are turned on by their presence. Arguments are denoted by a '-' prefix.
-     * @param tokenizer a CommandTokenizer based on the unconsumed portion of a command string
-     * @return a HashMap containing the arguments parsed
-     */
-    static public HashMap parseArguments(CommandTokenizer tokenizer) {
+    }
+
+    /** Parses arguments from a tokenizer and returns a HashMap of mappings. The tricky bit here is that not all entries in the HashMap are name->value pairs, as some arguments are boolean and are turned on by their presence. Arguments are denoted by a '-' prefix.
+     * @param tokenizer a CommandTokenizer based on the unconsumed portion of a command string
+     * @return a HashMap containing the arguments parsed
+     */
+    static public HashMap parseArguments(CommandTokenizer tokenizer) {
     HashMap arguments = new HashMap();
     String name = null;
     String value = null;
     while(tokenizer.hasMoreTokens() || name != null) {
-        // First we retrieve a name if we need one.
-        if(name == null) {
+        // First we retrieve a name if we need one.
+        if(name == null) {
         name = tokenizer.nextToken();
-        }
-        // Now we attempt to retrieve a value
-        if(tokenizer.hasMoreTokens()) {
+        }
+        // Now we attempt to retrieve a value
+        if(tokenizer.hasMoreTokens()) {
         value = tokenizer.nextToken();
         // Test if the value is actually a name, and if so add the name by itself, then put value into name so that it is parsed correctly during the next loop.
         if(value.startsWith(StaticStrings.MINUS_CHARACTER)) {
-            arguments.put(name, null);
-            name = value;
+            arguments.put(name, null);
+            name = value;
         }
         // Otherwise we have a typical name->value pair ready to go
         else {
-            arguments.put(name, value);
-            name = null;
-        }
-        }
-        // Otherwise its a binary flag
-        else {
+            arguments.put(name, value);
+            name = null;
+        }
+        }
+        // Otherwise its a binary flag
+        else {
         arguments.put(name, null);
         name = null;
-        }
+        }
     }
     return arguments;
-    }
-
-    static private ArrayList known_metadata;
-
-    static private CollectionConfiguration self;
-
-    static final private String EXTRACTED_PREFIX = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP;
-    /** Gives the preferred ordering of commands */
-    static final private String[] COMMAND_ORDER = {StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT, StaticStrings.COLLECTIONMETADATA_BETA_ELEMENT, StaticStrings.SEARCHTYPE_ELEMENT, StaticStrings.PLUGIN_ELEMENT, StaticStrings.INDEXES_ELEMENT, StaticStrings.LEVELS_ELEMENT, StaticStrings.INDEX_DEFAULT_ELEMENT, StaticStrings.LANGUAGES_ELEMENT, StaticStrings.LANGUAGE_DEFAULT_ELEMENT, StaticStrings.SUBCOLLECTION_ELEMENT, StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT, StaticStrings.SUBCOLLECTION_DEFAULT_INDEX_ELEMENT, StaticStrings.SUPERCOLLECTION_ELEMENT, StaticStrings.CLASSIFY_ELEMENT, StaticStrings.FORMAT_ELEMENT, StaticStrings.COLLECTIONMETADATA_ELEMENT};
-
-    /** ************************** Public Data Members ***************************/
-
-    /** ************************** Private Data Members ***************************/
-
-    private File collect_config_file;
-
-    /** ************************** Public Methods ***************************/
-
-    public CollectionConfiguration(File collect_config_file) {
+    }
+
+    static private ArrayList known_metadata;
+
+    static private CollectionConfiguration self;
+
+    static final private String EXTRACTED_PREFIX = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP;
+    /** Gives the preferred ordering of commands */
+    static final private String[] COMMAND_ORDER = {StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT, StaticStrings.COLLECTIONMETADATA_BETA_ELEMENT, StaticStrings.SEARCHTYPE_ELEMENT, StaticStrings.PLUGIN_ELEMENT, StaticStrings.INDEXES_ELEMENT, StaticStrings.LEVELS_ELEMENT, StaticStrings.INDEX_DEFAULT_ELEMENT, StaticStrings.LANGUAGES_ELEMENT, StaticStrings.LANGUAGE_DEFAULT_ELEMENT, StaticStrings.SUBCOLLECTION_ELEMENT, StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT, StaticStrings.SUBCOLLECTION_DEFAULT_INDEX_ELEMENT, StaticStrings.SUPERCOLLECTION_ELEMENT, StaticStrings.CLASSIFY_ELEMENT, StaticStrings.FORMAT_ELEMENT, StaticStrings.COLLECTIONMETADATA_ELEMENT};
+
+    /** ************************** Public Data Members ***************************/
+
+    /** ************************** Private Data Members ***************************/
+
+    private File collect_config_file;
+
+    /** ************************** Public Methods ***************************/
+
+    public CollectionConfiguration(File collect_config_file) {
     this.self = this;
     this.collect_config_file = collect_config_file;
@@ -321 +321 @@
     String collect_config_name = collect_config_file.getName();
     if(collect_config_name.equals(COLLECTCONFIGURATION_XML)) {
-        // Parse with Utility but don't use class loader
-        document = Utility.parse(collect_config_file, false);
+        // Parse with Utility but don't use class loader
+        document = Utility.parse(collect_config_file, false);
     }
     // Otherwise if this is a legacy collect.cfg file then read in the template and send to magic parser
     else if(collect_config_name.equals(COLLECT_CFG)) {
-        document = Utility.parse(PSEUDO_COLLECTCONFIGURATION_XML, true);
-        parse(collect_config_file);
-    }
-    }
-
-    /** This debug facility shows the currently loaded collect.cfg or CollectConfig.xml file as a DOM tree. */
-    public void display() {
+        document = Utility.parse(PSEUDO_COLLECTCONFIGURATION_XML, true);
+        parse(collect_config_file);
+    }
+    }
+
+    /** This debug facility shows the currently loaded collect.cfg or CollectConfig.xml file as a DOM tree. */
+    public void display() {
     JDialog dialog = new JDialog(Gatherer.g_man, "Collection Configuration", false);
     dialog.setSize(400,400);
@@ -340 +340 @@
     refresh_button.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent event) {
-            tree.setDocument(document);
-        }
-        });
+            tree.setDocument(document);
+        }
+        });
     content_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
     content_pane.setLayout(new BorderLayout());
@@ -348 +348 @@
     content_pane.add(refresh_button, BorderLayout.SOUTH);
     dialog.show();
-    }
-
-    public Element getBeta() {
+    }
+
+    public Element getBeta() {
     Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_BETA_ELEMENT, null, null);
     element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_BETA_STR);
     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     return element;
-    }
-
-    public Element getCreator() {
+    }
+
+    public Element getCreator() {
     Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_CREATOR_ELEMENT, null, null);
     element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_CREATOR_STR);
     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     return element;
-    }
-
-    public Element getDocumentElement() {
+    }
+
+    public Element getDocumentElement() {
     return document.getDocumentElement();
-    }
-
-    public File getFile() {
+    }
+
+    public File getFile() {
     return collect_config_file;
-    }
-
-    /** Retrieve or create the languages Element. */
-    public Element getLanguages() {
+    }
+
+    /** Retrieve or create the languages Element. */
+    public Element getLanguages() {
     return getOrCreateElementByTagName(LANGUAGES_ELEMENT, null, null);
-    }
-
-    public Element getLevels() {
+    }
+
+    public Element getLevels() {
     return getOrCreateElementByTagName(LEVELS_ELEMENT, null, null);
-    }
-
-    public Element getMaintainer() {
+    }
+
+    public Element getMaintainer() {
     Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_MAINTAINER_ELEMENT, null, null);
     element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_MAINTAINER_STR);
     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     return element;
-    }
-
-    /** Retrieve or create the indexes Element. Note that this method behaves differently from the other getBlah methods, in that it also has to keep in mind that indexes come in two flavours, MG and MGPP. */
-    public Element getMGIndexes() {
+    }
+
+    /** Retrieve or create the indexes Element. Note that this method behaves differently from the other getBlah methods, in that it also has to keep in mind that indexes come in two flavours, MG and MGPP. */
+    public Element getMGIndexes() {
     return getOrCreateElementByTagName(INDEXES_ELEMENT, MGPP_ATTRIBUTE, FALSE_STR);
-    }
-
-    public Element getMGPPIndexes() {
+    }
+
+    public Element getMGPPIndexes() {
     return getOrCreateElementByTagName(INDEXES_ELEMENT, MGPP_ATTRIBUTE, TRUE_STR);
-    }
-
-    public Element getPublic() {
+    }
+
+    public Element getPublic() {
     Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_PUBLIC_ELEMENT, null, null);
     element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_PUBLIC_STR);
     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     return element;
-    }
-
-    /** Retrieve or create the searchtype element. */
-    public Element getSearchType() {
+    }
+
+    /** Retrieve or create the searchtype element. */
+    public Element getSearchType() {
     ///ystem.err.println("Get or create element by tag name: " + name);
     Element document_element = document.getDocumentElement();
@@ -411 +411 @@
     int elements_length = elements.getLength();
     if(elements_length > 0) {
-        document_element = null;
-        return (Element) elements.item(0);
+        document_element = null;
+        return (Element) elements.item(0);
     }
     // Create the element
@@ -418 +418 @@
     Node target_node = findInsertionPoint(element);
     if(target_node != null) {
-        document_element.insertBefore(element, target_node);
+        document_element.insertBefore(element, target_node);
     }
     else {
-        document_element.appendChild(element);
+        document_element.appendChild(element);
     }
     document_element = null;
@@ -429 +429 @@
     element.appendChild(a_searchtype_element);
     return element;
-    }
-
-    /** Retrieve or create the subindexes Element. */
-    public Element getSubIndexes() {
+    }
+
+    /** Retrieve or create the subindexes Element. */
+    public Element getSubIndexes() {
     return getOrCreateElementByTagName(SUBCOLLECTION_INDEXES_ELEMENT, null, null);
-    }
-
-    /** Retrieve or create the supercollections Element. */
-    public Element getSuperCollection() {
+    }
+
+    /** Retrieve or create the supercollections Element. */
+    public Element getSuperCollection() {
     return getOrCreateElementByTagName(SUPERCOLLECTION_ELEMENT, null, null);
-    }
-
-    public boolean ready() {
+    }
+
+    public boolean ready() {
     return document != null;
-    }
-
-    public void save() {
+    }
+
+    public void save() {
     save(false);
-    }
-
-    public void save(boolean force_xml) {
+    }
+
+    public void save(boolean force_xml) {
     if(collect_config_file.exists()) {
-        File original_file = new File(collect_config_file.getParentFile(), COLLECT_CFG);
-        File backup_file = new File(collect_config_file.getParentFile(), "collect.bak");
-        if(backup_file.exists()) {
+        File original_file = new File(collect_config_file.getParentFile(), COLLECT_CFG);
+        File backup_file = new File(collect_config_file.getParentFile(), "collect.bak");
+        if(backup_file.exists()) {
         backup_file.delete();
-        }
-        if(!original_file.renameTo(backup_file)) {
+        }
+        if(!original_file.renameTo(backup_file)) {
         Gatherer.println("Can't rename collect.cfg");
-        }
+        }
     }
     if(force_xml || collect_config_file.getName().equals(COLLECTCONFIGURATION_XML)) {
-        ///ystem.err.println("Writing XML");
-        Utility.export(document, new File(collect_config_file.getParentFile(), COLLECTCONFIGURATION_XML));
+        ///ystem.err.println("Writing XML");
+        Utility.export(document, new File(collect_config_file.getParentFile(), COLLECTCONFIGURATION_XML));
     }
     else {
-        ///ystem.err.println("Writing text");
-        try {
+        ///ystem.err.println("Writing text");
+        try {
         FileWriter file_writer = new FileWriter(collect_config_file, false);
         BufferedWriter buffered_writer = new BufferedWriter(file_writer);
@@ -476 +476 @@
         boolean just_wrote_newline = false; // Prevent two or more newlines in a row
         for(int i = 0; i < command_elements.getLength(); i++) {
-            Node command_node = command_elements.item(i);
-            if(command_node instanceof Element) {
+            Node command_node = command_elements.item(i);
+            if(command_node instanceof Element) {
             Element command_element = (Element) command_node;
             // The only thing left are NewLine elements
             if(command_element.getNodeName().equals(NEWLINE_ELEMENT) && !just_wrote_newline) {
-                buffered_writer.newLine();
-                just_wrote_newline = true;
+                buffered_writer.newLine();
+                just_wrote_newline = true;
             }
             // Anything else we write to file, but only if it has been assigned, the exception being the Indexes element which just get commented if unassigned (a side effect of MG && MGPP compatibility)
             else if(!command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR) || command_element.getNodeName().equals(INDEXES_ELEMENT) || command_element.getNodeName().equals(INDEX_DEFAULT_ELEMENT) || command_element.getNodeName().equals(LEVELS_ELEMENT)){
-                String command = toString(command_element, false);
-                if(command != null && command.length() > 0) {
+                String command = toString(command_element, false);
+                if(command != null && command.length() > 0) {
                 write(buffered_writer, command);
                 buffered_writer.newLine();
                 just_wrote_newline = false;
-                }
-            }
-            }
+                }
+            }
+            }
         }
         buffered_writer.close();
         known_metadata = null;
-        }
-        catch (Exception exception) {
+        }
+        catch (Exception exception) {
         Gatherer.println("Error in CollectionConfiguration.save(boolean): " + exception);
         Gatherer.printStackTrace(exception);
-        }
-    }
-    }
-
-    /** ************************** Private Methods ***************************/
-
-    private String classifyToString(Element command_element, boolean show_extracted_namespace) {
+        }
+    }
+    }
+
+    /** ************************** Private Methods ***************************/
+
+    private String classifyToString(Element command_element, boolean show_extracted_namespace) {
     StringBuffer text = new StringBuffer(CLASSIFY_STR);
     text.append(TAB_CHARACTER);
@@ -515 +515 @@
     int option_elements_length = option_elements.getLength();
     for(int j = 0; j < option_elements_length; j++) {
-        Element option_element = (Element) option_elements.item(j);
-        if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
+        Element option_element = (Element) option_elements.item(j);
+        if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
         text.append(StaticStrings.MINUS_CHARACTER);
         text.append(option_element.getAttribute(NAME_ATTRIBUTE));
         String value_str = MSMUtils.getValue(option_element);
         if(value_str.length() > 0) {
-            // If the value happens to be the identifier of an extracted metadata element, then remove the namespace.
-            if(!show_extracted_namespace && value_str.startsWith(EXTRACTED_PREFIX)) {
+            // If the value happens to be the identifier of an extracted metadata element, then remove the namespace.
+            if(!show_extracted_namespace && value_str.startsWith(EXTRACTED_PREFIX)) {
             value_str = value_str.substring(EXTRACTED_PREFIX.length());
-            }
-            text.append(SPACE_CHARACTER);
-            if(value_str.indexOf(SPACE_CHARACTER) == -1) {
+            }
+            text.append(SPACE_CHARACTER);
+            if(value_str.indexOf(SPACE_CHARACTER) == -1) {
             text.append(value_str);
-            }
-            else {
+            }
+            else {
             text.append(SPEECH_CHARACTER);
             text.append(value_str);
             text.append(SPEECH_CHARACTER);
-            }
+            }
         }
         value_str = null;
         if(j < option_elements_length - 1) {
-            text.append(SPACE_CHARACTER);
-        }
-        }
-        option_element = null;
+            text.append(SPACE_CHARACTER);
+        }
+        }
+        option_element = null;
     }
     option_elements = null;
     return text.toString();
-    }
-
-    private String formatToString(Element command_element, boolean show_extracted_namespace) {
+    }
+
+    private String formatToString(Element command_element, boolean show_extracted_namespace) {
     StringBuffer text = new StringBuffer(FORMAT_STR);
     text.append(SPACE_CHARACTER);
@@ -553 +553 @@
     String value_str = command_element.getAttribute(VALUE_ATTRIBUTE);
     if(value_str.length() != 0) {
-        text.append(value_str);
+        text.append(value_str);
     }
     else {
@@ -560 +560 @@
        // Remove any references to a namespace for extracted metadata
        if(!show_extracted_namespace) {
-          value_str.replaceAll(EXTRACTED_PREFIX, "");
+          value_str.replaceAll(EXTRACTED_PREFIX, "");
        }
        text.append(SPEECH_CHARACTER);
@@ -568 +568 @@
     value_str = null;
     return text.toString();
-    }
-
-    /** Retrieve or create the indexes Element. */
-    private Element getOrCreateElementByTagName(String name, String conditional_attribute, String required_value) {
+    }
+
+    /** Retrieve or create the indexes Element. */
+    private Element getOrCreateElementByTagName(String name, String conditional_attribute, String required_value) {
     Element document_element = document.getDocumentElement();
     NodeList elements = document_element.getElementsByTagName(name);
     int elements_length = elements.getLength();
     if(elements_length > 0) {
-        if(conditional_attribute == null) {
+        if(conditional_attribute == null) {
         document_element = null;
         return (Element) elements.item(0);
-        }
-        else {
+        }
+        else {
         for(int i = 0; i < elements_length; i++) {
-            Element element = (Element) elements.item(i);
-            if(element.getAttribute(conditional_attribute).equals(required_value)) {
+            Element element = (Element) elements.item(i);
+            if(element.getAttribute(conditional_attribute).equals(required_value)) {
             document_element = null;
             return element;
-            }
-            element = null;
-        }
-        }
+            }
+            element = null;
+        }
+        }
     }
     // Create the element
@@ -595 +595 @@
     // If there was a property set it
     if(conditional_attribute != null) {
-        element.setAttribute(conditional_attribute, required_value);
+        element.setAttribute(conditional_attribute, required_value);
     }
     Node target_node = findInsertionPoint(element);
     if(target_node != null) {
-        document_element.insertBefore(element, target_node);
+        document_element.insertBefore(element, target_node);
     }
     else {
-        document_element.appendChild(element);
+        document_element.appendChild(element);
     }
     document_element = null;
     return element;
-    }
-
-    private String indexesToString(Element command_element, boolean show_extracted_namespace) {
+    }
+
+    private String indexesToString(Element command_element, boolean show_extracted_namespace) {
     boolean comment_only = false;
     StringBuffer text = new StringBuffer("");
     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) {
-        text.append("#");
-        comment_only = true;
+        text.append("#");
+        comment_only = true;
     }
     text.append(INDEX_STR);
     text.append(TAB_CHARACTER);
     if(!comment_only) {
-        text.append(TAB_CHARACTER);
+        text.append(TAB_CHARACTER);
     }
     NodeList index_elements = command_element.getElementsByTagName(INDEX_ELEMENT);
     if (index_elements.getLength() == 0) { // no indexes
-        return "";
+        return "";
     }
     // For each index, write its level, a colon, then concatenate its child content elements into a single comma separated list
     int index_elements_length = index_elements.getLength();
     for(int j = 0; j < index_elements_length; j++) {
-        Element index_element = (Element) index_elements.item(j);
-        String level_str = index_element.getAttribute(LEVEL_ATTRIBUTE);
-        if(level_str.length() > 0) {
+        Element index_element = (Element) index_elements.item(j);
+        String level_str = index_element.getAttribute(LEVEL_ATTRIBUTE);
+        if(level_str.length() > 0) {
         text.append(level_str);
         text.append(StaticStrings.COLON_CHARACTER);
-        }
-        NodeList content_elements = index_element.getElementsByTagName(CONTENT_ELEMENT);
-        int content_elements_length = content_elements.getLength();
-        // Don't output anything if no indexes are set
-        if(content_elements_length == 0) {
+        }
+        NodeList content_elements = index_element.getElementsByTagName(CONTENT_ELEMENT);
+        int content_elements_length = content_elements.getLength();
+        // Don't output anything if no indexes are set
+        if(content_elements_length == 0) {
         return null;
-        }
-        for(int k = 0; k < content_elements_length; k++) {
+        }
+        for(int k = 0; k < content_elements_length; k++) {
         Element content_element = (Element) content_elements.item(k);
         String name_str = content_element.getAttribute(NAME_ATTRIBUTE);
         if(!show_extracted_namespace && name_str.startsWith(EXTRACTED_PREFIX)) {
-            name_str = name_str.substring(EXTRACTED_PREFIX.length());
+            name_str = name_str.substring(EXTRACTED_PREFIX.length());
         }
         text.append(name_str);
         name_str = null;
         if(k < content_elements_length - 1) {
-            text.append(StaticStrings.COMMA_CHARACTER);
+            text.append(StaticStrings.COMMA_CHARACTER);
         }
         content_element = null;
-        }
-        if(j < index_elements_length - 1) {
+        }
+        if(j < index_elements_length - 1) {
         text.append(SPACE_CHARACTER);
-        }
-        content_elements = null;
-        index_element = null;
+        }
+        content_elements = null;
+        index_element = null;
     }
     index_elements = null;
     return text.toString();
-    }
-
-    private String indexDefaultToString(Element command_element, boolean show_extracted_namespace) {
+    }
+
+    private String indexDefaultToString(Element command_element, boolean show_extracted_namespace) {
     StringBuffer text = new StringBuffer("");
     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) {
-        text.append("#");
+        text.append("#");
     }
     text.append(INDEX_DEFAULT_STR);
@@ -674 +674 @@
     int content_elements_length = content_elements.getLength();
     for(int j = 0; j < content_elements_length; j++) {
-        Element content_element = (Element) content_elements.item(j);
-        String name_str = content_element.getAttribute(NAME_ATTRIBUTE);
-        if(!show_extracted_namespace && name_str.startsWith(EXTRACTED_PREFIX)) {
+        Element content_element = (Element) content_elements.item(j);
+        String name_str = content_element.getAttribute(NAME_ATTRIBUTE);
+        if(!show_extracted_namespace && name_str.startsWith(EXTRACTED_PREFIX)) {
         name_str = name_str.substring(EXTRACTED_PREFIX.length());
-        }
-        text.append(name_str);
-        name_str = null;
-        if(j < content_elements_length - 1) {
+        }
+        text.append(name_str);
+        name_str = null;
+        if(j < content_elements_length - 1) {
         text.append(StaticStrings.COMMA_CHARACTER);
-        }
-        content_element = null;
+        }
+        content_element = null;
     }
     content_elements = null;
     return text.toString();
-    }
-
-    private String languagesToString(Element command_element) {
+    }
+
+    private String languagesToString(Element command_element) {
     StringBuffer text = new StringBuffer(LANGUAGES_STR);
     text.append(TAB_CHARACTER);
@@ -697 +697 @@
     int language_elements_length = language_elements.getLength();
     if(language_elements_length == 0) {
-        return null;
+        return null;
     }
     for(int j = 0; j < language_elements_length; j++) {
-        Element language_element = (Element) language_elements.item(j);
-        text.append(language_element.getAttribute(NAME_ATTRIBUTE));
-        if(j < language_elements_length - 1) {
+        Element language_element = (Element) language_elements.item(j);
+        text.append(language_element.getAttribute(NAME_ATTRIBUTE));
+        if(j < language_elements_length - 1) {
         text.append(SPACE_CHARACTER);
-        }
+        }
     }
     return text.toString();
-    }
-
-    private String languageDefaultToString(Element command_element) {
+    }
+
+    private String languageDefaultToString(Element command_element) {
     StringBuffer text = new StringBuffer(LANGUAGE_DEFAULT_STR);
     text.append(TAB_CHARACTER);
     text.append(command_element.getAttribute(NAME_ATTRIBUTE));
     return text.toString();
-    }
-
-    private String levelsToString(Element command_element) {
+    }
+
+    private String levelsToString(Element command_element) {
     StringBuffer text = new StringBuffer("");
     if(!command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
-        text.append("#");
+        text.append("#");
     }
     text.append(LEVELS_STR);
@@ -728 +728 @@
     // Don't output anything if no levels are set.
     if(content_elements_length == 0) {
-        return null;
+        return null;
     }
     for(int i = 0; i < content_elements_length; i++) {
-        Element content_element = (Element) content_elements.item(i);
-        text.append(content_element.getAttribute(NAME_ATTRIBUTE));
-        text.append(SPACE_CHARACTER);
+        Element content_element = (Element) content_elements.item(i);
+        text.append(content_element.getAttribute(NAME_ATTRIBUTE));
+        text.append(SPACE_CHARACTER);
     }
     return text.substring(0, text.length() - 1);
-    }
-
-    static public String metadataToString(Element command_element, boolean text_value) {
+    }
+
+    static public String metadataToString(Element command_element, boolean text_value) {
     boolean special = false;
     // If there is no value attribute, then we don't write anything
@@ -745 +745 @@
     // If the name is one of the special four, we don't write the collectionmeta first. Note the maintainer collectionmeta is singled out for 'prittying' reasons.
     if(name_str.equals(COLLECTIONMETADATA_MAINTAINER_STR)) {
-        text.append(name_str);
-        text.append(TAB_CHARACTER);
-        special = true;
+        text.append(name_str);
+        text.append(TAB_CHARACTER);
+        special = true;
     }
     else if(name_str.equals(COLLECTIONMETADATA_BETA_STR) || name_str.equals(COLLECTIONMETADATA_CREATOR_STR) || name_str.equals(COLLECTIONMETADATA_PUBLIC_STR)) {
-        text.append(name_str);
-        text.append(TAB_CHARACTER);
-        text.append(TAB_CHARACTER);
-        special = true;
+        text.append(name_str);
+        text.append(TAB_CHARACTER);
+        text.append(TAB_CHARACTER);
+        special = true;
     }
     else {
-        text.append(COLLECTIONMETADATA_STR);
-        text.append(TAB_CHARACTER);
-        text.append(name_str);
-        text.append(SPACE_CHARACTER);
-        String language_str = command_element.getAttribute(LANGUAGE_ATTRIBUTE);
-        // If this is element is in english, and it is the first one found, we don't need to write the language argument.
-        //if(!language_str.equals(ENGLISH_LANGUAGE_STR) || known_metadata == null || known_metadata.contains(name_str)) {
-        // changed so that we always write the language string
-        text.append(LBRACKET_CHARACTER);
-        text.append(LANGUAGE_ARGUMENT);
-        text.append(language_str);
-        text.append(RBRACKET_CHARACTER);
-        text.append(SPACE_CHARACTER);
-        //}
-        if(known_metadata != null) {
+        text.append(COLLECTIONMETADATA_STR);
+        text.append(TAB_CHARACTER);
+        text.append(name_str);
+        text.append(SPACE_CHARACTER);
+        String language_str = command_element.getAttribute(LANGUAGE_ATTRIBUTE);
+        // If this is element is in english, and it is the first one found, we don't need to write the language argument.
+        //if(!language_str.equals(ENGLISH_LANGUAGE_STR) || known_metadata == null || known_metadata.contains(name_str)) {
+        // changed so that we always write the language string
+        text.append(LBRACKET_CHARACTER);
+        text.append(LANGUAGE_ARGUMENT);
+        text.append(language_str);
+        text.append(RBRACKET_CHARACTER);
+        text.append(SPACE_CHARACTER);
+        //}
+        if(known_metadata != null) {
         known_metadata.add(name_str);
-        }
-        language_str = null;
+        }
+        language_str = null;
     }
     name_str = null;
-    
+
     String value_str = MSMUtils.getValue(command_element);
     // The value string we retrieved will be encoded for xml, so we now decode it - to text if text_value set. This parameter was originally show_extracted_namespace, but sincethis is only true for 'toString()' commands from within the CDM, its good enough to determine if this toString() will be used to display on screen, or write to collect.cfg
     if(text_value == CollectionMeta.TEXT) {
-        value_str = Codec.transform(value_str, Codec.DOM_TO_TEXT);
+        value_str = Codec.transform(value_str, Codec.DOM_TO_TEXT);
     }
     else {
-        value_str = Codec.transform(value_str, Codec.DOM_TO_GREENSTONE);
-    }
-    
+        value_str = Codec.transform(value_str, Codec.DOM_TO_GREENSTONE);
+    }
+
     // We don't wrap the email addresses in quotes, nor the other special metadata
     if(special) {
-        text.append(value_str);
+        text.append(value_str);
     }
     else {
-        text.append(SPEECH_CHARACTER);
-        text.append(value_str);
-        text.append(SPEECH_CHARACTER);
+        text.append(SPEECH_CHARACTER);
+        text.append(value_str);
+        text.append(SPEECH_CHARACTER);
     }
     value_str = null;
     return text.toString();
-    }
-
-    /** Parse a collect.cfg into a DOM model representation. */
-    private void parse(File collect_config_file) {
-    try {
-        Element collect_cfg_element = document.getDocumentElement();
-        // Read in the file one command at a time.
-        FileReader in_reader = new FileReader(collect_config_file);
-        BufferedReader in = new BufferedReader(in_reader);
-        String command_str = null;
-        while((command_str = in.readLine()) != null) {
-        Element command_element = null;
-        // A command may be broken over several lines.
-        command_str = command_str.trim();
-        boolean eof = false;
-        while(!eof && command_str.endsWith(NEWLINE_CHARACTER)) {
-            String next_line = in.readLine();
-            if(next_line != null) {
-            next_line = next_line.trim();
-            if(next_line.length() > 0) {
-                // Remove the new line character
-                command_str = command_str.substring(0, command_str.lastIndexOf(NEWLINE_CHARACTER));
-                // And append the next line, which due to the test above must be non-zero length
-                command_str = command_str + next_line;
-            }
-            next_line = null;
-            }
-            // If we've reached the end of the file theres nothing more we can do
-            else {
-            eof = true;
-            }
-        }
-        // If there is still a new line character, then we remove it and hope for the best
-        if(command_str.endsWith(NEWLINE_CHARACTER)) {
-            command_str = command_str.substring(0, command_str.lastIndexOf(NEWLINE_CHARACTER));
-        }
-        // Now we've either got a command to parse...
-        if(command_str.length() != 0) {
-            // Start trying to figure out what it is
-            StringTokenizer tokenizer = new StringTokenizer(command_str);
-            String command_type = tokenizer.nextToken().toLowerCase();
-            tokenizer = null;
-            // Why can't you switch on strings eh? We pass it to the various subparsers who each have a bash at parsing the command. If none can parse the command, an unknown element is created
-            if(command_element == null && command_type.equals(CLASSIFY_STR)) {
-            command_element = parseClassify(command_str);
-            }
-            if(command_element == null && command_type.equals(FORMAT_STR)) {
-            command_element = parseFormat(command_str, in);
-            }
-            if(command_element == null && (command_type.equals(INDEX_STR)  || command_type.equals(COMMENTED_INDEXES_STR))) {
-            command_element = parseIndex(command_str);
-            }
-            if(command_element == null && (command_type.equals(INDEX_DEFAULT_STR) || command_type.equals(COMMENTED_INDEX_DEFAULT_STR))) {
-            command_element = parseIndexDefault(command_str);
-            }
-            if(command_element == null && command_type.equals(LANGUAGES_STR)) {
-            command_element = parseLanguage(command_str);
-            }
-            if(command_element == null && command_type.equals(LANGUAGE_DEFAULT_STR)) {
-            command_element = parseLanguageDefault(command_str);
-            }
-            if(command_element == null && (command_type.equals(LEVELS_STR) || command_type.equals(COMMENTED_LEVELS_STR))) {
-            command_element = parseLevels(command_str);
-            }
-            if(command_element == null && command_type.equals(COLLECTIONMETADATA_STR)) {
-            // collectionmeta may go over more than one line, so 
-            // pass in the reader
-            command_element = parseMetadata(command_str, in);
-            }
-            if(command_element == null && (command_type.equals(COLLECTIONMETADATA_BETA_STR) || command_type.equals(COLLECTIONMETADATA_PUBLIC_STR) || command_type.equals(COLLECTIONMETADATA_CREATOR_STR) || command_type.equals(COLLECTIONMETADATA_MAINTAINER_STR))) {
-            command_element = parseMetadataSpecial(command_str);
-            }
-            if(command_element == null && command_type.equals(PLUGIN_STR)) {
-            command_element = parsePlugIn(command_str);
-            }
-            if(command_element == null && command_type.equals(SEARCHTYPE_STR)) {
-            command_element = parseSearchType(command_str);
-            }
-            if(command_element == null && command_type.equals(SUBCOLLECTION_STR)) {
-            command_element = parseSubCollection(command_str);
-            }
-            if(command_element == null && command_type.equals(SUBCOLLECTION_DEFAULT_INDEX_STR)) {
-            command_element = parseSubCollectionDefaultIndex(command_str);
-            }
-            if(command_element == null && command_type.equals(SUBCOLLECTION_INDEX_STR)) {
-            command_element = parseSubCollectionIndex(command_str);
-            }
-            if(command_element == null && (command_type.equals(SUPERCOLLECTION_STR) || command_type.equals(CCS_STR))) {
-            command_element = parseSuperCollection(command_str);
-            }
-            // Doesn't match any known type
-            command_type = null;
-            if(command_element == null) {
+    }
+
+    /** Parse a collect.cfg into a DOM model representation. */
+    private void parse(File collect_config_file) {
+        try {
+            Element collect_cfg_element = document.getDocumentElement();
+            // Read in the file one command at a time.
+            FileReader in_reader = new FileReader(collect_config_file);
+            BufferedReader in = new BufferedReader(in_reader);
+            String command_str = null;
+            while((command_str = in.readLine()) != null) {
+                Element command_element = null;
+                // A command may be broken over several lines.
+                command_str = command_str.trim();
+                boolean eof = false;
+                while(!eof && command_str.endsWith(NEWLINE_CHARACTER)) {
+                    String next_line = in.readLine();
+                    if(next_line != null) {
+                        next_line = next_line.trim();
+                        if(next_line.length() > 0) {
+                            // Remove the new line character
+                            command_str = command_str.substring(0, command_str.lastIndexOf(NEWLINE_CHARACTER));
+                            // And append the next line, which due to the test above must be non-zero length
+                            command_str = command_str + next_line;
+                        }
+                        next_line = null;
+                    }
+                    // If we've reached the end of the file theres nothing more we can do
+                    else {
+                        eof = true;
+                    }
+                }
+                // If there is still a new line character, then we remove it and hope for the best
+                if(command_str.endsWith(NEWLINE_CHARACTER)) {
+                    command_str = command_str.substring(0, command_str.lastIndexOf(NEWLINE_CHARACTER));
+                }
+                // Now we've either got a command to parse...
+                if(command_str.length() != 0) {
+                    // Start trying to figure out what it is
+                    //StringTokenizer tokenizer = new StringTokenizer(command_str);
+                    // Instead of a standard string tokenizer I'm going to use the new version of CommandTokenizer, which is not only smart enough to correctly notice speech marks and correctly parse them out, but now also takes the input stream so it can rebuild tokens that stretch over several lines.
+                    CommandTokenizer tokenizer = new CommandTokenizer(command_str, in);
+                    String command_type = tokenizer.nextToken().toLowerCase();
+                    // Why can't you switch on strings eh? We pass it to the various subparsers who each have a bash at parsing the command. If none can parse the command, an unknown element is created
+                    if(command_element == null && command_type.equals(CLASSIFY_STR)) {
+                        command_element = parseClassify(command_str);
+                    }
+                    if(command_element == null && command_type.equals(FORMAT_STR)) {
+                        command_element = parseFormat(tokenizer); // Revised to handle multiple lines
+                    }
+                    if(command_element == null && (command_type.equals(INDEX_STR)  || command_type.equals(COMMENTED_INDEXES_STR))) {
+                        command_element = parseIndex(command_str);
+                    }
+                    if(command_element == null && (command_type.equals(INDEX_DEFAULT_STR) || command_type.equals(COMMENTED_INDEX_DEFAULT_STR))) {
+                        command_element = parseIndexDefault(command_str);
+                    }
+                    if(command_element == null && command_type.equals(LANGUAGES_STR)) {
+                        command_element = parseLanguage(command_str);
+                    }
+                    if(command_element == null && command_type.equals(LANGUAGE_DEFAULT_STR)) {
+                        command_element = parseLanguageDefault(command_str);
+                    }
+                    if(command_element == null && (command_type.equals(LEVELS_STR) || command_type.equals(COMMENTED_LEVELS_STR))) {
+                        command_element = parseLevels(command_str);
+                    }
+                    if(command_element == null && command_type.equals(COLLECTIONMETADATA_STR)) {
+                        command_element = parseMetadata(tokenizer); // Revised to handle multiple lines
+                    }
+                    if(command_element == null && (command_type.equals(COLLECTIONMETADATA_BETA_STR) || command_type.equals(COLLECTIONMETADATA_PUBLIC_STR) || command_type.equals(COLLECTIONMETADATA_CREATOR_STR) || command_type.equals(COLLECTIONMETADATA_MAINTAINER_STR))) {
+                        command_element = parseMetadataSpecial(command_str);
+                    }
+                    if(command_element == null && command_type.equals(PLUGIN_STR)) {
+                        command_element = parsePlugIn(command_str);
+                    }
+                    if(command_element == null && command_type.equals(SEARCHTYPE_STR)) {
+                        command_element = parseSearchType(command_str);
+                    }
+                    if(command_element == null && command_type.equals(SUBCOLLECTION_STR)) {
+                        command_element = parseSubCollection(command_str);
+                    }
+                    if(command_element == null && command_type.equals(SUBCOLLECTION_DEFAULT_INDEX_STR)) {
+                        command_element = parseSubCollectionDefaultIndex(command_str);
+                    }
+                    if(command_element == null && command_type.equals(SUBCOLLECTION_INDEX_STR)) {
+                        command_element = parseSubCollectionIndex(command_str);
+                    }
+                    if(command_element == null && (command_type.equals(SUPERCOLLECTION_STR) || command_type.equals(CCS_STR))) {
+                        command_element = parseSuperCollection(command_str);
+                    }
+            // Doesn't match any known type
+            command_type = null;
+            if(command_element == null) {
             // No-one knows what to do with this command, so we create an Unknown command element
             command_element = document.createElement(UNKNOWN_ELEMENT);
@@ -897 +896 @@
         // Or an empty line to remember for later
         else {
-            command_element = document.createElement(NEWLINE_ELEMENT);
+            command_element = document.createElement(NEWLINE_ELEMENT);
         }
         // Now command element shouldn't be null so we append it to the collection config DOM
         collect_cfg_element.appendChild(command_element);
-        }
+        }
     }
     catch(Exception exception) {
-        Gatherer.println("Error in CollectionConfiguration.parse(java.io.File): " + exception);
-        Gatherer.printStackTrace(exception);
-    }
-    }
-
-    private Element parseClassify(String command_str) {
+        Gatherer.println("Error in CollectionConfiguration.parse(java.io.File): " + exception);
+        Gatherer.printStackTrace(exception);
+    }
+    }
+
+    private Element parseClassify(String command_str) {
     Element command_element = null;
     try {
-        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
-        // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument).
-        if(tokenizer.countTokens() >= 2) {  // Must support "classify Phind" (no args)
+        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
+        // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument).
+        if(tokenizer.countTokens() >= 2) {  // Must support "classify Phind" (no args)
         command_element = document.createElement(CLASSIFY_ELEMENT);
         // First token is classify
@@ -925 +924 @@
         Iterator names = arguments.keySet().iterator();
         while(names.hasNext()) {
-            String name = (String) names.next();
-            String value = (String) arguments.get(name); // Can be null
-            // The metadata argument gets added as the content attribute
-            if(name.equals(METADATA_ARGUMENT) && value != null) {
+            String name = (String) names.next();
+            String value = (String) arguments.get(name); // Can be null
+            // The metadata argument gets added as the content attribute
+            if(name.equals(METADATA_ARGUMENT) && value != null) {
             // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace.
             if(value.indexOf(MSMUtils.NS_SEP) == -1) {
-                value = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + value;
+                value = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + value;
             }
             //command_element.setAttribute(CONTENT_ATTRIBUTE, value);
-            }
-            // Everything else is an Option Element
-            Element option_element = document.createElement(OPTION_ELEMENT);
-            option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1));
-            if(value != null) {
+            }
+            // Everything else is an Option Element
+            Element option_element = document.createElement(OPTION_ELEMENT);
+            option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1));
+            if(value != null) {
             // Remove any speech marks appended in strings containing whitespace
             if(value.startsWith(SPEECH_CHARACTER) && value.endsWith(SPEECH_CHARACTER)) {
-                value = value.substring(1, value.length() - 1);
+                value = value.substring(1, value.length() - 1);
             }
             MSMUtils.setValue(option_element, value);
-            }
-            option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
-            option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR);
-            command_element.appendChild(option_element);
-            option_element = null;
-            name = null;
-            value = null;
+            }
+            option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
+            option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR);
+            command_element.appendChild(option_element);
+            option_element = null;
+            name = null;
+            value = null;
         }
         names = null;
         arguments = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch(Exception error) {
     }
     return command_element;
-    }
-
-    private Element parseFormat(String command_str, BufferedReader in) {
+    }
+
+    private Element parseFormat(CommandTokenizer tokenizer) {
+        Element command_element = null;
+        try {
+            command_element = document.createElement(FORMAT_ELEMENT);
+            String name_str = tokenizer.nextToken();
+            String value_str = tokenizer.nextToken();
+            if(name_str != null && value_str != null) {
+                command_element.setAttribute(NAME_ATTRIBUTE, name_str);
+                // If the value is true or false we add it as an attribute
+                if(value_str.equalsIgnoreCase(TRUE_STR) || value_str.equalsIgnoreCase(FALSE_STR)) {
+                    command_element.setAttribute(VALUE_ATTRIBUTE, value_str.toLowerCase());
+                }
+                // Otherwise it gets added as a text node
+                else {
+                    // Ready the value str (which can contain all sorts of funky characters) for writing as a DOM value
+                    value_str = Codec.transform(value_str, Codec.GREENSTONE_TO_DOM);
+                    MSMUtils.setValue(command_element, value_str);
+                }
+            }
+            else {
+                command_element = null;
+            }
+            name_str = null;
+            value_str = null;
+        }
+        catch (Exception exception) {
+            Gatherer.printStackTrace(exception);
+            command_element = null;
+        }
+        return command_element;
+    }
+
+    private Element parseIndex(String command_str) {
     Element command_element = null;
     try {
-        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
-        if(tokenizer.countTokens() >= 3) {
-        command_element = document.createElement(FORMAT_ELEMENT);
-        // First token is format
-        tokenizer.nextToken();
-        command_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
-        String value_str = tokenizer.nextToken();
-        // If the value is true or false we add it as an attribute
-        if(value_str.equalsIgnoreCase(TRUE_STR) || value_str.equalsIgnoreCase(FALSE_STR)) {
-            command_element.setAttribute(VALUE_ATTRIBUTE, value_str.toLowerCase());
-        }
-        // Otherwise it gets added as a text node
-        else {
-
-            // now we need to handle the case where the value is enclosed in quotes (single or double) and may extend across multiple lines
-            String start_string = value_str.substring(0,1);
-            if (start_string.equals("\"") || start_string.equals("\'")) {
-            if (value_str.endsWith(start_string) && value_str.length()!=1) {
-                // we remove the quotes from the ends
-                value_str = value_str.substring(1, value_str.length() - 1);
-            } else {
-                
-                // remove the first quote
-                StringBuffer value_raw = new StringBuffer(value_str.substring(1));
-                // add the new line back in
-                value_raw.append(StaticStrings.NEW_LINE_CHAR);
-                int pos = value_raw.indexOf(start_string);
-                int old_pos = 0;
-                while (pos != -1 && value_raw.charAt(pos-1)=='\\') {
-                old_pos = pos+1;
-                pos = value_raw.indexOf(start_string, old_pos);
-                }
-                while(pos == -1) {
-                String next_line = in.readLine();
-                if(next_line != null) {
-                    value_raw.append(next_line);
-                    value_raw.append(StaticStrings.NEW_LINE_CHAR);
-                }
-                next_line = null;
-                pos = value_raw.indexOf(start_string, old_pos);
-                while (pos != -1 && value_raw.charAt(pos-1)=='\\') {
-                    old_pos = pos+1;
-                    pos = value_raw.indexOf(start_string, old_pos);
-                }
-                }
-                
-                value_str = value_raw.substring(0, value_raw.lastIndexOf(start_string));
-                value_raw = null;
-                
-            } // else
-            } // if starts with a quote
-                    
-            if(value_str != null) {
-            // Ready the value str (which can contain all sorts of funky characters) for writing as a DOM value
-            value_str = Codec.transform(value_str, Codec.GREENSTONE_TO_DOM);
-            MSMUtils.setValue(command_element, value_str);
-            }
-            else {
-            command_element = null;
-            }
-            start_string = null;
-        }
-        value_str = null;
-        
-        }
-        tokenizer = null;
-    }
-    catch (Exception exception) {
-    }
-    return command_element;
-    }
-
-    private Element parseIndex(String command_str) {
-    Element command_element = null;
-    try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        String command = tokenizer.nextToken();
-        command_element = document.createElement(INDEXES_ELEMENT);
-        command_element.setAttribute(ASSIGNED_ATTRIBUTE, (command.equals(INDEX_STR) ? TRUE_STR : FALSE_STR));
-        command = null;
-        if(!tokenizer.hasMoreTokens()) {
-        
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        String command = tokenizer.nextToken();
+        command_element = document.createElement(INDEXES_ELEMENT);
+        command_element.setAttribute(ASSIGNED_ATTRIBUTE, (command.equals(INDEX_STR) ? TRUE_STR : FALSE_STR));
+        command = null;
+        if(!tokenizer.hasMoreTokens()) {
+
         // there are no indexes
         command_element.setAttribute(ASSIGNED_ATTRIBUTE, FALSE_STR);
@@ -1052 +1008 @@
         tokenizer = null;
         return command_element;
-        }
-        
-        while(tokenizer.hasMoreTokens()) {
+        }
+
+        while(tokenizer.hasMoreTokens()) {
         Element index_element = document.createElement(INDEX_ELEMENT);
         String index_str = tokenizer.nextToken();
@@ -1060 +1016 @@
         boolean old_index;
         if(index_str.indexOf(COLON_CHARACTER) != -1) {
-            old_index = true;
-            index_element.setAttribute(LEVEL_ATTRIBUTE, index_str.substring(0, index_str.indexOf(StaticStrings.COLON_CHARACTER)));
-            index_str = index_str.substring(index_str.indexOf(StaticStrings.COLON_CHARACTER) + 1);
-            command_element.setAttribute(MGPP_ATTRIBUTE, FALSE_STR);
+            old_index = true;
+            index_element.setAttribute(LEVEL_ATTRIBUTE, index_str.substring(0, index_str.indexOf(StaticStrings.COLON_CHARACTER)));
+            index_str = index_str.substring(index_str.indexOf(StaticStrings.COLON_CHARACTER) + 1);
+            command_element.setAttribute(MGPP_ATTRIBUTE, FALSE_STR);
         }
         else {
-            command_element.setAttribute(MGPP_ATTRIBUTE, TRUE_STR);
-            old_index = false;
+            command_element.setAttribute(MGPP_ATTRIBUTE, TRUE_STR);
+            old_index = false;
         }
         StringTokenizer content_tokenizer = new StringTokenizer(index_str, StaticStrings.COMMA_CHARACTER);
         while(content_tokenizer.hasMoreTokens()) {
-            Element content_element = document.createElement(CONTENT_ELEMENT);
-            String content_str = content_tokenizer.nextToken();
-            // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
-            if(content_str.indexOf(MSMUtils.NS_SEP) == -1) {
+            Element content_element = document.createElement(CONTENT_ELEMENT);
+            String content_str = content_tokenizer.nextToken();
+            // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
+            if(content_str.indexOf(MSMUtils.NS_SEP) == -1) {
             if(content_str.equals(StaticStrings.TEXT_STR) || (!old_index && content_str.equals(StaticStrings.ALLFIELDS_STR))) {
-                // Our special strings are OK.
+                // Our special strings are OK.
             }
             else {
-                content_str = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + content_str;
-            }
-            }
-            content_element.setAttribute(NAME_ATTRIBUTE, content_str);
-            index_element.appendChild(content_element);
-            content_element = null;
+                content_str = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + content_str;
+            }
+            }
+            content_element.setAttribute(NAME_ATTRIBUTE, content_str);
+            index_element.appendChild(content_element);
+            content_element = null;
         }
         content_tokenizer = null;
@@ -1090 +1046 @@
         command_element.appendChild(index_element);
         index_element = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch (Exception exception) {
-        exception.printStackTrace();
+        exception.printStackTrace();
     }
     return command_element;
-    }
-
-    private Element parseIndexDefault(String command_str) {
+    }
+
+    private Element parseIndexDefault(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        if(tokenizer.countTokens() >= 2) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        if(tokenizer.countTokens() >= 2) {
         command_element = document.createElement(INDEX_DEFAULT_ELEMENT);
         command_element.setAttribute(ASSIGNED_ATTRIBUTE, ((tokenizer.nextToken()).equals(INDEX_DEFAULT_STR) ? TRUE_STR : FALSE_STR));
@@ -1111 +1067 @@
         StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER);
         while(content_tokenizer.hasMoreTokens()) {
-            Element content_element = document.createElement(CONTENT_ELEMENT);
-            content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
-            command_element.appendChild(content_element);
-            content_element = null;
+            Element content_element = document.createElement(CONTENT_ELEMENT);
+            content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
+            command_element.appendChild(content_element);
+            content_element = null;
         }
         content_tokenizer = null;
@@ -1120 +1076 @@
         content_str = null;
         index_str = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch (Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseLanguage(String command_str) {
+    }
+
+    private Element parseLanguage(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        tokenizer.nextToken();
-        if(tokenizer.hasMoreTokens()) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        tokenizer.nextToken();
+        if(tokenizer.hasMoreTokens()) {
         command_element = document.createElement(LANGUAGES_ELEMENT);
         while(tokenizer.hasMoreTokens()) {
-            Element language_element = document.createElement(LANGUAGE_ELEMENT);
-            language_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
-            command_element.appendChild(language_element);
-            language_element = null;
-        }
-        }
-        tokenizer = null;
+            Element language_element = document.createElement(LANGUAGE_ELEMENT);
+            language_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
+            command_element.appendChild(language_element);
+            language_element = null;
+        }
+        }
+        tokenizer = null;
     }
     catch (Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseLanguageDefault(String command_str) {
+    }
+
+    private Element parseLanguageDefault(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        if(tokenizer.countTokens() >= 2) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        if(tokenizer.countTokens() >= 2) {
         command_element = document.createElement(LANGUAGE_DEFAULT_ELEMENT);
         tokenizer.nextToken();
@@ -1160 +1116 @@
         command_element.setAttribute(ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
         default_language_str = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch (Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseLevels(String command_str) {
+    }
+
+    private Element parseLevels(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        // First token is command type (levels)
-        String command = tokenizer.nextToken();
-        if(tokenizer.hasMoreTokens()) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        // First token is command type (levels)
+        String command = tokenizer.nextToken();
+        if(tokenizer.hasMoreTokens()) {
         command_element = document.createElement(LEVELS_ELEMENT);
         command_element.setAttribute(ASSIGNED_ATTRIBUTE, (command.equals(LEVELS_STR) ? TRUE_STR : FALSE_STR));
         while(tokenizer.hasMoreTokens()) {
-            Element level_element = document.createElement(CONTENT_ELEMENT);
-            level_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
-            command_element.appendChild(level_element);
-            level_element = null;
-        }
-        }
-        command = null;
+            Element level_element = document.createElement(CONTENT_ELEMENT);
+            level_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
+            command_element.appendChild(level_element);
+            level_element = null;
+        }
+        }
+        command = null;
     }
     catch(Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseMetadata(String command_str, BufferedReader in) {
+    }
+
+    private Element parseMetadata(CommandTokenizer tokenizer) {
+        Element command_element = null;
+        try {
+            command_element = document.createElement(COLLECTIONMETADATA_ELEMENT);
+            String name_str = tokenizer.nextToken();
+            String value_str = tokenizer.nextToken();
+            if(name_str != null && value_str != null) {
+                String language_str = "en"; // By default - why do we assume English???
+                // Check if the value string is actually a language string
+                if(value_str.startsWith(LBRACKET_CHARACTER) && value_str.endsWith(RBRACKET_CHARACTER)) {
+                    language_str = value_str.substring(value_str.indexOf(LANGUAGE_ARGUMENT) + 2, value_str.length() - 1);
+                    value_str = tokenizer.nextToken();
+                }
+                if(value_str != null) {
+                    // Ready the value str (which can contain all sorts of funky characters) for writing as a DOM value
+                    value_str = Codec.transform(value_str, Codec.GREENSTONE_TO_DOM);
+                    command_element.setAttribute(NAME_ATTRIBUTE, name_str);
+                    command_element.setAttribute(LANGUAGE_ATTRIBUTE, language_str);
+                    command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
+                    MSMUtils.setValue(command_element, value_str);
+                }
+                else {
+                    command_element = null;
+                }
+                language_str = null;
+            }
+            else {
+                command_element = null;
+            }
+            name_str = null;
+            value_str = null;
+        }
+        catch (Exception exception) {
+            Gatherer.printStackTrace(exception);
+            command_element = null;
+        }
+        return command_element;
+    }
+
+    private Element parseMetadataSpecial(String command_str) {
     Element command_element = null;
     try {
-        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
-        if(tokenizer.countTokens() >= 3) {
-        command_element = document.createElement(COLLECTIONMETADATA_ELEMENT);
-        // First token is command type
-        tokenizer.nextToken();
-        String name_str = tokenizer.nextToken();
-        String value_str = tokenizer.nextToken();
-        String language_str = "en"; // By default - why do we assume English???
-        // Check if the value string is actually a language string
-        if(value_str.startsWith(LBRACKET_CHARACTER) && value_str.endsWith(RBRACKET_CHARACTER)) {
-            language_str = value_str.substring(value_str.indexOf(LANGUAGE_ARGUMENT) + 2, value_str.length() - 1);
-            value_str = tokenizer.nextToken();
-        }
-
-        // now we need to handle the case where the value is enclosed in quotes (single or double) and may extend across multiple lines
-        String start_string = value_str.substring(0,1);
-        if (start_string.equals("\"") || start_string.equals("\'")) {
-
-            if (value_str.endsWith(start_string) && value_str.length()!=1) {
-            // we remove the quotes from the ends
-            value_str = value_str.substring(1, value_str.length() - 1);
-            } else {
-            
-            // remove the first quote
-            StringBuffer value_raw = new StringBuffer(value_str.substring(1));
-            // add the new line back in
-            value_raw.append(StaticStrings.NEW_LINE_CHAR);
-
-            int pos = value_raw.indexOf(start_string);
-            int old_pos = 0;
-            while (pos != -1 && value_raw.charAt(pos-1)=='\\') {
-                old_pos = pos+1;
-                pos = value_raw.indexOf(start_string, old_pos);
-            }
-            while(pos == -1) {
-                String next_line = in.readLine();
-                if(next_line != null) {
-                value_raw.append(next_line);
-                value_raw.append(StaticStrings.NEW_LINE_CHAR);
-                }
-                next_line = null;
-                pos = value_raw.indexOf(start_string, old_pos);
-                while (pos != -1 && value_raw.charAt(pos-1)=='\\') {
-                old_pos = pos+1;
-                pos = value_raw.indexOf(start_string, old_pos);
-                }
-            }
-            
-            value_str = value_raw.substring(0, value_raw.lastIndexOf(start_string));
-            value_raw = null;
-            
-            } // else
-        } // if starts with a quote
-                    
-        if(value_str != null) {
-            // Ready the value str (which can contain all sorts of funky characters) for writing as a DOM value
-            value_str = Codec.transform(value_str, Codec.GREENSTONE_TO_DOM);
-            command_element.setAttribute(NAME_ATTRIBUTE, name_str);
-            command_element.setAttribute(LANGUAGE_ATTRIBUTE, language_str);
-            command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
-            MSMUtils.setValue(command_element, value_str);
-        }
-        else {
-            command_element = null;
-        }
-        language_str = null;
-        value_str = null;
-        name_str = null;
-        }
-        tokenizer = null;
-    }
-    catch (Exception exception) {
-    }
-    return command_element;
-    }
-
-    private Element parseMetadataSpecial(String command_str) {
-    Element command_element = null;
-    try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        if(tokenizer.countTokens() >= 2) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        if(tokenizer.countTokens() >= 2) {
         String name_str = tokenizer.nextToken();
         String value_str = tokenizer.nextToken();
         if(name_str.equals(COLLECTIONMETADATA_BETA_STR)) {
-            command_element = document.createElement(COLLECTIONMETADATA_BETA_ELEMENT);
+            command_element = document.createElement(COLLECTIONMETADATA_BETA_ELEMENT);
         }
         else if(name_str.equals(COLLECTIONMETADATA_CREATOR_STR)) {
-            command_element = document.createElement(COLLECTIONMETADATA_CREATOR_ELEMENT);
+            command_element = document.createElement(COLLECTIONMETADATA_CREATOR_ELEMENT);
         }
         else if(name_str.equals(COLLECTIONMETADATA_MAINTAINER_STR)) {
-            command_element = document.createElement(COLLECTIONMETADATA_MAINTAINER_ELEMENT);
+            command_element = document.createElement(COLLECTIONMETADATA_MAINTAINER_ELEMENT);
         }
         else if(name_str.equals(COLLECTIONMETADATA_PUBLIC_STR)) {
-            command_element = document.createElement(COLLECTIONMETADATA_PUBLIC_ELEMENT);
+            command_element = document.createElement(COLLECTIONMETADATA_PUBLIC_ELEMENT);
         }
         if(command_element != null) {
-            command_element.setAttribute(NAME_ATTRIBUTE, name_str);
-            command_element.setAttribute(LANGUAGE_ATTRIBUTE, ENGLISH_LANGUAGE_STR);
-            command_element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
-            command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
-            if(value_str.startsWith(SPEECH_CHARACTER) && value_str.endsWith(SPEECH_CHARACTER)) {
+            command_element.setAttribute(NAME_ATTRIBUTE, name_str);
+            command_element.setAttribute(LANGUAGE_ATTRIBUTE, ENGLISH_LANGUAGE_STR);
+            command_element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
+            command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
+            if(value_str.startsWith(SPEECH_CHARACTER) && value_str.endsWith(SPEECH_CHARACTER)) {
             value_str = value_str.substring(1, value_str.length() - 1);
-            }
-            MSMUtils.setValue(command_element, value_str);
+            }
+            MSMUtils.setValue(command_element, value_str);
         }
         value_str = null;
         name_str = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch (Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parsePlugIn(String command_str) {
+    }
+
+    private Element parsePlugIn(String command_str) {
     Element command_element = null;
     boolean use_metadata_files = false;
     boolean show_progress = false;
     try {
-        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
-        // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument).
-        if(tokenizer.countTokens() >= 2) {
+        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
+        // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument).
+        if(tokenizer.countTokens() >= 2) {
         command_element = document.createElement(PLUGIN_ELEMENT);
         // First token is plugin
@@ -1328 +1244 @@
         Iterator names = arguments.keySet().iterator();
         while(names.hasNext()) {
-            String name = (String) names.next();
-            String value = (String) arguments.get(name); // Can be null
-            Element option_element = document.createElement(OPTION_ELEMENT);
-            if(name.substring(1).equals(USE_METADATA_FILES_ARGUMENT)) {
+            String name = (String) names.next();
+            String value = (String) arguments.get(name); // Can be null
+            Element option_element = document.createElement(OPTION_ELEMENT);
+            if(name.substring(1).equals(USE_METADATA_FILES_ARGUMENT)) {
             use_metadata_files = true;
-            }
-            else if(name.substring(1).equals(SHOW_PROGRESS_ARGUMENT)) {
-               show_progress = true;
-            }
-            option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1));
-            option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
-            option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR); // All arguments are considered to be custom until matched against base plugins arguments
-            if(value != null) {
+            }
+            else if(name.substring(1).equals(SHOW_PROGRESS_ARGUMENT)) {
+               show_progress = true;
+            }
+            option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1));
+            option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
+            option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR); // All arguments are considered to be custom until matched against base plugins arguments
+            if(value != null) {
             // Remove any speech marks appended in strings containing whitespace
             if(value.startsWith(SPEECH_CHARACTER) && value.endsWith(SPEECH_CHARACTER)) {
-                value = value.substring(1, value.length() - 1);
+                value = value.substring(1, value.length() - 1);
             }
             if(name.equals(METADATA_ARGUMENT)) {
-                // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace.
-                if(value.indexOf(MSMUtils.NS_SEP) == -1) {
+                // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace.
+                if(value.indexOf(MSMUtils.NS_SEP) == -1) {
                 value = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + value;
-                }
+                }
             }
             MSMUtils.setValue(option_element, value);
-            }
-            command_element.appendChild(option_element);
-            option_element = null;
-            name = null;
-            value = null;
+            }
+            command_element.appendChild(option_element);
+            option_element = null;
+            name = null;
+            value = null;
         }
 
         // We must have some RecPlug options: use_metadata_files, and show_progress
         if (type.equals(RECPLUG_STR)) {
-            if (!use_metadata_files) {
+            if (!use_metadata_files) {
             Element option_element = document.createElement(OPTION_ELEMENT);
             option_element.setAttribute(NAME_ATTRIBUTE, USE_METADATA_FILES_ARGUMENT);
@@ -1368 +1284 @@
             command_element.appendChild(option_element);
             option_element = null;
-            }
-            if(!show_progress) {
-               Element option_element = document.createElement(OPTION_ELEMENT);
-               option_element.setAttribute(NAME_ATTRIBUTE, SHOW_PROGRESS_ARGUMENT);
-               option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
-               option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR);
-               command_element.appendChild(option_element);
-               option_element = null;
-            }
+            }
+            if(!show_progress) {
+               Element option_element = document.createElement(OPTION_ELEMENT);
+               option_element.setAttribute(NAME_ATTRIBUTE, SHOW_PROGRESS_ARGUMENT);
+               option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
+               option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR);
+               command_element.appendChild(option_element);
+               option_element = null;
+            }
         }
         type = null;
         names = null;
         arguments = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch(Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseSearchType(String command_str) {
+    }
+
+    private Element parseSearchType(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        // First token is command type (levels)
-        tokenizer.nextToken();
-        if(tokenizer.hasMoreTokens()) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        // First token is command type (levels)
+        tokenizer.nextToken();
+        if(tokenizer.hasMoreTokens()) {
         command_element = document.createElement(SEARCHTYPE_ELEMENT);
         command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
         while(tokenizer.hasMoreTokens()) {
-            Element search_element = document.createElement(CONTENT_ELEMENT);
-            search_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
-            command_element.appendChild(search_element);
-            search_element = null;
-        }
-        }
+            Element search_element = document.createElement(CONTENT_ELEMENT);
+            search_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
+            command_element.appendChild(search_element);
+            search_element = null;
+        }
+        }
     }
     catch(Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseSubCollection(String command_str) {
+    }
+
+    private Element parseSubCollection(String command_str) {
     Element command_element = null;
     try {
-        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
-        if(tokenizer.countTokens() >= 3) {
+        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
+        if(tokenizer.countTokens() >= 3) {
         command_element = document.createElement(SUBCOLLECTION_ELEMENT);
         // First token is command type
@@ -1427 +1343 @@
         // Set inclusion/exclusion flag, remove any exclaimation mark and the speech marks
         if(exclusion) {
-            full_pattern_str = full_pattern_str.substring(2, full_pattern_str.length() - 1);
-            command_element.setAttribute(TYPE_ATTRIBUTE, EXCLUDE_STR);
+            full_pattern_str = full_pattern_str.substring(2, full_pattern_str.length() - 1);
+            command_element.setAttribute(TYPE_ATTRIBUTE, EXCLUDE_STR);
         }
         else {
-            full_pattern_str = full_pattern_str.substring(1, full_pattern_str.length() - 1);
-            command_element.setAttribute(TYPE_ATTRIBUTE, INCLUDE_STR);
+            full_pattern_str = full_pattern_str.substring(1, full_pattern_str.length() - 1);
+            command_element.setAttribute(TYPE_ATTRIBUTE, INCLUDE_STR);
         }
         StringTokenizer pattern_tokenizer = new StringTokenizer(full_pattern_str, SEPARATOR_CHARACTER);
         if(pattern_tokenizer.countTokens() >= 2) {
-            String content_str = pattern_tokenizer.nextToken();
-            // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
-            if(!content_str.equals(StaticStrings.FILENAME_STR) && content_str.indexOf(MSMUtils.NS_SEP) == -1) {
+            String content_str = pattern_tokenizer.nextToken();
+            // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
+            if(!content_str.equals(StaticStrings.FILENAME_STR) && content_str.indexOf(MSMUtils.NS_SEP) == -1) {
             content_str = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + content_str;
-            }
-            command_element.setAttribute(CONTENT_ATTRIBUTE, content_str);
-            MSMUtils.setValue(command_element, pattern_tokenizer.nextToken());
-            if(pattern_tokenizer.hasMoreTokens()) {
+            }
+            command_element.setAttribute(CONTENT_ATTRIBUTE, content_str);
+            MSMUtils.setValue(command_element, pattern_tokenizer.nextToken());
+            if(pattern_tokenizer.hasMoreTokens()) {
             command_element.setAttribute(OPTIONS_ATTRIBUTE, pattern_tokenizer.nextToken());
-            }
+            }
         }
         pattern_tokenizer = null;
-        }
+        }
     }
     catch(Exception exception) {
-        exception.printStackTrace();
+        exception.printStackTrace();
     }
     return command_element;
-    }
-
-    private Element parseSubCollectionDefaultIndex(String command_str) {
+    }
+
+    private Element parseSubCollectionDefaultIndex(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        if(tokenizer.countTokens() == 2) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        if(tokenizer.countTokens() == 2) {
         command_element = document.createElement(SUBCOLLECTION_DEFAULT_INDEX_ELEMENT);
         tokenizer.nextToken();
@@ -1467 +1383 @@
         StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER);
         while(content_tokenizer.hasMoreTokens()) {
-            Element content_element = document.createElement(CONTENT_ELEMENT);
-            content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
-            command_element.appendChild(content_element);
-            content_element = null;
+            Element content_element = document.createElement(CONTENT_ELEMENT);
+            content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
+            command_element.appendChild(content_element);
+            content_element = null;
         }
         content_tokenizer = null;
         content_str = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch(Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseSubCollectionIndex(String command_str) {
+    }
+
+    private Element parseSubCollectionIndex(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        tokenizer.nextToken();
-        if(tokenizer.hasMoreTokens()) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        tokenizer.nextToken();
+        if(tokenizer.hasMoreTokens()) {
         command_element = document.createElement(SUBCOLLECTION_INDEXES_ELEMENT);
-        }
-        while(tokenizer.hasMoreTokens()) {
+        }
+        while(tokenizer.hasMoreTokens()) {
         Element subcollectionindex_element = document.createElement(INDEX_ELEMENT);
         //command_element.setAttribute(CONTENT_ATTRIBUTE, tokenizer.nextToken());
@@ -1496 +1412 @@
         StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER);
         while(content_tokenizer.hasMoreTokens()) {
-            Element content_element = document.createElement(CONTENT_ELEMENT);
-            content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
-            subcollectionindex_element.appendChild(content_element);
-            content_element = null;
+            Element content_element = document.createElement(CONTENT_ELEMENT);
+            content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
+            subcollectionindex_element.appendChild(content_element);
+            content_element = null;
         }
         content_tokenizer = null;
@@ -1505 +1421 @@
         command_element.appendChild(subcollectionindex_element);
         subcollectionindex_element = null;
-        }
-        tokenizer = null;
+        }
+        tokenizer = null;
     }
     catch (Exception exception) {
     }
     return command_element;
-    }
-
-    private Element parseSuperCollection(String command_str) {
+    }
+
+    private Element parseSuperCollection(String command_str) {
     Element command_element = null;
     try {
-        StringTokenizer tokenizer = new StringTokenizer(command_str);
-        if(tokenizer.countTokens() >= 3) {
+        StringTokenizer tokenizer = new StringTokenizer(command_str);
+        if(tokenizer.countTokens() >= 3) {
         command_element = document.createElement(SUPERCOLLECTION_ELEMENT);
         tokenizer.nextToken();
         while(tokenizer.hasMoreTokens()) {
-            Element collection_element = document.createElement(COLLECTION_ELEMENT);
-            collection_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
-            command_element.appendChild(collection_element);
-            collection_element = null;
-        }
-        }
-        tokenizer = null;
+            Element collection_element = document.createElement(COLLECTION_ELEMENT);
+            collection_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
+            command_element.appendChild(collection_element);
+            collection_element = null;
+        }
+        }
+        tokenizer = null;
     }
     catch(Exception exception) {
     }
     return command_element;
-    }
-
-    private String pluginToString(Element command_element, boolean show_extracted_namespace) {
+    }
+
+    private String pluginToString(Element command_element, boolean show_extracted_namespace) {
     StringBuffer text = new StringBuffer();
     if(!command_element.getAttribute(SEPARATOR_ATTRIBUTE).equals(TRUE_STR)) {
-        text.append(PLUGIN_STR);
-        text.append(TAB_CHARACTER);
-        text.append(TAB_CHARACTER);
-        text.append(command_element.getAttribute(TYPE_ATTRIBUTE));
-        // Retrieve, and output, the arguments
-        NodeList option_elements = command_element.getElementsByTagName(OPTION_ELEMENT);
-        int option_elements_length = option_elements.getLength();
-        if(option_elements_length > 0) {
+        text.append(PLUGIN_STR);
+        text.append(TAB_CHARACTER);
+        text.append(TAB_CHARACTER);
+        text.append(command_element.getAttribute(TYPE_ATTRIBUTE));
+        // Retrieve, and output, the arguments
+        NodeList option_elements = command_element.getElementsByTagName(OPTION_ELEMENT);
+        int option_elements_length = option_elements.getLength();
+        if(option_elements_length > 0) {
         text.append(SPACE_CHARACTER);
         for(int j = 0; j < option_elements_length; j++) {
-            Element option_element = (Element) option_elements.item(j);
-            if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
+            Element option_element = (Element) option_elements.item(j);
+            if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
             text.append(StaticStrings.MINUS_CHARACTER);
             text.append(option_element.getAttribute(NAME_ATTRIBUTE));
             String value_str = MSMUtils.getValue(option_element);
             if(!show_extracted_namespace && value_str.startsWith(EXTRACTED_PREFIX)) {
-                value_str = value_str.substring(EXTRACTED_PREFIX.length());
+                value_str = value_str.substring(EXTRACTED_PREFIX.length());
             }
             if(value_str.length() > 0) {
-                text.append(SPACE_CHARACTER);
-                if(value_str.indexOf(SPACE_CHARACTER) == -1) {
+                text.append(SPACE_CHARACTER);
+                if(value_str.indexOf(SPACE_CHARACTER) == -1) {
                 text.append(value_str);
-                }
-                else {
+                }
+                else {
                 text.append(SPEECH_CHARACTER);
                 text.append(value_str);
                 text.append(SPEECH_CHARACTER);
-                }
+                }
             }
             value_str = null;
             if(j < option_elements_length - 1) {
-                text.append(SPACE_CHARACTER);
-            }
-            }
-            option_element = null;
-        }
-        }
-        option_elements = null;
+                text.append(SPACE_CHARACTER);
+            }
+            }
+            option_element = null;
+        }
+        }
+        option_elements = null;
     }
     return text.toString();
-    }
-
-    private String searchtypeToString(Element command_element) {
+    }
+
+    private String searchtypeToString(Element command_element) {
     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
-        StringBuffer text = new StringBuffer(SEARCHTYPE_STR);
-        text.append(TAB_CHARACTER);
-        NodeList search_elements = command_element.getElementsByTagName(CONTENT_ELEMENT);
-        int search_elements_length = search_elements.getLength();
-        for(int i = 0; i < search_elements_length; i++) {
+        StringBuffer text = new StringBuffer(SEARCHTYPE_STR);
+        text.append(TAB_CHARACTER);
+        NodeList search_elements = command_element.getElementsByTagName(CONTENT_ELEMENT);
+        int search_elements_length = search_elements.getLength();
+        for(int i = 0; i < search_elements_length; i++) {
         Element search_element = (Element) search_elements.item(i);
         text.append(search_element.getAttribute(NAME_ATTRIBUTE));
         text.append(SPACE_CHARACTER);
-        }
-        return text.substring(0, text.length() - 1);
+        }
+        return text.substring(0, text.length() - 1);
     }
     else {
-        return null;
-    }
-    }
-
-    private String subcollectionToString(Element command_element, boolean show_extracted_namespace) {
+        return null;
+    }
+    }
+
+    private String subcollectionToString(Element command_element, boolean show_extracted_namespace) {
     StringBuffer text = new StringBuffer(SUBCOLLECTION_STR);
     text.append(SPACE_CHARACTER);
@@ -1605 +1521 @@
     text.append(SPEECH_CHARACTER);
     if(command_element.getAttribute(TYPE_ATTRIBUTE).equals(EXCLUDE_STR)) {
-        text.append(EXCLAIMATION_CHARACTER);
+        text.append(EXCLAIMATION_CHARACTER);
     }
     String content_str = command_element.getAttribute(CONTENT_ATTRIBUTE);
     if(!show_extracted_namespace && content_str.startsWith(EXTRACTED_PREFIX)) {
-        content_str = content_str.substring(EXTRACTED_PREFIX.length());
+        content_str = content_str.substring(EXTRACTED_PREFIX.length());
     }
     text.append(content_str);
@@ -1618 +1534 @@
     String options_str = command_element.getAttribute(OPTIONS_ATTRIBUTE);
     if(options_str.length() > 0) {
-        text.append(options_str);
+        text.append(options_str);
     }
     options_str = null;
     text.append(SPEECH_CHARACTER);
     return text.toString();
-    }
-
-    private String subcollectionDefaultIndexToString(Element command_element) {
+    }
+
+    private String subcollectionDefaultIndexToString(Element command_element) {
     StringBuffer text = new StringBuffer(SUBCOLLECTION_DEFAULT_INDEX_STR);
     text.append(TAB_CHARACTER);
@@ -1631 +1547 @@
     int content_elements_length = content_elements.getLength();
     for(int j = 0; j < content_elements_length; j++) {
-        Element content_element = (Element) content_elements.item(j);
-        text.append(content_element.getAttribute(NAME_ATTRIBUTE));
-        if(j < content_elements_length - 1) {
+        Element content_element = (Element) content_elements.item(j);
+        text.append(content_element.getAttribute(NAME_ATTRIBUTE));
+        if(j < content_elements_length - 1) {
         text.append(StaticStrings.COMMA_CHARACTER);
-        }
+        }
     }
     return text.toString();
-    }
-
-    private String subcollectionIndexesToString(Element command_element) {
+    }
+
+    private String subcollectionIndexesToString(Element command_element) {
     StringBuffer text = new StringBuffer(SUBCOLLECTION_INDEX_STR);
     text.append(TAB_CHARACTER);
@@ -1647 +1563 @@
     int subcollectionindex_elements_length = subcollectionindex_elements.getLength();
     if(subcollectionindex_elements_length == 0) {
-        return null;
+        return null;
     }
     for(int j = 0; j < subcollectionindex_elements_length; j++) {
-        Element subcollectionindex_element = (Element) subcollectionindex_elements.item(j);
-        NodeList content_elements = subcollectionindex_element.getElementsByTagName(CONTENT_ELEMENT);
-        int content_elements_length = content_elements.getLength();
-        for(int k = 0; k < content_elements_length; k++) {
+        Element subcollectionindex_element = (Element) subcollectionindex_elements.item(j);
+        NodeList content_elements = subcollectionindex_element.getElementsByTagName(CONTENT_ELEMENT);
+        int content_elements_length = content_elements.getLength();
+        for(int k = 0; k < content_elements_length; k++) {
         Element content_element = (Element) content_elements.item(k);
         text.append(content_element.getAttribute(NAME_ATTRIBUTE));
         if(k < content_elements_length - 1) {
-            text.append(StaticStrings.COMMA_CHARACTER);
-        }
-        }
-        if(j < subcollectionindex_elements_length - 1) {
+            text.append(StaticStrings.COMMA_CHARACTER);
+        }
+        }
+        if(j < subcollectionindex_elements_length - 1) {
         text.append(SPACE_CHARACTER);
-        }
+        }
     }
     return text.toString();
-    }
-
-    private String supercollectionToString(Element command_element) {
+    }
+
+    private String supercollectionToString(Element command_element) {
     NodeList content_elements = command_element.getElementsByTagName(COLLECTION_ELEMENT);
     int content_elements_length = content_elements.getLength();
     if(content_elements_length > 1) {
-        StringBuffer text = new StringBuffer(SUPERCOLLECTION_STR);
-        text.append(TAB_CHARACTER);
-        for(int j = 0; j < content_elements_length; j++) {
+        StringBuffer text = new StringBuffer(SUPERCOLLECTION_STR);
+        text.append(TAB_CHARACTER);
+        for(int j = 0; j < content_elements_length; j++) {
         Element content_element = (Element) content_elements.item(j);
         text.append(content_element.getAttribute(NAME_ATTRIBUTE));
         if(j < content_elements_length - 1) {
-            text.append(SPACE_CHARACTER);
-        }
-        }
-        return text.toString();
+            text.append(SPACE_CHARACTER);
+        }
+        }
+        return text.toString();
     }
     return null;
-    }
-
-    private String unknownToString(Element command_element) {
+    }
+
+    private String unknownToString(Element command_element) {
     return MSMUtils.getValue(command_element);
-    }
-
-    /** Write the text to the buffer. This is used so we don't have to worry about storing intermediate String values just so we can calaulate length and offset.
-     * @param writer the BufferedWriter to which the str will be written
-     * @param str the String to be written
-     */
-    private void write(BufferedWriter writer, String str)
+    }
+
+    /** Write the text to the buffer. This is used so we don't have to worry about storing intermediate String values just so we can calaulate length and offset.
+     * @param writer the BufferedWriter to which the str will be written
+     * @param str the String to be written
+     */
+    private void write(BufferedWriter writer, String str)
     throws IOException {
     writer.write(str, 0, str.length());
-    }
+    }
 }

trunk/gli/src/org/greenstone/gatherer/cdm/CollectionDesignManager.java

@@ -96 +96 @@
     classifier_manager = new ClassifierManager();
     general_manager = new GeneralManager();
-    
+
     searchtype_manager = new SearchTypeManager(collect_config.getSearchType());
     if(searchtype_manager.isMGPPEnabled()) {
@@ -104 +104 @@
         index_manager = new IndexManager(collect_config.getMGIndexes());
     }
-    
+
     metadataset_view = new MetadataSetView();
     plugin_manager = new PlugInManager();
@@ -156 +156 @@
     general_manager.gainFocus();
     }
-   
+
     /** Retrieve the name of the collection configuration file which is being used as the source of the information in this object.
      * @return The files absolute path as a <strong>String</strong>.
@@ -192 +192 @@
      collection_released = true;
       }
-      
+
       general_manager.loseFocus();
       collect_config.save();
-      
+
       // Readd collection
       ///ystem.err.println("Would have added collection if it had been released.");
@@ -206 +206 @@
       }
     }
-   
+
+   /** Ensures that the collection is now public. Useful for collections that are based on another, or that are about to be exported */
+   public void setCollectionAsPublic() {
+       CollectionMeta public_collectionmeta = new CollectionMeta(CollectionDesignManager.collect_config.getPublic());
+       if(public_collectionmeta != null) {
+            public_collectionmeta.setValue(CollectionConfiguration.TRUE_STR);
+            public_collectionmeta = null;
+       }
+   }
+
     /** Method used during a global search and replace to highlight the appropriate record within the Collection Design Managers version of the Metadata Set Manager (view only).
      * @param element The name of the desired element as a <strong>String</strong>.
@@ -221 +230 @@
     private class CDMChangeListener
     implements ActionListener, DocumentListener {
-    
+
     public void actionPerformed(ActionEvent event) {
         Gatherer.c_man.getCollection().setSaved(false);
@@ -230 +239 @@
         Gatherer.c_man.getCollection().setSaved(false);
     }
-          
+
     /** Gives notification that there was an insert into the document. */
     public void insertUpdate(DocumentEvent e) {
         Gatherer.c_man.getCollection().setSaved(false);
     }
-         
+
     /** Gives notification that a portion of the document has been removed. */
     public void removeUpdate(DocumentEvent e) {

trunk/gli/src/org/greenstone/gatherer/cdm/CommandTokenizer.java

@@ -38 +38 @@
 
 /**************************************************************************************
- * Title:        Gatherer
+ * Title:       Gatherer
  * Description:  The Gatherer: a tool for gathering and enriching a digital collection.
- * Company:      The University of Waikato
- * Written:      07/05/02
- * Revised:      03/10/02 - Commented
+ * Company:   The University of Waikato
+ * Written:   07/05/02
+ * Revised:   03/10/02 - Commented
  **************************************************************************************/
+import java.io.BufferedReader;
 import java.util.StringTokenizer;
+import org.greenstone.gatherer.Gatherer;
+import org.greenstone.gatherer.util.StaticStrings;
 
 /** This class provides an extension to the standard StringTokenizer in that it recognizes quotes (or some form of bracketting) enclose a single token so in something like: <br>format Search '&lt;table&gt;&lt;img src=... &lt;/table&gt;'<br> the formatting string is parsed as a single token. Unfortunately this makes countTokens() unreliable for exact measurement of tokens remaining, and only useful for determining if there are tokens left to be processed (includes any that have already been read into command buffer).
@@ -50 +53 @@
  * @version 2.3
  */
-public class CommandTokenizer
-    extends StringTokenizer {
-
-    private int last_type = -1;
-
-    static final public int BRACKET_ENCLOSED      = 0;
-    static final public int DOUBLE_QUOTE_ENCLOSED = 1;
-    static final public int NORMAL                = 2;
-    static final public int QUOTE_ENCLOSED        = 3;
-
-    /** Constructor.
-     * @param command The command <strong>String</strong> you wish to tokenize.
-     */
-    public CommandTokenizer(String command) {
-    super(command);
-    }
-
-    /* private int getLastType() {
-    return last_type;
-    } */
-
-    /* private boolean isComment() {
-    return (last_type == DOUBLE_QUOTE_ENCLOSED || last_type == QUOTE_ENCLOSED);
-    } */
-
-    /** Method to retrieve the next token from the command, taking care to group tokens enclosed in speech marks.
-     * @return A <strong>String</strong> containing the next token from the command.
-     */
-    public String nextToken() {
-    String result = null;
-    if(hasMoreTokens()) {
-        StringBuffer buffer = new StringBuffer(super.nextToken());
-        switch(buffer.charAt(0)) {
-        case '\"':
-        while((buffer.length() == 1 || buffer.charAt(buffer.length() - 1) != '\"') && hasMoreTokens()) {
-            buffer.append(" ");
-            buffer.append(super.nextToken());
-            ///ystem.err.println("Current Buffer = '" + buffer.toString() + "'");
-        }
-        ///ystem.err.println("Final Buffer = '" + buffer.toString() + "'");
-        last_type = DOUBLE_QUOTE_ENCLOSED;
-        break;
-        case '\'':
-        while((buffer.length() == 1 || buffer.charAt(buffer.length() - 1) != '\'') && hasMoreTokens()) {
-            buffer.append(" ");
-            buffer.append(super.nextToken());
-        }
-        last_type = QUOTE_ENCLOSED;
-        break;
-        case '[':
-        while((buffer.length() == 1 || buffer.charAt(buffer.length() - 1) != ']') && hasMoreTokens()) {
-            buffer.append(" ");
-            buffer.append(super.nextToken());
-        }
-        last_type = BRACKET_ENCLOSED;
-        break;
-        default:
-        last_type = NORMAL;
-        }
-        result = buffer.toString();
-    }
-    return result;
-    }
-
-    /** Unfortunately the StringBuffer doesn't have a built in endsWith method, so I'll just have to implement my own.
-     * @param str The <strong>StringBuffer</strong> we are checking the end of.
-     * @param target The <strong>String</strong> fragment we are searching for.
-     * @return <i>true</i> if str ends with target, <i>false</i> otherwise.
-     */
-    private boolean endsWith(StringBuffer str, String target) {
-    String temp = str.toString();
-    if(temp.endsWith(target) != (str.lastIndexOf(target) == str.length() - target.length())) {
-        ///ystem.err.println("Holy error that'll crash the HFile creator if it happens twice, Batman!");
-        ///ystem.err.println("String = '" + temp + "'");
-        ///ystem.err.println("Target = '" + target + "'");
-    }
-    return str.lastIndexOf(target) == str.length() - target.length();
-    }
+public class CommandTokenizer {
+
+    static final public int BRACKET_ENCLOSED            = 0;
+    static final public int DOUBLE_QUOTE_ENCLOSED   = 1;
+    static final public int NORMAL                      = 2;
+    static final public int QUOTE_ENCLOSED              = 3;
+
+    private BufferedReader in_stream;
+    private int count = -1;
+    private StringTokenizer internal_tokenizer;
+
+    /** Basic Constructor. Used to parse tokens from a string keeping tokens surrounded by speechmarks or square brackets intact. Thus something like:<br>
+     * collectionmeta collectionextra [l = en] "Hello World"<br>
+     * is tokenized thus<br>
+     * {'collectionmeta', 'collectionextra', 'l = en', 'Hello World'}
+     * @param command the command String you wish to tokenize
+     */
+    public CommandTokenizer(String command) {
+        this.internal_tokenizer = new StringTokenizer(command);
+        this.in_stream = null;
+    }
+
+    /** Advanced Constructor. As above but with one major difference. Since it is provided an input stream (presumably where the command string originated from), it is able to parse a quote enclosed command token that stretches over several lines. Each newline is preserved in the resulting token. There is an extra bitchslap here as comething like a collection extra might have html code in them that contain escaped speechmarks, so extra care must be taken not to break at them. Thus something like:<br>
+     * collectionmeta collectionextra [l = en] "<br>
+     *     an example of the crazy as description we sometimes get which includes of all things something like <a href=\"this.html\"<br>
+     *     >this</a> which you could easily see might be a problem if I parse this niavely."<br>
+     * is tokenized thus<br>
+     * {'collectionmeta', 'collectionextra', 'l = en', '\nan example of the crazy as description we sometimes get which includes of all things something like <a href=\"this.html\"\n>this</a> which you could easily see might be a problem if I parse this niavely.'}
+     * @param command the command String you wish to tokenize
+     * @param in_stream a BufferedReader from which the tokenizer can draw further lines as necessary
+     */
+    public CommandTokenizer(String command, BufferedReader in_stream) {
+        ///atherer.println("***** CommandTokenizer *****\nparse:\t" + command + "\n****************************");
+        this.internal_tokenizer = new StringTokenizer(command);
+        this.in_stream = in_stream;
+    }
+
+    /** Returns the minumum number of remaining tokens before the tokenizer runs out of string. There may be more tokens than this count, but never less. The discrepancy is due to internal functionality and the fact we can't read ahead in the string or associated stream without risking the need for unpredictable push-back
+     * @return the minumum number of tokens available as an int
+     */
+    public int countTokens() {
+        if(count == 0 && internal_tokenizer.countTokens() > 1) {
+             return 1;
+        }
+        if(count == -1) {
+             count = internal_tokenizer.countTokens();
+        }
+        return count;
+    }
+
+    /** Determine if there are still tokens available.
+     * @return true if there are more tokens, false otherwise
+     */
+    public boolean hasMoreTokens() {
+         return internal_tokenizer.hasMoreTokens();
+    }
+
+    /** Method to retrieve the next token from the command, taking care to group tokens enclosed in speech marks.
+     * @return a String containing the next token from the command
+     */
+    public String nextToken() {
+        String result = null;
+        if(internal_tokenizer.hasMoreTokens()) {
+            StringBuffer buffer = new StringBuffer(internal_tokenizer.nextToken());
+            switch(buffer.charAt(0)) {
+                case StaticStrings.DOUBLEQUOTE_CHAR:
+                    result = buildToken(buffer, StaticStrings.DOUBLEQUOTE_CHAR, true);
+                    break;
+                case StaticStrings.SINGLEQUOTE_CHAR:
+                    result = buildToken(buffer, StaticStrings.SINGLEQUOTE_CHAR, true);
+                    break;
+                case StaticStrings.OPENBRACKET_CHAR:
+                    result = buildToken(buffer, StaticStrings.CLOSEBRACKET_CHAR, false);
+                    break;
+                default:
+                    result = buffer.toString();
+            }
+            buffer = null;
+        }
+        // Because of our tricky counting system we never want to have negative tokens remaining. In fact, unless the internal string buffer is empty, we will return a count of 1 anyway
+        if(count > 0) {
+            count = count - 1;
+        }
+        ///atherer.println("----- CommandTokenizer -----\ntoken:\t" + result + "\n----------------------------");
+        return result;
+    }
+
+    /** Parse in the next token. paying heed to enclosing characters demands, escaped characters, newlines and empty buffers and consequential unexpected end of tokens
+     * @param buffer the StringBuffer in which the partial token is stored (at the first bit that caused this method to be called)
+     * @param end_char the sentinel char we are watching for as it encloses a token
+     * @param strip_characters a boolean denoting whether the enclosing characters should be stripped off
+     * @return the token, either in its entirity less the enclosing characters if required or, if an unexpected end occured, whatever we parsed without its starting enclosing character, again only if required. In fact if we weren't asked to strip characters then we add the enclosing character back in
+     */
+    private String buildToken(StringBuffer buffer, char end_char, boolean strip_characters) {
+        while(buffer.charAt(buffer.length() - 1) != end_char || (buffer.length() > 3 && buffer.charAt(buffer.length() - 2) == StaticStrings.BACKSLASH_CHAR)) {
+            try {
+                // The first version is for the basic tokenizer which has no idea of an input stream, so runs out tokens at the same time as the internal tokenizer does
+                if(internal_tokenizer.hasMoreTokens()) {
+                    buffer.append(StaticStrings.SPACE_CHAR);
+                    buffer.append(internal_tokenizer.nextToken());
+                }
+                // While the second version can draw more lines from the stream until eof occurs
+                else if(in_stream != null) {
+                    String line_str = null;
+                    while(!internal_tokenizer.hasMoreTokens() && (line_str = in_stream.readLine()) != null) {
+                        ///atherer.println("+++++ CommandTokenizer +++++\nappend:\t" + line_str + "\n+++++++++++++++++++++++++++++");
+                        // Its at this stage the our token count becomes completely patu
+                        internal_tokenizer = new StringTokenizer(line_str);
+                        buffer.append(StaticStrings.NEW_LINE_CHAR); // A new line in the final token
+                    }
+                    line_str = null;
+                    if(internal_tokenizer.hasMoreTokens()) {
+                        // Don't add a space if we just added a newline
+                        if(buffer.charAt(buffer.length() - 1) != StaticStrings.NEW_LINE_CHAR) {
+                            buffer.append(StaticStrings.SPACE_CHAR);
+                        }
+                        buffer.append(internal_tokenizer.nextToken());
+                    }
+                    // We've prematurely run out of content, so throw the dummy, or at least return whatever we managed to parse sans its opening character
+                    else {
+                        if(strip_characters) {
+                            return buffer.substring(1);
+                        }
+                        else {
+                            buffer.append(end_char);
+                            return buffer.toString();
+                        }
+                    }
+                }
+                // We've prematurely run out of content, so throw the dummy, or at least return whatever we managed to parse sans its opening character
+                else {
+                    if(strip_characters) {
+                        return buffer.substring(1);
+                    }
+                    else {
+                        buffer.append(end_char);
+                        return buffer.toString();
+                    }
+                }
+            }
+            // Exception throw when we attempted reading from the input stream, so throw the dummy, or at least return whatever we managed to parse sans its opening character
+            catch(Exception exception) {
+                Gatherer.printStackTrace(exception);
+                if(strip_characters) {
+                    return buffer.substring(1);
+                }
+                else {
+                    buffer.append(end_char);
+                    return buffer.toString();
+                }
+            }
+        }
+        // Return the string sans enclosing characters
+        if(buffer.length() > 0 && strip_characters) {
+            return buffer.substring(1, buffer.length() - 1);
+        }
+        else {
+            return buffer.toString();
+        }
+    }
 }

trunk/gli/src/org/greenstone/gatherer/cdm/GeneralManager.java

@@ -133 +133 @@
     /** This class represents the visual component of the general options stored in the CollectionDesignManager. */
     private class GeneralControl
-    extends JPanel 
+    extends JPanel
     implements Control {
     private boolean ready = false;
@@ -262 +262 @@
         instruction_panel.add(title_label, BorderLayout.NORTH);
         instruction_panel.add(new JScrollPane(instructions_textarea), BorderLayout.CENTER);
-        
+
         creator_panel.setLayout(new BorderLayout());
         creator_panel.add(creator_label, BorderLayout.WEST);
@@ -334 +334 @@
         small_icon_textfield.setText(icon_collection_small_collectionmeta.getValue(CollectionMeta.TEXT));
         small_icon_textfield.setCaretPosition(0);
+        // I forgot to keep the checkboxes up to date. Why hasn't this caused problems before today?
+        public_checkbox.setSelected(public_collectionmeta.getValue(CollectionMeta.TEXT).equals(CollectionConfiguration.TRUE_STR));
+        beta_checkbox.setSelected(beta_collectionmeta.getValue(CollectionMeta.TEXT).equals(CollectionConfiguration.TRUE_STR));
         ready = true;
     }
@@ -343 +346 @@
         beta_collectionmeta.setValue((beta_checkbox.isSelected() ? CollectionConfiguration.TRUE_STR : CollectionConfiguration.FALSE_STR));
         public_collectionmeta.setValue((public_checkbox.isSelected() ? CollectionConfiguration.TRUE_STR : CollectionConfiguration.FALSE_STR));
-        creator_collectionmeta.setValue(creator_emailfield.getText());
+        String creator_email_str = creator_emailfield.getText();
+        creator_collectionmeta.setValue(creator_email_str);
+        Gatherer.config.setEmail(creator_email_str); // Store the email address in the configuration
         collection_extra_collectionmeta.setValue(description_textarea.getText());
         icon_collection_collectionmeta.setValue(icon_textfield.getText());
@@ -356 +361 @@
     private class BrowseListener
         implements ActionListener {
-        
+
         public void actionPerformed(ActionEvent event) {
         // Open an almost standard file browser to the images folder of the current collection
@@ -405 +410 @@
         }
         }
-        
+
         /** ImageFilter.java is a 1.4 example used by FileChooserDemo2.java. */
-        private class ImageFilter 
+        private class ImageFilter
         extends javax.swing.filechooser.FileFilter {
-        
+
         private Pattern pattern = null;
-        
+
         public ImageFilter() {
             pattern = Pattern.compile(".*\\.(gif|png|jpe?g)");
         }
-        
+
         // Accept all directories and all .col files
         public boolean accept(File f) {
@@ -422 +427 @@
             return f.isDirectory() || matcher.matches();
         }
-        
+
         // The description of this filter
         public String getDescription() {

trunk/gli/src/org/greenstone/gatherer/cdm/IndexManager.java

@@ -331 +331 @@
     Gatherer.c_man.configurationChanged();
     }
-    
+
     /** This method is reponsible for changing the underlying Index commands from MG to MGPP and back again. This turns out to be easyish for MG->MGPP and very hard for the reverse. For the former we remove the level fragment and make sure the same levels are set, then we produce a list of the sources involved, breaking down comma seperated lists and making sure each item it unique. Changing back the other way turns out to be impossible, so we don't (beyond generating document:text, section:text and paragraph:text if text is an index and the respective levels are present). In either case we start by creating a comment containing the old index information.
      * @param  state true to enable MGPP indexes, false to use standard MG style ones
@@ -378 +378 @@
             index = null;
             }
-            // Replace mg element with mgpp element 
+            // Replace mg element with mgpp element
             setRoot(mgpp_element);
 
@@ -426 +426 @@
         }
         else {
-            // Replace mg element with mgpp element 
+            // Replace mg element with mgpp element
             setRoot(mgpp_element);
         }
@@ -444 +444 @@
             default_index.setAssigned(true);
         }
-        // If mg element has no indexes, and the current mgpp index include a text one, then generate text indexes for each of the registered levels. 
+        // If mg element has no indexes, and the current mgpp index include a text one, then generate text indexes for each of the registered levels.
         NodeList indexes = mgpp_element.getElementsByTagName(CollectionConfiguration.INDEX_ELEMENT);
         if(indexes.getLength() == 0) {
@@ -489 +489 @@
     /** This class creates a set of controls for editing the indexes. */
     private class IndexControl
-    extends JPanel 
+    extends JPanel
     implements Control {
 
@@ -728 +728 @@
         else if(source_list.isSelectionEmpty()) {
         add_enabled = false;
-        } 
+        }
         // If we get this far, create a dummy index and see if its already assigned in the collection
         else {
@@ -806 +806 @@
         return component;
         }
-          
+
     }
 
     private class MoveListener
         implements ActionListener {
-        
+
         private boolean move_up;
 
@@ -849 +849 @@
     private class SetDefaultListener
         implements ActionListener {
-        
+
         public void actionPerformed(ActionEvent event) {
         Index index = (Index) index_list.getSelectedValue();
@@ -879 +879 @@
         validateAddButton();
         }
-        
+
         /** Gives notification that there was an insert into the document. */
         public void insertUpdate(DocumentEvent e) {
         validateAddButton();
         }
-        
+
         /** Gives notification that a portion of the document has been removed. */
         public void removeUpdate(DocumentEvent e) {
@@ -928 +928 @@
         // Create Indexes
         JPanel indexes_panel = new JPanel();
-        
+
         JPanel current_indexes_panel = new JPanel();
 
@@ -1053 +1053 @@
         index_spacer_panel.add(index_body_panel, BorderLayout.NORTH);
         index_spacer_panel.add(index_empty_panel, BorderLayout.CENTER);
-        
+
         indexes_panel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
         indexes_panel.setLayout(new BorderLayout());
@@ -1061 +1061 @@
         // Create Levels
         JPanel levels_panel = new JPanel();
-        
+
         JPanel current_levels_panel = new JPanel();
 
@@ -1119 +1119 @@
         add_level_button.setMnemonic(KeyEvent.VK_A);
         Dictionary.registerBoth(add_level_button, "CDM.IndexManager.MGPP.Add_Level", "CDM.IndexManager.MGPP.Add_Level_Tooltip");
-        
+
         remove_level_button = new JButton("CDM.IndexManager.MGPP.Remove_Level");
         remove_level_button.setEnabled(false);
@@ -1173 +1173 @@
         level_spacer_panel.add(level_body_panel, BorderLayout.NORTH);
         level_spacer_panel.add(level_empty_panel, BorderLayout.CENTER);
-        
+
         levels_panel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
         levels_panel.setLayout(new BorderLayout());
@@ -1181 +1181 @@
         // Create General
         JPanel header_panel = new JPanel();
-        
+
         title_label = new JLabel();
         title_label.setHorizontalAlignment(JLabel.CENTER);
@@ -1376 +1376 @@
         validateAddButton();
         }
-          
+
         /** Gives notification that a portion of the document has been removed.
          * @param  event a DocumentEvent containing information about the text removed
@@ -1383 +1383 @@
         validateAddButton();
         }
-        
+
         /** Change the enable state of the add button depending on the current value in the search type combobox. */
         public void validateAddButton() {
@@ -1438 +1438 @@
         validateAddButton();
         }
-          
+
         /** Gives notification that a portion of the document has been removed.
          * @param  event a DocumentEvent containing information about the text removed
@@ -1445 +1445 @@
         validateAddButton();
         }
-        
+
         /** Change the enable state of the add button depending on the current value in the search type combobox. */
         public void validateAddButton() {
@@ -1500 +1500 @@
 
     /** Replace really only replaces the string. */
-    private class ReplaceIndexActionListener 
+    private class ReplaceIndexActionListener
         implements ActionListener {
 
@@ -1526 +1526 @@
         }
     }
-    
+
     private class RemoveIndexActionListener
         implements ActionListener {

trunk/gli/src/org/greenstone/gatherer/cdm/MetadataSetView.java

@@ -158 +158 @@
     /** This class creates and lays-out the various controls for reviewing the metadata sets, and their commands as they would appear in the collection configuration file. */
     private class MetadataSetControl
-    extends JPanel 
+    extends JPanel
     implements Control {
     /** The label denoting the element list. */
@@ -324 +324 @@
         String namespace = set.getNamespace();
         // Watch out for the greenstone set, with its namespace of ""
-        if(namespace == null || namespace.length() == 0) {
-        namespace = "greenstone";
-        }
-        return "metadataset " + namespace + " \"" + set.getFile().getName() + "\"";
+        return "metadataset " + namespace + " \"" + set.getName() + "\"";
     }
     }

trunk/gli/src/org/greenstone/gatherer/cdm/PlugInManager.java

@@ -967 +967 @@
      */
     private class RemoveListener
-        implements ActionListener {
-        /** Any implementation of <i>ActionListener</i> must include this method so that we can be informed when an action has occured on one of our target controls.
-         * @param event An <strong>ActionEvent</strong> containing information garnered from the control action.
-         */
-        public void actionPerformed(ActionEvent event) {
-        if(!plugin_list.isSelectionEmpty()) {
-            Object [] objects = plugin_list.getSelectedValues();
-            for(int i = 0; i < objects.length; i++) {
-            if(objects[i] instanceof PlugIn) {
-                removePlugIn((PlugIn)objects[i]);
+        implements ActionListener {
+        /** Any implementation of <i>ActionListener</i> must include this method so that we can be informed when an action has occured on one of our target controls.
+         * @param event An <strong>ActionEvent</strong> containing information garnered from the control action.
+         */
+        public void actionPerformed(ActionEvent event) {
+            int selected_index = plugin_list.getSelectedIndex();
+            if(selected_index != -1) {
+                PlugIn selected_plugin = (PlugIn) plugin_list.getSelectedValue();
+                removePlugIn(selected_plugin);
+                selected_plugin = null;
+                // Select the next plugin if available
+                if(selected_index < plugin_list.getModel().getSize()) {
+                    // If the new selection is above the separator we can remove it
+                    if(selected_index < findSeparatorIndex()) {
+                        plugin_list.setSelectedIndex(selected_index);
+                        remove.setEnabled(true);
+                    }
+                    // Otherwise select the first non-removable plugin
+                    else {
+                        plugin_list.setSelectedIndex(selected_index + 1);
+                        remove.setEnabled(false);
+                    }
+                }
+                else {
+                    remove.setEnabled(false);
+                }
+                // Refresh the available plugins
+                plugin.setModel(new DefaultComboBoxModel(getAvailable()));
             }
-            }
-            // Refresh the available plugins
-            plugin.setModel(new DefaultComboBoxModel(getAvailable()));
-        }
-        remove.setEnabled(false);
-        }
+            else {
+                remove.setEnabled(false);
+            }
+            /*
+            if(!plugin_list.isSelectionEmpty()) {
+                Object [] objects = plugin_list.getSelectedValues();
+                for(int i = 0; i < objects.length; i++) {
+                    if(objects[i] instanceof PlugIn) {
+                        removePlugIn((PlugIn)objects[i]);
+                    }
+                }
+                // Refresh the available plugins
+                plugin.setModel(new DefaultComboBoxModel(getAvailable()));
+            }
+            */
+        }
     }
     }

trunk/gli/src/org/greenstone/gatherer/cdm/SearchTypeManager.java

@@ -29 +29 @@
 /**************************************************************************************
  * Written:      16/07/03
- * Revised:      
+ * Revised:
  **************************************************************************************/
 import java.awt.*;
@@ -82 +82 @@
     return controls;
     }
-    
-    public String getSearchTypes() {
-    StringBuffer search_types = new StringBuffer();
-    ArrayList types = children();
-    for (int i=0; i<types.size(); i++) {
-        if (i>0) {
-        search_types.append(",");
-        }
-        search_types.append(((SearchType)types.get(i)).getName());
-    }
-    return search_types.toString();
-    }
-    /** Be examining the SearchType 'root' we were created with, determine if mgpp is enabled.
-     * @return true if MGPP is enabled, false otherwise
-     */
-    public boolean isMGPPEnabled() {
-    return root.getAttribute(CollectionConfiguration.ASSIGNED_ATTRIBUTE).equals(CollectionConfiguration.TRUE_STR);
-    }
+
+    /** Return a list of the currently assigned search types as a comma separated string.
+     * @return a String
+     */
+    public String getSearchTypes() {
+        StringBuffer search_types = new StringBuffer();
+        ArrayList types = children();
+        for (int i = 0; i < types.size(); i++) {
+            if (i>0) {
+                search_types.append(",");
+            }
+            search_types.append(((SearchType)types.get(i)).getName());
+        }
+        return search_types.toString();
+    }
+
+    /** Be examining the SearchType 'root' we were created with, determine if mgpp is enabled.
+     * @return true if MGPP is enabled, false otherwise
+     */
+    public boolean isMGPPEnabled() {
+        return root.getAttribute(CollectionConfiguration.ASSIGNED_ATTRIBUTE).equals(CollectionConfiguration.TRUE_STR);
+    }
 
     public void moveSearchType(SearchType search_type, boolean direction) {
@@ -127 +131 @@
     remove(search_type);
     add(index, search_type);
-    Gatherer.c_man.configurationChanged(); 
+    Gatherer.c_man.configurationChanged();
     }
 
@@ -147 +151 @@
     private JButton move_up_button;
     private JButton remove_button;
-    
+
     private JCheckBox enable_advanced_searches_checkbox;
 
@@ -267 +271 @@
         inner_panel.add(current_search_types_panel, BorderLayout.CENTER);
         inner_panel.add(search_type_panel, BorderLayout.SOUTH);
-        
+
         spacer_panel.setLayout(new BorderLayout());
         spacer_panel.add(inner_panel, BorderLayout.NORTH);
@@ -280 +284 @@
     public void destroy() {
     }
-    
+
     public void gainFocus() {
         instructions_textarea.setCaretPosition(0);
@@ -413 +417 @@
 
     /** Listens for changes in the search types combobox, and enabled add button appropriately. */
-    private class SearchTypesActionDocumentListener 
+    private class SearchTypesActionDocumentListener
         implements ActionListener, DocumentListener {
         /** Called whenever a selection action occurs on the combobox.
@@ -434 +438 @@
         validateAddButton();
         }
-          
+
         /** Gives notification that a portion of the document has been removed.
          * @param  event a DocumentEvent containing information about the text removed
@@ -441 +445 @@
         validateAddButton();
         }
-        
+
         /** Change the enable state of the add button depending on the current value in the search type combobox. */
         private void validateAddButton() {

trunk/gli/src/org/greenstone/gatherer/cdm/SuperCollectionManager.java

@@ -37 +37 @@
 import org.greenstone.gatherer.checklist.CheckList;
 import org.greenstone.gatherer.checklist.Entry;
-import org.greenstone.gatherer.collection.CollectionConfiguration;
+import org.greenstone.gatherer.collection.BasicCollectionConfiguration;
 import org.greenstone.gatherer.util.StaticStrings;
 import org.greenstone.gatherer.util.Utility;
@@ -43 +43 @@
 
 /** This class contains the information about what supercollection has been specified (if any) and methods for changing this information. Note that there is a major difference between this manager and the others in that its DOM model is never used directly in any list component. It is only used to decide whether a certain entry in the actual checklist is checked. */
-public class SuperCollectionManager 
+public class SuperCollectionManager
     extends DOMProxyListModel {
 
@@ -107 +107 @@
     /** Provides controls for altering the SuperCollection settings. */
     private class SuperCollectionControl
-    extends JPanel 
+    extends JPanel
     implements Control {
 
@@ -119 +119 @@
         // Creation
         JPanel header_panel = new JPanel();
-        
+
         JLabel title_label = new JLabel();
         title_label.setHorizontalAlignment(JLabel.CENTER);
@@ -141 +141 @@
         header_panel.add(title_label, BorderLayout.NORTH);
         header_panel.add(new JScrollPane(instructions), BorderLayout.CENTER);
-        
+
         setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
         setLayout(new BorderLayout());
@@ -198 +198 @@
         File collect_cfg_file = new File(possible_collections[i], Utility.CONFIG_DIR);
         if(collect_cfg_file.exists()) {
-            CollectionConfiguration collect_cfg = new CollectionConfiguration(collect_cfg_file);
+            BasicCollectionConfiguration collect_cfg = new BasicCollectionConfiguration(collect_cfg_file);
             String collection_title = collect_cfg.getName();
             String collection_name = possible_collections[i].getName();
@@ -210 +210 @@
             collection_checklist_model.add(entry);
             entry = null;
-            
+
             }
             collection_name = null;