protected HSSFSheet(HSSFWorkbook workbook) 
{
                                                  
        sheet = Sheet.createSheet();
        rows = new TreeMap();   // new ArrayList(INITIAL_CAPACITY);
        this.workbook = workbook;
        this.book = workbook.getWorkbook();
}

Creates new HSSFSheet - called by HSSFWorkbook to create a sheet from scratch. You should not be calling this from application code (its protected anyhow).

Parameters:

workbook - - The HSSF Workbook object associated with the sheet.

Also see:

org.apache.poi.hssf.usermodel.HSSFWorkbook#createSheet()

 protected HSSFSheet(HSSFWorkbook workbook,
    Sheet sheet) 
{
        this.sheet = sheet;
        rows = new TreeMap();
        this.workbook = workbook;
        this.book = workbook.getWorkbook();
        setPropertiesFromSheet(sheet);
}

Creates an HSSFSheet representing the given Sheet object. Should only be called by HSSFWorkbook when reading in an exisiting file.

Parameters:

workbook - - The HSSF Workbook object associated with the sheet.

sheet - - lowlevel Sheet object this sheet will represent

Also see:

org.apache.poi.hssf.usermodel.HSSFWorkbook#createSheet()

 public int addMergedRegion(Region region) 
{
        //return sheet.addMergedRegion((short) region.getRowFrom(),
        return sheet.addMergedRegion( region.getRowFrom(),
                region.getColumnFrom(),
                //(short) region.getRowTo(),
                region.getRowTo(),
                region.getColumnTo());
}

adds a merged region of cells (hence those cells form one)

 public  void addValidationData(HSSFDataValidation obj_validation) 
{
       if ( obj_validation == null )
       {
         return;
       }
       DVALRecord dvalRec = (DVALRecord)sheet.findFirstRecordBySid( DVALRecord.sid );
       int eofLoc = sheet.findFirstRecordLocBySid( EOFRecord.sid );
       if ( dvalRec == null )
       {
          dvalRec = new DVALRecord();
          sheet.getRecords().add( eofLoc, dvalRec );
       }
       int curr_dvRecNo = dvalRec.getDVRecNo();
       dvalRec.setDVRecNo(curr_dvRecNo+1);
       //create dv record
       DVRecord dvRecord = new DVRecord();
       //dv record's option flags
       dvRecord.setDataType( obj_validation.getDataValidationType() );
       dvRecord.setErrorStyle(obj_validation.getErrorStyle());
       dvRecord.setEmptyCellAllowed(obj_validation.getEmptyCellAllowed());
       dvRecord.setSurppresDropdownArrow(obj_validation.getSurppressDropDownArrow());
       dvRecord.setShowPromptOnCellSelected(obj_validation.getShowPromptBox());
       dvRecord.setShowErrorOnInvalidValue(obj_validation.getShowErrorBox());
       dvRecord.setConditionOperator(obj_validation.getOperator());
       //string fields
       dvRecord.setStringField( DVRecord.STRING_PROMPT_TITLE,obj_validation.getPromptBoxTitle());
       dvRecord.setStringField( DVRecord.STRING_PROMPT_TEXT, obj_validation.getPromptBoxText());
       dvRecord.setStringField( DVRecord.STRING_ERROR_TITLE, obj_validation.getErrorBoxTitle());
       dvRecord.setStringField( DVRecord.STRING_ERROR_TEXT, obj_validation.getErrorBoxText());
       //formula fields ( size and data )
       String str_formula = obj_validation.getFirstFormula();
       FormulaParser fp = new FormulaParser(str_formula, workbook);
       fp.parse();
       Stack ptg_arr = new Stack();
       Ptg[] ptg  = fp.getRPNPtg();
       int size = 0;
       for (int k = 0; k <  ptg.length; k++)
       {
           if ( ptg[k] instanceof org.apache.poi.hssf.record.formula.AreaPtg )
           {
              //we should set ptgClass to Ptg.CLASS_REF and explicit formula string to false
              ptg[k].setClass(Ptg.CLASS_REF);
              obj_validation.setExplicitListFormula(false);
           }
           size += ptg[k].getSize();
           ptg_arr.push(ptg[k]);
       }
       dvRecord.setFirstFormulaRPN(ptg_arr);
       dvRecord.setFirstFormulaSize((short)size);
       dvRecord.setListExplicitFormula(obj_validation.getExplicitListFormula());
       if ( obj_validation.getSecondFormula() != null )
       {
         str_formula = obj_validation.getSecondFormula();
         fp = new FormulaParser(str_formula, workbook);
         fp.parse();
         ptg_arr = new Stack();
         ptg  = fp.getRPNPtg();
         size = 0;
         for (int k = 0; k <  ptg.length; k++)
         {
             size += ptg[k].getSize();
             ptg_arr.push(ptg[k]);
         }
         dvRecord.setSecFormulaRPN(ptg_arr);
         dvRecord.setSecFormulaSize((short)size);
       }
       //dv records cell range field
       HSSFCellRangeAddress cell_range = new HSSFCellRangeAddress();
       cell_range.addADDRStructure(obj_validation.getFirstRow(), obj_validation.getFirstColumn(), obj_validation.getLastRow(), obj_validation.getLastColumn());
       dvRecord.setCellRangeAddress(cell_range);
       //add dv record
       eofLoc = sheet.findFirstRecordLocBySid( EOFRecord.sid );
       sheet.getRecords().add( eofLoc, dvRecord );
}

