Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/



	package javax.swing;



	import java.io.*;
	import java.awt.Component;



	/**
	* Monitors the progress of reading from some InputStream. This ProgressMonitor
	* is normally invoked in roughly this form:
	* <pre>
	* InputStream in = new BufferedInputStream(
	* new ProgressMonitorInputStream(
	* parentComponent,
	* "Reading " + fileName,
	* new FileInputStream(fileName)));
	* </pre><p>
	* This creates a progress monitor to monitor the progress of reading
	* the input stream. If it's taking a while, a ProgressDialog will
	* be popped up to inform the user. If the user hits the Cancel button
	* an InterruptedIOException will be thrown on the next read.
	* All the right cleanup is done when the stream is closed.
	*
	*
	* <p>
	*
	* For further documentation and examples see
	* <a href="https://docs.oracle.com/javase/tutorial/uiswing/components/progress.html">How to Monitor Progress</a>,
	* a section in <em>The Java Tutorial.</em>
	*
	* @see ProgressMonitor
	* @see JOptionPane
	* @author James Gosling
	*/
	public class ProgressMonitorInputStream extends FilterInputStream
	{
	private ProgressMonitor monitor;
	private int nread = 0;
	private int size = 0;


	/**
	* Constructs an object to monitor the progress of an input stream.
	*
	* @param message Descriptive text to be placed in the dialog box
	* if one is popped up.
	* @param parentComponent The component triggering the operation
	* being monitored.
	* @param in The input stream to be monitored.
	*/
	public ProgressMonitorInputStream(Component parentComponent,
	Object message,
	InputStream in) {
	super(in);
	try {
	size = in.available();
	}
	catch(IOException ioe) {
	size = 0;
	}
	monitor = new ProgressMonitor(parentComponent, message, null, 0, size);
	}


	/**
	* Get the ProgressMonitor object being used by this stream. Normally
	* this isn't needed unless you want to do something like change the
	* descriptive text partway through reading the file.
	* @return the ProgressMonitor object used by this object
	*/
	public ProgressMonitor getProgressMonitor() {
	return monitor;
	}


	/**
	* Overrides <code>FilterInputStream.read</code>
	* to update the progress monitor after the read.
	*/
	public int read() throws IOException {
	int c = in.read();
	if (c >= 0) monitor.setProgress(++nread);
	if (monitor.isCanceled()) {
	InterruptedIOException exc =
	new InterruptedIOException("progress");
	exc.bytesTransferred = nread;
	throw exc;
	}
	return c;
	}


	/**
	* Overrides <code>FilterInputStream.read</code>
	* to update the progress monitor after the read.
	*/
	public int read(byte b[]) throws IOException {
	int nr = in.read(b);
	if (nr > 0) monitor.setProgress(nread += nr);
	if (monitor.isCanceled()) {
	InterruptedIOException exc =
	new InterruptedIOException("progress");
	exc.bytesTransferred = nread;
	throw exc;
	}
	return nr;
	}


	/**
	* Overrides <code>FilterInputStream.read</code>
	* to update the progress monitor after the read.
	*/
	public int read(byte b[],
	int off,
	int len) throws IOException {
	int nr = in.read(b, off, len);
	if (nr > 0) monitor.setProgress(nread += nr);
	if (monitor.isCanceled()) {
	InterruptedIOException exc =
	new InterruptedIOException("progress");
	exc.bytesTransferred = nread;
	throw exc;
	}
	return nr;
	}


	/**
	* Overrides <code>FilterInputStream.skip</code>
	* to update the progress monitor after the skip.
	*/
	public long skip(long n) throws IOException {
	long nr = in.skip(n);
	if (nr > 0) monitor.setProgress(nread += nr);
	return nr;
	}


	/**
	* Overrides <code>FilterInputStream.close</code>
	* to close the progress monitor as well as the stream.
	*/
	public void close() throws IOException {
	in.close();
	monitor.close();
	}


	/**
	* Overrides <code>FilterInputStream.reset</code>
	* to reset the progress monitor as well as the stream.
	*/
	public synchronized void reset() throws IOException {
	in.reset();
	nread = size - in.available();
	monitor.setProgress(nread);
	}
	}

Back to index...