spoolerutil.java

打印管理程序,测试完全通过.windows开发环境.

package jp.co.ntl.swing.ext.spooler;

import java.util.Vector;

import javax.swing.JComponent;
import javax.swing.JTable;

import jp.co.ntl.ComResource;
import jp.co.ntl.NetworkException;
import jp.co.ntl.ServerException;
import jp.co.ntl.SpoolerException;
import jp.co.ntl.TimeOutException;
import jp.co.ntl.spooler.SpoolerInfo;
import jp.co.ntl.swing.TableSorter;
import jp.co.ntl.swing.ext.MsgUtil;

public class SpoolerUtil {

	public static final int		CHECKJOBSTATUS_IDX_RET_PRINT	= 0;
	public static final int		CHECKJOBSTATUS_IDX_RET_CANCEL	= 1;
	public static final int		CHECKJOBSTATUS_IDX_RET_ERROR	= 2;

	private JComponent			parent;
	private JTable				tblSpooler;
	private TableSorter		sorter;
	private SpoolerTableModel	mdlSpooler;
	private SpoolerInvoker		invoker;
	
	public SpoolerUtil(JComponent parent, JTable tblSpooler, TableSorter sorter, SpoolerTableModel mdlSpooler, SpoolerInvoker invoker) {
		this.parent = parent;
		this.tblSpooler = tblSpooler;
		this.sorter = sorter;
		this.mdlSpooler = mdlSpooler;
		this.invoker = invoker;
	}
	
	public boolean doPrint(Vector queTypes) throws NetworkException, ServerException, TimeOutException {
/*		PrintingThread	th = new PrintingThread(parent, PrintingThread.KIND_PRINTING);
		th.start();*/
		doPrintingProc(PrintingThread.KIND_PRINTING, queTypes);
		return true;
	}
	
	public boolean doCancel(Vector queTypes) throws NetworkException, ServerException, TimeOutException {
/*		PrintingThread	th = new PrintingThread(parent, PrintingThread.KIND_CANCEL);
		th.start();*/
		doPrintingProc(PrintingThread.KIND_CANCEL, queTypes);
		return true;
	}
	
	public boolean doDelete(Vector queTypes) throws NetworkException, ServerException, TimeOutException {
/*		PrintingThread	th = new PrintingThread(parent, PrintingThread.KIND_DELETE);
		th.start();*/
		doPrintingProc(PrintingThread.KIND_DELETE, queTypes);
		return true;
	}
	
	// 2007.10.19 lium 堦妵報嶞儃僞儞捛壛 add start
	public boolean doPrintAll(Vector queTypes) throws NetworkException, ServerException, TimeOutException {
		Vector	vcSpoolerInfo = new Vector();
		
		int nCount = mdlSpooler.getRowCount();
		for (int i = 0; i < nCount; i++) {
			int	selRow = sorter.modelIndex(i);
			SpoolerInfo	spoolerInfo = (SpoolerInfo)mdlSpooler.getSelectedInfo(selRow);
			
			// 報嶞壜偺僨乕僞傪憲怣偡傞			
			if (isPrintableJob(spoolerInfo)) {
				vcSpoolerInfo.add(spoolerInfo);
			}
		}
		if (vcSpoolerInfo.size() == 0) {
			return true;
		}
		
		try {
			if (!invoker.doPrintingJobs(vcSpoolerInfo, queTypes)) {
				showMessage(MsgUtil.getMessage(MsgUtil.ERROR_PRINTING, null));
				return false;
			}
		} catch (SpoolerException e) {
			throw new NetworkException(e.getMessage());
		}
		
		for (int i = 0; i < vcSpoolerInfo.size(); i++) {
			SpoolerInfo	splInfo = (SpoolerInfo)vcSpoolerInfo.get(i);
			// 僕儑僽偑報嶞偝傟傑偟偨丅(儐乕僓丗{0}丂僉乕丗{1}丂僕儑僽ID丗{2}丂僕儑僽柤丗{3})
//			log.info(ComResource.getString(ComResource.MSG_BTN_PRINT_EXCUTED,
//					new String[] {splInfo.getSPKeyInfo().getUser().getUserName(), 
//									splInfo.getSPKeyInfo().getSerial(),
//									splInfo.getJobID(),
//									splInfo.getJob()}
//				));
		}
		return true;
	}
	
