Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2004 University of New Mexico and the

 *                  Regents of the University of California

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 */

package edu.ucsb.nceas.metacat.harvesterClient;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.PrintStream;

import java.io.PrintWriter;

import java.io.Reader;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.KeyStroke;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.table.TableModel;

import javax.swing.text.Document;

import javax.xml.parsers.ParserConfigurationException;

import org.xml.sax.Attributes;

import org.xml.sax.ContentHandler;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.DefaultHandler;

import org.xml.sax.helpers.XMLReaderFactory;

/**

 * The Harvest List Editor reads a Harvest List XML file and displays it as a

 * JTable. Allows user to add, modify, or delete <Document> elements in the

 * Harvest List, and save changes back to the disk.

 *

 */

public class HarvestListEditor extends JFrame implements ActionListener {

  String clipboardDocumentType = "";

  String clipboardDocumentURL = "";

  String clipboardIdentifier = "";

  String clipboardRevision = "";

  String clipboardScope = "";

	JButton copyButton;

	JButton cutButton;

  String defaultDocumentType;

  String defaultDocumentURL;

  String defaultHarvestList;

  String defaultIdentifier;

  String defaultRevision;

  String defaultScope;

	Document doc;

	JScrollPane docPane;

  JFileChooser fileChooser = new JFileChooser();

  File harvestListFile;

  boolean harvestListHasChanged = false;

	JMenuBar menuBar;

	JButton pasteButton;

	JButton pasteDefaultsButton;

    "eml://ecoinformatics.org/harvestList ../../lib/harvester/harvestList.xsd";

  int selectedRow = -1;

  final JTable table;

  TableModel tableModel;

  String title = "Harvest List Editor";

  // Menu items

  JMenuItem exitMenuItem = new JMenuItem("Exit");

  JMenuItem newMenuItem = new JMenuItem("New");

  JMenuItem openMenuItem = new JMenuItem("Open...");

  JMenuItem saveMenuItem = new JMenuItem("Save");

  JMenuItem saveAsMenuItem = new JMenuItem("Save As...");

  /**

   * The main program. Instantiate the main frame, a HarvestListEditor object.

   *

   * @param args

   */

  public static void main(String[] args) {

    HarvestListEditor harvestListEditor = new HarvestListEditor();

  }

  /**

   * Constructor for HarvestListEditor class.

   */

