excel.h

/* Swinder - Portable library for spreadsheet
   Copyright (C) 2003-2006 Ariya Hidayat <ariya@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA
*/
 
#ifndef SWINDER_EXCEL_H
#define SWINDER_EXCEL_H
 
#include <string>
#include <iostream>
#include <vector>
 
#include "swinder.h"
 
namespace Swinder
{
 
enum { UnknownExcel = 0, Excel95, Excel97, Excel2000 };
 
class Record;
 
// rich-text, unicode, far-east support Excel string
 
class EString
{
public:
 
  EString();
  
  EString( const EString& );
  
  EString& operator=( const EString& );
  
  ~EString();
  
  bool unicode() const;
  
  void setUnicode( bool u );
  
  bool richText() const;
  
  void setRichText( bool r );
    
  UString str() const;
  
  void setStr( const UString& str );
  
  // space allocate for the string, not length (use string.length() for that) 
  unsigned size() const;
  void setSize( unsigned size ); // HACKS
  
  
  static EString fromUnicodeString( const void* p, bool longString, unsigned maxsize = 0 );
  
  static EString fromSheetName( const void* p, unsigned maxsize = 0 );
  
  // from the buffer
  // longstring means 16-bit string length, usually for label
  // longstring=false is normally for sheet name
  static EString fromByteString( const void* p, bool longString, unsigned maxsize = 0 );
  
private:
  class Private;
  Private* d;
};
 
class FormulaToken
{
public:
 
  enum
  {
    // should match Excel's PTG
    Unused      = 0x00,
    Matrix      = 0x01,
    Table       = 0x02,
    Add         = 0x03,
    Sub         = 0x04,
    Mul         = 0x05,
    Div         = 0x06,
    Power       = 0x07,
    Concat      = 0x08,
    LT          = 0x09,
    LE          = 0x0a,
    EQ          = 0x0b,
    GE          = 0x0c,
    GT          = 0x0d,
    NE          = 0x0e,
    Intersect   = 0x0f,
    List        = 0x10,
    Range       = 0x11,
    UPlus       = 0x12,
    UMinus      = 0x13,
    Percent     = 0x14,
    Paren       = 0x15,
    MissArg     = 0x16,
    String      = 0x17,
    NatFormula  = 0x18,
    Attr        = 0x19,
    Sheet       = 0x1a,
    EndSheet    = 0x1b,
    ErrorCode   = 0x1c,
    Bool        = 0x1d,
    Integer     = 0x1e,
    Float       = 0x1f,
    Array       = 0x20,
    Function    = 0x21,
    FunctionVar = 0x22,
    Name        = 0x23,
    Ref         = 0x24,
    Area        = 0x25,
    MemArea     = 0x26,
    MemErr      = 0x27,
    MemNoMem    = 0x28,
    MemFunc     = 0x29,
    RefErr      = 0x2a,
    AreaErr     = 0x2b,
    RefN        = 0x2c,
    AreaN       = 0x2d,
    MemAreaN    = 0x2e,
    MemNoMemN   = 0x2f,
    NameX       = 0x39,
    Ref3d       = 0x3a,
    Area3d      = 0x3b,
    RefErr3d    = 0x3c,
    AreaErr3d   = 0x3d
  };
 
  FormulaToken();
  FormulaToken( unsigned id );
  FormulaToken( const FormulaToken& );
  ~FormulaToken();
  
  // token id, excluding token class
  unsigned id() const;
  const char* idAsString() const;
  
  // Excel version
  unsigned version() const;
  void setVersion( unsigned version );  // Excel version
  
  // size of data, EXCLUDING the byte for token id
  unsigned size() const;
  void setData( unsigned size, const unsigned char* data );
  
  // only when id returns ErrorCode, Bool, Integer, Float, or String
  Value value() const;
  
  // only when id is Function or FunctionVar
  unsigned functionIndex() const;
  const char* functionName() const;  // for non external function
  unsigned functionParams() const;
  