Creates a data validation object

 public  void autoSizeColumn(short column) 
{
    	autoSizeColumn(column, false);
}

Adjusts the column width to fit the contents. This process can be relatively slow on large sheets, so this should normally only be called once per column, at the end of your processing.

 public  void autoSizeColumn(short column,
    boolean useMergedCells) 
{
        AttributedString str;
        TextLayout layout;
        /**
         * Excel measures columns in units of 1/256th of a character width
         * but the docs say nothing about what particular character is used.
         * '0' looks to be a good choice.
         */
        char defaultChar = '0";
        /**
         * This is the multiple that the font height is scaled by when determining the
         * boundary of rotated text.
         */
        double fontHeightMultiple = 2.0;
        FontRenderContext frc = new FontRenderContext(null, true, true);
        HSSFWorkbook wb = new HSSFWorkbook(book);
        HSSFFont defaultFont = wb.getFontAt((short) 0);
        str = new AttributedString("" + defaultChar);
        copyAttributes(defaultFont, str, 0, 1);
        layout = new TextLayout(str.getIterator(), frc);
        int defaultCharWidth = (int)layout.getAdvance();
        double width = -1;
        rows:
        for (Iterator it = rowIterator(); it.hasNext();) {
            HSSFRow row = (HSSFRow) it.next();
            HSSFCell cell = row.getCell(column);
            if (cell == null) continue;
            int colspan = 1;
            for (int i = 0 ; i <  getNumMergedRegions(); i++) {
                if (getMergedRegionAt(i).contains(row.getRowNum(), column)) {
                	if (!useMergedCells) {
                    	// If we're not using merged cells, skip this one and move on to the next. 
                		continue rows;
                	}
                	cell = row.getCell(getMergedRegionAt(i).getColumnFrom());
                	colspan = 1+ getMergedRegionAt(i).getColumnTo() - getMergedRegionAt(i).getColumnFrom();
                }
            }
            HSSFCellStyle style = cell.getCellStyle();
            HSSFFont font = wb.getFontAt(style.getFontIndex());
            if (cell.getCellType() == HSSFCell.CELL_TYPE_STRING) {
                HSSFRichTextString rt = cell.getRichStringCellValue();
                String[] lines = rt.getString().split("\\n");
                for (int i = 0; i <  lines.length; i++) {
                    String txt = lines[i] + defaultChar;
                    str = new AttributedString(txt);
                    copyAttributes(font, str, 0, txt.length());
                    if (rt.numFormattingRuns()  > 0) {
                        for (int j = 0; j <  lines[i].length(); j++) {
                            int idx = rt.getFontAtIndex(j);
                            if (idx != 0) {
                                HSSFFont fnt = wb.getFontAt((short) idx);
                                copyAttributes(fnt, str, j, j + 1);
                            }
                        }
                    }
                    layout = new TextLayout(str.getIterator(), frc);
                    if(style.getRotation() != 0){
                        /*
                         * Transform the text using a scale so that it's height is increased by a multiple of the leading,
                         * and then rotate the text before computing the bounds. The scale results in some whitespace around
                         * the unrotated top and bottom of the text that normally wouldn't be present if unscaled, but
                         * is added by the standard Excel autosize.
                         */
                        AffineTransform trans = new AffineTransform();
                        trans.concatenate(AffineTransform.getRotateInstance(style.getRotation()*2.0*Math.PI/360.0));
                        trans.concatenate(
                        AffineTransform.getScaleInstance(1, fontHeightMultiple)
                        );
                        width = Math.max(width, ((layout.getOutline(trans).getBounds().getWidth() / colspan) / defaultCharWidth) + cell.getCellStyle().getIndention());
                    } else {
                        width = Math.max(width, ((layout.getBounds().getWidth() / colspan) / defaultCharWidth) + cell.getCellStyle().getIndention());
                    }
                }
            } else {
                String sval = null;
                if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC) {
                    HSSFDataFormat dataformat = wb.createDataFormat();
                    short idx = style.getDataFormat();
                    String format = dataformat.getFormat(idx).replaceAll("\"", "");
                    double value = cell.getNumericCellValue();
                    try {
                        NumberFormat fmt;
                        if ("General".equals(format))
                            sval = "" + value;
                        else
                        {
                            fmt = new DecimalFormat(format);
                            sval = fmt.format(value);
                        }
                    } catch (Exception e) {
                        sval = "" + value;
                    }
                } else if (cell.getCellType() == HSSFCell.CELL_TYPE_BOOLEAN) {
                    sval = String.valueOf(cell.getBooleanCellValue());
                }
                if(sval != null) {
                    String txt = sval + defaultChar;
                    str = new AttributedString(txt);
                    copyAttributes(font, str, 0, txt.length());
                    layout = new TextLayout(str.getIterator(), frc);
                    if(style.getRotation() != 0){
                        /*
                         * Transform the text using a scale so that it's height is increased by a multiple of the leading,
                         * and then rotate the text before computing the bounds. The scale results in some whitespace around
                         * the unrotated top and bottom of the text that normally wouldn't be present if unscaled, but
                         * is added by the standard Excel autosize.
                         */
                        AffineTransform trans = new AffineTransform();
                        trans.concatenate(AffineTransform.getRotateInstance(style.getRotation()*2.0*Math.PI/360.0));
                        trans.concatenate(
                        AffineTransform.getScaleInstance(1, fontHeightMultiple)
                        );
                        width = Math.max(width, ((layout.getOutline(trans).getBounds().getWidth() / colspan) / defaultCharWidth) + cell.getCellStyle().getIndention());
                    } else {
                        width = Math.max(width, ((layout.getBounds().getWidth() / colspan) / defaultCharWidth) + cell.getCellStyle().getIndention());
                    }
                }
            }
        }
        if (width != -1) {
            if (width  > Short.MAX_VALUE) { //width can be bigger that Short.MAX_VALUE!
            	width = Short.MAX_VALUE;
            }
            sheet.setColumnWidth(column, (short) (width * 256));
        }
}