	// 巜掕偡傞僕儑僽偺忬懺偼報嶞拞偱偡偐偳偆偐
	public boolean isPrintingJob(SpoolerInfo spoolerInfo) {
		boolean	ret = false;
		
		switch (spoolerInfo.getStatus()) {
		case SpoolerInfo.SC_SPOOL:
		case SpoolerInfo.SC_DEVICE:
		case SpoolerInfo.SC_PRINT:
			// 報嶞拞
			ret = true;
			break;
		case SpoolerInfo.SC_SPOOL_END:
			if (spoolerInfo.getQueType() == SpoolerInfo.PRINTING_QUEUE) {
				ret = true; // 憲怣拞
			}
			break;
		case SpoolerInfo.SC_DEVICE_END:
		case SpoolerInfo.SC_PRINT_END:
			break;
		default:
			break;
		}

		return ret;
	}
	
	// 巜掕偡傞僕儑僽偺忬懺偼報嶞壜擻偱偡偐偳偆偐
	public boolean isPrintableJob(SpoolerInfo spoolerInfo) {
		boolean	ret = false;
		
		switch (spoolerInfo.getStatus()) {
		case SpoolerInfo.SC_SPOOL:
			break;
		case SpoolerInfo.SC_DEVICE:
			break;
		case SpoolerInfo.SC_PRINT:
			break;
		case SpoolerInfo.SC_SPOOL_END:
			if (spoolerInfo.getQueType() == SpoolerInfo.PRINTING_QUEUE) {
				ret = false;
			} else {
				ret = true;
			}
			break;
		case SpoolerInfo.SC_DEVICE_END:
		case SpoolerInfo.SC_PRINT_END:
			ret = true;
			break;
		default:
			break;
		}
		
		return ret;
	}	
	
	// 僥乕僽儖慡懱偵報嶞壜偺僕儑僽偑偁傞応崌丄true傪栠傞
	public boolean hasPrintableJob() {
		boolean	ret = false;
		
		int nCount = mdlSpooler.getRowCount();
		for (int i = 0; i < nCount; i++) {
			SpoolerInfo	spoolerInfo = (SpoolerInfo)mdlSpooler.getSelectedInfo(i);
			if(isPrintableJob(spoolerInfo)) {
				ret = true;
				break;
			}
		}		
		return ret;
	}
	
	// 慖戰偝傟偨暋悢偵報嶞拞偺僕儑僽偑偁傞応崌丄true傪栠傞
	public boolean hasPrintingJob() {
		boolean	ret = false;
		
		int[]	selViewRows = tblSpooler.getSelectedRows();
		for (int i = 0; i < selViewRows.length; i++) {
			if (selViewRows[i] >= sorter.getRowCount()) {
				return ret;
			}
			int	selRow = sorter.modelIndex(selViewRows[i]);
			SpoolerInfo	spoolerInfo = (SpoolerInfo)mdlSpooler.getSelectedInfo(selRow);
			if(isPrintingJob(spoolerInfo)) {
				ret = true;
				break;
			}
		}
		
		return ret;
	}	
	// 2007.10.19 lium 堦妵報嶞儃僞儞捛壛 add end
	