  // only when id is Ref or Ref3d
  UString ref( unsigned row, unsigned col ) const;
 
  // only when id is Area or Area3d
  UString area( unsigned row, unsigned col ) const;
 
  // only when id is Ref3d or Area3d
  unsigned externSheetRef() const;
 
  // only when id is Attr
  unsigned attr() const;
 
  // only when id is NameX
  unsigned nameIndex() const;
 
  // only when id is Matrix
  unsigned refRow() const;
  unsigned refColumn() const;
 
private:
  class Private;
  Private *d;  
};
 
typedef std::vector<FormulaToken> FormulaTokens;
 
std::ostream& operator<<( std::ostream& s, FormulaToken token );
 
class Record
{
public:
 
  static const unsigned int id;
  
  virtual unsigned int rtti(){
      return this->id;
  }
  
  Record();
  
  virtual ~Record();
  
  static Record* create( unsigned type );
  
  void setVersion( unsigned v ){ ver = v; };
  
  unsigned version(){ return ver; };
 
  virtual void setData( unsigned size, const unsigned char* data );
  
  void setPosition( unsigned pos );
  
  unsigned position() const;
  
  virtual const char* name(){ return "Unknown"; }
 
  virtual void dump( std::ostream& out ) const;
  
protected:
 
   // position of this record in the OLE stream
   unsigned stream_position;
 
   // in which version does this record denote ?
   unsigned ver;
 
private:
   // no copy or assign
   Record( const Record& );
   Record& operator=( const Record& );
   
};
 
class CellInfo
{
public:
 
  CellInfo();
 
  virtual ~CellInfo();
 
  virtual unsigned row() const;
 
  virtual unsigned column() const;
 
  virtual unsigned xfIndex() const;
 
  virtual void setRow( unsigned r );
 
  virtual void setColumn( unsigned c );
 
  virtual void setXfIndex( unsigned i );
 
private:
   // no copy or assign
   CellInfo( const CellInfo& );
   CellInfo& operator=( const CellInfo& );
 
   class Private;
   Private* info;
};
 
class ColumnSpanInfo
{
public:
 
  ColumnSpanInfo();
 
  virtual ~ColumnSpanInfo();
 
  virtual unsigned firstColumn() const;
 
  virtual unsigned lastColumn() const;
 
  virtual void setFirstColumn( unsigned c );
 
  virtual void setLastColumn( unsigned c );
 
private:
   // no copy or assign
   ColumnSpanInfo( const ColumnSpanInfo& );
   ColumnSpanInfo& operator=( const ColumnSpanInfo& );
 
   class Private;
   Private* spaninfo;
};
 
class BackupRecord : public Record
{
public:
 
  static const unsigned int id;
 
  BackupRecord();
  
  ~BackupRecord();
  
  unsigned int rtti(){
      return this->id;
  }
  bool backup() const;
  
  void setBackup( bool r );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "BACKUP"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  BackupRecord( const BackupRecord& );
  BackupRecord& operator=( const BackupRecord& );
 
  class Private;
  Private* d;
};
 
 
class BOFRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  enum { UnknownType = 0, Workbook, Worksheet, Chart, VBModule, MacroSheet, Workspace };
 
  BOFRecord();
 
  virtual ~BOFRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  unsigned version() const;
 
  const char* versionAsString() const;
 
  unsigned type() const;
 
  const char* typeAsString() const;
 
  virtual const char* name(){ return "BOF"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   BOFRecord( const BOFRecord& );
   BOFRecord& operator=( const BOFRecord& );
 
   class Private;
   Private *d;
};
 
class BlankRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  BlankRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "BLANK"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   BlankRecord( const BlankRecord& );
   BlankRecord& operator=( const BlankRecord& );
};
 
class BoolErrRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){ return this->id; }
 
  BoolErrRecord();
 
  virtual ~BoolErrRecord();
 
  Value value() const;
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "BOOLERR"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  BoolErrRecord( const BoolErrRecord& );
  BoolErrRecord& operator=( const BoolErrRecord& );
 
  class Private;
  Private* d;
};
 
class BottomMarginRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
  BottomMarginRecord();
  
  ~BottomMarginRecord();
  
  double bottomMargin() const;
  
  void setBottomMargin( double m );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "BOTTOMMARGIN"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  BottomMarginRecord( const BottomMarginRecord& );
  BottomMarginRecord& operator=( const BottomMarginRecord& );
 
  class Private;
  Private* d;
};
 
// TODO support for strong visible
 
class BoundSheetRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  BoundSheetRecord();
 
  virtual ~BoundSheetRecord();
  
  enum { Worksheet=0, Chart=2, VBModule=6 };
  
  void setType( unsigned type );
  
  unsigned type() const;
  
  const char* typeAsString() const;
  
  void setVisible( bool visible );
  
  bool visible() const;
  
  void setSheetName( const UString& name );
  
  UString sheetName() const;
  
  void setBofPosition( unsigned pos );
  
  unsigned bofPosition() const;
 
  virtual void setData( unsigned size, const unsigned char* data );
  
  virtual const char* name(){ return "BOUNDSHEET"; }
  
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  BoundSheetRecord( const BoundSheetRecord& );
  BoundSheetRecord& operator=( const BoundSheetRecord& );
 
  class Private;
  Private* d;
};
 
class CalcModeRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  CalcModeRecord();
  
  ~CalcModeRecord();
  
  bool autoCalc() const;
  
  void setAutoCalc( bool r );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "CALCMODE"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  CalcModeRecord( const CalcModeRecord& );
  CalcModeRecord& operator=( const CalcModeRecord& );
 
  class Private;
  Private* d;
};
 
class ColInfoRecord : public Record, public ColumnSpanInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  ColInfoRecord();
 
  virtual ~ColInfoRecord();
  
  unsigned xfIndex() const;
  
  void setXfIndex( unsigned i );
  
  unsigned width() const;
  
  void setWidth( unsigned w );
  
  bool hidden() const;
  
  void setHidden( bool h );
 
  bool collapsed() const;
  
  void setCollapsed( bool c );
  
  unsigned outlineLevel() const;
  
  void setOutlineLevel( unsigned l );
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "COLINFO"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   ColInfoRecord( const ColInfoRecord& );
   ColInfoRecord& operator=( const ColInfoRecord& );
 
   class Private;
   Private *d;
};
 
class DateModeRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  DateModeRecord();
  
  ~DateModeRecord();
  
  bool base1904() const;
  
  void setBase1904( bool r );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "DATEMODE"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  DateModeRecord( const DateModeRecord& );
  DateModeRecord& operator=( const DateModeRecord& );
 
  class Private;
  Private* d;
};
 
class DimensionRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  DimensionRecord();
  
  ~DimensionRecord();
  
  unsigned firstRow() const;
  
  void setFirstRow( unsigned r );
  
  unsigned lastRow() const;
  
  void setLastRow( unsigned r );
  
  unsigned firstColumn() const;
  
  void setFirstColumn( unsigned r );
  
  unsigned lastColumn() const;
  
  void setLastColumn( unsigned r );
  
  virtual const char* name(){ return "DIMENSION"; }
  
  virtual void setData( unsigned size, const unsigned char* data );
  
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   DimensionRecord( const DimensionRecord& );
   DimensionRecord& operator=( const DimensionRecord& );
   
   class Private;
   Private *d;
};
 
class ExternNameRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
    return this->id;
  }
 
  ExternNameRecord();
 
  ~ExternNameRecord();
 
  // one-based sheet index
  // if 0 means AddIn function
  unsigned sheetIndex() const;
 
  void setSheetIndex( unsigned sheetIndex );
 
  UString externName() const;
 
  void setExternName( const UString& name );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
 
 
  virtual const char* name(){ return "EXTERNNAME"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   ExternNameRecord( const ExternNameRecord& );
   ExternNameRecord& operator=( const ExternNameRecord& );
   
   class Private;
   Private *d;
};
 
class ExternSheetRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
    return this->id;
  }
 
  ExternSheetRecord();
 
  ~ExternSheetRecord();
 
  unsigned count() const;
 
  unsigned refIndex(unsigned i) const;
  unsigned firstSheet(unsigned i) const;
  unsigned lastSheet(unsigned i) const;
 
  UString refName() const;
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "EXTERNSHEET"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   ExternSheetRecord( const ExternNameRecord& );
   ExternSheetRecord& operator=( const ExternNameRecord& );
   
   class Private;
   Private *d;
};
 
 
class EOFRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  EOFRecord();
 
  virtual ~EOFRecord();
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "EOF"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   EOFRecord( const EOFRecord& );
   EOFRecord& operator=( const EOFRecord& );
};
 
class FilepassRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
    return this->id;
  }
 
  FilepassRecord();
 
  virtual ~FilepassRecord();
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "FILEPASS"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   FilepassRecord( const FilepassRecord& );
   FilepassRecord& operator=( const FilepassRecord& );
};
 
class FontRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  FontRecord();
  
  FontRecord( const FontRecord& fr );
  
  FontRecord& operator=( const FontRecord& fr );
 
  virtual ~FontRecord();
  
  enum { 
    Normal = 0, 
    Superscript = 1,
    Subscript = 2 };
    
  enum { 
    None = 0, 
    Single = 1, 
    Double = 2, 
    SingleAccounting = 0x21, 
    DoubleAccounting = 0x22 };
  
  unsigned height() const;
  void setHeight( unsigned h );
  
  UString fontName() const;
  
  void setFontName( const UString& fn );
 
  // FIXME what is this font family ? index ?  
  unsigned fontFamily() const;
  void setFontFamily( unsigned f );
  
  // FIXME and character set index ?
  unsigned characterSet() const;
  void setCharacterSet( unsigned s );
  
  unsigned colorIndex() const;
  
  void setColorIndex( unsigned c );
  
  unsigned boldness() const;
  
  void setBoldness( unsigned b );
  
  bool italic() const;
  
  void setItalic( bool i );
  
  bool strikeout() const;
  
  void setStrikeout( bool s );
  
  unsigned escapement() const;
  
  void setEscapement( unsigned s );
  
  unsigned underline() const;
  
  void setUnderline( unsigned u );
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "FONT"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   class Private;
   Private *d;
};
 
class FooterRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  FooterRecord();
  
  ~FooterRecord();
  
  UString footer() const;
  
  void setFooter( const UString& f );
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "FOOTER"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  FooterRecord( const FooterRecord& );
  FooterRecord& operator=( const FooterRecord& );
 
  class Private;
  Private* d;
};
 
class FormatRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  FormatRecord();
  
  ~FormatRecord();
  
  FormatRecord( const FormatRecord& fr );
  
  FormatRecord& operator=( const FormatRecord& fr );
  
  unsigned index() const;
  
  void setIndex( unsigned i );
 
  UString formatString() const;
  
  void setFormatString( const UString& fs );
    
  virtual const char* name(){ return "FORMAT"; }
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual void dump( std::ostream& out ) const;
 
private:
   class Private;
   Private *d;
};
 
class FormulaRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
  static const unsigned int idOld; // for Pocket Excel support
 
  unsigned int rtti(){
      return this->id;
  }
 
  FormulaRecord();
  
  ~FormulaRecord();
  
  Value result() const;
  
  void setResult( const Value& v );
  
  FormulaTokens tokens() const;
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "FORMULA"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  FormulaRecord( const FormulaRecord& );
  FormulaRecord& operator=( const FormulaRecord& );
 
  class Private;
  Private* d;
};
 
class HeaderRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  HeaderRecord();
  
  ~HeaderRecord();
  
  UString header() const;
  
  void setHeader( const UString& h );
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "HEADER"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  HeaderRecord( const HeaderRecord& );
  HeaderRecord& operator=( const HeaderRecord& );
 
  class Private;
  Private* d;
};
 
 
class LabelRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  LabelRecord();
 
  virtual ~LabelRecord();
 
  UString label() const;
  
  void setLabel( const UString& l );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "LABEL"; }
  
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   LabelRecord( const LabelRecord& );
   LabelRecord& operator=( const LabelRecord& );
 
   class Private;
   Private *d;
};
 
class LabelSSTRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  LabelSSTRecord();
 
  virtual ~LabelSSTRecord();
 
  unsigned sstIndex() const;
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "LABELSST"; }
  
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   LabelSSTRecord( const LabelSSTRecord& );
   LabelSSTRecord& operator=( const LabelSSTRecord& );
 
   class Private;
   Private *d;
};
 
class LeftMarginRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  LeftMarginRecord();
  
  ~LeftMarginRecord();
  
  double leftMargin() const;
  
  void setLeftMargin( double m );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "LEFTMARGIN"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  LeftMarginRecord( const LeftMarginRecord& );
  LeftMarginRecord& operator=( const LeftMarginRecord& );
 
  class Private;
  Private* d;
};
 
 
class MergedCellsRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  MergedCellsRecord();
 
  virtual ~MergedCellsRecord();
  
  unsigned count() const;
  
  unsigned firstRow( unsigned i ) const;
  
  unsigned lastRow( unsigned i ) const;
  
  unsigned firstColumn( unsigned i ) const;
  
  unsigned lastColumn( unsigned i ) const;
 
  virtual void setData( unsigned size, const unsigned char* data );
  
  virtual const char* name(){ return "MERGEDCELLS"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   MergedCellsRecord( const MergedCellsRecord& );
   MergedCellsRecord& operator=( const MergedCellsRecord& );
 
   class Private;
   Private *d;
};
 
class MulBlankRecord : public Record, public CellInfo, public ColumnSpanInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  MulBlankRecord();
 
  virtual ~MulBlankRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  unsigned xfIndex( unsigned i ) const;
 
  virtual const char* name(){ return "MULBLANK"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   MulBlankRecord( const MulBlankRecord& );
   MulBlankRecord& operator=( const MulBlankRecord& );
 
   class Private;
   Private *d;
 
   // from CellInfo, we don't need it
   // mark as private so nobody can call them
   virtual unsigned column() const { return CellInfo::column(); }
   virtual unsigned xfIndex() const { return CellInfo::xfIndex(); }
};
 
class MulRKRecord : public Record, public CellInfo, public ColumnSpanInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  MulRKRecord();
 
  virtual ~MulRKRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  unsigned xfIndex( unsigned i ) const;
  
  bool isInteger( unsigned i ) const;
  
  int asInteger( unsigned i ) const;
  
  double asFloat( unsigned i ) const;
  
  unsigned encodedRK( unsigned i ) const;
  
  virtual const char* name(){ return "MULRK"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   MulRKRecord( const MulRKRecord& );
   MulRKRecord& operator=( const MulRKRecord& );
 
   class Private;
   Private *d;
 
   // from CellInfo, we don't need it
   // mark as private so nobody can call them
   virtual unsigned column() const { return CellInfo::column(); }
   virtual unsigned xfIndex() const { return CellInfo::xfIndex(); }
};
 
 
class NameRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
    return this->id;
  }
 
  NameRecord();
 
  ~NameRecord();
 
  UString definedName() const;
 
  void setDefinedName( const UString& name );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "NAME"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   NameRecord( const NameRecord& );
   NameRecord& operator=( const NameRecord& );
   
   class Private;
   Private *d;
};
 
 
class NumberRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  NumberRecord();
 
  virtual ~NumberRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
  
  double number() const;
  
  void setNumber( double f );
 
  virtual const char* name(){ return "NUMBER"; }
  
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   NumberRecord( const NumberRecord& );
   NumberRecord& operator=( const NumberRecord& );
 
   class Private;
   Private *d;
};
 
class PaletteRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  PaletteRecord();
  
  ~PaletteRecord();
 
  Color color( unsigned i ) const;
 
  unsigned count() const;
  
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "PALETTE"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  PaletteRecord( const PaletteRecord& );
  PaletteRecord& operator=( const PaletteRecord& );
 
  class Private;
  Private* d;
};
 
 
 
class RightMarginRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  RightMarginRecord();
  
  ~RightMarginRecord();
  
  double rightMargin() const;
  
  void setRightMargin( double m );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "RIGHTMARGIN"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  RightMarginRecord( const RightMarginRecord& );
  RightMarginRecord& operator=( const RightMarginRecord& );
 
  class Private;
  Private* d;
};
 
 
 
class RKRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  RKRecord();
 
  virtual ~RKRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
  
  bool isInteger() const;
  
  bool isFloat() const;
    
  int asInteger() const;
  
  double asFloat() const;
  
  void setInteger( int i );
  
  void setFloat( double f );
 
  unsigned encodedRK() const;
  
  virtual const char* name(){ return "RK"; }
  
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   RKRecord( const RKRecord& );
   RKRecord& operator=( const RKRecord& );
 
   class Private;
   Private *d;
};
 
class RowRecord : public Record, public ColumnSpanInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  RowRecord();
 
  virtual ~RowRecord();
  
  unsigned row() const;
  
  void setRow( unsigned r );
    
  unsigned xfIndex() const;
  
  void setXfIndex( unsigned i );
  
  unsigned height() const;
  
  void setHeight( unsigned h );
  
  bool hidden() const;
  
  void setHidden( bool h );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "ROW"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   RowRecord( const RowRecord& );
   RowRecord& operator=( const RowRecord& );
 
   class Private;
   Private *d;
};
 
 
class RStringRecord : public Record, public CellInfo
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  RStringRecord();
 
  virtual ~RStringRecord();
 
  UString label() const;
  
  void setLabel( const UString& l );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "RSTRING"; }
  
  virtual void dump( std::ostream& out ) const;
 
private:
   // no copy or assign
   RStringRecord( const RStringRecord& );
   RStringRecord& operator=( const RStringRecord& );
 
   class Private;
   Private *d;
};
 
 
class SSTRecord : public Record
{
public:
 
  static const unsigned int id;
  
  unsigned int rtti(){
      return this->id;
  }
 
  SSTRecord();
  
  virtual ~SSTRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
  
  unsigned count() const;
  
  UString stringAt( unsigned index ) const;
  
  virtual const char* name(){ return "SST"; }
  
  virtual void dump( std::ostream& out ) const;
  
private:
   // no copy or assign
   SSTRecord( const SSTRecord& );
   SSTRecord& operator=( const SSTRecord& );
 
   class Private;
   Private *d;
};
 
 
class StringRecord : public Record
{
public:
 
  static const unsigned int id;
  
  unsigned int rtti(){ return this->id; }
 
  StringRecord();
  
  virtual ~StringRecord();
 
  virtual void setData( unsigned size, const unsigned char* data );
  
  UString ustring() const;
  
  Value value() const;
  
  virtual const char* name(){ return "STRING"; }
  
  virtual void dump( std::ostream& out ) const;
  
private:
   // no copy or assign
   StringRecord( const SSTRecord& );
   StringRecord& operator=( const SSTRecord& );
 
   class Private;
   Private *d;
};
 
class SupbookRecord : public Record
{
public:
 