Adjusts the column width to fit the contents. This process can be relatively slow on large sheets, so this should normally only be called once per column, at the end of your processing. You can specify whether the content of merged cells should be considered or ignored. Default is to ignore merged cells.

 HSSFSheet cloneSheet(HSSFWorkbook workbook) 
{
      return new HSSFSheet(workbook, sheet.cloneSheet());
}

 public HSSFPatriarch createDrawingPatriarch() 
{
        // Create the drawing group if it doesn't already exist.
        book.createDrawingGroup();
        sheet.aggregateDrawingRecords(book.getDrawingManager(), true);
        EscherAggregate agg = (EscherAggregate) sheet.findFirstRecordBySid(EscherAggregate.sid);
        HSSFPatriarch patriarch = new HSSFPatriarch(this, agg);
        agg.clear();     // Initially the behaviour will be to clear out any existing shapes in the sheet when
                         // creating a new patriarch.
        agg.setPatriarch(patriarch);
        return patriarch;
}

Creates the top-level drawing patriarch. This will have the effect of removing any existing drawings on this sheet. This may then be used to add graphics or charts

 public  void createFreezePane(int colSplit,
    int rowSplit) 
{
        createFreezePane( colSplit, rowSplit, colSplit, rowSplit );
}

Creates a split (freezepane). Any existing freezepane or split pane is overwritten.

 public  void createFreezePane(int colSplit,
    int rowSplit,
    int leftmostColumn,
    int topRow) 
{
        if (colSplit <  0 || colSplit  > 255) throw new IllegalArgumentException("Column must be between 0 and 255");
        if (rowSplit <  0 || rowSplit  > 65535) throw new IllegalArgumentException("Row must be between 0 and 65535");
        if (leftmostColumn <  colSplit) throw new IllegalArgumentException("leftmostColumn parameter must not be less than colSplit parameter");
        if (topRow <  rowSplit) throw new IllegalArgumentException("topRow parameter must not be less than leftmostColumn parameter");
        getSheet().createFreezePane( colSplit, rowSplit, topRow, leftmostColumn );
}

Creates a split (freezepane). Any existing freezepane or split pane is overwritten.

 public HSSFRow createRow(int rownum) 
{
        HSSFRow row = new HSSFRow(workbook, sheet, rownum);
        addRow(row, true);
        return row;
}

Create a new row within the sheet and return the high level representation

 public  void createSplitPane(int xSplitPos,
    int ySplitPos,
    int leftmostColumn,
    int topRow,
    int activePane) 
{
        getSheet().createSplitPane( xSplitPos, ySplitPos, topRow, leftmostColumn, activePane );
}