	public boolean doPrintingProc(int kind, Vector queTypes) throws NetworkException, ServerException, TimeOutException {
		Vector	vcSpoolerInfo = new Vector();
		int[]	selViewRows = tblSpooler.getSelectedRows();
		int		i;
		
		for (i = 0; i < selViewRows.length; i++) {
			int	selRow;
			if (sorter != null) {
				selRow = sorter.modelIndex(selViewRows[i]);
			} else {
				selRow = selViewRows[i];
			}
			if (selRow >= 0) {
				SpoolerInfo	splInfo = (SpoolerInfo)mdlSpooler.getSelectedInfo(selRow);

				switch (kind) {
				case PrintingThread.KIND_PRINTING:
					// 20071016 lium del start
					// 報嶞儃僞儞墴壓応崌丄忬懺愝掕張棟嶍彍
//					splInfo.setState(SpoolerInfo.SC_PRINT);
					// 20071016 lium del end
					break;
				case PrintingThread.KIND_CANCEL:
					splInfo.setState(SpoolerInfo.EC_CANCEL);
					break;
				case PrintingThread.KIND_DELETE:
					splInfo.setState(SpoolerInfo.SC_DELETING);
					break;
				}
			
				mdlSpooler.setInfo(selRow, splInfo);
				vcSpoolerInfo.addElement(splInfo);
			}
		}
		
		switch (kind) {
		case PrintingThread.KIND_PRINTING:
			try {
				if (!invoker.doPrintingJobs(vcSpoolerInfo, queTypes)) {
					showMessage(MsgUtil.getMessage(MsgUtil.ERROR_PRINTING, null));
					return false;
				}
			} catch (SpoolerException e) {
				throw new NetworkException(e.getMessage());
			}
			
			for (i = 0; i < vcSpoolerInfo.size(); i++) {
				SpoolerInfo	splInfo = (SpoolerInfo)vcSpoolerInfo.get(i);
				// 僕儑僽偑報嶞偝傟傑偟偨丅(儐乕僓丗{0}丂僉乕丗{1}丂僕儑僽ID丗{2}丂僕儑僽柤丗{3})
/*				log.info(ComResource.getString(ComResource.MSG_BTN_PRINT_EXCUTED,
						new String[] {splInfo.getSPKeyInfo().getUser().getUserName(), 
										splInfo.getSPKeyInfo().getSerial(),
										splInfo.getJobID(),
										splInfo.getJob()}
					));
*/			}
// 2006.10.09 夋柺偺僼儕僢僇懳墳丂lium del start
//			for (i = selViewRows.length - 1; i >= 0; i--) {
//				int	selRow = sorter.modelIndex(selViewRows[i]);
//				if (selRow >= 0) {
//					mdlSpooler.deleteInfo(selRow);
//					log.debug("doPrintingProc Del KIND_PRINTING[index=" + selRow + "]");
//				}
//			}
// 2006.10.09 夋柺偺僼儕僢僇懳墳丂lium del end
			
			break;
		case PrintingThread.KIND_CANCEL:
			try {
				if (!invoker.cancelJobs(vcSpoolerInfo, queTypes)) {
					showMessage(MsgUtil.getMessage(MsgUtil.ERROR_NETWORK, null));
					return false;
				}
			} catch (SpoolerException e) {
				throw new NetworkException(e.getMessage());
			}
			break;
		case PrintingThread.KIND_DELETE:
			try {
				if (!invoker.deleteJobs(vcSpoolerInfo, queTypes)) {
					showMessage(MsgUtil.getMessage(MsgUtil.ERROR_NETWORK, null));
					return false;
				} else {
//					for (i = selViewRows.length - 1; i >= 0; i--) {
//						int	selRow = sorter.modelIndex(selViewRows[i]);
//						if (selRow >= 0) {
//							mdlSpooler.deleteInfo(selRow);
//						}
//					}
				}
			} catch (SpoolerException e) {
				throw new NetworkException(e.getMessage());
			}
			
			for (i = 0; i < vcSpoolerInfo.size(); i++) {
				SpoolerInfo	splInfo = (SpoolerInfo)vcSpoolerInfo.get(i);
				// 僕儑僽偑嶍彍偝傟傑偟偨丅(儐乕僓丗{0}丂僉乕丗{1}丂僕儑僽ID丗{2}丂僕儑僽柤丗{3})
/*				log.info(ComResource.getString(ComResource.MSG_BTN_DELETE_EXCUTED,
						new String[] {splInfo.getSPKeyInfo().getUser().getUserName(), 
										splInfo.getSPKeyInfo().getSerial(),
										splInfo.getJobID(),
										splInfo.getJob()}
					));
*/			}
			break;
		}
		
		return true;
	}
	
