templet.java

Excel Report是一款基于Excel的报表生成工具

            entry = (Entry)itr.next();
            element = (BaseElement)entry.getValue();
            if(null != element){
                if(element instanceof BaseBand){
                    ((BaseBand)element).removeAllTempletImages(sheet);
                }
            }
        }
        if(null != images){
	        for(int i=0; i<images.size(); i++){
	            sheet.removeImage((WritableImage)images.get(i));
	        }
        }
        return true;
    }
    
    /*
     *  (non-Javadoc)
     * @see excel.report.base.ITempletContainer#write(excel.report.base.Parameter)
     */
	public boolean write(Parameter param) throws Exception {
        BaseElement element = null;
        
        int beginTempletRow = getBeginRow();
        int endTempletRow = getEndRow();
        
        //保存开始位置
        int bRow = param.curRow;
        
        for (int row = beginTempletRow + 1; row < endTempletRow; row++) {
            if((element = haveBaseBand(param, row)) != null){
                //如果有嵌套band或group
                element.write(param);
                row = ((BaseBand) element).getEndRow();
                //跳过band模板行
                continue;
            }else{
	            //创建一个新行
	            copyEmptyRow(param, row, param.curRow);
	            //根据模板行数据定义生成新行的数据
	            copyRow(param, row, param.curRow);
            }
            param.curRow++;
        }
        
        //拷贝合并单元格信息
        copyMergedCells(param, bRow);
        //拷贝图片信息
        copyImages(param, bRow);
        
        return true;
    }
    
    private BaseElement haveBaseBand(Parameter param, int curRow){
        int cells = param.sheet.getRow(curRow).length;
        BaseElement element = null;
        //
        for (int col = 0; col < cells; col++) {
            element = getElement(col, curRow);
            if (null != element) {
                if (element instanceof BaseBand) {
                    return element;
                }
            }
        }
        return null;
    }
    
    /**
     * 
     * @param param
     * @param sourceRow
     * @param destRow
     * @throws RowsExceededException
     */
    private void copyEmptyRow(Parameter param, int sourceRow, int destRow) 
				throws RowsExceededException{
		//拷贝行高度
		CellView rowView = param.sheet.getRowView(sourceRow);
		param.sheet.insertRow(destRow);
		param.sheet.setRowView(destRow, rowView.getSize());
	}
    
    /**
     * 拷贝一行数据，并将模板行定义的变量值写入到新行相应的位置
     * @param param
     * @param sourceRow
     * @param destRow
     * @throws Exception
     */
    private void copyRow(Parameter param, int sourceRow, int destRow) throws Exception{
        int cells = param.sheet.getColumns();
        BaseElement element = null;
        WritableCell newWc = null;
        WritableCell wc = null;
        //从模板拷贝行数据
        for (int col = 0; col < cells; col++) {
            wc = param.sheet.getWritableCell(col, sourceRow);
            element = getElement(col, sourceRow);
            if (null != element) {
                param.wc = wc;
                param.destCol = col;
                param.destRow = destRow;
                element.write(param);
                newWc = param.wc;
                param.wc = null;
            }else{
                newWc = wc.copyTo(col, destRow);
            }
            
            if(null != newWc){
                param.sheet.addCell(newWc);
                newWc = null;
            }
        }
    }
    
    /**
     * 拷贝组内合并单元格信息
     * @param param
     * @param bRow  开始行
     * @throws Exception
     */
    private void copyMergedCells(Parameter param,
				            int bRow)
    						throws Exception{
        
        //处理当前组.
        List mergedCells = getMergedCells();
        if(null == mergedCells){
            return;
        }
        
        Cell topLeft = null, bottonRight = null;
        int topLeftRow = 0, btRightRow = 0;
        BaseBand baseBand = null;
        int bandBeginRow = 0;
        
        for(int i=0; i<mergedCells.size(); i++){
            topLeft = ((Range)mergedCells.get(i)).getTopLeft();
            bottonRight = ((Range)mergedCells.get(i)).getBottomRight();
            //判断当前需合并的单元格之前是否存在嵌套的band，如果存在嵌套的band其
            //计算合并单元格的方法不一样，后者需要判断嵌套的band数据的结束位置，
            //并根据该结束位置加上模板中需合并的单元格与该band的逻辑位置来计算
            if((baseBand = getBaseBand(param, this.beginRow, topLeft.getRow())) == null){
                bandBeginRow = bRow;
                topLeftRow = bandBeginRow + (topLeft.getRow() - (this.beginRow + 1));
                btRightRow = bandBeginRow + (bottonRight.getRow() - (this.beginRow + 1));
            }else{
                bandBeginRow = baseBand.getRealBeginRow() + baseBand.getRealRowCount();
                topLeftRow = bandBeginRow + (topLeft.getRow() - (baseBand.getEndRow() + 1));
                btRightRow = bandBeginRow + (bottonRight.getRow() - (baseBand.getEndRow() + 1));
            }
            
            //debug info
            if(log.isDebugEnable()){
	            log.debug("merge cell beginrow:" + topLeftRow 
	                    				+ " begincol:" + topLeft.getColumn()
	                    				+ " endRow:" + btRightRow
	                    				+ " endCol:" + bottonRight.getColumn()
	                    				);
            }
            param.sheet.mergeCells(topLeft.getColumn(), 
                    topLeftRow,
                    bottonRight.getColumn(),
                    btRightRow);
        }
    }
    
    /**
     * 拷贝容器中的图片元素
     * @param param
     * @param bRow
     * @throws Exception
     */
    private void copyImages(Parameter param, int bRow) throws Exception {

        //处理当前容器中的图片.
        List imgs = this.getImages();
        if(null == imgs){
            return;
        }
        
        WritableImage image = null;
        WritableImage imgnew = null;
        double newTopLeftRow = 0.0;
        double leftRow = 0.0;
        BaseBand baseBand = null;
        int bandBeginRow = 0;
        //取得顶层模板容器所占行数
        ITempletContainer container = getTopContainer();
        
        int templetHeight = container.getEndRow() - container.getBeginRow() - 1;
        
        for(int i=0; i<imgs.size(); i++){
        	image = (WritableImage)imgs.get(i);
        	leftRow = image.getRow();
            //判断当前需合并的单元格之前是否存在嵌套的band，如果存在嵌套的band其
            //计算合并单元格的方法不一样，后者需要判断嵌套的band数据的结束位置，
            //并根据该结束位置加上模板中需合并的单元格与该band的逻辑位置来计算
            if((baseBand = getBaseBand(param, this.beginRow, (int)leftRow)) == null){
                bandBeginRow = bRow;
                newTopLeftRow = bandBeginRow + (leftRow - (this.beginRow + 1));
            }else{
                bandBeginRow = baseBand.getRealBeginRow() + baseBand.getRealRowCount();
                newTopLeftRow = bandBeginRow + (leftRow - (baseBand.getEndRow() + 1));
            }
            
            //拷贝图像的真实位置为删除模板后的位置，因为在删除模板时，整个Excel报表文件的行数会发生改变，
            //这时而图片的位置不会自动改变，所以在这里拷贝图像时，图像的实际位置因为删除模板后的位置。
            //log.debug(newTopLeftRow + " " + templetHeight);
            newTopLeftRow -= templetHeight;
            
            //debug info
            if(log.isDebugEnable()){
	            log.debug("copy images beginrow:" + newTopLeftRow 
	                    				+ " begincol:" + image.getColumn()
	                    				+ " endRow:" + newTopLeftRow + image.getHeight()
	                    				+ " endCol:" + image.getColumn() + image.getWidth()
	                    				);
            }
            
            imgnew = new WritableImage(image.getColumn(),
            		newTopLeftRow,
                    image.getWidth(),
                    image.getHeight(),
                    image.getImageData());
            param.sheet.addImage(imgnew);
        }
	}
    
    /**
     * 取得从结束位置endRow开始到开始位置间最靠近结束位置的BaseBand
     * @param param 
     * @param beginRow
     * @param endRow
     * @return
     */
    private BaseBand getBaseBand(Parameter param, int beginRow, int endRow){
        BaseElement element = null;
        int cols = param.sheet.getColumns();
        for(int row=endRow; row>=beginRow; row--){
            for(int col=0; col<cols; col++){
                element = this.getElement(col, row);
                if(element instanceof BaseBand){
                    return (BaseBand)element;
                }
            }
        }
        return null;
    }
    
    public String toString(){
        return "beginRow=" + beginRow + " beginCol=" + beginCol + 
        		" endRow=" + endRow + " endCol=" + endCol + " \n" +
        		this.elements.toString();
    }
    
    private int beginRow = 0;
    private int beginCol = 0;
    private int endRow = 0;
    private int endCol = 0;
    private Map elements = null;
    private List mergedCells = null;
    private List images = null;
    private ITempletContainer parentContainer = null;
}