Sheet.java :  » Web-Framework » cocoon » org » apache » cocoon » components » elementprocessor » impl » poi » hssf » elements » Java Open Source

Java Open Source » Web Framework » cocoon 
cocoon » org » apache » cocoon » components » elementprocessor » impl » poi » hssf » elements » Sheet.java
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.cocoon.components.elementprocessor.impl.poi.hssf.elements;

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.avalon.framework.logger.AbstractLogEnabled;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFFooter;
import org.apache.poi.hssf.usermodel.HSSFHeader;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.hssf.util.Region;

/**
 * internal representation of a Sheet
 *
 * @author Marc Johnson (marc_johnson27591@hotmail.com)
 * @author Andrew C. Oliver (acoliver2@users.sourceforge.net)
 * @version CVS $Id: Sheet.java 433543 2006-08-22 06:22:54Z crossley $
 */

// package scope

class Sheet extends AbstractLogEnabled {

    private HSSFSheet _sheet;
    private String _name;
    private int _physical_index;
    private Workbook _workbook;

    // keys are Shorts (row numbers), values are Row instances
    private Map _rows;

    private Map regions;

    //optimization constant
    private final static int ROWS_CAPACITY = 200;

    //optimization constant
    private final static int REGION_CAPACITY = 20;

    /**
     * Constructor Sheet
     * @param workbook
     */
    Sheet(final Workbook workbook) {
        _workbook = workbook;
        _name = _workbook.getNextName();
        _sheet = _workbook.createSheet(_name);
        _physical_index = _workbook.getPhysicalIndex(_name);
        _rows = new HashMap(ROWS_CAPACITY);
        regions = new HashMap(REGION_CAPACITY);
    }

    /**
     * renameSheet
     * @param new_name
     */
    void renameSheet(final String new_name) {
        if (!_name.equals(new_name)) {
            _workbook.renameSheet(_physical_index, new_name);
            _name = new_name;
        }
    }

    /**
     * set a column's width
     * @param number the column number
     * @param points
     * @exception IOException if any arguments are illegal
     */
    void setColumnWidth(final int number, final double points)
        throws IOException {
        if (number < 0 || number > Short.MAX_VALUE) {
            throw new IOException("column number " + number + " is too large");
        }
        if (!isValidColumnPoints(points)) {
            throw new IOException("points " + points + " is out of range");
        }
        _sheet.setColumnWidth((short)number, (short) ((points * 48) + .5));
    }

    /**
     * get the column width of a specified column
     * @param number the column number
     * @return column width in characters
     */
    short getColumnWidth(short number) {
        return _sheet.getColumnWidth(number);
    }

    /**
     * set default column width
     * @param width width, in points
     * @exception IOException
     */
    void setDefaultColumnWidth(double width) throws IOException {
        if (width < 0 || (width >= (4.8 * (0.5 + Short.MAX_VALUE)))) {
            throw new IOException("Invalid width (" + width + ")");
        } // 12 is being used as a "guessed" points for the font
        _sheet.setDefaultColumnWidth((short) ((width / 4.8) + 0.5));
    }

    /**
     * @return default column width (in 1/256ths of a character width)
     */
    short getDefaultColumnWidth() {
        return _sheet.getDefaultColumnWidth();
    }

    /**
     * set default row height
     * @param height height, in points
     * @exception IOException
     */
    void setDefaultRowHeight(double height) throws IOException {
        if (!isValidPoints(height)) {
            throw new IOException("Invalid height (" + height + ")");
        }
        _sheet.setDefaultRowHeight((short) ((height * 20) + .5));
    }

    /**
     * @return default row height
     */
    short getDefaultRowHeight() {
        return _sheet.getDefaultRowHeight();
    }

    /**
     * @return name
     */
    String getName() {
        return _name;
    }

    /**
     * @return index
     */
    int getIndex() {
        return _physical_index;
    }

    /**
     * get a specified row
     * @param rowNo the row number
     * @return a Row object
     * @exception IOException if rowNo is out of range
     */
    Row getRow(int rowNo) throws IOException {
        if (rowNo < 0) {
            throw new IOException("Illegal row number: " + rowNo);
        }
        Short key = new Short((short)rowNo);
        Object o = _rows.get(key);
        Row rval = null;

        if (o == null) {
            rval = createRow(rowNo);
            _rows.put(key, rval);
        } else {
            rval = (Row)o;
        }
        return rval;
    }

    HSSFCellStyle addStyleRegion(Region region) {
        HSSFCellStyle style = _workbook.createStyle();
        regions.put(region, style);
        return style;
    }

    /**
     * returns the HSSFCellStyle for a cell if defined by region if there is
     * not a definition it returns null. If you don't expect that then your
     * code dies a horrible death.
     * @return HSSFCellStyle
     */
    HSSFCellStyle getCellStyleForRegion(int row, short col) {
        Iterator iregions = regions.keySet().iterator();
        while (iregions.hasNext()) {
            Region region = ((Region)iregions.next());
            if (region.contains(row, col)) {
                return (HSSFCellStyle)regions.get(region);
            }
        }
        return null;
    }

    private Row createRow(final int rowNo) {
        return new Row(_sheet.createRow(rowNo), this);
    }

    private boolean isValidPoints(double points) {
        return (points >= 0 && points <= ((Short.MAX_VALUE + 0.5) / 20));
    }

    private boolean isValidColumnPoints(double points) {
        return (points >= 0 && points <= ((Short.MAX_VALUE + 0.5) / 48));
    }

    /*
     * this method doesn't appear to be used private boolean
     * isValidCharacters(double characters) { return ((characters >= 0) &&
     * (characters <= ((Short.MAX_VALUE + 0.5) / 256)));
     */