Creates a split pane. Any existing freezepane or split pane is overwritten.

 public  void dumpDrawingRecords(boolean fat) 
{
        sheet.aggregateDrawingRecords(book.getDrawingManager(), false);
        EscherAggregate r = (EscherAggregate) getSheet().findFirstRecordBySid(EscherAggregate.sid);
        List escherRecords = r.getEscherRecords();
        PrintWriter w = new PrintWriter(System.out);
        for ( Iterator iterator = escherRecords.iterator(); iterator.hasNext(); )
        {
            EscherRecord escherRecord = (EscherRecord) iterator.next();
            if (fat)
                System.out.println(escherRecord.toString());
            else
                escherRecord.display(w, 0);
        }
        w.flush();
}

Aggregates the drawing records and dumps the escher record hierarchy to the standard output.

 public boolean getAlternateExpression() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getAlternateExpression();
}

whether alternate expression evaluation is on

 public boolean getAlternateFormula() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getAlternateFormula();
}

whether alternative formula entry is on

 public boolean getAutobreaks() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getAutobreaks();
}

show automatic page breaks or not

 public HSSFComment getCellComment(int row,
    int column) 
{
        // Don't call findCellComment directly, otherwise
        //  two calls to this method will result in two
        //  new HSSFComment instances, which is bad
        HSSFRow r = getRow(row);
        if(r != null) {
            HSSFCell c = r.getCell((short)column);
            if(c != null) {
                return c.getCellComment();
            } else {
                // No cell, so you will get new
                //  objects every time, sorry...
                return HSSFCell.findCellComment(sheet, row, column);
            }
        }
        return null;
}

Returns cell comment for the specified row and column

 public short[] getColumnBreaks() 
{
        //we can probably cache this information, but this should be a sparsely used function
        int count = sheet.getNumColumnBreaks();
        if (count  > 0) {
          short[] returnValue = new short[count];
          Iterator iterator = sheet.getColumnBreaks();
          int i = 0;
          while (iterator.hasNext()) {
            PageBreakRecord.Break breakItem = (PageBreakRecord.Break)iterator.next();
            returnValue[i++] = breakItem.main;
          }
          return returnValue;
        }
        return null;
}

Retrieves all the vertical page breaks

 public short getColumnWidth(short column) 
{
        return sheet.getColumnWidth(column);
}

get the width (in units of 1/256th of a character width )

 public short getDefaultColumnWidth() 
{
        return sheet.getDefaultColumnWidth();
}

get the default column width for the sheet (if the columns do not define their own width) in characters

 public short getDefaultRowHeight() 
{
        return sheet.getDefaultRowHeight();
}

get the default row height for the sheet (if the rows do not define their own height) in twips (1/20 of a point)

 public float getDefaultRowHeightInPoints() 
{
        return (sheet.getDefaultRowHeight() / 20);
}

get the default row height for the sheet (if the rows do not define their own height) in points.

 public boolean getDialog() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getDialog();
}

get whether sheet is a dialog sheet or not

 public boolean getDisplayGuts() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getDisplayGuts();
}

get whether to display the guts or not

 public EscherAggregate getDrawingEscherAggregate() 
{
        book.findDrawingGroup();
        // If there's now no drawing manager, then there's
        //  no drawing escher records on the workbook
        if(book.getDrawingManager() == null) {
            return null;
        }
        int found = sheet.aggregateDrawingRecords(
                book.getDrawingManager(), false
        );
        if(found == -1) {
            // Workbook has drawing stuff, but this sheet doesn't
            return null;
        }
        // Grab our aggregate record, and wire it up
        EscherAggregate agg = (EscherAggregate) sheet.findFirstRecordBySid(EscherAggregate.sid);
        return agg;
}

Returns the agregate escher records for this sheet, it there is one. WARNING - calling this will trigger a parsing of the associated escher records. Any that aren't supported (such as charts and complex drawing types) will almost certainly be lost or corrupted when written out.

 public HSSFPatriarch getDrawingPatriarch() 
{
    	EscherAggregate agg = getDrawingEscherAggregate();
    	if(agg == null) return null;
        HSSFPatriarch patriarch = new HSSFPatriarch(this, agg);
        agg.setPatriarch(patriarch);
        // Have it process the records into high level objects
        //  as best it can do (this step may eat anything
        //  that isn't supported, you were warned...)
        agg.convertRecordsToUserModel();
        // Return what we could cope with
        return patriarch;
}

Returns the top-level drawing patriach, if there is one. This will hold any graphics or charts for the sheet. WARNING - calling this will trigger a parsing of the associated escher records. Any that aren't supported (such as charts and complex drawing types) will almost certainly be lost or corrupted when written out. Only use this with simple drawings, otherwise call HSSFSheet#createDrawingPatriarch() and start from scratch!

 public int getFirstRowNum() 
{
        return firstrow;
}

