Index: org/apache/poi/hssf/dev/HSSF.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/dev/HSSF.java,v
retrieving revision 1.6
diff -u -r1.6 HSSF.java
--- org/apache/poi/hssf/dev/HSSF.java	23 Aug 2004 08:52:26 -0000	1.6
+++ org/apache/poi/hssf/dev/HSSF.java	25 Nov 2005 11:11:36 -0000
@@ -183,7 +183,7 @@
     public HSSF(String infile, String outfile, boolean write)
         throws IOException
     {
-        this.filename = filename;
+        this.filename = infile;
         POIFSFileSystem fs =
             new POIFSFileSystem(new FileInputStream(filename));
 
Index: org/apache/poi/hssf/model/Sheet.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/model/Sheet.java,v
retrieving revision 1.60
diff -u -r1.60 Sheet.java
--- org/apache/poi/hssf/model/Sheet.java	2 Sep 2005 03:48:29 -0000	1.60
+++ org/apache/poi/hssf/model/Sheet.java	25 Nov 2005 11:11:40 -0000
@@ -936,10 +936,13 @@
     public void addValueRecord(int row, CellValueRecordInterface col)
     {
         checkCells();
-        log.logFormatted(POILogger.DEBUG, "add value record  row,loc %,%", new int[]
+        if(log.check(POILogger.DEBUG))
         {
-            row, loc
-        });
+          log.logFormatted(POILogger.DEBUG, "add value record  row,loc %,%", new int[]
+          {
+              row, loc
+          });
+        }
         DimensionsRecord d = ( DimensionsRecord ) records.get(getDimsLoc());
 
         if (col.getColumn() > d.getLastCol())
@@ -1764,9 +1767,10 @@
 
         if (columns != null)
         {
-            for ( Iterator iterator = columns.getIterator(); iterator.hasNext(); )
+            int count=columns.getNumColumns();
+            for ( int k=0;k<count;k++ )
             {
-                ci = ( ColumnInfoRecord ) iterator.next();
+                ci = columns.getColInfo(k);
                 if ((ci.getFirstColumn() <= column)
                         && (column <= ci.getLastColumn()))
                 {
@@ -1804,8 +1808,10 @@
         short retval = 0;
         ColumnInfoRecord ci = null;
         if (columns != null) {
-            for (Iterator iterator = columns.getIterator(); iterator.hasNext();) {
-                ci = (ColumnInfoRecord) iterator.next();
+          int count=columns.getNumColumns();
+          for ( int k=0;k<count;k++ )
+          {
+                ci = columns.getColInfo(k);
                 if ((ci.getFirstColumn() <= column)
                         && (column <= ci.getLastColumn())) {
                     break;
@@ -1850,9 +1856,10 @@
 
         // Determine the maximum overall level
         int maxLevel = 0;
-        for ( Iterator iterator = columns.getIterator(); iterator.hasNext(); )
+        int count=columns.getNumColumns();
+        for ( int k=0;k<count;k++ )
         {
-            ColumnInfoRecord columnInfoRecord = (ColumnInfoRecord) iterator.next();
+            ColumnInfoRecord columnInfoRecord = columns.getColInfo(k);
             maxLevel = Math.max(columnInfoRecord.getOutlineLevel(), maxLevel);
         }
 
Index: org/apache/poi/hssf/record/RowRecord.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/record/RowRecord.java,v
retrieving revision 1.12
diff -u -r1.12 RowRecord.java
--- org/apache/poi/hssf/record/RowRecord.java	2 Sep 2005 03:48:29 -0000	1.12
+++ org/apache/poi/hssf/record/RowRecord.java	25 Nov 2005 11:11:41 -0000
@@ -52,13 +52,13 @@
     // for generated sheets.
     private short             field_6_reserved;
     private short             field_7_option_flags;
-    private BitField          outlineLevel  = BitFieldFactory.getInstance(0x07);
+    private static final BitField          outlineLevel  = BitFieldFactory.getInstance(0x07);
 
     // bit 3 reserved
-    private BitField          colapsed      = BitFieldFactory.getInstance(0x10);
-    private BitField          zeroHeight    = BitFieldFactory.getInstance(0x20);
-    private BitField          badFontHeight = BitFieldFactory.getInstance(0x40);
-    private BitField          formatted     = BitFieldFactory.getInstance(0x80);
+    private static final BitField          colapsed      = BitFieldFactory.getInstance(0x10);
+    private static final BitField          zeroHeight    = BitFieldFactory.getInstance(0x20);
+    private static final BitField          badFontHeight = BitFieldFactory.getInstance(0x40);
+    private static final BitField          formatted     = BitFieldFactory.getInstance(0x80);
     private short             field_8_xf_index;   // only if isFormatted
 
     public RowRecord()
Index: org/apache/poi/hssf/record/TickRecord.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/record/TickRecord.java,v
retrieving revision 1.8
diff -u -r1.8 TickRecord.java
--- org/apache/poi/hssf/record/TickRecord.java	2 Sep 2005 03:48:29 -0000	1.8
+++ org/apache/poi/hssf/record/TickRecord.java	25 Nov 2005 11:11:41 -0000
@@ -370,7 +370,7 @@
      */
     public void setZero3(short field_12_zero3)
     {
-        this.field_12_zero5 = field_12_zero5;
+        this.field_12_zero5 = field_12_zero3;
     }
 
     /**
Index: org/apache/poi/hssf/record/UnicodeString.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/record/UnicodeString.java,v
retrieving revision 1.15
diff -u -r1.15 UnicodeString.java
--- org/apache/poi/hssf/record/UnicodeString.java	2 Sep 2005 03:41:40 -0000	1.15
+++ org/apache/poi/hssf/record/UnicodeString.java	25 Nov 2005 11:11:42 -0000
@@ -49,9 +49,9 @@
     private String            field_3_string;        // = null;
     private List field_4_format_runs;
     private byte[] field_5_ext_rst;
-    private  BitField   highByte  = BitFieldFactory.getInstance(0x1);
-    private  BitField   extBit    = BitFieldFactory.getInstance(0x4);
-    private  BitField   richText  = BitFieldFactory.getInstance(0x8);
+    private  static final BitField   highByte  = BitFieldFactory.getInstance(0x1);
+    private  static final BitField   extBit    = BitFieldFactory.getInstance(0x4);
+    private  static final BitField   richText  = BitFieldFactory.getInstance(0x8);
 
     public static class FormatRun implements Comparable {
       private short character;
Index: org/apache/poi/hssf/record/aggregates/ColumnInfoRecordsAggregate.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/record/aggregates/ColumnInfoRecordsAggregate.java,v
retrieving revision 1.4
diff -u -r1.4 ColumnInfoRecordsAggregate.java
--- org/apache/poi/hssf/record/aggregates/ColumnInfoRecordsAggregate.java	18 Aug 2005 07:06:39 -0000	1.4
+++ org/apache/poi/hssf/record/aggregates/ColumnInfoRecordsAggregate.java	25 Nov 2005 11:11:43 -0000
@@ -2,7 +2,7 @@
 
 import org.apache.poi.hssf.record.ColumnInfoRecord;
 import org.apache.poi.hssf.record.Record;
-import org.apache.poi.hssf.record.RecordInputStream;
+import org.apache.poi.hssf.record.RecordInputStream;
 
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -24,7 +24,7 @@
     }
 
     /** You never fill an aggregate */
-    protected void fillFields(RecordInputStream in)
+    protected void fillFields(RecordInputStream in)
     {
     }
 
@@ -58,11 +58,11 @@
     public Object clone()
     {
         ColumnInfoRecordsAggregate rec = new ColumnInfoRecordsAggregate();
-        for ( Iterator colIter = getIterator(); colIter.hasNext(); )
+        for (int k = 0; k < records.size(); k++)
         {
-            //return the cloned Row Record & insert
-            ColumnInfoRecord col = (ColumnInfoRecord) ( (ColumnInfoRecord) colIter.next() ).clone();
-            rec.insertColumn( col );
+            ColumnInfoRecord ci = ( ColumnInfoRecord ) records.get(k);
+            ci=(ColumnInfoRecord) ci.clone();
+            rec.insertColumn( ci );
         }
         return rec;
     }
Index: org/apache/poi/hssf/record/aggregates/ValueRecordsAggregate.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/record/aggregates/ValueRecordsAggregate.java,v
retrieving revision 1.18
diff -u -r1.18 ValueRecordsAggregate.java
--- org/apache/poi/hssf/record/aggregates/ValueRecordsAggregate.java	18 Aug 2005 07:06:39 -0000	1.18
+++ org/apache/poi/hssf/record/aggregates/ValueRecordsAggregate.java	25 Nov 2005 11:11:43 -0000
@@ -41,144 +41,72 @@
     public final static short sid       = -1000;
     int                       firstcell = -1;
     int                       lastcell  = -1;
-    TreeMap                   records   = null;
+  CellValueRecordInterface[][] records;
 
-   /** This class is used to find a row in the TreeMap.
-    *  
-    * This instance of which is used by the rowHasCells method as the key.
-    */
-   private class RowComparator implements CellValueRecordInterface, Comparable {
-     private int row;
-     
-     public void setRow(int row) {
-       this.row = row;
-     }
-     
-     public int compareTo(Object obj) {
-         CellValueRecordInterface cell = (CellValueRecordInterface) obj;
- 
-         if (row == cell.getRow()) {
-           return 0;
-         }
-         else if (row < cell.getRow()) {
-           return -1;
-         }
-         else if (row > cell.getRow()){
-           return 1;
-         }
-         return -1;         
-     }
-     public int getRow() { return row;}     
-     public short getColumn() { return 0;}
-     public void setColumn(short col){}
-     public void setXFIndex(short xf){}
-     public short getXFIndex(){return 0;}
-     public boolean isBefore(CellValueRecordInterface i){ return false; }
-     public boolean isAfter(CellValueRecordInterface i){ return false; }
-     public boolean isEqual(CellValueRecordInterface i){ return false; }
-     public Object clone(){ return null;}     
-   }
-   
-   /**
-    * Iterates the cell records that exist between the startRow and endRow (inclusive).
-    * 
-    * User must ensure that hasNext & next are called insequence for correct
-    * operation. Could fix, but since this is only used internally to the
-    * ValueRecordsAggregate class there doesnt seem much point.
-    */   
-   private class RowCellIterator implements Iterator {
-     private int startRow;
-     private int endRow;
-     private Iterator internalIterator;
-     private CellValueRecordInterface atCell;
-     
-     public class RowCellComparator extends RowComparator {
-       public int compareTo(Object obj) {
-           CellValueRecordInterface cell = (CellValueRecordInterface) obj;
-  
-           if (getRow() == cell.getRow() && cell.getColumn() == 0) {
-             return 0;
-           }
-           else if (getRow() < cell.getRow()) {
-             return -1;
-           }
-           else if (getRow() > cell.getRow()){
-             return 1;
-           }
-           if (cell.getColumn() > 0)
-           {
-               return -1;
-           }
-           if (cell.getColumn() < 0)
-           {
-               return 1;
-           }
-           return -1;         
-       }
-     }
-     
-     private RowCellComparator rowCellCompare;
-     
-     
-     public RowCellIterator(int startRow, int endRow) {
-       this.startRow = startRow;
-       this.endRow = endRow;
-       rowCellCompare = new RowCellComparator();
-       rowCellCompare.setRow(startRow);
-     }
-     
-     public boolean hasNext() {
-       if (internalIterator == null) {
-         internalIterator = records.tailMap(rowCellCompare).values().iterator();
-       }
-       if (internalIterator.hasNext()) {
-         atCell = (CellValueRecordInterface) internalIterator.next();
-         return (atCell.getRow() <= endRow);
-       } else return false;
-     }
-     
-     public Object next() {
-       return atCell;
-     }
-     
-     public void remove() {
-       //Do Nothing (Not called)
-     }
-   }
-   
-   //Only need a single instance of this class, but the row fields
-   //will probably change each use. Instance is only used in the rowHasCells method.
-   public final RowComparator compareRow = new RowComparator();
-   
     /** Creates a new instance of ValueRecordsAggregate */
 
     public ValueRecordsAggregate()
     {
-        records = new TreeMap();
+    records = new CellValueRecordInterface[30][]; // We start with 30 Rows.
     }
 
-    public void insertCell(CellValueRecordInterface cell)
-    {
-        Object o = records.put(cell, cell);
+  public void insertCell(CellValueRecordInterface cell) {
+    short column = cell.getColumn();
+    int row = cell.getRow();
+    if (row >= records.length) {
+      CellValueRecordInterface[][] oldRecords = records;
+      int newSize = oldRecords.length * 2;
+      if(newSize<row+1) newSize=row+1;
+      records = new CellValueRecordInterface[newSize][];
+      System.arraycopy(oldRecords, 0, records, 0, oldRecords.length);
+    }
+    CellValueRecordInterface[] rowCells = records[row];
+    if (rowCells == null) {
+      int newSize = column + 1;
+      if(newSize<10) newSize=10;
+      rowCells = new CellValueRecordInterface[newSize];
+      records[row] = rowCells;
+    }
+    if (column >= rowCells.length) {
+      CellValueRecordInterface[] oldRowCells = rowCells;
+      int newSize = oldRowCells.length * 2;
+      if(newSize<column+1) newSize=column+1;
+      // if(newSize>257) newSize=257; // activate?
+      rowCells = new CellValueRecordInterface[newSize];
+      System.arraycopy(oldRowCells, 0, rowCells, 0, oldRowCells.length);
+      records[row] = rowCells;
+    }
+    rowCells[column] = cell;
 
-        if ((cell.getColumn() < firstcell) || (firstcell == -1))
-        {
-            firstcell = cell.getColumn();
-        }
-        if ((cell.getColumn() > lastcell) || (lastcell == -1))
-        {
-            lastcell = cell.getColumn();
-        }
+    if ((column < firstcell) || (firstcell == -1)) {
+      firstcell = column;
+    }
+    if ((column > lastcell) || (lastcell == -1)) {
+      lastcell = column;
     }
+  }
 
     public void removeCell(CellValueRecordInterface cell)
     {
-        records.remove(cell);
+    short column = cell.getColumn();
+    int row = cell.getRow();
+    if(row>=records.length) return;
+    CellValueRecordInterface[] rowCells=records[row];
+    if(rowCells==null) return;
+    if(column>=rowCells.length) return;
+    rowCells[column]=null;
     }
 
     public int getPhysicalNumberOfCells()
     {
-        return records.size();
+    int count=0;
+    for(int r=0;r<records.length;r++) {
+      CellValueRecordInterface[] rowCells=records[r];
+      for(short c=0;c<rowCells.length;c++) {
+        if(rowCells[c]!=null) count++;
+      }
+    }
+    return count;
     }
 
     public int getFirstCellNum()
@@ -246,7 +174,7 @@
      *  that are attached to the rows in the range specified.
      */
     public int getRowCellBlockSize(int startRow, int endRow) {
-      RowCellIterator itr = new RowCellIterator(startRow, endRow);
+      MyIterator itr = new MyIterator(startRow, endRow);
       int size = 0;
       while (itr.hasNext()) {
         CellValueRecordInterface cell = (CellValueRecordInterface)itr.next();
@@ -261,14 +189,18 @@
 
     /** Returns true if the row has cells attached to it */
     public boolean rowHasCells(int row) {
-      compareRow.setRow(row);
-      return records.containsKey(compareRow);
+      CellValueRecordInterface[] rowCells=records[row];
+      if(rowCells==null) return false;
+      for(int col=0;col<rowCells.length;col++) {
+        if(rowCells[col]!=null) return true;
+      }
+      return false;
     }
 
     /** Serializes the cells that are allocated to a certain row range*/
     public int serializeCellRow(final int row, int offset, byte [] data)
     {
-        RowCellIterator itr = new RowCellIterator(row, row);      
+      MyIterator itr = new MyIterator(row, row);
         int      pos = offset;
 
         while (itr.hasNext())
@@ -318,7 +250,7 @@
     public int getRecordSize() {
     
         int size = 0;
-        Iterator irecs = records.values().iterator();
+    Iterator irecs = this.getIterator();
         
         while (irecs.hasNext()) {
                 size += (( Record ) irecs.next()).getRecordSize();
@@ -329,7 +261,7 @@
 
     public Iterator getIterator()
     {
-        return records.values().iterator();
+    return new MyIterator();
     }
 
     /** Performs a deep clone of the record*/
@@ -341,4 +273,51 @@
       }
       return rec;
     }
+  
+  public class MyIterator implements Iterator {
+    short nextColumn=-1;
+    int nextRow,lastRow;
+
+    public MyIterator()
+    {
+      this.nextRow=0;
+      this.lastRow=records.length-1;
+      findNext();
+    }
+    
+    public MyIterator(int firstRow,int lastRow)
+    {
+      this.nextRow=firstRow;
+      this.lastRow=lastRow;
+      findNext();
+    }
+
+    public boolean hasNext() {
+      return nextRow<=lastRow;
+    }
+    public Object next() {
+      Object o=records[nextRow][nextColumn];
+      findNext();
+      return o;
+    }
+    public void remove() {
+      throw new UnsupportedOperationException("gibt's noch nicht");
+    }
+
+    private void findNext() {
+      nextColumn++;
+      for(;nextRow<=lastRow;nextRow++) {
+        CellValueRecordInterface[] rowCells=records[nextRow];
+        if(rowCells==null) { // This row is empty
+          nextColumn=0;
+          continue;
+        }
+        for(;nextColumn<rowCells.length;nextColumn++) {
+          if(rowCells[nextColumn]!=null) return;
+        }
+        nextColumn=0;
+      }
+    }
+
+  }
 }
\ No newline at end of file
Index: org/apache/poi/hssf/usermodel/DummyGraphics2d.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/usermodel/DummyGraphics2d.java,v
retrieving revision 1.4
diff -u -r1.4 DummyGraphics2d.java
--- org/apache/poi/hssf/usermodel/DummyGraphics2d.java	23 Aug 2004 08:52:42 -0000	1.4
+++ org/apache/poi/hssf/usermodel/DummyGraphics2d.java	25 Nov 2005 11:11:45 -0000
@@ -411,7 +411,7 @@
 
     public void drawChars(char data[], int offset, int length, int x, int y) {
         System.out.println( "drawChars(data,int,int,int,int):" );
-        System.out.println( "data = " + data );
+        System.out.println( "data = " + data.toString() );
         System.out.println( "offset = " + offset );
         System.out.println( "length = " + length );
         System.out.println( "x = " + x );
Index: org/apache/poi/hssf/usermodel/HSSFCell.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/usermodel/HSSFCell.java,v
retrieving revision 1.33
diff -u -r1.33 HSSFCell.java
--- org/apache/poi/hssf/usermodel/HSSFCell.java	2 Sep 2005 03:48:31 -0000	1.33
+++ org/apache/poi/hssf/usermodel/HSSFCell.java	25 Nov 2005 11:11:46 -0000
@@ -106,18 +106,11 @@
     public final static short        ENCODING_UNCHANGED          = -1;
     public final static short        ENCODING_COMPRESSED_UNICODE = 0;
     public final static short        ENCODING_UTF_16             = 1;
-    private short                    cellNum;
     private int                      cellType;
-    private HSSFCellStyle            cellStyle;
-    private double                   cellValue;
     private HSSFRichTextString       stringValue;
-    private boolean                  booleanValue;
-    private byte                     errorValue;
     private short                    encoding = ENCODING_UNCHANGED;
     private Workbook                 book;
     private Sheet                    sheet;
-    //private short                    row;
-    private int                    row;
     private CellValueRecordInterface record;
 
     /**
@@ -141,24 +134,15 @@
     protected HSSFCell(Workbook book, Sheet sheet, int row, short col)
     {
         checkBounds(col);
-        cellNum      = col;
-        this.row     = row;
-        cellStyle    = null;
-        cellValue    = 0;
         stringValue  = null;
-        booleanValue = false;
-        errorValue   = ( byte ) 0;
         this.book    = book;
         this.sheet   = sheet;
 
         // Relying on the fact that by default the cellType is set to 0 which
         // is different to CELL_TYPE_BLANK hence the following method call correctly
         // creates a new blank cell.
-        setCellType(CELL_TYPE_BLANK, false);
-        
         short xfindex = sheet.getXFIndexForColAt(col);
-        ExtendedFormatRecord xf = book.getExFormatAt(xfindex);
-        setCellStyle(new HSSFCellStyle(xfindex, xf));
+        setCellType(CELL_TYPE_BLANK, false, row, col,xfindex);
     }
 
     /**
@@ -173,8 +157,6 @@
      *                CELL_TYPE_BOOLEAN, CELL_TYPE_ERROR
      *                Type of cell
      * @see org.apache.poi.hssf.usermodel.HSSFRow#createCell(short,int)
-     * @deprecated As of 22-Jan-2002 use @see org.apache.poi.hssf.usermodel.HSSFRow#createCell(short)
-     * and use setCellValue to specify the type lazily.
      */
 
     //protected HSSFCell(Workbook book, Sheet sheet, short row, short col,
@@ -182,68 +164,13 @@
                        int type)
     {
         checkBounds(col);
-        cellNum      = col;
-        this.row     = row;
-        cellType     = type;
-        cellStyle    = null;
-        cellValue    = 0;
+        cellType     = -1; // Force 'setCellType' to create a first Record
         stringValue  = null;
-        booleanValue = false;
-        errorValue   = ( byte ) 0;
         this.book    = book;
         this.sheet   = sheet;
-        switch (type)
-        {
-
-            case CELL_TYPE_NUMERIC :
-                record = new NumberRecord();
-                (( NumberRecord ) record).setColumn(col);
-                (( NumberRecord ) record).setRow(row);
-                (( NumberRecord ) record).setValue(( short ) 0);
-                (( NumberRecord ) record).setXFIndex(( short ) 0);
-                break;
-
-            case CELL_TYPE_STRING :
-                record = new LabelSSTRecord();
-                (( LabelSSTRecord ) record).setColumn(col);
-                (( LabelSSTRecord ) record).setRow(row);
-                (( LabelSSTRecord ) record).setXFIndex(( short ) 0);
-                break;
-
-            case CELL_TYPE_BLANK :
-                record = new BlankRecord();
-                (( BlankRecord ) record).setColumn(col);
-                (( BlankRecord ) record).setRow(row);
-                (( BlankRecord ) record).setXFIndex(( short ) 0);
-                break;
-
-            case CELL_TYPE_FORMULA :
-                FormulaRecord formulaRecord = new FormulaRecord();
-                record = new FormulaRecordAggregate(formulaRecord,null);
-                formulaRecord.setColumn(col);
-                formulaRecord.setRow(row);
-                formulaRecord.setXFIndex(( short ) 0);
-            case CELL_TYPE_BOOLEAN :
-                record = new BoolErrRecord();
-                (( BoolErrRecord ) record).setColumn(col);
-                (( BoolErrRecord ) record).setRow(row);
-                (( BoolErrRecord ) record).setXFIndex(( short ) 0);
-                (( BoolErrRecord ) record).setValue(false);
-                break;
-
-            case CELL_TYPE_ERROR :
-                record = new BoolErrRecord();
-                (( BoolErrRecord ) record).setColumn(col);
-                (( BoolErrRecord ) record).setRow(row);
-                (( BoolErrRecord ) record).setXFIndex(( short ) 0);
-                (( BoolErrRecord ) record).setValue(( byte ) 0);
-                break;
-        }
-
-        int xfindex = sheet.getXFIndexForColAt(col);
-        ExtendedFormatRecord xf = book.getExFormatAt(xfindex);
-
-        setCellStyle(new HSSFCellStyle(( short ) 0xf, xf));
+        
+        short xfindex = sheet.getXFIndexForColAt(col);
+        setCellType(type,false,row,col,xfindex);
     }
 
     /**
@@ -259,21 +186,13 @@
     protected HSSFCell(Workbook book, Sheet sheet, int row,
                        CellValueRecordInterface cval)
     {
-        cellNum     = cval.getColumn();
         record      = cval;
-        this.row    = row;
         cellType    = determineType(cval);
-        cellStyle   = null;
         stringValue = null;
         this.book   = book;
         this.sheet  = sheet;
         switch (cellType)
         {
-
-            case CELL_TYPE_NUMERIC :
-                cellValue = (( NumberRecord ) cval).getValue();
-                break;
-
             case CELL_TYPE_STRING :
                 stringValue = new HSSFRichTextString(book, (LabelSSTRecord ) cval);
                 break;
@@ -282,17 +201,8 @@
                 break;
 
             case CELL_TYPE_FORMULA :
-                cellValue = (( FormulaRecordAggregate ) cval).getFormulaRecord().getValue();
                 stringValue=new HSSFRichTextString(((FormulaRecordAggregate) cval).getStringValue());
                 break;
-
-            case CELL_TYPE_BOOLEAN :
-                booleanValue = (( BoolErrRecord ) cval).getBooleanValue();
-                break;
-
-            case CELL_TYPE_ERROR :
-                errorValue = (( BoolErrRecord ) cval).getErrorValue();
-                break;
         }
         ExtendedFormatRecord xf = book.getExFormatAt(cval.getXFIndex());
 
@@ -352,7 +262,6 @@
 
     public void setCellNum(short num)
     {
-        cellNum = num;
         record.setColumn(num);
     }
 
@@ -363,7 +272,7 @@
 
     public short getCellNum()
     {
-        return cellNum;
+        return record.getColumn();
     }
 
     /**
@@ -378,7 +287,10 @@
 
     public void setCellType(int cellType)
     {
-        setCellType(cellType, true);
+        int row=record.getRow();
+        short col=record.getColumn();
+        short styleIndex=record.getXFIndex();
+        setCellType(cellType, true, row, col, styleIndex);
     }
 
     /**
@@ -390,7 +302,7 @@
      *
      */
 
-    private void setCellType(int cellType, boolean setValue)
+    private void setCellType(int cellType, boolean setValue, int row,short col, short styleIndex)
     {
 
         // if (cellType == CELL_TYPE_FORMULA)
@@ -416,12 +328,12 @@
                 {
                     frec = ( FormulaRecordAggregate ) record;
                 }
-                frec.setColumn(getCellNum());
+                frec.setColumn(col);
                 if (setValue)
                 {
                     frec.getFormulaRecord().setValue(getNumericCellValue());
                 }
-                frec.setXFIndex(( short ) cellStyle.getIndex());
+                frec.setXFIndex(styleIndex);
                 frec.setRow(row);
                 record = frec;
                 break;
@@ -437,12 +349,12 @@
                 {
                     nrec = ( NumberRecord ) record;
                 }
-                nrec.setColumn(getCellNum());
+                nrec.setColumn(col);
                 if (setValue)
                 {
                     nrec.setValue(getNumericCellValue());
                 }
-                nrec.setXFIndex(( short ) cellStyle.getIndex());
+                nrec.setXFIndex(styleIndex);
                 nrec.setRow(row);
                 record = nrec;
                 break;
@@ -458,9 +370,9 @@
                 {
                     lrec = ( LabelSSTRecord ) record;
                 }
-                lrec.setColumn(getCellNum());
+                lrec.setColumn(col);
                 lrec.setRow(row);
-                lrec.setXFIndex(( short ) cellStyle.getIndex());
+                lrec.setXFIndex(styleIndex);
                 if (setValue)
                 {
                     if ((getStringCellValue() != null)
@@ -495,17 +407,10 @@
                 {
                     brec = ( BlankRecord ) record;
                 }
-                brec.setColumn(getCellNum());
+                brec.setColumn(col);
 
                 // During construction the cellStyle may be null for a Blank cell.
-                if (cellStyle != null)
-                {
-                    brec.setXFIndex(( short ) cellStyle.getIndex());
-                }
-                else
-                {
-                    brec.setXFIndex(( short ) 0);
-                }
+                brec.setXFIndex(styleIndex);
                 brec.setRow(row);
                 record = brec;
                 break;
@@ -521,12 +426,12 @@
                 {
                     boolRec = ( BoolErrRecord ) record;
                 }
-                boolRec.setColumn(getCellNum());
+                boolRec.setColumn(col);
                 if (setValue)
                 {
                     boolRec.setValue(getBooleanCellValue());
                 }
-                boolRec.setXFIndex(( short ) cellStyle.getIndex());
+                boolRec.setXFIndex(styleIndex);
                 boolRec.setRow(row);
                 record = boolRec;
                 break;
@@ -542,17 +447,18 @@
                 {
                     errRec = ( BoolErrRecord ) record;
                 }
-                errRec.setColumn(getCellNum());
+                errRec.setColumn(col);
                 if (setValue)
                 {
                     errRec.setValue(getErrorCellValue());
                 }
-                errRec.setXFIndex(( short ) cellStyle.getIndex());
+                errRec.setXFIndex(styleIndex);
                 errRec.setRow(row);
                 record = errRec;
                 break;
         }
-        if (cellType != this.cellType)
+        if (cellType != this.cellType && 
+            this.cellType!=-1 )  // Special Value to indicate an uninitialized Cell
         {
             int loc = sheet.getLoc();
 
@@ -585,12 +491,14 @@
      */
     public void setCellValue(double value)
     {
+        int row=record.getRow();
+        short col=record.getColumn();
+        short styleIndex=record.getXFIndex();
         if ((cellType != CELL_TYPE_NUMERIC) && (cellType != CELL_TYPE_FORMULA))
         {
-            setCellType(CELL_TYPE_NUMERIC, false);
+            setCellType(CELL_TYPE_NUMERIC, false, row, col, styleIndex);
         }
         (( NumberRecord ) record).setValue(value);
-        cellValue = value;
     }
 
     /**
@@ -648,15 +556,18 @@
 
     public void setCellValue(HSSFRichTextString value)
     {
+        int row=record.getRow();
+        short col=record.getColumn();
+        short styleIndex=record.getXFIndex();
         if (value == null)
         {
-            setCellType(CELL_TYPE_BLANK, false);
+            setCellType(CELL_TYPE_BLANK, false, row, col, styleIndex);
         }
         else
         {
             if ((cellType != CELL_TYPE_STRING ) && ( cellType != CELL_TYPE_FORMULA))
             {
-                setCellType(CELL_TYPE_STRING, false);
+                setCellType(CELL_TYPE_STRING, false, row, col, styleIndex);
             }
             int index = 0;
 
@@ -677,11 +588,14 @@
     }
 
     public void setCellFormula(String formula) {
+        int row=record.getRow();
+        short col=record.getColumn();
+        short styleIndex=record.getXFIndex();
         //Workbook.currentBook=book;
         if (formula==null) {
-            setCellType(CELL_TYPE_BLANK,false);
+            setCellType(CELL_TYPE_BLANK,false,row,col,styleIndex);
         } else {
-            setCellType(CELL_TYPE_FORMULA,false);
+            setCellType(CELL_TYPE_FORMULA,false,row,col,styleIndex);
             FormulaRecordAggregate rec = (FormulaRecordAggregate) record;
             rec.getFormulaRecord().setOptions(( short ) 2);
             rec.getFormulaRecord().setValue(0);
@@ -736,7 +650,15 @@
             throw new NumberFormatException(
                 "You cannot get a numeric value from an error cell");
         }
-        return cellValue;
+        if(cellType == CELL_TYPE_NUMERIC)
+        {
+          return ((NumberRecord)record).getValue();
+        }
+        if(cellType == CELL_TYPE_FORMULA)
+        {
+          return ((FormulaRecord)record).getValue();
+        }
+        throw new NumberFormatException("Unknown Record Type in Cell:"+cellType);
     }
 
     /**
@@ -764,11 +686,12 @@
             throw new NumberFormatException(
                 "You cannot get a date value from an error cell");
         }
+        double value=this.getNumericCellValue();
         if (book.isUsing1904DateWindowing()) {
-            return HSSFDateUtil.getJavaDate(cellValue,true);
+            return HSSFDateUtil.getJavaDate(value,true);
         }
         else {
-            return HSSFDateUtil.getJavaDate(cellValue,false);
+            return HSSFDateUtil.getJavaDate(value,false);
         }
     }
 
@@ -829,12 +752,14 @@
 
     public void setCellValue(boolean value)
     {
+        int row=record.getRow();
+        short col=record.getColumn();
+        short styleIndex=record.getXFIndex();
         if ((cellType != CELL_TYPE_BOOLEAN ) && ( cellType != CELL_TYPE_FORMULA))
         {
-            setCellType(CELL_TYPE_BOOLEAN, false);
+            setCellType(CELL_TYPE_BOOLEAN, false, row, col, styleIndex);
         }
         (( BoolErrRecord ) record).setValue(value);
-        booleanValue = value;
     }
 
     /**
@@ -848,12 +773,14 @@
 
     public void setCellErrorValue(byte value)
     {
+        int row=record.getRow();
+        short col=record.getColumn();
+        short styleIndex=record.getXFIndex();
         if ((cellType != CELL_TYPE_ERROR) && (cellType != CELL_TYPE_FORMULA))
         {
-            setCellType(CELL_TYPE_ERROR, false);
+            setCellType(CELL_TYPE_ERROR, false, row, col, styleIndex);
         }
         (( BoolErrRecord ) record).setValue(value);
-        errorValue = value;
     }
 
     /**
@@ -865,7 +792,7 @@
     {
         if (cellType == CELL_TYPE_BOOLEAN)
         {
-            return booleanValue;
+            return (( BoolErrRecord ) record).getBooleanValue();
         }
         if (cellType == CELL_TYPE_BLANK)
         {
@@ -884,7 +811,7 @@
     {
         if (cellType == CELL_TYPE_ERROR)
         {
-            return errorValue;
+            return (( BoolErrRecord ) record).getErrorValue();
         }
         if (cellType == CELL_TYPE_BLANK)
         {
@@ -905,7 +832,6 @@
 
     public void setCellStyle(HSSFCellStyle style)
     {
-        cellStyle = style;
         record.setXFIndex(style.getIndex());
     }
 
@@ -917,7 +843,9 @@
 
     public HSSFCellStyle getCellStyle()
     {
-        return cellStyle;
+      short styleIndex=record.getXFIndex();
+      ExtendedFormatRecord xf = book.getExFormatAt(styleIndex);
+      return new HSSFCellStyle(styleIndex, xf);
     }
 
     /**
@@ -978,8 +906,10 @@
      */
     public void setAsActiveCell()
     {
-        this.sheet.setActiveCellRow(this.row);
-        this.sheet.setActiveCellCol(this.cellNum);
+        int row=record.getRow();
+        short col=record.getColumn();
+        this.sheet.setActiveCellRow(row);
+        this.sheet.setActiveCellCol(col);
     }
     
     /**
Index: org/apache/poi/hssf/usermodel/HSSFCellStyle.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/usermodel/HSSFCellStyle.java,v
retrieving revision 1.17
diff -u -r1.17 HSSFCellStyle.java
--- org/apache/poi/hssf/usermodel/HSSFCellStyle.java	23 Aug 2005 03:44:59 -0000	1.17
+++ org/apache/poi/hssf/usermodel/HSSFCellStyle.java	25 Nov 2005 11:11:47 -0000
@@ -35,7 +35,6 @@
 {
     private ExtendedFormatRecord format                     = null;
     private short                index                      = 0;
-    private short                fontindex                  = 0;
 
     /**
      * general (normal) horizontal alignment
@@ -276,7 +275,7 @@
     public void setFont(HSSFFont font)
     {
         format.setIndentNotParentFont(true);
-        fontindex = font.getIndex();
+        short fontindex = font.getIndex();
         format.setFontIndex(fontindex);
     }
 
Index: org/apache/poi/hssf/usermodel/HSSFRow.java
===================================================================
RCS file: /home/cvspublic/jakarta-poi/src/java/org/apache/poi/hssf/usermodel/HSSFRow.java,v
retrieving revision 1.20
diff -u -r1.20 HSSFRow.java
--- org/apache/poi/hssf/usermodel/HSSFRow.java	1 May 2005 11:26:18 -0000	1.20
+++ org/apache/poi/hssf/usermodel/HSSFRow.java	25 Nov 2005 11:11:47 -0000
@@ -46,7 +46,7 @@
     public final static int INITIAL_CAPACITY = 5;
     //private short rowNum;
     private int rowNum;
-    private HashMap cells;
+    private HSSFCell[] cells=new HSSFCell[INITIAL_CAPACITY];
 //    private short firstcell = -1;
 //    private short lastcell = -1;
 
@@ -84,7 +84,7 @@
     //protected HSSFRow(Workbook book, Sheet sheet, short rowNum)
     protected HSSFRow(Workbook book, Sheet sheet, int rowNum)
     {
-        cells = new HashMap(10);   // new ArrayList(INITIAL_CAPACITY);
+        this.rowNum = rowNum;
         this.book = book;
         this.sheet = sheet;
         row = new RowRecord();
@@ -108,7 +108,6 @@
 
     protected HSSFRow(Workbook book, Sheet sheet, RowRecord record)
     {
-        cells = new HashMap();   // ArrayList(INITIAL_CAPACITY);
         this.book = book;
         this.sheet = sheet;
         row = record;
@@ -129,11 +128,7 @@
 
     public HSSFCell createCell(short column)
     {
-        HSSFCell cell = new HSSFCell(book, sheet, getRowNum(), column);
-
-        addCell(cell);
-        sheet.addValueRecord(getRowNum(), cell.getCellValueRecord());
-        return cell;
+      return this.createCell(column,HSSFCell.CELL_TYPE_BLANK);
     }
 
     /**
@@ -145,8 +140,6 @@
      * @param column - the column number this cell represents
      *
      * @return HSSFCell a high level representation of the created cell.
-     * @deprecated As of 22-Jan-2002 use createCell(short) and use setCellValue to
-     * specify the type lazily.
      */
 
     public HSSFCell createCell(short column, int type)
@@ -167,7 +160,11 @@
         CellValueRecordInterface cval = cell.getCellValueRecord();
 
         sheet.removeValueRecord(getRowNum(), cval);
-        cells.remove(new Integer(cell.getCellNum()));
+        short column=cell.getCellNum();
+        if(cell!=null && column<cells.length)
+        {
+          cells[column]=null;
+        }
 
         if (cell.getCellNum() == row.getLastCol())
         {
@@ -231,23 +228,33 @@
 
     private void addCell(HSSFCell cell)
     {
+        short column=cell.getCellNum();
         if (row.getFirstCol() == -1)
         {
-            row.setFirstCol(cell.getCellNum());
+            row.setFirstCol(column);
         }
         if (row.getLastCol() == -1)
         {
-            row.setLastCol(cell.getCellNum());
+            row.setLastCol(column);
+        }
+
+        if(column>=cells.length)
+        {
+          HSSFCell[] oldCells=cells;
+          int newSize=oldCells.length*2;
+          if(newSize<column+1) newSize=column+1;
+          cells=new HSSFCell[newSize];
+          System.arraycopy(oldCells,0,cells,0,oldCells.length);
         }
-        cells.put(new Integer(cell.getCellNum()), cell);
+        cells[column]=cell;
 
-        if (cell.getCellNum() < row.getFirstCol())
+        if (column < row.getFirstCol())
         {
-            row.setFirstCol(cell.getCellNum());
+            row.setFirstCol(column);
         }
-        if (cell.getCellNum() > row.getLastCol())
+        if (column > row.getLastCol())
         {
-            row.setLastCol(cell.getCellNum());
+            row.setLastCol(column);
         }
     }
 
@@ -261,17 +268,8 @@
 
     public HSSFCell getCell(short cellnum)
     {
-
-/*        for (int k = 0; k < cells.size(); k++)
-        {
-            HSSFCell cell = ( HSSFCell ) cells.get(k);
-
-            if (cell.getCellNum() == cellnum)
-            {
-                return cell;
-            }
-        }*/
-        return (HSSFCell) cells.get(new Integer(cellnum));
+      if(cellnum>=cells.length) return null;
+      return cells[cellnum];
     }
 
     /**
@@ -309,11 +307,12 @@
 
     public int getPhysicalNumberOfCells()
     {
-        if (cells == null)
-        {
-            return 0;   // shouldn't be possible but it is due to missing API support for BLANK/MULBLANK
-        }
-        return cells.size();
+      int count=0;
+      for(int i=0;i<cells.length;i++)
+      {
+        if(cells[i]!=null) count++;
+      }
+      return count;
     }
 
     /**
@@ -432,7 +431,43 @@
 
     public Iterator cellIterator()
     {
-        return cells.values().iterator();
+      return new CellIterator();
+    }
+    
+    private class CellIterator implements Iterator
+    {
+      int thisId,nextId=0;
+      
+      public CellIterator()
+      {
+        findNext();
+      }
+
+      public boolean hasNext() {
+        return nextId<cells.length;
+      }
+
+      public Object next() {
+        HSSFCell cell=cells[nextId];
+        thisId=nextId;
+        findNext();
+        return cell;
+      }
+
+      public void remove() {
+        cells[thisId]=null;
+      }
+      
+      private void findNext()
+      {
+        int i=nextId+1;
+        for(;i<cells.length;i++)
+        {
+          if(cells[i]!=null) break;
+        }
+        nextId=i;
+      }
+      
     }
 
     public int compareTo(Object obj)