    /**
     * Flag a certain region of cells to be merged
     * @param region the region to create as merged
     */
    void addMergedRegion(Region region) {
        this._sheet.addMergedRegion(region);
    }

    /**
     * assigns blank cells to regions where no cell is currently allocated.
     * Meaning if there is a sheet with a cell defined at 1,1 and a style
     * region from 0,0-1,1 then cells 0,0;0,1;1,0 will be defined as blank
     * cells pointing to the style defined by the style region. If there is not
     * a defined cell and no styleregion encompases the area, then no cell is
     * defined.
     */
    public void assignBlanksToRegions() {
        Iterator iregions = regions.keySet().iterator();
        while (iregions.hasNext()) {
            Region region = ((Region)iregions.next());
            for (int rownum = region.getRowFrom(); rownum < region.getRowTo() + 1; rownum++) {
                HSSFRow row = _sheet.getRow(rownum);
                for (short colnum = region.getColumnFrom();
                            colnum < region.getColumnTo() + 1; colnum++) {
                    HSSFCellStyle style = (HSSFCellStyle)regions.get(region);
                    if (!isBlank(style)) {
                        //don't waste time with huge blocks of blankly styled cells
                        if (row == null) {
                            if (rownum > Short.MAX_VALUE) {
                                rownum = Short.MAX_VALUE;
                            }
                            row = _sheet.createRow(rownum);
                        }
                        HSSFCell cell = row.getCell(colnum);
                        if (cell == null) {
                            cell = row.createCell(colnum);
                            cell.setCellType(HSSFCell.CELL_TYPE_BLANK);
                            cell.setCellStyle(
                                (HSSFCellStyle)regions.get(region));
                        }
                    }
                }
            }
        }
    }

    private boolean isBlank(HSSFCellStyle style) {
        HSSFFont font = null;
        if (style.getFontIndex() > 0) {
            font = (_workbook.getWorkbook().getFontAt(style.getFontIndex()));
        }
        if (style.getBorderBottom() == 0 && style.getBorderTop() == 0
            && style.getBorderRight() == 0 && style.getBorderLeft() == 0
            && style.getFillBackgroundColor() == HSSFColor.WHITE.index
            && style.getFillPattern() == 0 && (style.getFontIndex() == 0
                || ((font.getFontName().equals("Arial")
                    || font.getFontName().equals("Helvetica"))
                    && font.getFontHeightInPoints() > 8
                    && font.getFontHeightInPoints() < 12))) {
            return true;
        }
        return false;
    }

    /**
     * Set the paper size.
     * @param paperSize the paper size.
     */

    void setPaperSize(short paperSize) {
        _sheet.getPrintSetup().setPaperSize(paperSize);
    }

    /**
     * Set whether to print in landscape
     * @param ls landscape
     */

    void setOrientation(boolean ls) {
        _sheet.getPrintSetup().setLandscape(ls);
    }

    /**
     * Set whether or not the grid is printed for the worksheet
     * @param gridLines boolean to turn on or off the printing of
     * gridlines
     */

    void setPrintGridLines(boolean gridLines) {
        _sheet.setPrintGridlines(gridLines);
    }
    
    /**
     * Set whether or not the worksheet content is centered (horizontally)
     * on the page when it is printed
     */
    void setHCenter(boolean hCenter) {
        _sheet.setHorizontallyCenter(hCenter);
    }

    /**
     * Setwhether or not the worksheet content is centered (vertically)
     * on the page when it is printed
     */
    void setVCenter(boolean vCenter) {
        _sheet.setVerticallyCenter(vCenter);
    }
    
    /**
     * Setup whether or not printing is in monochrome (no color)
     */
    void setMonochrome(boolean noColor) {
        _sheet.getPrintSetup().setNoColor(noColor);
    }
    
    /**
     * Setup whether or not the worksheet is printed in draft format
     */
    void setDraft(boolean draftMode) {
        _sheet.getPrintSetup().setDraft(draftMode);
    }
    
    /**
     * Set text to be printed at the top of every page
     */
    void setHeader(String left, String middle, String right) {
        HSSFHeader header = _sheet.getHeader();
        header.setLeft(left);
        header.setCenter(middle);
        header.setRight(right);
    }
    
    /**
     * Set text to be printed at the bottom of every page
     */
    void setFooter(String left, String middle, String right) {
        HSSFFooter footer = _sheet.getFooter();
        footer.setLeft(left);
        footer.setCenter(middle);
        footer.setRight(right);
    }
    
    /**
     * Set the top margin of the page
     */
    void setTopMargin(double points) {
        _sheet.setMargin(HSSFSheet.TopMargin, points);
    }
    
    /**
     * Set the left margin of the page
     */
    void setLeftMargin(double points) {
        _sheet.setMargin(HSSFSheet.LeftMargin, points);
    }
    
    /**
     * Set the right margin of the page
     */
    void setRightMargin(double points) {
        _sheet.setMargin(HSSFSheet.RightMargin, points);
    }
    
    /**
     * Set the bottom margin of the page
     */
    void setBottomMargin(double points) {
        _sheet.setMargin(HSSFSheet.BottomMargin, points);
    }
    
    /**
     * Set the header margin of the page
     */
    void setHeaderMargin(double points) {
        _sheet.getPrintSetup().setHeaderMargin(points);
    }
    
    /**
     * Set the header margin of the page
     */
    void setFooterMargin(double points) {
        _sheet.getPrintSetup().setFooterMargin(points);
    }

} // end package scope class Sheet
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.