gets the first row on the sheet

 public boolean getFitToPage() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getFitToPage();
}

fit to page option is on

 public HSSFFooter getFooter() 
{
        return new HSSFFooter( getSheet().getFooter() );
}

Gets the user model for the document footer.

 public boolean getForceFormulaRecalculation() 
{
        return sheet.getUncalced();
}

Whether a record must be inserted or not at generation to indicate that formula must be recalculated when workbook is opened.

 public HSSFHeader getHeader() 
{
        return new HSSFHeader( getSheet().getHeader() );
}

Gets the user model for the document header.

 public boolean getHorizontallyCenter() 
{
        HCenterRecord record =
                (HCenterRecord) sheet.findFirstRecordBySid(HCenterRecord.sid);
        return record.getHCenter();
}

Determine whether printed output for this sheet will be horizontally centered.

 public int getLastRowNum() 
{
        return lastrow;
}

gets the last row on the sheet

 public short getLeftCol() 
{
        return sheet.getLeftCol();
}

The left col in the visible view when the sheet is first viewed after opening it in a viewer

 public double getMargin(short margin) 
{
        return getSheet().getMargin( margin );
}

Gets the size of the margin in inches.

 public Region getMergedRegionAt(int index) 
{
        return new Region(sheet.getMergedRegionAt(index));
}

gets the region at a particular index

 public int getNumMergedRegions() 
{
        return sheet.getNumMergedRegions();
}

returns the number of merged regions

 public boolean getObjectProtect() 
{
        return getSheet().isProtected()[1];
}

Answer whether object protection is enabled or disabled

 public PaneInformation getPaneInformation() 
{
      return getSheet().getPaneInformation();
}

Returns the information regarding the currently configured pane (split or freeze).

 public short getPassword() 
{
        return getSheet().getPassword().getPassword();
}

 public int getPhysicalNumberOfRows() 
{
        return rows.size();
}

Returns the number of phsyically defined rows (NOT the number of rows in the sheet)

 public HSSFPrintSetup getPrintSetup() 
{
        return new HSSFPrintSetup( getSheet().getPrintSetup() );
}

Gets the print setup object.

 public boolean getProtect() 
{
        return getSheet().isProtected()[0];
}

Answer whether protection is enabled or disabled

 public HSSFRow getRow(int rownum) 
{
        HSSFRow row = new HSSFRow();
        //row.setRowNum((short) rownum);
        row.setRowNum( rownum);
        return (HSSFRow) rows.get(row);
}

Returns the logical row (not physical) 0-based. If you ask for a row that is not defined you get a null. This is to say row 4 represents the fifth row on a sheet.

 public int[] getRowBreaks() 
{
        //we can probably cache this information, but this should be a sparsely used function
        int count = sheet.getNumRowBreaks();
        if (count  > 0) {
          int[] returnValue = new int[count];
          Iterator iterator = sheet.getRowBreaks();
          int i = 0;
          while (iterator.hasNext()) {
            PageBreakRecord.Break breakItem = (PageBreakRecord.Break)iterator.next();
            returnValue[i++] = breakItem.main;
          }
          return returnValue;
        }
        return null;
}

Retrieves all the horizontal page breaks

 public boolean getRowSumsBelow() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getRowSumsBelow();
}

get if row summaries appear below detail in the outline

 public boolean getRowSumsRight() 
{
        return ((WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid))
                .getRowSumsRight();
}

get if col summaries appear right of the detail in the outline

 public boolean getScenarioProtect() 
{
        return getSheet().isProtected()[2];
}

Answer whether scenario protection is enabled or disabled

 protected Sheet getSheet() 
{
        return sheet;
}

used internally in the API to get the low level Sheet record represented by this Object.

 public HSSFSheetConditionalFormatting getSheetConditionalFormatting() 
{
        return new HSSFSheetConditionalFormatting(workbook, sheet);
}

 public short getTopRow() 
{
        return sheet.getTopRow();
}

The top row in the visible view when the sheet is first viewed after opening it in a viewer

 public boolean getVerticallyCenter() 
{
        VCenterRecord record =
                (VCenterRecord) sheet.findFirstRecordBySid(VCenterRecord.sid);
        return record.getVCenter();
}

Determine whether printed output for this sheet will be vertically centered.

 public boolean getVerticallyCenter(boolean value) 
{
        return getVerticallyCenter();
}

TODO: Boolean not needed, remove after next release

 public  void groupColumn(short fromColumn,
    short toColumn) 
{
        sheet.groupColumnRange( fromColumn, toColumn, true );
}