	private void showMessage(String message) {
		if (parent instanceof SpoolerUserPanel) {
			((SpoolerUserPanel)parent).setStatus(message);
		} else if (parent instanceof PrintedQueuePanel) {
			((PrintedQueuePanel)parent).sendActionEvent(message);
		} else if (parent instanceof WaitQueuePanel) {
			((WaitQueuePanel)parent).sendActionEvent(message);
		}
//		log.error(message);
	}
	
	public boolean[] checkJobStatus() {
		boolean[]	ret = new boolean[] {false, false, false};
		int[]	selViewRows = tblSpooler.getSelectedRows();
		for (int i = 0; i < selViewRows.length; i++) {
			int	selRow;
			if (sorter != null) {
				if (selViewRows[i] >= sorter.getRowCount()) {
					return ret;
				}
				selRow = sorter.modelIndex(selViewRows[i]);
			} else {
				if (selViewRows[i] >= tblSpooler.getRowCount()) {
					return ret;
				}
				selRow = selViewRows[i];
			}
			SpoolerInfo	spoolerInfo = (SpoolerInfo)mdlSpooler.getSelectedInfo(selRow);
			switch (spoolerInfo.getStatus()) {
			case SpoolerInfo.SC_SPOOL:
			case SpoolerInfo.SC_DEVICE:
			case SpoolerInfo.SC_PRINT:
				ret[CHECKJOBSTATUS_IDX_RET_CANCEL] = true;
				break;
			case SpoolerInfo.SC_SPOOL_END:
				// 2007.10.19 lium 報嶞拞報嶞儃僞儞妶惈愝掕 add start
				if (spoolerInfo.getQueType() == SpoolerInfo.PRINTING_QUEUE) {
					ret[CHECKJOBSTATUS_IDX_RET_PRINT] = false;
				} else {
					ret[CHECKJOBSTATUS_IDX_RET_PRINT] = true;
				}
				break;
				// 2007.10.19 lium 報嶞拞報嶞儃僞儞妶惈愝掕 add end
			case SpoolerInfo.SC_DEVICE_END:
			case SpoolerInfo.SC_PRINT_END:
				ret[CHECKJOBSTATUS_IDX_RET_PRINT] = true;
				break;
			default:
				ret[CHECKJOBSTATUS_IDX_RET_PRINT] = false;
				ret[CHECKJOBSTATUS_IDX_RET_CANCEL] = false;
				// 2007.10.19 lium 報嶞拞報嶞儃僞儞妶惈愝掕 mod start
				//ret[2] = true;
				ret[CHECKJOBSTATUS_IDX_RET_ERROR] = true;
				// 2007.10.19 lium 報嶞拞報嶞儃僞儞妶惈愝掕 mod end
				break;
			}
			
			if (ret[CHECKJOBSTATUS_IDX_RET_ERROR]) {
				break;
			}
		}
		
		return ret;
	}
	
	public Vector getQueTypes(int que) {
		Vector	queTypes = new Vector();
		if (que == SpoolerInfo.TYPE_WAIT) {
			queTypes.addElement(SpoolerInfo.PRINTING_QUEUE_STR);
			queTypes.addElement(SpoolerInfo.WAIT_QUEUE_STR);
		} else {
			queTypes.addElement(SpoolerInfo.ERROR_QUEUE_STR);
			queTypes.addElement(SpoolerInfo.OK_QUEUE_STR);
		}
		
		return queTypes;
	}
	
	private class PrintingThread extends Thread {
		public static final int		KIND_PRINTING	= 0;
		public static final int		KIND_CANCEL		= 1;
		public static final int		KIND_DELETE		= 2;
		
		int			kind;
		JComponent	parent;
		int			que;
		
		public PrintingThread(JComponent parent, int kind, int que) {
			super();
			this.kind = kind;
			this.parent = parent;
			this.que = que;
		}
		
		public void run() {
			Vector	queTypes = getQueTypes(que);
			try {
				doPrintingProc(kind, queTypes);
			} catch (NetworkException e) {
				showMessage(MsgUtil.getMessage(MsgUtil.ERROR_NETWORK, null));
			} catch (ServerException e) {
				showMessage(MsgUtil.getMessage(MsgUtil.ERROR_SERVER, null));
			} catch (TimeOutException e) {
			}
		}
		
	}
}