source: trunk/gli/src/org/greenstone/gatherer/sarm/SearchAndReplace.java@ 4360

package org.greenstone.gatherer.sarm;
/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.regex.*;
import javax.swing.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.file.FileNode;
import org.greenstone.gatherer.gui.CollectionPane;
import org.greenstone.gatherer.gui.MetaEditPane;
import org.greenstone.gatherer.gui.MetaEditPrompt;
import org.greenstone.gatherer.gui.table.GTableModel;
import org.greenstone.gatherer.msm.ElementWrapper;
import org.greenstone.gatherer.msm.Metadata;
import org.greenstone.gatherer.util.EnumeratedVector;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.util.XORToggleButtonGroup;
import org.greenstone.gatherer.valuetree.GValueModel;
import org.greenstone.gatherer.valuetree.GValueNode;
/** Provides a convenient class which searches through all of the various data attached to a collection, globally searching and replacing values as necessary, and firing the relevant events to have the gui update properly. 
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3
 */
public class SearchAndReplace
     extends JDialog {
     /** <i>true</i> if this dialog should allow for the replace and replace all buttons to be validated, <i>false</i> otherwise. */
     private boolean enable_replace = false;
     /** <i>true</i> if the last call to find() found something, <i>false</i> otherwise. */
     private boolean found = false;
     /** The size of the current screen real-estate. */
     private Dimension screen_size = Toolkit.getDefaultToolkit().getScreenSize();
     /** The metadata element that we are currently inspecting. If we are anywhere but within the find() function, then this is the last element found that matched the search string. */
     private ElementWrapper current_element = null;
     /** A vector containing the result of a depth first enumeration of the records in the collection record set tree. */
     private EnumeratedVector records = null;
     /** The file record that we are currently inspecting. If we are anywhere but within the find() function, and the target type is a FileNode, then this is the last record that matched our search string. Otherwise this is the record that the last metadata value that matched resides in. */
     private FileNode current_record = null;
     /** The button used to close the dialog. Has the same action as the destroy button. */
     private JButton close_button = null;
     /** The button used to begin a find() function call. Something must be typed in the search field before this button becomes active. */
     private JButton find_button = null;
     /** The button used to repeat the find() call in order to find the next matching object. Note this only becomes active after a successful find button press. */
     private JButton find_next_button = null;
     /** Redoes the action the was last undoes. Doesn't become active until there are job that are undone to be redone. :P */
     private JButton redo_button = null;
     /** Replaces the currently selected object with the given replacement text. The selection was determined by find() either as part of a previous action, or immediately before the replace() is called. This button only become active if there is something typed in the search and replace fields and if enable_replace is set. */
     private JButton replace_button = null;
     /** Replace all occurances of the search string with the replace string. This returns to the start of the collection and replaced every single matching reference. It only becomes enabled if something is typed in the search and replace fields and enable_replace is set. */
     private JButton replace_all_button = null;
     /** When pressed this button returns the 'searching pointer' back to the start of the collection. This is used when there are no further matches for your query, or at anytime you wish to start a new query. This button only becomes active after a success find(). */
     private JButton reset_button = null;
     /** This button undoes any changes made by the previous action, such as restoring all objects affected by a replace all. It only makes sense for this button to be active after a successful action. */
     private JButton undo_button = null;
     /** When checked this control indicates the search comparisons should be made taking into account case. Otherwise the case becomes irrelevant to matching. */
     private JCheckBox case_sensitive = null;
     /** When checked the SARM treats both search and replace string as regular expression when matching and replacing. */
     private JCheckBox regular_expression = null;
     /** When checked the SARM will search the metadata element identifiers for values that match your search string. Note that at least one of the search domains is selected at all times. */
     private JCheckBox search_elements = null;
     /** When checked the SARM will search the file records in the collection for values that match your search string. Note that at least one of the search domains is selected at all times. */
     private JCheckBox search_records = null;
     /** When checked the SARM will search the metadata values associated with each file record in the collection for values that match your search string. Note that at least one of the search domains is selected at all times. */ 
     private JCheckBox search_values = null;
     /** The status label shows the result of the last action. */
     private JLabel status = null;
     /** This field is used to enter a string which is in turn used to replace any text value that matches the search string. If enable_replace is not set, this field remains grayed out. If enabled, and you type within this field the replace buttons will become active. */
     private JTextField replace = null;
     /** The value entered in the search field is used to determine what object should be selected and brought to your attention. Note that this field can contain plain text or a regular expression, and that any typing in this field automatically resets the find() functions state to the start of the collection. */
     private JTextField search = null;
     /** Whenever a string is tested against the compiled regular Pattern, a Matcher is created. Not only does this matcher allow us to determine if the test string matches the pattern, but is can be subsequently used during a replace action to evaluate special 'capture group flags' within a regular expression based replace string.<BR><BR>For instance:Seach - '(.*)fug(.*)' will match 'Refugee'<BR>and<BR>Replace - '\1\1\1. \2' will replace the match with 'ReReRe. ee'. */
     private Matcher matcher = null;
     /** This is the current metadata value that we are inspecting. If non-null anywhere other then in the find() method, then this is the last metadata value that matched on search string. However it makes no sense by itself, and current_record is needed to actually reference this piece of metadata. */
     private Metadata current_value = null;
     /** This is used to determine the target class of any object whose text component we are trying to replace. It is actually set to the last object that matched the search string. */
     private Object target = null;
     /** This object is created by compiling a regular expression string retrieved from the search field, and in only non-null when regualr_expressions is checked. By compiling it once at the very beginning of the find() method, we lower processing time. Note that pattern is set to null whenever the find() state is reset. */ 
     private Pattern pattern = null;
     /** A reference to ourselves so that our inner classes can dispose of us for the insurance money. */
     private SearchAndReplace self = null;
     /** A stack of actions that have been undone, wait to be done again. */
     private Stack redo = new Stack();
     /** A stack of actions that have been done, waiting to undo. */
     private Stack undo = new Stack();
     /** A vector of the metadata elements attached to this collection, in the form of ElementWrappers for ease of data access. */ 
     private Vector elements = null;
     /** The default size for a label, used to produce purty column alignment. */
     static final private Dimension LABEL_SIZE = new Dimension(120, 30);
     /** The default size for the dialog. */
     static final private Dimension SIZE = new Dimension(640,210);
     /** Constructor.
      * @param enable_replace <i>true</i> if this dialog can be used for replace actions, <i>false</i> otherwise.
      */
     public SearchAndReplace(boolean enable_replace) {
          super();
          ///ystem.err.println("Creating a new search and replace dialog.");
          this.enable_replace = enable_replace;
          this.self = this;
          // Creation
          setModal(false);
          setSize(SIZE);
          setTitle(get("Title"));
          JPanel content_pane = (JPanel) getContentPane();

          JPanel central_pane = new JPanel();

          JPanel search_pane = new JPanel();
          JLabel search_label = new JLabel(get("Search"));
          search_label.setPreferredSize(LABEL_SIZE);
          search = new JTextField("");

          JPanel replace_pane = new JPanel();
          JLabel replace_label = new JLabel(get("Replace"));
          replace_label.setPreferredSize(LABEL_SIZE);
          replace = new JTextField("");
          replace.setEnabled(enable_replace);     
          if(!enable_replace) {
                replace.setBackground(Color.lightGray);
          }

          JPanel options_pane = new JPanel();
          JLabel options_label = new JLabel(get("Options"));
          options_label.setPreferredSize(LABEL_SIZE);
          JPanel inner_options_pane = new JPanel();
          case_sensitive = new JCheckBox(get("Case_Sensitive"));
          regular_expression = new JCheckBox(get("Regular_Expression"));
          
          JPanel options2_pane = new JPanel();
          JLabel options2_label = new JLabel(get("Search_In"));
          options2_label.setPreferredSize(LABEL_SIZE);
          JPanel inner_options2_pane = new JPanel();
          XORToggleButtonGroup check_box_group = new XORToggleButtonGroup();
          search_elements = new JCheckBox(get("Search_Elements"));
          search_elements.setSelected(true);
          check_box_group.add(search_elements);
          search_records = new JCheckBox(get("Search_Records"));
          search_records.setSelected(true);
          check_box_group.add(search_records);
          search_values = new JCheckBox(get("Search_Values"));
          search_values.setSelected(true);
          check_box_group.add(search_values);

          JPanel results_pane = new JPanel();
          status = new JLabel(get("Status"));

          JPanel buttons_pane = new JPanel();
          find_button = new JButton(get("Find_Button"));
          find_button.setMnemonic(KeyEvent.VK_F);
          find_next_button = new JButton(get("Find_Next_Button"));
          find_next_button.setEnabled(false);
          find_next_button.setMnemonic(KeyEvent.VK_N);
          replace_button = new JButton(get("Replace_Button"));
          replace_button.setEnabled(false);
          replace_button.setMnemonic(KeyEvent.VK_R);
          replace_all_button = new JButton(get("Replace_All_Button"));
          replace_all_button.setEnabled(false);
          replace_all_button.setMnemonic(KeyEvent.VK_N);
          reset_button = new JButton(get("Reset"));
          reset_button.setEnabled(false);
          reset_button.setMnemonic(KeyEvent.VK_ESCAPE);
          undo_button = new JButton(get("Undo"));
          undo_button.setEnabled(false);
          undo_button.setMnemonic(KeyEvent.VK_U);
          redo_button = new JButton(get("Redo"));
          redo_button.setEnabled(false);
          redo_button.setMnemonic(KeyEvent.VK_D);
          close_button = new JButton(get("General.Close"));
          close_button.setMnemonic(KeyEvent.VK_C);
          // Connection
          close_button.addActionListener(new CloseActionListener());
          find_button.addActionListener(new FindActionListener());
          find_next_button.addActionListener(new FindNextActionListener());
          redo_button.addActionListener(new RedoActionListener());
          replace.addActionListener(new FindActionListener());
          replace_button.addActionListener(new ReplaceActionListener());
          replace_all_button.addActionListener(new ReplaceAllActionListener());
          reset_button.addActionListener(new ResetActionListener());
          undo_button.addActionListener(new UndoActionListener());
          replace.addKeyListener(new ReplaceKeyListener());
          search.addKeyListener(new SearchKeyListener());
          // Layout
          search_label.setBorder(BorderFactory.createEmptyBorder(0,0,0,5));

          search_pane.setLayout(new BorderLayout());
          search_pane.add(search_label, BorderLayout.WEST);
          search_pane.add(search, BorderLayout.CENTER);

          replace_label.setBorder(BorderFactory.createEmptyBorder(0,0,0,5));
          
          replace_pane.setBorder(BorderFactory.createEmptyBorder(2,0,0,0));
          replace_pane.setLayout(new BorderLayout());
          replace_pane.add(replace_label, BorderLayout.WEST);
          replace_pane.add(replace, BorderLayout.CENTER);

          inner_options_pane.setLayout(new GridLayout(1,2));
          inner_options_pane.add(case_sensitive);
          inner_options_pane.add(regular_expression);

          options_pane.setBorder(BorderFactory.createEmptyBorder(2,0,0,0));
          options_pane.setLayout(new BorderLayout());
          options_pane.add(options_label, BorderLayout.WEST);
          options_pane.add(inner_options_pane, BorderLayout.CENTER);

          inner_options2_pane.setLayout(new GridLayout(1,3));
          inner_options2_pane.add(search_elements);
          inner_options2_pane.add(search_records);
          inner_options2_pane.add(search_values);

          options2_pane.setBorder(BorderFactory.createEmptyBorder(2,0,0,0));
          options2_pane.setLayout(new BorderLayout());
          options2_pane.add(options2_label, BorderLayout.WEST);
          options2_pane.add(inner_options2_pane, BorderLayout.CENTER);

          results_pane.setBorder(BorderFactory.createRaisedBevelBorder());
          results_pane.setLayout(new BorderLayout());
          results_pane.add(status, BorderLayout.CENTER);

          central_pane.setLayout(new GridLayout(5,1));
          central_pane.add(search_pane);
          central_pane.add(replace_pane);
          central_pane.add(options_pane);
          central_pane.add(options2_pane);
          central_pane.add(results_pane);
          
          buttons_pane.setBorder(BorderFactory.createEmptyBorder(2,0,0,0));
          buttons_pane.setLayout(new GridLayout(2,4));
          buttons_pane.add(find_button);
          buttons_pane.add(find_next_button);
          buttons_pane.add(replace_button);
          buttons_pane.add(replace_all_button);
          buttons_pane.add(reset_button);
          buttons_pane.add(undo_button);
          buttons_pane.add(redo_button);
          buttons_pane.add(close_button);

          content_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
          content_pane.setLayout(new BorderLayout());
          content_pane.add(central_pane, BorderLayout.CENTER);
          content_pane.add(buttons_pane, BorderLayout.SOUTH);
          // Reset data.
          reset();
          // Restore visual position.
          setLocation((screen_size.width - SIZE.width) / 2, (screen_size.height - SIZE.height) / 2);
          show();
     }
     /** Updates the status bar to reflect the result of the latest action. Includes the ability to reset the status label whenever the find() state resets.
      * @param key A <strong>String</strong> of text to use as the explaination of the actions result.
      * @param optional_count An <i>int</i> which if any value, other than -1, shows the number of objects the action was performed on. 
      */
     private void changeStatus(String key, int optional_count) {
          String args[] = null;
          if(optional_count >= 0) {
                args = new String[2];
                args[1] = "" + optional_count + "";
          }
          else {
                args = new String[1];
          }
          if(key != null) {
                args[0] = search.getText();
                status.setText(get("Status") + ": " + get(key, args));
          }
          else {
                status.setText(get("Status"));
          }
     }
     /** The guts of this module, the find method, in conjunction with the matches method, searches through the several targetted domains looking for values which match the search string, returning true while leaving itself in a state that points to the matching object if one is found. What exact part of each object is matched against is decided by the objects type, and in one case this is made even more complex as one type of object exists inside the other so we need to carefully iterate through the inner before increamenting the outer. 
      * @param <i>true</i> if a match was found thus the current_<object> parameters are pointing to it, otherwise <i>false</i>.
      */
     private boolean find() {
          boolean local_found = false;
          String find_str = search.getText();
          if(find_str.length() > 0) {
                // If a pattern currently hasn't been compiled, compile one.
                if(pattern == null) {
                     // If no actual regular expression script is present add .* to either end of the search string so we actually search for content of the target string not exact equality.
                     if(!regular_expression.isSelected()) {
                          find_str = "(.*)("+find_str+")(.*)";  
                     }
                     // Compile pattern
                     try {
                          if(case_sensitive.isSelected()) {
                                pattern = Pattern.compile(find_str);
                          }
                          else {
                                pattern = Pattern.compile(find_str.toLowerCase());
                          }
                     }
                     catch(Exception error) {
                     }
                }
                // Search through the metadata elements if required for a matching entry.
                if(search_elements.isSelected()) {
                     for(int i = (current_element != null ? elements.indexOf(current_element) + 1 : 0); !local_found && i < elements.size(); i++) {
                          current_element = (ElementWrapper) elements.get(i);
                          if(match(current_element.getIdentity())) {
                                local_found = true;
                                target = current_element;
                                fireSelect(current_element);
                          }
                     }
                }
                // Search through file names.
                if(!local_found && (search_records.isSelected() || search_values.isSelected()) && (records.hasMoreElements() || current_record != null)) {
                     if(current_record == null) {
                          current_record = (FileNode)records.nextElement();
                     }
                     while(!local_found && (current_record != null || records.hasMoreElements())) {
                          // Try to match current record (if we haven't already).
                          if(match(current_record.toString()) && search_records.isSelected() && current_record != target) {
                                local_found = true;
                                target = current_record;
                                fireSelect(current_record);
                          }
                          else {
                                // Search through metadata values is required.
                                if(search_values.isSelected()) {
                                     ArrayList metadatum = Gatherer.c_man.getCollection().gdm.getMetadata(current_record.getFile());
                                     for(int i = (current_value != null ? metadatum.indexOf(current_value) + 1 : 0); !local_found && i < metadatum.size(); i++) {
                                          current_value = (Metadata)metadatum.get(i);
                                          if(match(current_value.getValue())) {
                                                local_found = true;
                                                target = current_value;
                                                fireSelect(current_record, current_value);
                                          }
                                     }
                                     if(!local_found) {
                                          current_value = null;
                                     }
                                }
                          }
                          if(!local_found) {
                                current_record = (FileNode)records.nextElement();
                          }
                     }
                }
          }
          return local_found;
     }
     /** When a metadata element that matches our search string is found, this method is called to provide a visual cue as to what element matched in which collection. This is done by changing the tab view of the main gui and selecting the correct line from the list of sets/elements on one screen of the CDM. This method subsequently calls unhideBound() passing in the bounds of the selected component (cell or row). 
      * @param element The <strong>ElementWrapper</strong> that matches our search string.
      */
     private void fireSelect(ElementWrapper element) {
          // Ensure the CDM view is visible.
          Gatherer.g_man.setSelectedView(Gatherer.g_man.config_pane);
          // Select the correct metadata element
          Rectangle bounds = Gatherer.g_man.config_pane.setSelectedElement(element);
          unhideSelection(bounds);
     }
     /** When a file record that matches our search string is found, this method is called to provide a visual cue as to what file matched. This is done by changing the tab view of the main gui and expanding and selecting the correct line from the tree of file records. This method subsequently calls unhideBound() passing in the bounds of the selected component (cell or row). 
      * @param record The <strong>FileNode</strong> that matches our search string.
      */
     private void fireSelect(FileNode record) {
          // Ensure that either the CollectionPane or the MetaEditPane is visible. If not make the CollectionPane visible.
          Gatherer.g_man.setSelectedView(Gatherer.g_man.collection_pane);
          // Select the appropriate record.
          TreePath path = new TreePath(record.getPath());
          Rectangle bounds = Gatherer.g_man.collection_pane.expandPath(path);
          unhideSelection(bounds);
     }
     /** When a metadata value that matches our search string is found, this method is called to provide a visual cue as to what value from which file matched. This is done by changing the tab view of the main gui and expanding and selecting the correct line from the tree of file records, and then highlighting the appropriate line of the metadata table. This method subsequently calls unhideBound() passing in the bounds of the selected component (cell or row). 
      * @param record The <strong>FileNode</strong> that matches our search string.
      */
     private void fireSelect(FileNode record, Metadata metadata) {
          // Ensure that either the MetaEditPane is visible.
          Gatherer.g_man.setSelectedView(Gatherer.g_man.metaedit_pane);
          // Select the appropriate record in the metaedit pane tree, which will cause the Metadata table to update with the appropriate bunch of metadata... 
          TreePath path = new TreePath(record.getPath());
          Gatherer.g_man.metaedit_pane.expandPath(path);
          // Now select the correct metadata.
          Rectangle bounds = Gatherer.g_man.metaedit_pane.setSelectedMetadata(metadata);
          unhideSelection(bounds);
     }
     /** Retrieve a pharse string from the Dictionary matching the given key.
      * @param key The <strong>String</strong> which maps to a certain phrase.
      * @return The required, locale specific, phrase as a <strong>String</strong>.
      * @see org.greenstone.gatherer.Dictionary
      */
     private String get(String key) {
          return get(key, null);
     }
     /** Retrieve a pharse string from the Dictionary matching the given key and based apon the given arguments.
      * @param key The <strong>String</strong> which maps to a certain phrase.
      * @param args The argument Strings to the Dictionary, as a <strong>String[]</strong>.
      * @return The required, locale specific, phrase as a <strong>String</strong>.
      * @see org.greenstone.gatherer.Dictionary
      */
     private String get(String key, String args[]) {
          if(key.indexOf(".") == -1) {
                key = "SearchAndReplace." + key;
          }
          return Gatherer.dictionary.get(key, args);
     }
     /** Used to determine is one string matches another tkaing into account the options of case sensitivity and regular expressions.
      * @param find_str The search <strong>String</strong> we are trying to find. This may be a regular expression.
      * @param target_str The <strong>String</strong> we are matching it against, as provided by some object.
      * @return <i>true</i> if the Strings match given the option settings, <i>false</i> otherwise.
      */
     private boolean match(String target_str) {
          ///ystem.err.println("Matching " + target_str + " against " + pattern.pattern());
          boolean result = false;
          if(!case_sensitive.isSelected()) {
                target_str = target_str.toLowerCase();
          }
          try {
                matcher = pattern.matcher(target_str);
                result = matcher.matches();
          }
          catch(Exception error) {
          }
          return result;
     }
     /** Called once by the replace button, or repeatedly by replace all, in order to replace the text of the target object, as referenced by the current_<object>s, with the replace text string. This takes into account if regular expressions are expected, and modifies the replacement string with appropriate 'capture groups'. 
      * @return <i>true</i> if the replace action was successful, <i>false</i> otherwise.
      */
     private boolean replace() {
          boolean result = false;
          String replace_str = replace.getText();
          // If regular expressions are allowed, we have to search for regular expression commands and deal with them.
          if(matcher != null) {
                StringBuffer temp = new StringBuffer("");
                int index_ptr = 0;
                while(index_ptr < replace_str.length()) {
                     char c = replace_str.charAt(index_ptr);
                     // First we check for escaped regualr expression commands which start '\\'
                     if(c == '\\') {
                          index_ptr++;
                          char s = replace_str.charAt(index_ptr);
                          if(s == '\\') {
                                index_ptr++;
                                char i = replace_str.charAt(index_ptr);
                                // I currently only support one regular expression command, 'capture groups'.
                                if(Character.isDigit(i)) {
                                     try {
                                          int group_num = Character.getNumericValue(i);
                                          if(group_num <= matcher.groupCount()) {
                                                temp.append(matcher.group(group_num));
                                          }
                                     }
                                     catch (Exception error) {
                                     }
                                }
                          }
                          // The \ had nothing to do with groups, so I guess its a path marker.
                          else {
                                temp.append(c);
                                temp.append(s);
                          }
                     }
                     else {
                          temp.append(c);
                     }
                     index_ptr++;
                }
                replace_str = temp.toString();
          }
          if(found && replace_str.length() > 0) {
                if(target instanceof ElementWrapper) {
                     undo.push(new UndoItem(current_element, current_element.getIdentity(), replace_str));
                     updateElement(current_element, replace_str);
                     result = true;
                }
                if(target instanceof FileNode) {
                     undo.push(new UndoItem(current_record, current_record.toString(), replace_str));
                     updateRecord(current_record, replace_str);
                     result = true;
                }
                if(target instanceof Metadata) {
                     // If we are replacing metadata value there is a bit more messaging we need to do to any replacement string to ensure that any hierarchy context is transferred to the new value, so...
                     String absolute_value = current_value.getAbsoluteValue();
                     if(absolute_value.indexOf("\\") != -1) {
                          String absolute_path = absolute_value.substring(0, absolute_value.lastIndexOf("\\") + 1);
                          replace_str = absolute_path + replace_str;
                          ///ystem.err.println("I replaced a hierarchy value like so:\n"+absolute_value+"\nto\n"+replace_str);
                     }
                     undo.push(new UndoItem(current_value, current_record, current_value.getValue(), replace_str));
                     updateMetadata(current_value, current_record, replace_str);
                     result = true;
                }
          }
          ///ystem.err.println("Undo queue length = " + undo.size());
          return result;
     }
     /** Used to restore the search space within the collection to its initial state for find(). 
      */
     private void reset() {
          current_element = null;
          current_record = null;
          current_value = null;
          elements = Gatherer.c_man.getCollection().msm.getElements();
          found = false;
          matcher = null;
          pattern = null;
          records = Utility.depthFirstEnumeration((TreeNode)Gatherer.c_man.getRecordSet().getRoot(), new EnumeratedVector());
          target = null;
     }
     /** Attempts to move the dialog so that it doesn't obscure the coordinates detailed. Can't always do so. 
      * @param bounds A <strong>Rectangle</strong> around the selected component, with co-ordinates corrected to be absolute to the screen rather than relative to whatever parent component the selection was in. 
      */
     private void unhideSelection(Rectangle bounds) {
          /** @TODO - Elsewhere generate absolute references. Here make use of them. */
          ///ystem.err.println("Unhide selection with bounds " + bounds);
     }
     /** Whenever replace(), the undo action listener or the redo action listener wants to actually change the value of an element it uses this method. Hows that for code reuse.
      * @param element The <strong>ElementWrapper</strong> containing the metadata element we want to change.
      * @param value The new text value for the elements identifier as a <strong>String</strong>.
      */
     private void updateElement(ElementWrapper element, String value) {
          Gatherer.c_man.getCollection().msm.renameElement(element, value);
     }
     /** Whenever replace(), the undo action listener or the redo action listener wants to actually change the value of a metadata value it uses this method. Hows that for code reuse.
      * @param metadata The <strong>Metadata</strong> we want to change.
      * @param record The <strong>FileNode</strong> the target metadata will be found in.
      * @param value The new text value for the metadata as a <strong>String</strong>.
      */
     private void updateMetadata(Metadata metadata, FileNode record, String value) {
          FileNode array[] = new FileNode[1];
          array[0] = record;
          Gatherer.c_man.getCollection().msm.updateMetadata(0L, metadata, array, value, MetaEditPrompt.UPDATE_ONCE, metadata.isFileLevel());
     }
     /** Whenever replace(), the undo action listener or the redo action listener wants to actually change the value of a file record it uses this method. Hows that for code reuse.
      * @param record The <strong>FileNode</strong> we want to change.
      * @param value The new text value for the files name as a <strong>String</strong>.
      */
     private void updateRecord(FileNode record, String value) {
          TreeModel model = Gatherer.c_man.getRecordSet();
          /* @todo
              model.rename(record, value);
          */
     }
     /** Several actions methods call this to check if the current state of the dialog allows for the replace butons to become active.
      */
     private void validateReplaceButtons() {
          boolean value = (replace.getText().length() > 0) && enable_replace;
          ///ystem.err.println("Validating replace buttons to " + value);
          replace_button.setEnabled(value);
          replace_all_button.setEnabled(value);
     }

     private class CloseActionListener
          implements ActionListener {
          public void actionPerformed(ActionEvent event) {
                self.dispose();
          }
     }

     private class FindActionListener
          implements ActionListener {
          public void actionPerformed(ActionEvent event) {
                reset();
                if(find()) {
                     find_button.setEnabled(false);
                     find_next_button.setEnabled(true);
                     if(enable_replace) {
                          replace_button.setEnabled(true);
                          replace_all_button.setEnabled(true);
                     }
                     reset_button.setEnabled(true);
                     changeStatus("Found", -1);
                     found = true;
                }
                else {
                     changeStatus("Not_Found", -1);
                     found = false;
                }
          }
     }

     private class FindNextActionListener
          implements ActionListener {
          public void actionPerformed(ActionEvent event) {
                if(find()) {
                     changeStatus("Found", -1);
                     found = true;
                }
                else {
                     find_next_button.setEnabled(false);
                     changeStatus("Not_Found", -1);
                }
          }
     }

     private class RedoActionListener
          implements ActionListener {
          private boolean start = false;
          public void actionPerformed(ActionEvent event) {
                if(!redo.empty()) {
                     start = true;
                     UndoItem redo_item = (UndoItem) redo.pop();
                     while(redo_item != null && !redo_item.isDummy()) {
                          // Determine the type of action we have to undo, then undo it.
                          ElementWrapper element = redo_item.getElement();
                          if(element != null) {
                                updateElement(element, redo_item.getAfter());
                                addToUndo(redo_item);
                          }
                          FileNode record = redo_item.getRecord();
                          Metadata metadata = redo_item.getMetadata();
                          if(metadata != null && record != null) {
                                updateMetadata(metadata, record, redo_item.getAfter());
                                addToUndo(redo_item);
                          }
                          else if(record != null) {
                                updateRecord(record, redo_item.getAfter());
                                addToUndo(redo_item);
                          }
                          if(!redo.empty()) {
                                redo_item = (UndoItem) redo.pop();
                          }
                          else {
                                redo_item = null;
                          }
                     }
                     if(redo.empty()) {
                          redo_button.setEnabled(false);
                     }
                }
          }
          private void addToUndo(UndoItem redo_item) {
                if(start) {
                     undo.push(new UndoItem());
                     start = false;
                }
                undo.push(redo_item);
                undo_button.setEnabled(true);
          }
     }

     private class ReplaceActionListener
          implements ActionListener {
          public void actionPerformed(ActionEvent event) {
                if(!found) {
                     found = find();
                }
                if(found) {
                     undo.push(new UndoItem());
                     replace();
                     replace_button.setEnabled(false);
                     reset_button.setEnabled(true);
                     undo_button.setEnabled(true);
                     changeStatus("Replaced", -1);
                }
                else {
                     find_next_button.setEnabled(false);
                     replace_button.setEnabled(false);
                     replace_all_button.setEnabled(false);
                     changeStatus("Not_Found", -1);
                }
          }
     }

     private class ReplaceAllActionListener
          implements ActionListener {
          public void actionPerformed(ActionEvent event) {
                reset();
                int count = 0;
                boolean start = true;
                while((found = find()) == true) {
                     if(start) {
                          undo.push(new UndoItem());
                          start = false;
                     }
                     count++;
                     replace();
                }
                find_button.setEnabled(false);
                find_next_button.setEnabled(false);
                replace_button.setEnabled(false);
                replace_all_button.setEnabled(false);
                reset_button.setEnabled(true);
                if(!undo.empty()) {
                     undo_button.setEnabled(true);
                }
                changeStatus("Replaced_All", count);
          }
     }

     private class ResetActionListener
          implements ActionListener {
          public void actionPerformed(ActionEvent event) {
                reset();
                find_button.setEnabled(true);
                find_next_button.setEnabled(false);
                replace_button.setEnabled(false);
                replace_all_button.setEnabled(false);
                reset_button.setEnabled(false);
                changeStatus(null, -1);
          }
     }

     private class UndoActionListener
          implements ActionListener {
          private boolean start = false;
          public void actionPerformed(ActionEvent event) {
                if(!undo.empty()) {
                     start = true;
                     UndoItem undo_item = (UndoItem) undo.pop();
                     while(undo_item != null && !undo_item.isDummy()) {
                          // Determine the type of action we have to undo, then undo it.
                          ElementWrapper element = undo_item.getElement();
                          if(element != null) {
                                updateElement(element, undo_item.getBefore());
                                addToRedo(undo_item);
                          }
                          else {
                                FileNode record = undo_item.getRecord();
                                Metadata metadata = undo_item.getMetadata();
                                if(metadata != null && record != null) {
                                     // The old metadata doesn't actually exist anymore. We have to generate a new metadata object based on the old metadata objects element and the 'after' string.
                                     GValueModel model = Gatherer.c_man.getCollection().msm.getValueTree(metadata.getElement());
                                     GValueNode value = model.getValue(undo_item.getAfter());
                                     Metadata new_metadata = new Metadata(metadata.getElement(), value);
                                     updateMetadata(new_metadata, record, undo_item.getBefore());
                                     addToRedo(undo_item);
                                }
                                else if(record != null) {
                                     updateRecord(record, undo_item.getBefore());
                                     addToRedo(undo_item);
                                }
                                else {
                                     ///ystem.err.println("Unknown undo item.");
                                }
                          }
                          if(!undo.empty()) {
                                undo_item = (UndoItem) undo.pop();
                          }
                          else {
                                undo_item = null;
                          }
                     }
                     if(undo.empty()) {
                          undo_button.setEnabled(false);
                     }
                }
          }
          private void addToRedo(UndoItem undo_item) {
                if(start) {
                     redo.push(new UndoItem());
                     start = false;
                }
                redo.push(undo_item);
                redo_button.setEnabled(true);
          }
     }

     private class ReplaceKeyListener
          extends KeyAdapter {
          public void keyTyped(KeyEvent event) {
                validateReplaceButtons();
          }
     }

     private class SearchKeyListener
          extends KeyAdapter {
          public void keyTyped(KeyEvent event) {
                if(current_element != null || current_record != null || current_value != null) {
                     reset();
                     find_button.setEnabled(true);
                     find_next_button.setEnabled(false);
                     replace_button.setEnabled(false);
                     replace_all_button.setEnabled(false);
                     reset_button.setEnabled(false);
                     changeStatus(null, -1);
                }
          }
     }
     
     private class UndoItem {
          private ElementWrapper element = null;
          private FileNode record = null;
          private Metadata metadata = null;
          private String after = null;
          private String before = null;
          /** Constructor for a dummy item, which separates different batches of changes. */
          public UndoItem() {
          }
          public UndoItem(ElementWrapper element, String before, String after) {
                this.after = after;
                this.before = before;
                this.element = element;
          }
          public UndoItem(FileNode record, String before, String after) {
                this.after = after;
                this.before = before;
                this.record = record;
          }
          public UndoItem(Metadata metadata, FileNode record, String before, String after) {
                this.after = after;
                this.before = before;
                this.metadata = metadata;
                this.record = record;
          }
          public String getAfter() {
                return after;
          }
          public String getBefore() {
                return before;
          }
          public ElementWrapper getElement() {
                return element;
          }
          public Metadata getMetadata() {
                return metadata;
          }
          public FileNode getRecord() {
                return record;
          }
          public boolean isDummy() {
                return (element == null && record == null && metadata == null);
          }
     }
}