Create an outline for the provided column range.

 public  void groupRow(int fromRow,
    int toRow) 
{
        sheet.groupRowRange( fromRow, toRow, true );
}

 protected  void insertChartRecords(List records) 
{
        int window2Loc = sheet.findFirstRecordLocBySid( WindowTwoRecord.sid );
        sheet.getRecords().addAll( window2Loc, records );
}

 public boolean isActive() 
{
        return getSheet().getWindowTwo().isActive();
}

 public boolean isColumnBroken(short column) 
{
        return sheet.isColumnBroken(column);
}

Determines if there is a page break at the indicated column

 public boolean isColumnHidden(short column) 
{
        return sheet.isColumnHidden(column);
}

Get the hidden state for a given column.

 public boolean isDisplayFormulas() 
{
        return sheet.isDisplayFormulas();
}

Returns if formulas are displayed.

 public boolean isDisplayGridlines() 
{
    return sheet.isDisplayGridlines();
}

Returns if gridlines are displayed.

 public boolean isDisplayRowColHeadings() 
{
        return sheet.isDisplayRowColHeadings();
}

Returns if RowColHeadings are displayed.

 public boolean isGridsPrinted() 
{
        return sheet.isGridsPrinted();
}

get whether gridlines are printed.

 public boolean isPrintGridlines() 
{
        return getSheet().getPrintGridlines().getPrintGridlines();
}

Returns whether gridlines are printed.

 public boolean isRowBroken(int row) 
{
        return sheet.isRowBroken(row);
}

Determines if there is a page break at the indicated row

 public boolean isSelected() 
{
        return getSheet().getWindowTwo().getSelected();
}

Note - this is not the same as whether the sheet is focused (isActive)

 public Iterator iterator() 
{
        return rowIterator();
}

Alias for #rowIterator() to allow foreach loops

 public  void protectSheet(String password) 
{
                getSheet().protectSheet(password, true, true); //protect objs&scenarios(normal)
}

Sets the protection enabled as well as the password

 public  void removeColumnBreak(short column) 
{
        sheet.removeColumnBreak(column);
}

Removes a page break at the indicated column

 public  void removeMergedRegion(int index) 
{
        sheet.removeMergedRegion(index);
}

removes a merged region of cells (hence letting them free)

 public  void removeRow(HSSFRow row) 
{
        sheet.setLoc(sheet.getDimsLoc());
        if (rows.size()  > 0)
        {
            rows.remove(row);
            if (row.getRowNum() == getLastRowNum())
            {
                lastrow = findLastRow(lastrow);
            }
            if (row.getRowNum() == getFirstRowNum())
            {
                firstrow = findFirstRow(firstrow);
            }
            Iterator iter = row.cellIterator();
            while (iter.hasNext())
            {
                HSSFCell cell = (HSSFCell) iter.next();
                sheet.removeValueRecord(row.getRowNum(),
                        cell.getCellValueRecord());
            }
            sheet.removeRow(row.getRowRecord());
        }
}

Remove a row from this sheet. All cells contained in the row are removed as well

 public  void removeRowBreak(int row) 
{
        sheet.removeRowBreak(row);
}

Removes the page break at the indicated row

 public Iterator rowIterator() 
{
        return rows.values().iterator();
}

 public  void setActive(boolean sel) 
{
        getSheet().getWindowTwo().setActive(sel);
}

Sets whether sheet is selected.

 public  void setAlternativeExpression(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setAlternateExpression(b);
}

whether alternate expression evaluation is on

 public  void setAlternativeFormula(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setAlternateFormula(b);
}

whether alternative formula entry is on

 public  void setAutobreaks(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setAutobreaks(b);
}

show automatic page breaks or not

 public  void setColumnBreak(short column) 
{
        validateColumn(column);
        sheet.setColumnBreak(column, (short)0, (short)65535);
}

Sets a page break at the indicated column

 public  void setColumnGroupCollapsed(short columnNumber,
    boolean collapsed) 
{
        sheet.setColumnGroupCollapsed( columnNumber, collapsed );
}

Expands or collapses a column group.

 public  void setColumnHidden(short column,
    boolean hidden) 
{
        sheet.setColumnHidden(column, hidden);
}

Get the visibility state for a given column.

 public  void setColumnWidth(short column,
    short width) 
{
        sheet.setColumnWidth(column, width);
}

set the width (in units of 1/256th of a character width)

 public  void setDefaultColumnStyle(short column,
    HSSFCellStyle style) 
{
    sheet.setColumn(column, new Short(style.getIndex()), null, null, null, null);
}

Sets the default column style for a given column. POI will only apply this style to new cells added to the sheet.

 public  void setDefaultColumnWidth(short width) 
{
        sheet.setDefaultColumnWidth(width);
}

set the default column width for the sheet (if the columns do not define their own width) in characters

 public  void setDefaultRowHeight(short height) 
{
        sheet.setDefaultRowHeight(height);
}

