processmonitor.java

将用户指定的数据保存成一个iso文件

package jcdwriter.ui;

import java.awt.event.*;
import java.awt.*;

import jcdwriter.model.*;

import javax.swing.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Vector;


public class ProcessMonitor extends javax.swing.JDialog implements ActionListener, Runnable{
    
    BufferedReader outputReader, errorReader;
    java.io.InputStream processOutputStream, processErrorStream;
    public static String cr = "\n";
    String progressDetectPattern;
    Process processToMonitor;
    OutputAnalyzer outputAnalyzer;
    javax.swing.Timer  refreshTimer;
    private boolean autoStart = false; /* do not wait for user to press start */
    private boolean autoClose = false; /* close automatically after work is done */
    private boolean done = false;
    private boolean showUI = true;
    Semaphore semaphore;
    
    public ProcessMonitor(Process p, OutputAnalyzer oAnalyzer, Semaphore s) {
        processToMonitor = p;
        outputAnalyzer = oAnalyzer;
        semaphore = s;
        initComponents();
    }
    
    private void initComponents() {
        mainPanel = new javax.swing.JPanel();
        progressBar = new javax.swing.JProgressBar();
        logScrollPane = new javax.swing.JScrollPane();
        logTextArea = new javax.swing.JTextArea();
        jPanel1 = new javax.swing.JPanel();
        startButton = new javax.swing.JButton();
        cancelButton = new javax.swing.JButton();
        closeButton = new javax.swing.JButton();
        setTitle("Progress");
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent evt) {
                closeDialog(evt);
            }
        });
        
        mainPanel.setLayout(new java.awt.BorderLayout());
        
        mainPanel.setPreferredSize(new java.awt.Dimension(400, 200));
        mainPanel.add(progressBar, java.awt.BorderLayout.NORTH);
        
        logTextArea.setEditable(false);
        logScrollPane.setViewportView(logTextArea);
        
        mainPanel.add(logScrollPane, java.awt.BorderLayout.CENTER);
        
        startButton.setText("Start");
        startButton.setPreferredSize(null);
        startButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                startAndMonitor();
            }
        });
        jPanel1.add(startButton);
        
        cancelButton.setText("Cancel");
        cancelButton.setPreferredSize(null);
        cancelButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                cancelButtonActionPerformed(evt);
            }
        });
        
        jPanel1.add(cancelButton);
        
        closeButton.setText("Close");
        closeButton.setEnabled(false);
        closeButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                closeProcessMonitor(evt);
            }
        });
        
        jPanel1.add(closeButton);
        
        mainPanel.add(jPanel1, java.awt.BorderLayout.SOUTH);
        
        getContentPane().add(mainPanel, java.awt.BorderLayout.CENTER);
        
        pack();
    }
    
    public void setShowUI(boolean trueOrFalse) {
        showUI = trueOrFalse;
    }
    
    private void closeProcessMonitor(ActionEvent evt) {
        dispose();
    }
    
    private void startAndMonitor() {
        enableButton(cancelButton, false); //CANCEL does not work....need to figure out.
        enableButton(startButton, false);
        
        processThread = new ProcessThread(processToMonitor);
        
        processThread.start();
        processThread = new ProcessThread(processToMonitor);
        processThread.start();
        
        processOutputStream = processToMonitor.getInputStream();
        processErrorStream = processToMonitor.getErrorStream();
        outputReader = new BufferedReader(new InputStreamReader(processOutputStream));
        errorReader = new BufferedReader(new InputStreamReader(processErrorStream));
        
        monitor();
    }
    
    private void monitor() {
        
        String line=null;
        Log.writeln("ProcessMonitor monitor()",  "Started Monitoring", 4);
        
        do {
            try {
                while ( outputReader.ready()) {
                    line = outputReader.readLine();
                    //                    System.out.println("O" + line);
                    outputAnalyzer.processOutputLine(line);
                    setPercentComplete(outputAnalyzer.percentComplete());
                    appendToOutput(line);
                    appendCRToOutput();
                }
            }
            catch(java.io.IOException ie) {
            }
            /* read the ErrorStream of the program running */
            try {
                while ( errorReader.ready()) {
                    line = errorReader.readLine();
                    //                    System.out.println("E" + line);
                    outputAnalyzer.processOutputLine(line);
                    setPercentComplete(outputAnalyzer.percentComplete());
                    appendToOutput(line);
                    appendCRToOutput();
                }
            }
            catch(java.io.IOException ie) {
            }
            try {
                processToMonitor.exitValue();
                done = true;
            }
            catch (IllegalThreadStateException itse) {
                //System.out.println(itse);
                //                System.out.print("=");
                try {
                    Thread.sleep(100);
                    Thread.yield();
                }
                catch (InterruptedException ie) {
                    System.out.println(ie);
                }
            }
        } while (!done);
        workDone();
    }
    
    public void actionPerformed(ActionEvent evt) {
        //        System.out.print("#####");
        //        if (!processThread.isAlive()) workDone();
        monitor();
        if (done) workDone();
    }
    
    public void autoStart(boolean startFlag){
        autoStart = startFlag;
    }
    
    public void autoClose(boolean closeFlag){
        autoClose = closeFlag;
    }
    
    private void workDone() {
        /* Proces performing work is done.  Do cleanup */
        //        System.out.println("ALL DONE");
        progressBar.setValue(100);
        enableButton(cancelButton, false);
        enableButton(closeButton, true);
        enableButton(startButton, false);
        appendToLog("ALL DONE!");
        if (semaphore != null) semaphore.signal();
        if (autoClose) {
            setVisible(false);
            dispose();
        };
    }
    
    private void cancelButtonActionPerformed(ActionEvent evt) {
        System.out.println("CANCEL selected");
        cancelRequested = true;
        processToMonitor.destroy();
        progressBar.setIndeterminate(false);
        enableButton(cancelButton, false);
        enableButton(closeButton, true);
        enableButton(startButton, false);
        setTitle("Operation Done");
        // dispose();
    }
    
    
    private void closeDialog(WindowEvent evt) {
        setVisible(false);
        dispose();
    }
    
    
    
    public void setPercentComplete(int aPercent){
        if(aPercent < 0 || aPercent > 100) return;
        progressBar.setValue(aPercent);
    }
    
    public void appendToLog(String aString){
        logTextArea.append(aString);
        logTextArea.setCaretPosition(logTextArea.getText().length());
        //        System.out.print("Logged: " + aString);
        //        System.out.println(" scrollbar max " + logScrollPane.getVerticalScrollBar().getMaximum() + " current: " + logScrollPane.getVerticalScrollBar().getValue());
        logScrollPane.getVerticalScrollBar().setValue(logScrollPane.getVerticalScrollBar().getMaximum());
        myRepaint();
    }
    
    public void myRepaint() {
        this.validate();
        Graphics g = this.getGraphics();
        this.update(g);
        g.dispose();
    }
    
    public void appendCRToLog(){
        logTextArea.append("\n");
        logTextArea.setCaretPosition(logTextArea.getText().length());
    }
    
    public boolean isCancelRequested() {
        return cancelRequested;
    }
    
    public void enableButton(JButton aButton, boolean enableCloseButton){
        aButton.setEnabled(enableCloseButton);
    }
    
    private javax.swing.JPanel mainPanel;
    private javax.swing.JButton cancelButton;
    private javax.swing.JButton startButton;
    private javax.swing.JTextArea logTextArea;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JScrollPane logScrollPane;
    private javax.swing.JProgressBar progressBar;
    private javax.swing.JButton closeButton;
    private boolean cancelRequested = false;
    ProcessThread processThread;
    
    
    public void appendToOutput(String s) {
        if (s != null) appendToLog(s);
        //logTextArea.update(logTextArea.getGraphics());
        //        System.out.println("Appended to log");
    }
    public void appendCRToOutput(){
        appendToLog("\n");
        RepaintManager rm = new RepaintManager();
        rm.addInvalidComponent(logTextArea);
        rm.paintDirtyRegions();
    }
    
    public void show() {
        super.show();
        if (autoStart) this.startAndMonitor();
    }
    
    public void run() {
        if (showUI)
            show();
        else
            this.startAndMonitor();
        
    }
    
    public boolean isDone() {
        return done;
    }
    
}