  public HarvestListEditor() {

		super("Harvest List Editor");

		JPanel buttonPanel = new JPanel();

    String[] fileItems =

                  new String[] {"New", "Open...", "Save", "Save As...", "Exit"};

		JMenu fileMenu = new JMenu("File");

		char[] fileShortCuts = {'N', 'O', 'S', 'A', 'X'};

    TableColumn tableColumn;

    loadProperties();

		setDefaultCloseOperation(EXIT_ON_CLOSE);

		menuBar = new JMenuBar();

    /*

     * Add menu items to the File menu

     */

		newMenuItem.setAccelerator(KeyStroke.getKeyStroke('N',

									                                     java.awt.Event.CTRL_MASK,

                                                       false));

		newMenuItem.addActionListener(this);

		fileMenu.add(newMenuItem);

		openMenuItem.setAccelerator(KeyStroke.getKeyStroke('O',

									                                     java.awt.Event.CTRL_MASK,

                                                       false));

		openMenuItem.addActionListener(this);

		fileMenu.add(openMenuItem);

		saveMenuItem.setAccelerator(KeyStroke.getKeyStroke('S',

									                                     java.awt.Event.CTRL_MASK,

                                                       false));

		saveMenuItem.addActionListener(this);

    saveMenuItem.setEnabled(false);

		fileMenu.add(saveMenuItem);

		saveAsMenuItem.setAccelerator(KeyStroke.getKeyStroke('A',

									                                     java.awt.Event.CTRL_MASK,

                                                       false));

		saveAsMenuItem.addActionListener(this);

		fileMenu.add(saveAsMenuItem);

									                                     java.awt.Event.CTRL_MASK,

                                                       false));

		validateMenuItem.addActionListener(this);

		fileMenu.add(validateMenuItem);

									                                     java.awt.Event.CTRL_MASK,

                                                       false));

		exitMenuItem.addActionListener(this);

		fileMenu.add(exitMenuItem);

		menuBar.add(fileMenu);      // Add the File menu to the menu bar

		setJMenuBar(menuBar);       // Set the frame's menu bar to this menu bar

    //table = new JTable(numRows, numColumns);

    tableColumn = table.getColumnModel().getColumn(0);

    tableColumn = table.getColumnModel().getColumn(1);

    tableColumn = table.getColumnModel().getColumn(2);

    tableColumn.setPreferredWidth(50);

    tableColumn = table.getColumnModel().getColumn(3);

    tableColumn = table.getColumnModel().getColumn(5);

    tableColumn.setPreferredWidth(320);

    table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

    tableModel = table.getModel();

    //Ask to be notified of selection changes.

    ListSelectionModel rowSM = table.getSelectionModel();

    rowSM.addListSelectionListener(new ListSelectionListener() {

      public void valueChanged(ListSelectionEvent e) {

        ListSelectionModel lsm;

        //Ignore extra messages.

        if (e.getValueIsAdjusting()) return;

        lsm = (ListSelectionModel)e.getSource();

        // If now row is selected, disable all buttons.

        if (lsm.isSelectionEmpty()) {

          selectedRow = -1;

          cutButton.setEnabled(false);

          copyButton.setEnabled(false);

          pasteButton.setEnabled(false);

          pasteDefaultsButton.setEnabled(false);

        }

        // If a row is selected, manage the buttons based on the selected row

        // and the current clipboard values.

        else {

          selectedRow = lsm.getMinSelectionIndex();

          manageButtons(selectedRow);

        }

      }

    });

    docPane = new JScrollPane(table);

    getContentPane().add(docPane, BorderLayout.CENTER);

		cutButton = new JButton("Cut");

		copyButton = new JButton("Copy");

		pasteButton = new JButton("Paste");

		pasteDefaultsButton = new JButton("Paste Defaults");

    // Action listener for the Copy button.

    copyButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent ae) {

        copyRow(selectedRow);

        manageButtons(selectedRow);

        harvestListHasChanged = true;

			}

		}

    );

    // Action listener for the Cut button.

    cutButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent ae) {

        cutRow(selectedRow);

        manageButtons(selectedRow);

        harvestListHasChanged = true;

			}

		}

    );

    // Action listener for the Paste button.

    pasteButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent ae) {

        pasteRow(selectedRow);

        manageButtons(selectedRow);

        harvestListHasChanged = true;

			}

		}

    );

    // Action listener for the Paste Defaults button.

    pasteDefaultsButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent ae) {

        pasteDefaultValues(selectedRow);

        manageButtons(selectedRow);

        harvestListHasChanged = true;

			}

		}

    );

    cutButton.setEnabled(false);

    copyButton.setEnabled(false);

    pasteButton.setEnabled(false);

    pasteDefaultsButton.setEnabled(false);

		buttonPanel.add(cutButton);

		buttonPanel.add(copyButton);

		buttonPanel.add(pasteButton);

		buttonPanel.add(pasteDefaultsButton);

		buttonPanel.setOpaque(true);

		getContentPane().add(buttonPanel, BorderLayout.SOUTH);

    // If the default Harvest List option has a value, and the file exists,

    // loads its contents.

    //

    if ((defaultHarvestList != null) && (!defaultHarvestList.equals(""))) {

      harvestListFile = new File(defaultHarvestList);

      if (harvestListFile.exists()) {

        try {

          loadHarvestList(harvestListFile);

          saveMenuItem.setEnabled(true);

        }

        catch (ParserConfigurationException e) {

          System.out.println("Error parsing Harvest List: " + e.getMessage());

        }

      }

    }

      tempFile = File.createTempFile("harvestListTemp", ".xml");

    }

    catch (IOException ioe) {

      System.out.println("Error creating temporary file: " + ioe.getMessage());

    }

  }

  /**

   * Implements action listeners for menu items.

   *

   * @param e   An ActionEvent object, determines the menu item that was

   *            selected.

   */

	public void actionPerformed(ActionEvent e) {

		if ((e.getActionCommand()).equals("New")) {

      fileNew();

		}

		else if ((e.getActionCommand()).equals("Open...")) {

      fileOpen();

    }

    else if ((e.getActionCommand()).equals("Save")) {

      fileSave();

    }

		else if ((e.getActionCommand()).equals("Save As...")) {

      fileSaveAs();

    }

      fileValidate();

    }

      fileExit();

    }

	}

  /**

   * Adds a new row to the table, setting values for each of the five columns

   * in the row.

   *

   * @param rowIndex              the row index

   * @param scope                 the scope string

   * @param identifier            the identifier string

   * @param revision              the revision string

   * @param documentType          the document type

   * @param documentURL           the document URL

   */

  void addRow(int rowIndex, String scope, String identifier, String revision,

              String documentType, String documentURL) {

    tableModel.setValueAt(identifier,            rowIndex, 2);

    tableModel.setValueAt(revision,              rowIndex, 3);

    tableModel.setValueAt(documentType,          rowIndex, 4);

    tableModel.setValueAt(documentURL,           rowIndex, 5);

  /**

   * Composes a single tag line to be written in the Harvest List.

   *

   * @param indentLevel    the number of spaces to begin the line with

   * @param tag            the tag name

   * @param text           the text to insert within the begin and end tags

   * @return line          the composed line

   */

  String composeLine(int indentLevel, String tag, String text) {

    String line = "";

    for (int i = 0; i < indentLevel; i++) {

      line += " ";

    }

    line += "<" + tag + ">";

    line += text;

    line += "</" + tag + ">";

    return line;

  }

  /**

   * Clears all rows in the table, setting all values to null.

   */

  void clearHarvestList() {

    for (int rowIndex = 0; rowIndex < numRows; rowIndex++) {

      clearRow(rowIndex);

    }

  }

  /**

   * Clears a single row in the tables, setting all five fields to null.

   *

   * @param rowIndex   the index to the table row to be cleared

   */

  void clearRow(int rowIndex) {

    tableModel.setValueAt(nil, rowIndex, 1);

    tableModel.setValueAt(nil, rowIndex, 2);

    tableModel.setValueAt(nil, rowIndex, 3);

    tableModel.setValueAt(nil, rowIndex, 5);

  /**

   * Copies the values in a given table row to the clipboard.

   *

   * @param rowIndex  the index of the table row to be copied

   */

  void copyRow(int rowIndex) {

    clipboardIdentifier = (String) tableModel.getValueAt(rowIndex, 2);

    clipboardRevision = (String) tableModel.getValueAt(rowIndex, 3);

    clipboardDocumentType = (String) tableModel.getValueAt(rowIndex, 4);

    clipboardDocumentURL = (String) tableModel.getValueAt(rowIndex, 5);

  /**

   * Cuts a row from the table. The row is copied to the clipboard and then

   * cleared.

   *

   * @param rowIndex  the index of the table row to be copied

   */

  void cutRow(int rowIndex) {

    copyRow(rowIndex);

    clearRow(rowIndex);

  }

  /**

   * Exit from the Harvest List Editor. Prompt to save changes if appropriate.

   */

  void fileExit() {

    int value;

    if (harvestListHasChanged) {

      value = saveChangesDialog();

      if (value == JOptionPane.YES_OPTION) {

        try {

          // Save the changes then exit

          //

          fileSave();

          System.exit(0);

        }

        catch (Exception exception) {

          exception.printStackTrace();

        }

      }

      else if (value == JOptionPane.NO_OPTION) {

        // Exit without saving changes

        System.exit(0);

      }

    }

    else {

      System.exit(0);

    }

  }

  /**

   * Replace the current Harvest List with an empty Harvest List. Prompt to save

   * changes if appropriate.

   */

  void fileNew() {

    int value;

    if (harvestListHasChanged) {

      value = saveChangesDialog();

      if (value == JOptionPane.YES_OPTION) {

        try {

          fileSave();

        }

        catch (Exception exception) {

          exception.printStackTrace();

        }

      }

      else if (value == JOptionPane.CANCEL_OPTION) {

        return;

      }

    }

    clearHarvestList();

    harvestListFile = null;

    harvestListHasChanged = false;

  }

  /**

   * Opens a file dialog to load a Harvest List. Prompts to save changes to the

   * current Harvest List if appropriate.

   */

  void fileOpen() {

    int value;

    if (harvestListHasChanged) {

      value = saveChangesDialog();

      if (value == JOptionPane.YES_OPTION) {

        try {

          fileSave();

        }

        catch (Exception exception) {

          exception.printStackTrace();

        }

      }

      else if (value == JOptionPane.CANCEL_OPTION) {

        return;

      }

    }

    value = fileChooser.showOpenDialog(HarvestListEditor.this);

    if (value == JFileChooser.APPROVE_OPTION) {

      harvestListFile = fileChooser.getSelectedFile();

      try {

        clearHarvestList();

        loadHarvestList(harvestListFile);

      }

      catch (ParserConfigurationException e) {

        System.out.println("Error parsing Harvest List: " + e.getMessage());

      }

      harvestListHasChanged = false;

      saveMenuItem.setEnabled(true);

    }

  }

  /**

   * Save the current Harvest List to disk.

   */

  void fileSave() {

    if (harvestListFile != null) {

      writeFile(harvestListFile);

      harvestListHasChanged = false;

    }

    else {

      System.out.println("No action taken");

    }

  }

  /**

   * Save the current Harvest List as a potentially different file name.

   */

  void fileSaveAs() {

    int returnVal;

    returnVal = fileChooser.showOpenDialog(HarvestListEditor.this);

    if (returnVal == JFileChooser.APPROVE_OPTION) {

      harvestListFile = fileChooser.getSelectedFile();

      writeFile(harvestListFile);

      harvestListHasChanged = false;

    }

  }

  /**

   * Validate the Harvest List that is currently stored in the table. This is

   * implemented by writing the Harvest List to a temporary file and then

   * running the SAX parser on the temporary file.

   */

  void fileValidate() {

    FileInputStream fis;

    HarvestListHandler harvestListHandler = new HarvestListHandler();

    InputStreamReader inputStreamReader;

    boolean loadHarvestList = false;

    boolean validateHarvestList = true;

    writeFile(tempFile);

    try {

      fis = new FileInputStream(tempFile);

      inputStreamReader = new InputStreamReader(fis);

      harvestListHandler.runParser(this, inputStreamReader, schemaLocation,

                                   loadHarvestList, validateHarvestList);

      fis.close();

      tempFile.delete();

      harvestListMessage("Harvest List is valid");

    }

    catch (SAXException e) {

      harvestListMessage("Validation error: " + e.getMessage());

    }

    catch (ClassNotFoundException e) {

      System.out.println("ClassNotFoundException: " + e.getMessage());

    }

    catch (IOException ioe) {

      System.out.println("Error opening file: " + ioe.getMessage());

    }

  }

  /**

   *

   * @param message       the message text

   */

  void harvestListMessage(String message) {

    JOptionPane.showMessageDialog(this, message);

  }

  /**

   * Initializes the Harvest List table, filling column 0 with row numbers.

   * This is a non-editable column, so its values should never change after

   * this point.

   */

  void initHarvestList() {

    for (int rowIndex = 0; rowIndex < numRows; rowIndex++) {

      tableModel.setValueAt(new Integer(rowIndex + 1).toString(), rowIndex, 0);

    }

  }

  /**

   * empty if all five of the fields are empty.

   *

   * @return      true if the clipboard is empty, else false

   */

  boolean isEmptyClipboard() {

    boolean isEmpty = true;

    isEmpty = isEmpty && (clipboardScope.equals(""));

    isEmpty = isEmpty && (clipboardIdentifier.equals(""));

    isEmpty = isEmpty && (clipboardRevision.equals(""));

    isEmpty = isEmpty && (clipboardDocumentType.equals(""));

    isEmpty = isEmpty && (clipboardDocumentURL.equals(""));

    return isEmpty;

  }

  /**

   * Determines whether a given row in the table is empty. A row is empty if

   * all five of its fields contain either null or "".

   *

   * @param rowIndex    the index to the row in the table that is being checked

   * @return            true if the row is empty, else false

   */

  boolean isEmptyRow(int rowIndex) {

    boolean isEmpty = true;

    String identifier = (String) tableModel.getValueAt(rowIndex, 2);

    String revision = (String) tableModel.getValueAt(rowIndex, 3);

    String documentType = (String) tableModel.getValueAt(rowIndex, 4);

    String documentURL = (String) tableModel.getValueAt(rowIndex, 5);

    isEmpty = isEmpty && ((scope == null) || (scope.equals("")));

    isEmpty = isEmpty && ((identifier == null) || (identifier.equals("")));

    isEmpty = isEmpty && ((revision == null) || (revision.equals("")));

    isEmpty = isEmpty && ((documentType == null) || (documentType.equals("")));

    isEmpty = isEmpty && ((documentURL == null) || (documentURL.equals("")));

    return isEmpty;

  }

  /**

   * Loads the Harvest List from a file. Parses the file using the inner class,

   * HarvestListHandler, a SAX parser.

   *

   * @param harvestList  the File to be loaded

   * @throws ParserConfigurationException

   */

  void loadHarvestList(File harvestList) throws ParserConfigurationException {

    HarvestListHandler harvestListHandler = new HarvestListHandler();

    FileInputStream fis;

    InputStreamReader inputStreamReader;

    boolean validateHarvestList = false;

    try {

      fis = new FileInputStream(harvestList);

      inputStreamReader = new InputStreamReader(fis);

      harvestListHandler.runParser(this, inputStreamReader, schemaLocation,

                                   loadHarvestList, validateHarvestList);

    catch (SAXException e) {

      System.out.println("Error parsing Harvest List: " + e.getMessage());

    }

    catch (ClassNotFoundException e) {

      System.out.println("ClassNotFoundException: " + e.getMessage());

    }

    catch (IOException ioe) {

      System.out.println("Error opening file: " + ioe.getMessage());

    }

  }

  /**

   * directory.

   */

  void loadProperties () {

    String homedir = System.getProperty("user.home");

    File propertiesFile = new File(homedir, ".harvestListEditor");

    properties = new Properties();

    try {

      properties.load(new FileInputStream(propertiesFile));

      defaultHarvestList = properties.getProperty("defaultHarvestList");

      defaultDocumentType = properties.getProperty("defaultDocumentType");