source: trunk/gli/src/org/greenstone/gatherer/gui/DownloadPane.java@ 12142

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

import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.net.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.WGet;
import org.greenstone.gatherer.file.WorkspaceTree;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;

/**
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.1
 */
public class DownloadPane
    extends JPanel {

    /** The threshold for when the advanced options get added */
    static private final int THRESHOLD = Configuration.SYSTEMS_MODE;

    private boolean download_button_enabled = false;
    private boolean ready = false;
    private int current_mode;
    private JButton clear_cache_button;
    private JButton download_button;
    private JCheckBox higher_checkbox;
    private JCheckBox requisite_checkbox;
    private JCheckBox same_host_checkbox;
    private JScrollPane list_scroll;
    private JComboBox depth_combobox;
    private JPanel options_pane;
    private JTextField url_field;
    private Vector depth_model;
    private WGet getter;

    public DownloadPane() {
    super();
    // Create a new wget thread
        getter = new WGet();
        getter.start();
    // And retrieve its list of pending jobs
    list_scroll = getter.getDownloadJobList();

    current_mode = Configuration.getMode();
    // String user_dir = System.getProperty("user.dir"); // ****
    // System.err.println("**** user dir = "+user_dir);
    // Create
    JPanel edit_pane = new JPanel();
    JPanel details_pane = new JPanel();
    options_pane = new JPanel();

    JPanel url_pane = new JPanel();
    JLabel url_label = new JLabel(Dictionary.get("Mirroring.Source_URL"));
    url_field = new JTextField();
    url_field.setToolTipText(Dictionary.get("Mirroring.Source_URL_Tooltip"));
    
    depth_model = new Vector();
    depth_model.add(new DepthEntry(0, Dictionary.get("Mirroring.Download_Depth.Zero")));
    /* @todo - add to dictionary */
    depth_model.add(new DepthEntry(1, String.valueOf(1)));
    /* @todo - add to dictionary */
    depth_model.add(new DepthEntry(2, String.valueOf(2)));
    /* @todo - add to dictionary */
    depth_model.add(new DepthEntry(3, String.valueOf(3)));
    /* @todo - add to dictionary */
    depth_model.add(new DepthEntry(4, String.valueOf(4)));
    /* @todo - add to dictionary */
    depth_model.add(new DepthEntry(5, String.valueOf(5)));
    depth_model.add(new DepthEntry(-1, Dictionary.get("Mirroring.Download_Depth.Unlimited")));
    JPanel depth_pane = new JPanel();
    JLabel depth_label = new JLabel(Dictionary.get("Mirroring.Download_Depth"));
    depth_combobox = new JComboBox(depth_model);
    depth_combobox.setToolTipText(Dictionary.get("Mirroring.Download_Depth_Tooltip"));
    
    requisite_checkbox = new JCheckBox(Dictionary.get("Mirroring.Download_OnlyHTML"));
    
    higher_checkbox = new JCheckBox(Dictionary.get("Mirroring.Higher_Directories"));
    higher_checkbox.addActionListener(new CheckboxClickListener());
    
    same_host_checkbox = new JCheckBox(Dictionary.get("Mirroring.Same_Host"));
    same_host_checkbox.setSelected(true);
    
    JPanel button_pane = new JPanel();

    JButton preferences_button = new GLIButton(Dictionary.get("Mirroring.Preferences"), Dictionary.get("Mirroring.Preferences_Tooltip"));
    preferences_button.setEnabled(true);
        
    clear_cache_button = new GLIButton(Dictionary.get("Mirroring.ClearCache"), Dictionary.get("Mirroring.ClearCache_Tooltip"));
    clear_cache_button.setEnabled(true);
    
    download_button = new GLIButton(Dictionary.get("Mirroring.Download"), Dictionary.get("Mirroring.Download_Tooltip"));
    download_button.setEnabled(true);
    
    // Connect
    clear_cache_button.addActionListener(new ClearCacheListener());
    download_button.addActionListener(new DownloadButtonListener());
    preferences_button.addActionListener(new PreferencesButtonActionListener());

    // Layout
    url_pane.setLayout(new BorderLayout(5,0));
    url_pane.add(url_label, BorderLayout.WEST);
    url_pane.add(url_field, BorderLayout.CENTER);

    depth_pane.setLayout(new GridLayout(1,3));
    depth_pane.add(depth_label);
    depth_pane.add(new JPanel());
    depth_pane.add(depth_combobox);

    details_pane.setLayout(new GridLayout(2,1,0,5));
    details_pane.setBorder(BorderFactory.createEmptyBorder(2,2,5,2));
    details_pane.add(url_pane);
    details_pane.add(depth_pane);

    options_pane.setLayout(new GridLayout(3,1,0,5));
    
    options_pane.add(higher_checkbox);
    options_pane.add(same_host_checkbox);
    //if (current_mode >= THRESHOLD) {
    options_pane.add(requisite_checkbox);
        //}

    button_pane.setLayout(new GridLayout(3,1));
    button_pane.add(preferences_button);
    button_pane.add(clear_cache_button);
    button_pane.add(download_button);

    edit_pane.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEmptyBorder(2,0,0,0), BorderFactory.createCompoundBorder(BorderFactory.createTitledBorder(Dictionary.get("Mirroring.Download_Controls")), BorderFactory.createEmptyBorder(2,2,2,2))));
    edit_pane.setLayout(new BorderLayout());
    edit_pane.add(details_pane, BorderLayout.NORTH);
    edit_pane.add(button_pane, BorderLayout.EAST);
    edit_pane.add(options_pane, BorderLayout.CENTER);

    setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
    setLayout(new BorderLayout());
    add(edit_pane, BorderLayout.NORTH);
    add(list_scroll, BorderLayout.CENTER);
    }

    public void afterDisplay() {
    ready = true;
    }


    /** This method is called whenever the Download pane is brought into focus and is a good time to display a warning message if WGet is not available or of an older, problematic, version.
     */
    public void gainFocus() {
    if(!ready) {
        return;
    }
    // Lets see what warning message we should display, if any.
    String wget_version_str = Configuration.getWGetVersion();
    if(wget_version_str.equals(StaticStrings.NO_WGET_STR)) {
        // If there was no WGet available then downloading is disabled entirely
        download_button_enabled = false;
        // And we tell the user why.
        Gatherer.missingWGET();
    }
    else if(wget_version_str.equals(StaticStrings.WGET_OLD_STR)) {
        // Downloading is enabled
        download_button_enabled = true;
        // But we display a preventable warning message about the path problems.
        Gatherer.oldWGET();
    }
    // Otherwise version must be ok
    else {
        download_button_enabled = true;
    }
    // It is also a good time to determine if the download should be enabled - ie if its allowed to be enabled and a valid URL is present in the field.
    download_button.setEnabled(download_button_enabled);
    }

    public void modeChanged(int mode) {
    int old_mode = current_mode;
    current_mode = mode;
    if (old_mode >= THRESHOLD && current_mode >= THRESHOLD) {
        return;
    }
    if (old_mode < THRESHOLD && current_mode < THRESHOLD) {
        return;
    }

    //if (current_mode >= THRESHOLD) {
    //    options_pane.add(requisite_checkbox);
    //}
    //else {
    //   options_pane.remove(requisite_checkbox);
    //   requisite_checkbox.setSelected(false);
    //}
    return;
    }


    public void refresh(int refresh_reason, boolean ready)
    {
    }


    /** A DepthEntry contains a depth value, as an int, and a representitive text string. This allows for a more meaningful appearance than '0' for instance. */
    private class DepthEntry 
    implements Comparable {
    private int value;
    private String text;
    /** Default constructor. 
     * @param value the depth value as an int
     * @param text how this entry show represent itself as a String
     */
    public DepthEntry(int value, String text) {
        this.text = text;
        this.value = value;
    }
    /** Determines the natural ordering of this DepthEntry and some other object
     * @param object the Object to test for ordering
     * @return >0 if the object is before this one, 0 if they are equal, or <0 if the object is after this one
     */
    public int compareTo(Object object) {
        // If the object is a DepthEntry then this is easy pesy.
        if(object instanceof DepthEntry) {
        int target_value = ((DepthEntry) object).getValue();
        return value - target_value;
        }
        // If the object is a String, then we should try parsing an int from it
        if(object instanceof String) {
        try {
            int target_value = Integer.parseInt((String)object);
            return value - target_value;
        }
        catch(Exception exception) {
        }
        }
        // Otherwise we'll try a string comparison between our text and the toString of the object
        return text.compareTo(object.toString());
    }

    /** Determine if this DepthEntry is equal to some other object. Given that there is significant processing involved we push the resposiblility for this onto compareTo, so we only have the complex code once.
     * @param object the Object to test for equality
     * @return true if the object is equal to this depth entry, false otherwise
     */
    public boolean equals(Object object) {
        return (compareTo(object) == 0);
    }

    public int getValue() {
        return value;
    }

    public String toString() {
        return text;
    }
    }

    private class ClearCacheListener
    implements ActionListener {
    public void actionPerformed(ActionEvent event) {
        // Retrieve the cache folder and delete it.
        Utility.delete(Gatherer.getGLIUserCacheDirectoryPath());
        // ...and refresh the node in the workspace tree to show it's all gone
        Gatherer.g_man.refreshWorkspaceTree(WorkspaceTree.DOWNLOADED_FILES_CHANGED);
    }
    }

    private class CheckboxClickListener
    implements ActionListener {
    public void actionPerformed(ActionEvent event) {
        if (higher_checkbox.isSelected()) {
        same_host_checkbox.setEnabled(false);
        } else {
        same_host_checkbox.setEnabled(true);
        }
    }
    }
    
    private class DownloadButtonListener
    implements ActionListener {

    public void actionPerformed(ActionEvent event) {
        // Retrieve the current url and confirm it is valid
        String url_str = url_field.getText();
        URL url = null;
        try {
        url = new URL(url_str);
        }
        catch(MalformedURLException error) {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("Mirroring.Invalid_URL"), Dictionary.get("Mirroring.Invalid_URL_Title"), JOptionPane.ERROR_MESSAGE);
        }

        // Otherwise construct a new download job
        Object depth_object = depth_combobox.getSelectedItem();
        int depth_value = 0;
        if(depth_object instanceof DepthEntry) {
        depth_value = ((DepthEntry)depth_object).getValue();
        }
        else if(depth_object instanceof String) {
        String depth_string = (String) depth_object;
        try {
            depth_value = Integer.parseInt(depth_string);
            // Create a new entry for the purposes of comparison, and if needs be, addition
            DepthEntry new_entry = new DepthEntry(depth_value, depth_string);
            // Try to select the correct item from the combobox
            depth_combobox.setSelectedItem(null);
            depth_combobox.setSelectedItem(new_entry);
            // We can see if that worked, and if it didn't add the entry
            if(depth_combobox.getSelectedItem() == null) {
            depth_combobox.addItem(new_entry);
            depth_combobox.setSelectedItem(new_entry);
            }
            new_entry = null;
        }
        catch(Exception exception) {
            /* @todo - add to dictionary */
            JOptionPane.showMessageDialog(Gatherer.g_man, "Mirroring.Mirror_Depth.Invalid_Depth", "Mirroring.Mirror_Depth.Invalid_Depth_Title", JOptionPane.ERROR_MESSAGE);
            return;
        }
        depth_string = null;
        }
        depth_object = null;
    
        String destination_file_path = Gatherer.getGLIUserCacheDirectoryPath();
        (new File(destination_file_path)).mkdirs(); // If they aren't already

        if(url != null) {
        getter.newDownloadJob(higher_checkbox.isSelected(), (higher_checkbox.isSelected()? false : !same_host_checkbox.isSelected()), !requisite_checkbox.isSelected(), url, depth_value, destination_file_path);
        }
    }
    }

    private class PreferencesButtonActionListener
    implements ActionListener {
    public void actionPerformed(ActionEvent event) {
        new Preferences(Preferences.CONNECTION_PREFS);
    }
    }
}