set the default row height for the sheet (if the rows do not define their own height) in twips (1/20 of a point)

 public  void setDefaultRowHeightInPoints(float height) 
{
        sheet.setDefaultRowHeight((short) (height * 20));
}

set the default row height for the sheet (if the rows do not define their own height) in points

 public  void setDialog(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setDialog(b);
}

set whether sheet is a dialog sheet or not

 public  void setDisplayFormulas(boolean show) 
{
        sheet.setDisplayFormulas(show);
}

Sets whether the formulas are shown in a viewer.

 public  void setDisplayGridlines(boolean show) 
{
        sheet.setDisplayGridlines(show);
}

Sets whether the gridlines are shown in a viewer.

 public  void setDisplayGuts(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setDisplayGuts(b);
}

set whether to display the guts or not

 public  void setDisplayRowColHeadings(boolean show) 
{
        sheet.setDisplayRowColHeadings(show);
}

Sets whether the RowColHeadings are shown in a viewer.

 public  void setFitToPage(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setFitToPage(b);
}

fit to page option is on

 public  void setForceFormulaRecalculation(boolean value) 
{
        sheet.setUncalced(value);
}

Whether a record must be inserted or not at generation to indicate that formula must be recalculated when workbook is opened.

 public  void setGridsPrinted(boolean value) 
{
        sheet.setGridsPrinted(value);
}

set whether gridlines printed.

 public  void setHorizontallyCenter(boolean value) 
{
        HCenterRecord record =
                (HCenterRecord) sheet.findFirstRecordBySid(HCenterRecord.sid);
        record.setHCenter(value);
}

determines whether the output is horizontally centered on the page.

 public  void setMargin(short margin,
    double size) 
{
        getSheet().setMargin( margin, size );
}

Sets the size of the margin in inches.

 public  void setPrintGridlines(boolean newPrintGridlines) 
{
        getSheet().getPrintGridlines().setPrintGridlines( newPrintGridlines );
}

Turns on or off the printing of gridlines.

 public  void setProtect(boolean protect) 
{
        getSheet().getProtect().setProtect(protect);
}

Sets the protection on enabled or disabled

 public  void setRowBreak(int row) 
{
        validateRow(row);
        sheet.setRowBreak(row, (short)0, (short)255);
}

Sets a page break at the indicated row

 public  void setRowGroupCollapsed(int row,
    boolean collapse) 
{
        sheet.setRowGroupCollapsed( row, collapse );
}

 public  void setRowSumsBelow(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setRowSumsBelow(b);
}

set if row summaries appear below detail in the outline

 public  void setRowSumsRight(boolean b) 
{
        WSBoolRecord record =
                (WSBoolRecord) sheet.findFirstRecordBySid(WSBoolRecord.sid);
        record.setRowSumsRight(b);
}

set if col summaries appear right of the detail in the outline

 public  void setSelected(boolean sel) 
{
        getSheet().getWindowTwo().setSelected(sel);
}

Sets whether sheet is selected.

 public  void setVerticallyCenter(boolean value) 
{
        VCenterRecord record =
                (VCenterRecord) sheet.findFirstRecordBySid(VCenterRecord.sid);
        record.setVCenter(value);
}

determines whether the output is vertically centered on the page.

 public  void setZoom(int numerator,
    int denominator) 
{
        if (numerator <  1 || numerator  > 65535)
            throw new IllegalArgumentException("Numerator must be greater than 1 and less than 65536");
        if (denominator <  1 || denominator  > 65535)
            throw new IllegalArgumentException("Denominator must be greater than 1 and less than 65536");
        SCLRecord sclRecord = new SCLRecord();
        sclRecord.setNumerator((short)numerator);
        sclRecord.setDenominator((short)denominator);
        getSheet().setSCLRecord(sclRecord);
}

Sets the zoom magnication for the sheet. The zoom is expressed as a fraction. For example to express a zoom of 75% use 3 for the numerator and 4 for the denominator.

 protected  void shiftMerged(int startRow,
    int endRow,
    int n,
    boolean isRow) 
{
        List shiftedRegions = new ArrayList();
        //move merged regions completely if they fall within the new region boundaries when they are shifted
        for (int i = 0; i <  this.getNumMergedRegions(); i++) {
             Region merged = this.getMergedRegionAt(i);
             boolean inStart = (merged.getRowFrom()  >= startRow || merged.getRowTo()  >= startRow);
             boolean inEnd =  (merged.getRowTo() < = endRow || merged.getRowFrom() < = endRow);
             //dont check if it's not within the shifted area
             if (! (inStart && inEnd)) continue;
             //only shift if the region outside the shifted rows is not merged too
             if (!merged.contains(startRow-1, (short)0) && !merged.contains(endRow+1, (short)0)){
                 merged.setRowFrom(merged.getRowFrom()+n);
                 merged.setRowTo(merged.getRowTo()+n);
                 //have to remove/add it back
                 shiftedRegions.add(merged);
                 this.removeMergedRegion(i);
                 i = i -1; // we have to back up now since we removed one
             }
        }
        //readd so it doesn't get shifted again
        Iterator iterator = shiftedRegions.iterator();
        while (iterator.hasNext()) {
            Region region = (Region)iterator.next();
            this.addMergedRegion(region);
        }
}