  static const unsigned int id;
 
  typedef enum 
  {
      UnknownRef,
      ExternalRef,
      InternalRef,
      AddInRef,
      ObjectLink
  } ReferenceType;
 
  unsigned int rtti(){
      return this->id;
  }
 
  SupbookRecord();
 
  ~SupbookRecord();
 
  ReferenceType referenceType() const;
 
  void setReferenceType(ReferenceType type);
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "SUPBOOK"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  SupbookRecord( const SupbookRecord& );
  SupbookRecord& operator=( const SupbookRecord& );
 
  class Private;
  Private* d;
};
 
class TopMarginRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  TopMarginRecord();
  
  ~TopMarginRecord();
  
  double topMargin() const;
  
  void setTopMargin( double m );
 
  virtual void setData( unsigned size, const unsigned char* data );
 
  virtual const char* name(){ return "TOPMARGIN"; }
 
  virtual void dump( std::ostream& out ) const;
 
private:
  // no copy or assign
  TopMarginRecord( const TopMarginRecord& );
  TopMarginRecord& operator=( const TopMarginRecord& );
 
  class Private;
  Private* d;
};
 
class XFRecord : public Record
{
public:
 
  static const unsigned int id;
 
  unsigned int rtti(){
      return this->id;
  }
 
  XFRecord();
  
  XFRecord( const XFRecord& xf );
  
  XFRecord& operator=( const XFRecord& xf );
  
  ~XFRecord();
  
  unsigned fontIndex() const;
  
  void setFontIndex( unsigned fi );
 
  unsigned formatIndex() const;
  
  void setFormatIndex( unsigned fi );
  
  bool locked() const;
  
  void setLocked( bool l );
  
  bool formulaHidden() const;
 
  void setFormulaHidden( bool f );
  
  unsigned parentStyle() const;
  
  void setParentStyle( unsigned ps );
 
  enum { 
    General = 0, 
    Left, 
    Centered, 
    Right, 
    Filled, 
    Justified,
    CenteredSelection,
    Distributed };
  
  unsigned horizontalAlignment() const;
  
  void setHorizontalAlignment( unsigned ha );
  
  const char* horizontalAlignmentAsString() const; 
  
  enum { 
    Top = 0, 
    VCentered = 1, 
    Bottom = 2, 
    VJustified = 3, 
    VDistributed = 4 };
  
  unsigned verticalAlignment() const;
  
  void setVerticalAlignment( unsigned va );
  
  const char* verticalAlignmentAsString() const; 
  
  bool textWrap() const;
  
  void setTextWrap( bool wrap );
  
  unsigned rotationAngle() const;
  
  void setRotationAngle( unsigned angle );
  
  bool stackedLetters() const;
  
  void setStackedLetters( bool stacked );
 
  unsigned indentLevel() const;
  
  void setIndentLevel( unsigned i );
  
  bool shrinkContent() const;
  
  void setShrinkContent( bool s );
  
  enum
  {
    NoLine = 0,
    Thin = 1,
    Medium = 2,
    Dashed = 3,
    Dotted = 4,
    Thick = 5,
    Double = 6,
    Hair = 7,
    MediumDashed = 8,
    ThinDashDotted = 9,
    MediumDashDotted = 10,
    ThinDashDotDotted = 11,
    MediumDashDotDotted = 12,
    SlantedMediumDashDotted = 13    
  };
  
  unsigned leftBorderStyle() const;
  
  void setLeftBorderStyle( unsigned style );
  
  unsigned leftBorderColor() const;
  
  void setLeftBorderColor( unsigned color );
 
  unsigned rightBorderStyle() const;
  
  void setRightBorderStyle( unsigned style );
  
  unsigned rightBorderColor() const;
  
  void setRightBorderColor( unsigned color );
  
  unsigned topBorderStyle() const;
  
  void setTopBorderStyle( unsigned style );
  
  unsigned topBorderColor() const;
  
