source: trunk/gli/src/org/greenstone/gatherer/gui/GProgressBar.java@ 7183

/**
 *#########################################################################
 *
 * 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 javax.swing.*;
import javax.swing.border.*;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.collection.Job;
import org.greenstone.gatherer.gui.GLIButton;
import org.greenstone.gatherer.util.AppendLineOnlyFileDocument;
import org.greenstone.gatherer.util.Utility;

public class GProgressBar
    extends JPanel 
    implements ActionListener {

    static final private Dimension MINIMUM_BUTTON_SIZE = new Dimension(100, 25); 

    private boolean simple = false;

    private Dimension bar_size = new Dimension(520, 15);

    private int current_action;
    private int err_count;
    private int file_count;
    private int total_count;
    private int warning_count;

    private JLabel current_status;
    private JLabel main_status;
    private JLabel results_status;
    private JLabel status;
     
    private JPanel center_pane;
    private JPanel inner_pane;

    private JProgressBar progress;

    private long file_size;
    private long total_size;

    private String current_url;
    private String initial_url;

    private Job owner;

    public JButton action;
    public JButton log_button;
    public JButton cancel;

    public GProgressBar(Job owner, String initial_url, boolean simple) {
    this.owner = owner;
    this.current_url = null;
    this.err_count = 0;
    this.initial_url = initial_url;
    this.file_count = 0;
    this.file_size = 0;
    this.simple = simple;
    this.total_count = 0;
    this.total_size = 0;
    this.warning_count = 0;

    this.setLayout(new BorderLayout());
    this.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));

    this.current_action = Job.STOPPED;

    inner_pane = new JPanel(new BorderLayout());
    inner_pane.setBorder(BorderFactory.createEmptyBorder(2,(MINIMUM_BUTTON_SIZE.width + 2),2,2));

    center_pane = new JPanel(new GridLayout(3,1));

    main_status = new JLabel();

    current_status = new JLabel();
          
    results_status = new JLabel();

    progress = new JProgressBar();
    progress.setStringPainted(true);
    progress.setMinimum(0);
    progress.setMaximum(0);
    progress.setEnabled(false);
    Dictionary.setText(progress, "Mirroring.Job.Waiting");
    inner_pane.add(progress, BorderLayout.CENTER);

    center_pane.add(main_status);
    center_pane.add(current_status);
    center_pane.add(results_status);

    JPanel button_pane = new JPanel();

    /** @todo - add to dictionary, and rewrite existing tooltip */
    action = new GLIButton("Mirroring.Job.Retry");
    action.addActionListener(this);
    action.addActionListener(owner);
    action.setMinimumSize(MINIMUM_BUTTON_SIZE);
    action.setMnemonic(KeyEvent.VK_A);
    Dictionary.setTooltip(action, "Mirroring.Job.Start_Tooltip");

    /** @todo - add to dictionary, and rewrite existing tooltip */
    log_button = new GLIButton("Mirroring.Job.Log");
    log_button.addActionListener(owner);
    log_button.addActionListener(this);
    log_button.setEnabled(false);
    log_button.setMinimumSize(MINIMUM_BUTTON_SIZE);
    log_button.setMnemonic(KeyEvent.VK_L);
    //Dictionary.setTooltip(log_button, "Mirroring.Job.Stop_Tooltip");

    /** @todo - add to dictionary, and rewrite existing tooltip */
    cancel = new GLIButton("Mirroring.Job.Cancel");
    cancel.addActionListener(owner);
    cancel.addActionListener(this);
    cancel.setMinimumSize(MINIMUM_BUTTON_SIZE);
    cancel.setMnemonic(KeyEvent.VK_C);
    Dictionary.setTooltip(cancel, "Mirroring.Job.Stop_Tooltip");

    // Layout - or at least some of it

    inner_pane.add(center_pane, BorderLayout.NORTH);

    button_pane.setLayout(new GridLayout(3,1));
    button_pane.add(action);
    button_pane.add(log_button);
    button_pane.add(cancel);

    this.add(inner_pane, BorderLayout.CENTER);
    this.add(button_pane, BorderLayout.EAST);

    // Make the labels, etc update.
    refresh();
    }

    public void actionPerformed(ActionEvent event) {
    Object source = event.getSource();
    if(source == action) {
        current_action = Job.RUNNING;
        action.setEnabled(false);
        
    }
    else if(source == cancel) {
        // If we are running, stop.
        if (current_action == Job.RUNNING) {
        current_action = Job.STOPPED;
        action.setEnabled(true);
        }
    }
    else if(source == log_button) {
        LogDialog dialog = new LogDialog(owner.getLogDocument());
        dialog.show();
        dialog = null;
    }
    }

    /** This method is called when a new download is begun. The
     * details of the download are updated and a new JProgressBar
     * assigned to track the download.
     * @param url The url String of the file that is being downloaded.
     */
    public void addDownload(String url) {
    current_url = url;
    file_size = 0;
    refresh();
    }

    /** When the download of the current url is completed, this method
     * is called to enlighten the GProgressBar of this fact.
     */
    public void downloadComplete() {
    current_url = null;
    file_count++;
    if(total_count < (file_count + err_count + warning_count)) {
        total_count = (file_count + err_count + warning_count);
    }
    progress.setValue(progress.getMaximum());
    Dictionary.setText(progress, "Mirroring.Job.Download_Complete");
    refresh();
    }

    public void downloadFailed() {
    err_count++;
    if(total_count < (file_count + err_count + warning_count)) {
        total_count = (file_count + err_count + warning_count);
    }
    refresh();
    }

    public void downloadWarning() {
    warning_count++;
    if(total_count < (file_count + err_count + warning_count)) {
        total_count = (file_count + err_count + warning_count);
    }
    refresh();
    }

    public Dimension getPreferredSize() {
    return Utility.PROGRESS_BAR_SIZE;
    }

    /** When a link to be downloaded is located, the increaseTotalCount
     * method is called. In this way the total count shows the most
     * accurate remaining number of files to be downloaded.
     */
    public void increaseFileCount() {
    total_count++;
    refresh();
    }

    /** When a mirroring task is first initiated this function is called
     * to set initial values for the variables if necessary and to 
     * fiddle visual components such as the tool tip etc.
     * @param reset A Boolean specifying whether the variables should be
     * reset to zero.
     */
    public void mirrorBegun(boolean reset, boolean simple) {
    if(reset) {
        this.file_count = 0;
        this.file_size = 0;
        this.total_count = 0;
        this.total_size = 0;
        this.err_count = 0;
        this.warning_count = 0;
    }
    current_action = Job.RUNNING;
    action.setEnabled(false);
    log_button.setEnabled(true);
    if(simple) {
        progress.setIndeterminate(true);
    }
    }   

    /** Once a mirroring task is complete, is the Job returns from the
     * native call but the status is still running, then this method
     * is called to once again tinker with the pritty visual 
     * components.
     */
    public void mirrorComplete() {
    current_action = Job.COMPLETE;
    current_url = null;
    if(simple) {
        progress.setIndeterminate(false);
    }
    progress.setValue(progress.getMaximum());
    /** @todo - put into dictionary */
    progress.setString("Mirroring.Job.Mirror_Complete");
    //Dictionary.setText(progress, "Mirroring.Job.Mirror_Complete");

    action.setEnabled(false);
    cancel.setEnabled(true);
    this.updateUI();
    }

    /** When called this method updates the GProgressBar to reflect
     * the ammount of the current file downloaded.
     */
    public void updateProgress(long current, long expected) {
    file_size = file_size + current;
    if(!progress.isIndeterminate()) {
        // If current is zero, then this is the 'precall' before the
        // downloading actually starts.
        if(current == 0) {
        // Remove the old progress bar, then deallocate it.
        inner_pane.remove(progress);
        progress = null;
        if(expected == 0) {
            // We don't have a content length. This bar will go from 0 to 100 only!
            progress = new JProgressBar(0, 100);
        }
        else {
            // Assign a new progress bar of length expected content length.
            progress = new JProgressBar(0, (new Long(expected)).intValue());
        }
        progress.setEnabled(true);
        // Add the new progress bar.
        inner_pane.add(progress, BorderLayout.CENTER);
        inner_pane.updateUI();
        }
        // Otherwise if expected is not zero move the progress bar and
        // update percent complete.
        else if (expected != 0) {
        progress.setValue((new Long(file_size)).intValue());
        int p_c = (new Double(progress.getPercentComplete() * 100)).intValue();
        progress.setString(p_c + "%");
        progress.setStringPainted(true);
        }
        // Finally, in the case we have no content length, we'll instead
        // write the current number of bytes downloaded again.
        else {
        progress.setString(file_size + " b");
        progress.setStringPainted(true);
        }
    }
    refresh();
    }

    /** Causes the two labels associated with this GProgressBar object to
     * update, thus reflecting the progression of the download. This 
     * method is called by any of the other public setter methods in this 
     * class.
     */
    private void refresh() {
    // Refresh the contents of main label.
    String args1[] = new String[1];
    args1[0] = initial_url.toString();
    Dictionary.setText(main_status, "Mirroring.Job.Mirroring", args1);

    if (current_url != null) {
        // Refresh the current label contents.
        String args2[] = new String[1];
        args2[0] = current_url;
        Dictionary.setText(current_status, "Mirroring.Job.Downloading", args2);
    }
    else if (current_action == Job.STOPPED || current_action == Job.PAUSED) {
        Dictionary.setText(current_status, "Mirroring.Job.Waiting_User");
    }
    else {
        Dictionary.setText(current_status, "Mirroring.Job.Mirroring_Complete");
    }

    // Refresh the contents of results label
    String args3[] = new String[4]; 
    args3[0] = file_count + "";
    args3[1] = total_count + "";
    args3[2] = warning_count + "";
    args3[3] = err_count + "";
    Dictionary.setText(results_status, "Mirroring.Job.Status", args3);

    this.updateUI();
    }

    static final private Dimension DIALOG_SIZE = new Dimension(640,480);

    private class LogDialog
    extends JDialog {
    
    public LogDialog(AppendLineOnlyFileDocument document) {
        super(Gatherer.g_man, "Mirroring.Job.Download_Log_Dialog_Title");
        setSize(DIALOG_SIZE);
        JPanel content_pane = (JPanel) getContentPane();
        JTextArea text_area = new JTextArea(document);
        JButton button = new GLIButton(Dictionary.get("General.Close"));
        // Connection
        button.addActionListener(new CloseActionListener());
        // Layout
        content_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
        content_pane.setLayout(new BorderLayout());
        content_pane.add(new JScrollPane(text_area), BorderLayout.CENTER);
        content_pane.add(button, BorderLayout.SOUTH);
    }

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