Shifts the merged regions left or right depending on mode

TODO: MODE , this is only row specific

 public  void shiftRows(int startRow,
    int endRow,
    int n) 
{
        shiftRows(startRow, endRow, n, false, false);
}

Shifts rows between startRow and endRow n number of rows. If you use a negative number, it will shift rows up. Code ensures that rows don't wrap around. Calls shiftRows(startRow, endRow, n, false, false);

Additionally shifts merged regions that are completely defined in these rows (ie. merged 2 cells on a row to be shifted).

 public  void shiftRows(int startRow,
    int endRow,
    int n,
    boolean copyRowHeight,
    boolean resetOriginalRowHeight) 
{
        int s, e, inc;
        if ( n <  0 )
        {
            s = startRow;
            e = endRow;
            inc = 1;
        }
        else
        {
            s = endRow;
            e = startRow;
            inc = -1;
        }
        shiftMerged(startRow, endRow, n, true);
        sheet.shiftRowBreaks(startRow, endRow, n);
        for ( int rowNum = s; rowNum  >= startRow && rowNum < = endRow && rowNum  >= 0 && rowNum <  65536; rowNum += inc )
        {
            HSSFRow row = getRow( rowNum );
            HSSFRow row2Replace = getRow( rowNum + n );
            if ( row2Replace == null )
                row2Replace = createRow( rowNum + n );
            HSSFCell cell;
        // Removes the cells before over writting them.
            for ( short col = row2Replace.getFirstCellNum(); col < = row2Replace.getLastCellNum(); col++ )
            {
                cell = row2Replace.getCell( col );
                if ( cell != null )
                    row2Replace.removeCell( cell );
            }
        if (row == null) continue; // Nothing to do for this row
        else {
        if (copyRowHeight) {
            row2Replace.setHeight(row.getHeight());
        }
        if (resetOriginalRowHeight) {
            row.setHeight((short)0xff);
        }
        }
            for ( short col = row.getFirstCellNum(); col < = row.getLastCellNum(); col++ )
            {
                cell = row.getCell( col );
                if ( cell != null )
                {
                    row.removeCell( cell );
                    CellValueRecordInterface cellRecord = cell.getCellValueRecord();
                    cellRecord.setRow( rowNum + n );
                    row2Replace.createCellFromRecord( cellRecord );
                    sheet.addValueRecord( rowNum + n, cellRecord );
                }
                // move comments if exist (can exist even if cell is null)
                HSSFComment comment = getCellComment(rowNum, col);
                if (comment != null) {
                   comment.setRow(rowNum + n);
                }
            }
        }
        if ( endRow == lastrow || endRow + n  > lastrow ) lastrow = Math.min( endRow + n, 65535 );
        if ( startRow == firstrow || startRow + n <  firstrow ) firstrow = Math.max( startRow + n, 0 );
        // Update any formulas on this sheet that point to
        //  rows which have been moved
        updateFormulasAfterShift(startRow, endRow, n);
}

Shifts rows between startRow and endRow n number of rows. If you use a negative number, it will shift rows up. Code ensures that rows don't wrap around

Additionally shifts merged regions that are completely defined in these rows (ie. merged 2 cells on a row to be shifted).

TODO Might want to add bounds checking here

 public  void showInPane(short toprow,
    short leftcol) 
{
        this.sheet.setTopRow(toprow);
        this.sheet.setLeftCol(leftcol);
}

Sets desktop window pane display area, when the file is first opened in a viewer.

 public  void ungroupColumn(short fromColumn,
    short toColumn) 
{
        sheet.groupColumnRange( fromColumn, toColumn, false );
}

 public  void ungroupRow(int fromRow,
    int toRow) 
{
        sheet.groupRowRange( fromRow, toRow, false );
}

 protected  void validateColumn(short column) 
{
        if (column  > 255) throw new IllegalArgumentException("Maximum column number is 255");
        if (column <  0)    throw new IllegalArgumentException("Minimum column number is 0");
}

Runs a bounds check for column numbers

 protected  void validateRow(int row) 
{
        if (row  > 65535) throw new IllegalArgumentException("Maximum row number is 65535");
        if (row <  0) throw new IllegalArgumentException("Minumum row number is 0");
}

Runs a bounds check for row numbers