  void setTopBorderColor( unsigned color );
  
  unsigned bottomBorderStyle() const;
  
  void setBottomBorderStyle( unsigned style );
  
  unsigned bottomBorderColor() const;
  
  void setBottomBorderColor( unsigned color );
  
  bool diagonalTopLeft() const;
  
  void setDiagonalTopLeft( bool d );
  
  bool diagonalBottomLeft() const;
  
  void setDiagonalBottomLeft( bool d );
  
  unsigned diagonalStyle() const;
  
  void setDiagonalStyle( unsigned style );
  
  unsigned diagonalColor() const;
  
  void setDiagonalColor( unsigned color );
  
  unsigned fillPattern() const;
  
  void setFillPattern( unsigned pattern );
  
  unsigned patternForeColor() const;
  
  void setPatternForeColor( unsigned color );
  
  unsigned patternBackColor() const;    
  
  void setPatternBackColor( unsigned color );
  
  virtual const char* name(){ return "XF"; }
  
  virtual void setData( unsigned size, const unsigned char* data );
  
  virtual void dump( std::ostream& out ) const;
 
private:
  class Private;
  Private* d;
};
 
typedef std::vector<UString> UStringStack;
 
 
class ExcelReader
{
public:
  ExcelReader();
  virtual ~ExcelReader();
  bool load( Workbook* workbook, const char* filename );
  
protected:  
  virtual void handleRecord( Record* record );
    
private:  
  void handleBoundSheet( BoundSheetRecord* record );
  void handleBOF( BOFRecord* record );
  void handleBoolErr( BoolErrRecord* record );
  void handleBottomMargin( BottomMarginRecord* record );
  void handleBlank( BlankRecord* record );
  void handleCalcMode( CalcModeRecord* record );
  void handleColInfo( ColInfoRecord* record );
  void handleDateMode( DateModeRecord* record );
  void handleDimension( DimensionRecord* record );
  void handleExternName( ExternNameRecord* record );
  void handleExternSheet( ExternSheetRecord* record );
  void handleFilepass( FilepassRecord* record );
  void handleFormat( FormatRecord* record );
  void handleFormula( FormulaRecord* record );
  void handleFont( FontRecord* record );
  void handleFooter( FooterRecord* record );
  void handleHeader( HeaderRecord* record );
  void handleLabel( LabelRecord* record );
  void handleLabelSST( LabelSSTRecord* record );
  void handleLeftMargin( LeftMarginRecord* record );
  void handleMergedCells( MergedCellsRecord* record );
  void handleMulBlank( MulBlankRecord* record );
  void handleMulRK( MulRKRecord* record );
  void handleName( NameRecord* record );
  void handleNumber( NumberRecord* record );
  void handlePalette( PaletteRecord* record );
  void handleRightMargin( RightMarginRecord* record );
  void handleRString( RStringRecord* record );
  void handleRK( RKRecord* record );
  void handleRow( RowRecord* record );
  void handleSST( SSTRecord* record );
  void handleString( StringRecord* record );
  void handleSupbook( SupbookRecord* record );
  void handleTopMargin( TopMarginRecord* record );
  void handleXF( XFRecord* record );    
  
  Color convertColor( unsigned colorIndex );
  FormatFont convertFont( unsigned fontIndex );
  Format convertFormat( unsigned xfIndex );
  UString decodeFormula( unsigned row, unsigned col, 
    const FormulaTokens& tokens, bool openDocumentFormat=false );
  
  void mergeTokens( UStringStack* stack, int count, char mergeChar );
  void mergeTokens( UStringStack* stack, int count, const char* mergeString );
  
  // no copy or assign
  ExcelReader( const ExcelReader& );
  ExcelReader& operator=( const ExcelReader& );
  
  class Private;
  Private* d;
};
 
 
} // namespace Swinder
 
 
 
#endif // SWINDER_EXCEL_H