operatorprogress.java

为了下东西 随便发了个 datamining 的源代码

package eti.bi.alphaminer.tools.SystemTools.SystemToolPage;

import java.awt.Dimension;

import javax.swing.BoundedRangeModel;
import javax.swing.DefaultBoundedRangeModel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import eti.bi.alphaminer.core.handler.OperatorProcessThread;
import eti.bi.alphaminer.operation.operator.OperatorProgressModel;
import eti.bi.alphaminer.ui.Dialog.MessageDialog;
import eti.bi.common.System.SysLog;

public class OperatorProgress  extends JPanel{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private static OperatorProgress m_OperatorProgress;
	
	private JProgressBar progressBar;
	
	private OperatorProcessThread OperatorProcessThread;
	private OperatorProgressModel progressMode;
	
	private long delay = 500;
	private double percent = 0.05;
	
	private BoundedRangeModel defaultMode = new DefaultBoundedRangeModel();
	
	private Thread defaultmonitor = new Thread(){
		{
			setDaemon(true);
		}
		
		public void run() {
			setPriority(MIN_PRIORITY); 
			while (true) {
				int min = defaultMode.getMinimum();
				int max = defaultMode.getMaximum();
				int i = progressBar.getValue();
				i = i+(int)(max*percent);
				if(i<=max) {
					defaultMode.setValue(i);
				}
				else {
					defaultMode.setValue(min);
				}
				try {
					sleep(delay);
				} catch (InterruptedException e) {}
			}
		}
	};
	
//	private Thread modelmonitor = new Thread(){
//		{
//			setDaemon(true);
//		}
//		
//		public void run() {
//			setPriority(MIN_PRIORITY);
//			int min = progressBar.getMinimum();
//			int max = progressBar.getMaximum();
//			while (true) {
//				int i = progressMode.getValue();
//				if(i<=max&&i>=min) {
//					progressBar.setValue(i);
//				}
//				else if(i<min){
//					progressBar.setValue(min);
//				}
//				else {
//					progressBar.setValue(max);
//				}
//				try {
//					sleep(delay);
//				} catch (InterruptedException e) {}
//			}
//		}
//	};
	
	public static OperatorProgress getOperatorProgress(){
		if(m_OperatorProgress==null){
			m_OperatorProgress = new OperatorProgress();
		}
		return m_OperatorProgress;
	}
	
	private OperatorProgress() {
		//super(Resource.srcStr("OperatorProgress"));
		progressBar = new JProgressBar();
		createProgress();
		add(progressBar);
		//setBorder(BorderFactory.createTitledBorder(Resource.srcStr("OperatorProgress")));
	}
	
	private void createProgress() {
		//progressBar.setBorderPainted(true);
		progressBar.setStringPainted(true);
		progressBar.setMinimum(0);
		progressBar.setMaximum(100);
	}
	
	/**
	 * set new OperatorProcessThread, with OperatorProgressModel
	 * @param aThread a new OperatorProcessThread
	 * @return if no thread excuting now, register this thread, and return <code>true<code>, otherwise <code>false<code>
	 * */
	@SuppressWarnings("deprecation")
	public boolean setOperatorThread(OperatorProcessThread aThread ) {
		if(OperatorProcessThread!=null) {
			if(OperatorProcessThread.isrunning()) {
				return false;
			}
		}
		
		OperatorProcessThread = aThread;
		
		return true;
	}
	
	 /**
     * Sets the data model used by the <code>JProgressBar</code>.
     *
     * @param aThread the thread the model set to
     * @param newModel the <code>OperatorProgressModel</code> to use
     * @return <coede>true<code> if set the model to the specific thread succeed, else <code>false<code>
     */
	public boolean setOperatorProgressModel(OperatorProcessThread aThread,OperatorProgressModel newModel) {
		if(aThread==null||OperatorProcessThread!=aThread) {
			return false;
		}
		
		progressMode = newModel;
		
		progressBar.setModel(defaultMode);
		return true;
	}
	
	/**
	 * stop the current thread, and destroy it
	 * */
	@SuppressWarnings("deprecation")
	public boolean stopOperatorThread() {
		if(OperatorProcessThread==null) {
			return false;
		}
		
		try {
			if(!OperatorProcessThread.stopRuning()) {
				return false;
			}
			OperatorProcessThread.stop();
			OperatorProcessThread = null;
		}
		catch(Exception e) {
			e.printStackTrace();
			SysLog.error(OperatorProcessThread, e);
			MessageDialog.showMessageDialog(this, e.getMessage());
			return false;
		}
		OperatorProcessThread = null;
		return false;
	}
	
	public boolean hasThread() {
		return OperatorProcessThread!=null;
	}
	
	public void setSize(Dimension dimension) {
		this.setPreferredSize(dimension);
		progressBar.setPreferredSize(new Dimension(dimension.width-10,dimension.height-10));
	}
	
	@SuppressWarnings("deprecation")
	private void modelStart() {
		progressBar.setStringPainted(true);
		if(progressMode!=null) {
			progressBar.setModel(progressMode);
		}
	}
	
	@SuppressWarnings("deprecation")
	private void modelStop(boolean issucceessful) {
		
		if(issucceessful) {
			progressBar.setStringPainted(true);
			progressBar.setValue(progressBar.getMaximum());
		}
		else {
			progressBar.setValue(progressBar.getMinimum());
		}
		
		progressBar.setModel(defaultMode);
	}
	
	/**
	 * start monitor with default BoundedRangeModel
	 * */
	@SuppressWarnings("deprecation")
	private void defaultStart() {
		progressBar.setStringPainted(false);
		progressBar.setValue(0);
		try {
			defaultmonitor.start();
		}
		catch(Exception e) {
			try {
				defaultmonitor.resume();
			}
			catch(Exception e1){
				e1.printStackTrace();
			}
		}
	}
	
	@SuppressWarnings("deprecation")
	private void defaultStop(boolean issucceessful) {
		if(issucceessful) {
			progressBar.setStringPainted(true);
			progressBar.setValue(progressBar.getMaximum());
		}
		else {
			progressBar.setValue(progressBar.getMinimum());
		}
		
		try {
			defaultmonitor.suspend();
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public void startMonitor() {
		if(progressMode!=null) {
			modelStart();
		}
		else {
			defaultStart();
		}
	}
	
	public void stopMonitor(boolean issucceessful,boolean clearThread) {
		if(progressMode!=null) {
			modelStop(issucceessful);
		}
		else {
			defaultStop(issucceessful);
		}
		if(clearThread) {
			clearThread();
		}
	}
	
	private void clearThread() {
		OperatorProcessThread = null;
	}
	
	public void setProgress(boolean finish) {
		if(finish) {
			progressBar.setValue(progressBar.getMaximum());
		}
		else {
			progressBar.setValue(progressBar.getMinimum());
		}
	}

	public void dispose() {
		progressBar.removeAll();
		progressBar = null;
		progressMode = null;
		
		Runnable runnable = new Runnable() {
			@SuppressWarnings("deprecation")
			public void run() {
				defaultmonitor.stop();
			}
		};
		runnable.run();
	}


}