source: trunk/gli/src/org/greenstone/gatherer/gui/NewCollectionMetadataPrompt.java@ 9101

/**
 *#########################################################################
 *
 * 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.
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.gui;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.metadata.MetadataElement;
import org.greenstone.gatherer.metadata.MetadataSet;
import org.greenstone.gatherer.metadata.MetadataSetManager;
import org.greenstone.gatherer.metadata.MetadataTools;
import org.greenstone.gatherer.util.Utility;


public class NewCollectionMetadataPrompt
    extends ModalDialog {

    private boolean cancelled = true;
    private JDialog self;
    private JList elements_list;
    private MetadataSetList sets_list;
    static private Dimension size = new Dimension(700, 380);

    public NewCollectionMetadataPrompt() {
    this(false);
    }
    public NewCollectionMetadataPrompt(boolean existing_coll) {
    super(Gatherer.g_man, true);
    this.self = this;
    if (existing_coll) {
        setJMenuBar(new SimpleMenuBar("openingacollection"));
        Dictionary.setText(this, "NewCollectionPrompt.Metadata_Title_Existing");
    } else {
        setJMenuBar(new SimpleMenuBar("creatingacollection"));
        Dictionary.setText(this, "NewCollectionPrompt.Title");
    }
    setModal(true);
    setSize(size);

    // Show the metadata sets (except extracted!) available in the GLI "metadata" folder 
    ArrayList sets = MetadataSetManager.listMetadataSets(new File(Utility.METADATA_DIR));
    ArrayList metadata_set_list_entries = new ArrayList();
    for (int i = 0; i < sets.size(); i++) {
        MetadataSet metadata_set = (MetadataSet) sets.get(i);

        // Don't show the extracted metadata set
        if (metadata_set.getNamespace().equals(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE)) {
        continue;
        }
        // Hack: add dublin caore at the top
        if (metadata_set.getNamespace().equals("dc")) {
        metadata_set_list_entries.add(0, new MetadataSetListEntry(metadata_set));
        } else {
        metadata_set_list_entries.add(new MetadataSetListEntry(metadata_set));
        }
    }

    // Creation
    JPanel content_pane = (JPanel) getContentPane();

    JPanel instructions_panel = new JPanel();
    JLabel instructions_label1 = new JLabel();
    Dictionary.setText(instructions_label1, "NewCollectionPrompt.Metadata_Instructions1");
    JLabel instructions_label2 = new JLabel();
    Dictionary.setText(instructions_label2, "NewCollectionPrompt.Metadata_Instructions2");

    JPanel center_pane = new JPanel();

    JPanel sets_list_pane = new JPanel();
    JLabel sets_list_label = new JLabel();
    sets_list_label.setOpaque(false);
    Dictionary.setText(sets_list_label, "NewCollectionPrompt.Select_MDS");
    sets_list = new MetadataSetList();
    sets_list.setListData(new Vector(metadata_set_list_entries));
    sets_list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

    JPanel elements_list_pane = new JPanel();
    JLabel elements_list_label = new JLabel();
    Dictionary.setText(elements_list_label, "NewCollectionPrompt.Metadata_Elements");
    elements_list = new JList();
    elements_list.setCellRenderer(new MetadataElementListCellRenderer());
    elements_list.setBackground(Configuration.getColor("coloring.collection_tree_background", false));
    elements_list.setForeground(Configuration.getColor("coloring.collection_tree_foreground", false));
    elements_list.setSelectionBackground(Configuration.getColor("coloring.collection_tree_background", false));
    elements_list.setSelectionForeground(Configuration.getColor("coloring.collection_tree_foreground", false));

    // Select the Dublin Core metadata set by default, at Ian's request
    sets_list.selectDublinCoreMetadataSet();

    JPanel button_pane = new JPanel();
    JButton ok_button = new GLIButton();
    ok_button.setMnemonic(KeyEvent.VK_O);
    Dictionary.setBoth(ok_button, "General.OK", "General.OK_Tooltip");
    JButton cancel_button = new GLIButton();
    cancel_button.setMnemonic(KeyEvent.VK_C);
    Dictionary.setBoth(cancel_button, "General.Cancel", "General.Pure_Cancel_Tooltip");

    // Connection
    ok_button.addActionListener(new OKButtonListener());
    cancel_button.addActionListener(new CancelButtonListener());

    // Display
    instructions_panel.setLayout(new GridLayout(2,1));
    instructions_panel.add(instructions_label1);
    instructions_panel.add(instructions_label2);

    sets_list_pane.setLayout(new BorderLayout());
    sets_list_pane.add(sets_list_label, BorderLayout.NORTH);
    sets_list_pane.add(new JScrollPane(sets_list), BorderLayout.CENTER);

    elements_list_pane.setLayout(new BorderLayout());
    elements_list_pane.add(elements_list_label, BorderLayout.NORTH);
    elements_list_pane.add(new JScrollPane(elements_list), BorderLayout.CENTER);

    center_pane.setBorder(BorderFactory.createEmptyBorder(5,0,0,0));
    center_pane.setLayout(new GridLayout(2,1,0,5));
    center_pane.add(sets_list_pane);
    center_pane.add(elements_list_pane);

    button_pane.setBorder(BorderFactory.createEmptyBorder(5,0,0,0));
    button_pane.setLayout(new GridLayout(1,2,5,0));
    button_pane.add(ok_button);
    button_pane.add(cancel_button);

    content_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
    content_pane.setLayout(new BorderLayout());
    content_pane.add(instructions_panel, BorderLayout.NORTH);
    content_pane.add(center_pane, BorderLayout.CENTER);
    content_pane.add(button_pane, BorderLayout.SOUTH);

    // Show
    Dimension screen_size = Configuration.screen_size;
    setLocation((screen_size.width - size.width) / 2, (screen_size.height - size.height) / 2);
    setVisible(true);
    }

    public ArrayList getSets() {
    return sets_list.getSelectedMetadataSets();
    }

    public boolean isCancelled() {
    return cancelled;
    }


    private class CancelButtonListener
    implements ActionListener {
    public void actionPerformed(ActionEvent event) {
        cancelled = true;
        self.dispose();
    }
    }


    private class MetadataSetList
    extends JList
    {
    public MetadataSetList()
    {
        super();
        addListSelectionListener(new MetadataSetListSelectionListener());
        addMouseListener(new MetadataSetListSelectionListener());
        setCellRenderer(new MetadataSetListCellRenderer());
    }


    public ArrayList getSelectedMetadataSets()
    {
        ArrayList selected_metadata_sets = new ArrayList();

        ListModel model = (ListModel) getModel();
        for (int i = 0; i < model.getSize(); i++) {
        MetadataSetListEntry metadata_set_list_entry = (MetadataSetListEntry) model.getElementAt(i);
        if (metadata_set_list_entry.isSelected()) {
            selected_metadata_sets.add(metadata_set_list_entry.getMetadataSet());
        }
        }

        return selected_metadata_sets;
    }


    /** Hack special-case code, used to select the Dublin Core metadata set by default */
    public void selectDublinCoreMetadataSet()
    {
        ListModel model = (ListModel) getModel();
        for (int i = 0; i < model.getSize(); i++) {
        MetadataSetListEntry metadata_set_list_entry = (MetadataSetListEntry) model.getElementAt(i);
        if (metadata_set_list_entry.getMetadataSet().getNamespace().equals("dc")) {
            metadata_set_list_entry.setSelected(true);
            metadata_set_list_entry.grabFocus();
            setSelectedIndex(i);
            break;
        }
        }
    }


    private class MetadataSetListCellRenderer
        extends JLabel
        implements ListCellRenderer {

        public Component getListCellRendererComponent(JList list, Object value, int index, boolean is_selected, boolean cell_has_focus)
        {
        JCheckBox checkbox = (JCheckBox) value;
        checkbox.setBackground(is_selected ? list.getSelectionBackground() : list.getBackground());
        checkbox.setForeground(is_selected ? list.getSelectionForeground() : list.getForeground());
        checkbox.setBorderPainted(true);
        checkbox.setEnabled(list.isEnabled());
        checkbox.setFont(list.getFont());
        checkbox.setFocusPainted(false);
        checkbox.setBorder((is_selected) ? UIManager.getBorder("List.focusCellHighlightBorder") : new EmptyBorder(1, 1, 1, 1));
        return checkbox;
        }
    }


    private class MetadataSetListSelectionListener
        extends MouseAdapter
        implements ListSelectionListener {

        public void mousePressed(MouseEvent e)
        {
        JList list = (JList) e.getSource();
        int index = list.locationToIndex(e.getPoint());
        MetadataSetListEntry metadata_set_list_entry = (MetadataSetListEntry) list.getModel().getElementAt(index);
        metadata_set_list_entry.setSelected(!metadata_set_list_entry.isSelected());
        metadata_set_list_entry.grabFocus();
        list.ensureIndexIsVisible(index);

        // Fire a selection changed event
        fireSelectionValueChanged(index, index, false);
        }

        public void valueChanged(ListSelectionEvent event)
        {
        if (!sets_list.isSelectionEmpty()) {
            // Retrieve the selected set
            MetadataSetListEntry metadata_set_list_entry = (MetadataSetListEntry) sets_list.getSelectedValue();
            MetadataSet set = (MetadataSet) metadata_set_list_entry.getMetadataSet();
            elements_list.setListData(new Vector(set.getMetadataSetElements()));
        }
        else {
            elements_list.setListData(new String[0]);
        }
        }
    }
    }


    private class MetadataSetListEntry
    extends JCheckBox
    {
    private MetadataSet metadata_set = null;

    public MetadataSetListEntry(MetadataSet metadata_set)
    {
        this.metadata_set = metadata_set;
    }

    public MetadataSet getMetadataSet()
    {
        return metadata_set;
    }

    public String getText()
    {
        if (metadata_set == null) {
        return null;
        }

        String interface_language_code = Configuration.getLanguage();
        String metadata_set_name = MetadataTools.getMetadataSetAttribute(metadata_set, "Name", interface_language_code, "en");
        return metadata_set_name + " (" + metadata_set.getNamespace() + ")";
    }
    }


    private class OKButtonListener
    implements ActionListener {
    public void actionPerformed(ActionEvent event) {
        // See if the user has selected no metadata sets, and if so confirm thats what they really want.
        ArrayList selected_sets = sets_list.getSelectedMetadataSets();
        cancelled = false;
        if(selected_sets.size() == 0) {
        WarningDialog dialog = new WarningDialog("warning.NoMetadataSetsSelected", null, true);
        if(dialog.display() == JOptionPane.OK_OPTION) {
            // Otherwise we are free to go
            self.dispose();
        }
        dialog.dispose();
        dialog = null;
        }
        else {
        self.dispose();
        }
    }
    }
}