filters

excel.h

00001 /* Swinder - Portable library for spreadsheet
00002    Copyright (C) 2003 Ariya Hidayat <ariya@kde.org>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License as published by the Free Software Foundation; either
00007    version 2 of the License, or (at your option) any later version.
00008    
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017  * Boston, MA 02110-1301, USA
00018 */
00019 
00020 #ifndef SWINDER_EXCEL_H
00021 #define SWINDER_EXCEL_H
00022 
00023 #include <string>
00024 #include <iostream>
00025 #include <vector>
00026 
00027 #include "swinder.h"
00028 
00029 namespace Swinder
00030 {
00031 
00035 enum { UnknownExcel = 0, Excel95, Excel97, Excel2000 };
00036 
00037 class Record;
00038 
00039 // rich-text, unicode, far-east support Excel string
00040 
00041 class EString
00042 {
00043 public:
00044 
00045   EString();
00046   
00047   EString( const EString& );
00048   
00049   EString& operator=( const EString& );
00050   
00051   ~EString();
00052   
00053   bool unicode() const;
00054   
00055   void setUnicode( bool u );
00056   
00057   bool richText() const;
00058   
00059   void setRichText( bool r );
00060     
00061   UString str() const;
00062   
00063   void setStr( const UString& str );
00064   
00065   // space allocate for the string, not length (use string.length() for that) 
00066   unsigned size() const;
00067   void setSize( unsigned size ); // HACKS
00068   
00069   
00070   static EString fromUnicodeString( const void* p, bool longString, unsigned maxsize = 0 );
00071   
00072   static EString fromSheetName( const void* p, unsigned maxsize = 0 );
00073   
00074   // from the buffer
00075   // longstring means 16-bit string length, usually for label
00076   // longstring=false is normally for sheet name
00077   static EString fromByteString( const void* p, bool longString, unsigned maxsize = 0 );
00078   
00079 private:
00080   class Private;
00081   Private* d;
00082 };
00083 
00084 class FormulaToken
00085 {
00086 public:
00087 
00088   enum
00089   {
00090     // should match Excel's PTG
00091     Unused      = 0x00,
00092     Matrix      = 0x01,
00093     Table       = 0x02,
00094     Add         = 0x03,
00095     Sub         = 0x04,
00096     Mul         = 0x05,
00097     Div         = 0x06,
00098     Power       = 0x07,
00099     Concat      = 0x08,
00100     LT          = 0x09,
00101     LE          = 0x0a,
00102     EQ          = 0x0b,
00103     GE          = 0x0c,
00104     GT          = 0x0d,
00105     NE          = 0x0e,
00106     Intersect   = 0x0f,
00107     List        = 0x10,
00108     Range       = 0x11,
00109     UPlus       = 0x12,
00110     UMinus      = 0x13,
00111     Percent     = 0x14,
00112     Paren       = 0x15,
00113     MissArg     = 0x16,
00114     String      = 0x17,
00115     NatFormula  = 0x18,
00116     Attr        = 0x19,
00117     Sheet       = 0x1a,
00118     EndSheet    = 0x1b,
00119     ErrorCode   = 0x1c,
00120     Bool        = 0x1d,
00121     Integer     = 0x1e,
00122     Float       = 0x1f,
00123     Array       = 0x20,
00124     Function    = 0x21,
00125     FunctionVar = 0x22,
00126     Name        = 0x23,
00127     Ref         = 0x24,
00128     Area        = 0x25,
00129     MemArea     = 0x26,
00130     MemErr      = 0x27,
00131     MemNoMem    = 0x28,
00132     MemFunc     = 0x29,
00133     RefErr      = 0x2a,
00134     AreaErr     = 0x2b,
00135     RefN        = 0x2c,
00136     AreaN       = 0x2d,
00137     MemAreaN    = 0x2e,
00138     MemNoMemN   = 0x2f,
00139     NameX       = 0x39,
00140     Ref3d       = 0x3a,
00141     Area3d      = 0x3b,
00142     RefErr3d    = 0x3c,
00143     AreaErr3d   = 0x3d
00144   };
00145 
00146   FormulaToken();
00147   FormulaToken( unsigned id );
00148   FormulaToken( const FormulaToken& );
00149   ~FormulaToken();
00150   
00151   // token id, excluding token class
00152   unsigned id() const;
00153   const char* idAsString() const;
00154   
00155   // Excel version
00156   unsigned version() const;
00157   void setVersion( unsigned version );  // Excel version
00158   
00159   // size of data, EXCLUDING the byte for token id
00160   unsigned size() const;
00161   void setData( unsigned size, const unsigned char* data );
00162   
00163   // only when id returns ErrorCode, Bool, Integer, Float, or String
00164   Value value() const;
00165   
00166   // only when id is Function or FunctionVar
00167   unsigned functionIndex() const;
00168   const char* functionName() const;  // for non external function
00169   unsigned functionParams() const;
00170   
00171   // only when id is Ref
00172   UString ref( unsigned row, unsigned col ) const;
00173 
00174   // only when id is Area
00175   UString area( unsigned row, unsigned col ) const;
00176 
00177   // only when id is Attr
00178   unsigned attr() const;
00179 
00180   // only when id is NameX
00181   unsigned nameIndex() const;
00182 
00183 private:
00184   class Private;
00185   Private *d;  
00186 };
00187 
00188 typedef std::vector<FormulaToken> FormulaTokens;
00189 
00190 std::ostream& operator<<( std::ostream& s, FormulaToken token );
00191 
00197 class Record
00198 {
00199 public:
00200 
00205   static const unsigned int id;
00206   
00207   virtual unsigned int rtti(){
00208       return this->id;
00209   }
00210   
00214   Record();
00215   
00219   virtual ~Record();
00220   
00224   static Record* create( unsigned type );
00225   
00226   void setVersion( unsigned v ){ ver = v; };
00227   
00228   unsigned version(){ return ver; };
00229 
00233   virtual void setData( unsigned size, const unsigned char* data );
00234   
00239   void setPosition( unsigned pos );
00240   
00244   unsigned position() const;
00245   
00249   virtual const char* name(){ return "Unknown"; }
00250 
00254   virtual void dump( std::ostream& out ) const;
00255   
00256 protected:
00257 
00258    // position of this record in the OLE stream
00259    unsigned stream_position;
00260 
00261    // in which version does this record denote ?
00262    unsigned ver;
00263 
00264 private:
00265    // no copy or assign
00266    Record( const Record& );
00267    Record& operator=( const Record& );
00268    
00269 };
00270 
00276 class CellInfo
00277 {
00278 public:
00279 
00283   CellInfo();
00284 
00288   virtual ~CellInfo();
00289 
00296   virtual unsigned row() const;
00297 
00304   virtual unsigned column() const;
00305 
00311   virtual unsigned xfIndex() const;
00312 
00319   virtual void setRow( unsigned r );
00320 
00327   virtual void setColumn( unsigned c );
00328 
00334   virtual void setXfIndex( unsigned i );
00335 
00336 private:
00337    // no copy or assign
00338    CellInfo( const CellInfo& );
00339    CellInfo& operator=( const CellInfo& );
00340 
00341    class Private;
00342    Private* info;
00343 };
00344 
00350 class ColumnSpanInfo
00351 {
00352 public:
00353 
00357   ColumnSpanInfo();
00358 
00362   virtual ~ColumnSpanInfo();
00363 
00370   virtual unsigned firstColumn() const;
00371 
00378   virtual unsigned lastColumn() const;
00379 
00386   virtual void setFirstColumn( unsigned c );
00387 
00394   virtual void setLastColumn( unsigned c );
00395 
00396 private:
00397    // no copy or assign
00398    ColumnSpanInfo( const ColumnSpanInfo& );
00399    ColumnSpanInfo& operator=( const ColumnSpanInfo& );
00400 
00401    class Private;
00402    Private* spaninfo;
00403 };
00404 
00411 class BackupRecord : public Record
00412 {
00413 public:
00414 
00415   static const unsigned int id;
00416 
00420   BackupRecord();
00421   
00425   ~BackupRecord();
00426   
00427   unsigned int rtti(){
00428       return this->id;
00429   }
00435   bool backup() const;
00436   
00442   void setBackup( bool r );
00443 
00444   virtual void setData( unsigned size, const unsigned char* data );
00445 
00446   virtual const char* name(){ return "BACKUP"; }
00447 
00448   virtual void dump( std::ostream& out ) const;
00449 
00450 private:
00451   // no copy or assign
00452   BackupRecord( const BackupRecord& );
00453   BackupRecord& operator=( const BackupRecord& );
00454 
00455   class Private;
00456   Private* d;
00457 };
00458 
00459 
00473 class BOFRecord : public Record
00474 {
00475 public:
00476 
00480   static const unsigned int id;
00481 
00482   unsigned int rtti(){
00483       return this->id;
00484   }
00485 
00489   enum { UnknownType = 0, Workbook, Worksheet, Chart, VBModule, MacroSheet, Workspace };
00490 
00494   BOFRecord();
00495 
00499   virtual ~BOFRecord();
00500 
00501   virtual void setData( unsigned size, const unsigned char* data );
00502 
00509   unsigned version() const;
00510 
00514   const char* versionAsString() const;
00515 
00519   unsigned type() const;
00520 
00524   const char* typeAsString() const;
00525 
00526   virtual const char* name(){ return "BOF"; }
00527 
00528   virtual void dump( std::ostream& out ) const;
00529 
00530 private:
00531    // no copy or assign
00532    BOFRecord( const BOFRecord& );
00533    BOFRecord& operator=( const BOFRecord& );
00534 
00535    class Private;
00536    Private *d;
00537 };
00538 
00545 class BlankRecord : public Record, public CellInfo
00546 {
00547 public:
00548 
00549   static const unsigned int id;
00550 
00551   unsigned int rtti(){
00552       return this->id;
00553   }
00554 
00558   BlankRecord();
00559 
00560   virtual void setData( unsigned size, const unsigned char* data );
00561 
00562   virtual const char* name(){ return "BLANK"; }
00563 
00564   virtual void dump( std::ostream& out ) const;
00565 
00566 private:
00567    // no copy or assign
00568    BlankRecord( const BlankRecord& );
00569    BlankRecord& operator=( const BlankRecord& );
00570 };
00571 
00578 class BoolErrRecord : public Record, public CellInfo
00579 {
00580 public:
00581 
00585   static const unsigned int id;
00586 
00587   unsigned int rtti(){ return this->id; }
00588 
00592   BoolErrRecord();
00593 
00597   virtual ~BoolErrRecord();
00598 
00602   Value value() const;
00603 
00604   virtual void setData( unsigned size, const unsigned char* data );
00605 
00606   virtual const char* name(){ return "BOOLERR"; }
00607 
00608   virtual void dump( std::ostream& out ) const;
00609 
00610 private:
00611   // no copy or assign
00612   BoolErrRecord( const BoolErrRecord& );
00613   BoolErrRecord& operator=( const BoolErrRecord& );
00614 
00615   class Private;
00616   Private* d;
00617 };
00618 
00625 class BottomMarginRecord : public Record
00626 {
00627 public:
00628 
00629   static const unsigned int id;
00630 
00631   unsigned int rtti(){
00632       return this->id;
00633   }
00637   BottomMarginRecord();
00638   
00642   ~BottomMarginRecord();
00643   
00647   double bottomMargin() const;
00648   
00652   void setBottomMargin( double m );
00653 
00654   virtual void setData( unsigned size, const unsigned char* data );
00655 
00656   virtual const char* name(){ return "BOTTOMMARGIN"; }
00657 
00658   virtual void dump( std::ostream& out ) const;
00659 
00660 private:
00661   // no copy or assign
00662   BottomMarginRecord( const BottomMarginRecord& );
00663   BottomMarginRecord& operator=( const BottomMarginRecord& );
00664 
00665   class Private;
00666   Private* d;
00667 };
00668 
00682 // TODO support for strong visible
00683 
00684 class BoundSheetRecord : public Record
00685 {
00686 public:
00687 
00688   static const unsigned int id;
00689 
00690   unsigned int rtti(){
00691       return this->id;
00692   }
00693 
00697   BoundSheetRecord();
00698 
00702   virtual ~BoundSheetRecord();
00703   
00707   enum { Worksheet=0, Chart=2, VBModule=6 };
00708   
00713   void setType( unsigned type );
00714   
00719   unsigned type() const;
00720   
00726   const char* typeAsString() const;
00727   
00731   void setVisible( bool visible );
00732   
00736   bool visible() const;
00737   
00741   void setSheetName( const UString& name );
00742   
00746   UString sheetName() const;
00747   
00751   void setBofPosition( unsigned pos );
00752   
00756   unsigned bofPosition() const;
00757 
00758   virtual void setData( unsigned size, const unsigned char* data );
00759   
00760   virtual const char* name(){ return "BOUNDSHEET"; }
00761   
00762   virtual void dump( std::ostream& out ) const;
00763 
00764 private:
00765   // no copy or assign
00766   BoundSheetRecord( const BoundSheetRecord& );
00767   BoundSheetRecord& operator=( const BoundSheetRecord& );
00768 
00769   class Private;
00770   Private* d;
00771 };
00772 
00779 class CalcModeRecord : public Record
00780 {
00781 public:
00782 
00783   static const unsigned int id;
00784 
00785   unsigned int rtti(){
00786       return this->id;
00787   }
00788 
00792   CalcModeRecord();
00793   
00797   ~CalcModeRecord();
00798   
00804   bool autoCalc() const;
00805   
00811   void setAutoCalc( bool r );
00812 
00813   virtual void setData( unsigned size, const unsigned char* data );
00814 
00815   virtual const char* name(){ return "CALCMODE"; }
00816 
00817   virtual void dump( std::ostream& out ) const;
00818 
00819 private:
00820   // no copy or assign
00821   CalcModeRecord( const CalcModeRecord& );
00822   CalcModeRecord& operator=( const CalcModeRecord& );
00823 
00824   class Private;
00825   Private* d;
00826 };
00827 
00834 class ColInfoRecord : public Record, public ColumnSpanInfo
00835 {
00836 public:
00837 
00838   static const unsigned int id;
00839 
00840   unsigned int rtti(){
00841       return this->id;
00842   }
00843 
00847   ColInfoRecord();
00848 
00852   virtual ~ColInfoRecord();
00853   
00859   unsigned xfIndex() const;
00860   
00866   void setXfIndex( unsigned i );
00867   
00875   unsigned width() const;
00876   
00884   void setWidth( unsigned w );
00885   
00891   bool hidden() const;
00892   
00898   void setHidden( bool h );
00899 
00905   bool collapsed() const;
00906   
00912   void setCollapsed( bool c );
00913   
00920   unsigned outlineLevel() const;
00921   
00928   void setOutlineLevel( unsigned l );
00929   
00930   virtual void setData( unsigned size, const unsigned char* data );
00931 
00932   virtual const char* name(){ return "COLINFO"; }
00933 
00934   virtual void dump( std::ostream& out ) const;
00935 
00936 private:
00937    // no copy or assign
00938    ColInfoRecord( const ColInfoRecord& );
00939    ColInfoRecord& operator=( const ColInfoRecord& );
00940 
00941    class Private;
00942    Private *d;
00943 };
00944 
00955 class DateModeRecord : public Record
00956 {
00957 public:
00958 
00959   static const unsigned int id;
00960 
00961   unsigned int rtti(){
00962       return this->id;
00963   }
00964 
00968   DateModeRecord();
00969   
00973   ~DateModeRecord();
00974   
00981   bool base1904() const;
00982   
00989   void setBase1904( bool r );
00990 
00991   virtual void setData( unsigned size, const unsigned char* data );
00992 
00993   virtual const char* name(){ return "DATEMODE"; }
00994 
00995   virtual void dump( std::ostream& out ) const;
00996 
00997 private:
00998   // no copy or assign
00999   DateModeRecord( const DateModeRecord& );
01000   DateModeRecord& operator=( const DateModeRecord& );
01001 
01002   class Private;
01003   Private* d;
01004 };
01005 
01012 class DimensionRecord : public Record
01013 {
01014 public:
01015 
01016   static const unsigned int id;
01017 
01018   unsigned int rtti(){
01019       return this->id;
01020   }
01021 
01025   DimensionRecord();
01026   
01030   ~DimensionRecord();
01031   
01037   unsigned firstRow() const;
01038   
01044   void setFirstRow( unsigned r );
01045   
01051   unsigned lastRow() const;
01052   
01058   void setLastRow( unsigned r );
01059   
01065   unsigned firstColumn() const;
01066   
01072   void setFirstColumn( unsigned r );
01073   
01079   unsigned lastColumn() const;
01080   
01086   void setLastColumn( unsigned r );
01087   
01088   virtual const char* name(){ return "DIMENSION"; }
01089   
01090   virtual void setData( unsigned size, const unsigned char* data );
01091   
01092   virtual void dump( std::ostream& out ) const;
01093 
01094 private:
01095    // no copy or assign
01096    DimensionRecord( const DimensionRecord& );
01097    DimensionRecord& operator=( const DimensionRecord& );
01098    
01099    class Private;
01100    Private *d;
01101 };
01102 
01103 class ExternNameRecord : public Record
01104 {
01105 public:
01106 
01107   static const unsigned int id;
01108 
01109   unsigned int rtti(){
01110     return this->id;
01111   }
01112 
01113   ExternNameRecord();
01114 
01115   ~ExternNameRecord();
01116 
01117   // one-based sheet index
01118   // if 0 means AddIn function
01119   unsigned sheetIndex() const;
01120 
01121   void setSheetIndex( unsigned sheetIndex );
01122 
01123   UString externName() const;
01124 
01125   void setExternName( const UString& name );
01126 
01127   virtual void setData( unsigned size, const unsigned char* data );
01128 
01129 
01130 
01131   virtual const char* name(){ return "EXTERNNAME"; }
01132 
01133   virtual void dump( std::ostream& out ) const;
01134 
01135 private:
01136    // no copy or assign
01137    ExternNameRecord( const ExternNameRecord& );
01138    ExternNameRecord& operator=( const ExternNameRecord& );
01139    
01140    class Private;
01141    Private *d;
01142 };
01143 
01144 
01154 class EOFRecord : public Record
01155 {
01156 public:
01157 
01158   static const unsigned int id;
01159 
01160   unsigned int rtti(){
01161       return this->id;
01162   }
01163 
01167   EOFRecord();
01168 
01172   virtual ~EOFRecord();
01173   
01174   virtual void setData( unsigned size, const unsigned char* data );
01175 
01176   virtual const char* name(){ return "EOF"; }
01177 
01178   virtual void dump( std::ostream& out ) const;
01179 
01180 private:
01181    // no copy or assign
01182    EOFRecord( const EOFRecord& );
01183    EOFRecord& operator=( const EOFRecord& );
01184 };
01185 
01186 class FilepassRecord : public Record
01187 {
01188 public:
01189 
01190   static const unsigned int id;
01191 
01192   unsigned int rtti(){
01193     return this->id;
01194   }
01195 
01199   FilepassRecord();
01200 
01204   virtual ~FilepassRecord();
01205   
01206   virtual void setData( unsigned size, const unsigned char* data );
01207 
01208   virtual const char* name(){ return "FILEPASS"; }
01209 
01210   virtual void dump( std::ostream& out ) const;
01211 
01212 private:
01213    // no copy or assign
01214    FilepassRecord( const FilepassRecord& );
01215    FilepassRecord& operator=( const FilepassRecord& );
01216 };
01217 
01232 class FontRecord : public Record
01233 {
01234 public:
01235 
01236   static const unsigned int id;
01237 
01238   unsigned int rtti(){
01239       return this->id;
01240   }
01241 
01245   FontRecord();
01246   
01250   FontRecord( const FontRecord& fr );
01251   
01255   FontRecord& operator=( const FontRecord& fr );
01256 
01260   virtual ~FontRecord();
01261   
01262   enum { 
01263     Normal = 0, 
01264     Superscript = 1,
01265     Subscript = 2 };
01266     
01267   enum { 
01268     None = 0, 
01269     Single = 1, 
01270     Double = 2, 
01271     SingleAccounting = 0x21, 
01272     DoubleAccounting = 0x22 };
01273   
01274   unsigned height() const;
01275   void setHeight( unsigned h );
01276   
01282   UString fontName() const;
01283   
01289   void setFontName( const UString& fn );
01290 
01291   // FIXME what is this font family ? index ?  
01292   unsigned fontFamily() const;
01293   void setFontFamily( unsigned f );
01294   
01295   // FIXME and character set index ?
01296   unsigned characterSet() const;
01297   void setCharacterSet( unsigned s );
01298   
01304   unsigned colorIndex() const;
01305   
01311   void setColorIndex( unsigned c );
01312   
01319   unsigned boldness() const;
01320   
01327   void setBoldness( unsigned b );
01328   
01334   bool italic() const;
01335   
01341   void setItalic( bool i );
01342   
01348   bool strikeout() const;
01349   
01355   void setStrikeout( bool s );
01356   
01363   unsigned escapement() const;
01364   
01371   void setEscapement( unsigned s );
01372   
01380   unsigned underline() const;
01381   
01389   void setUnderline( unsigned u );
01390   
01391   virtual void setData( unsigned size, const unsigned char* data );
01392 
01393   virtual const char* name(){ return "FONT"; }
01394 
01395   virtual void dump( std::ostream& out ) const;
01396 
01397 private:
01398    class Private;
01399    Private *d;
01400 };
01401 
01408 class FooterRecord : public Record
01409 {
01410 public:
01411 
01412   static const unsigned int id;
01413 
01414   unsigned int rtti(){
01415       return this->id;
01416   }
01417 
01421   FooterRecord();
01422   
01426   ~FooterRecord();
01427   
01431   UString footer() const;
01432   
01436   void setFooter( const UString& f );
01437   
01438   virtual void setData( unsigned size, const unsigned char* data );
01439 
01440   virtual const char* name(){ return "FOOTER"; }
01441 
01442   virtual void dump( std::ostream& out ) const;
01443 
01444 private:
01445   // no copy or assign
01446   FooterRecord( const FooterRecord& );
01447   FooterRecord& operator=( const FooterRecord& );
01448 
01449   class Private;
01450   Private* d;
01451 };
01452 
01464 class FormatRecord : public Record
01465 {
01466 public:
01467 
01468   static const unsigned int id;
01469 
01470   unsigned int rtti(){
01471       return this->id;
01472   }
01473 
01477   FormatRecord();
01478   
01482   ~FormatRecord();
01483   
01487   FormatRecord( const FormatRecord& fr );
01488   
01492   FormatRecord& operator=( const FormatRecord& fr );
01493   
01500   unsigned index() const;
01501   
01508   void setIndex( unsigned i );
01509 
01516   UString formatString() const;
01517   
01523   void setFormatString( const UString& fs );
01524     
01525   virtual const char* name(){ return "FORMAT"; }
01526   
01527   virtual void setData( unsigned size, const unsigned char* data );
01528 
01529   virtual void dump( std::ostream& out ) const;
01530 
01531 private:
01532    class Private;
01533    Private *d;
01534 };
01535 
01542 class FormulaRecord : public Record, public CellInfo
01543 {
01544 public:
01545 
01546   static const unsigned int id;
01547 
01548   unsigned int rtti(){
01549       return this->id;
01550   }
01551 
01555   FormulaRecord();
01556   
01560   ~FormulaRecord();
01561   
01565   Value result() const;
01566   
01570   void setResult( const Value& v );
01571   
01572   FormulaTokens tokens() const;
01573   
01574   virtual void setData( unsigned size, const unsigned char* data );
01575 
01576   virtual const char* name(){ return "FORMULA"; }
01577 
01578   virtual void dump( std::ostream& out ) const;
01579 
01580 private:
01581   // no copy or assign
01582   FormulaRecord( const FormulaRecord& );
01583   FormulaRecord& operator=( const FormulaRecord& );
01584 
01585   class Private;
01586   Private* d;
01587 };
01588 
01595 class HeaderRecord : public Record
01596 {
01597 public:
01598 
01599   static const unsigned int id;
01600 
01601   unsigned int rtti(){
01602       return this->id;
01603   }
01604 
01608   HeaderRecord();
01609   
01613   ~HeaderRecord();
01614   
01618   UString header() const;
01619   
01623   void setHeader( const UString& h );
01624   
01625   virtual void setData( unsigned size, const unsigned char* data );
01626 
01627   virtual const char* name(){ return "HEADER"; }
01628 
01629   virtual void dump( std::ostream& out ) const;
01630 
01631 private:
01632   // no copy or assign
01633   HeaderRecord( const HeaderRecord& );
01634   HeaderRecord& operator=( const HeaderRecord& );
01635 
01636   class Private;
01637   Private* d;
01638 };
01639 
01640 
01650 class LabelRecord : public Record, public CellInfo
01651 {
01652 public:
01653 
01654   static const unsigned int id;
01655 
01656   unsigned int rtti(){
01657       return this->id;
01658   }
01659 
01663   LabelRecord();
01664 
01668   virtual ~LabelRecord();
01669 
01673   UString label() const;
01674   
01678   void setLabel( const UString& l );
01679 
01680   virtual void setData( unsigned size, const unsigned char* data );
01681 
01682   virtual const char* name(){ return "LABEL"; }
01683   
01684   virtual void dump( std::ostream& out ) const;
01685 
01686 private:
01687    // no copy or assign
01688    LabelRecord( const LabelRecord& );
01689    LabelRecord& operator=( const LabelRecord& );
01690 
01691    class Private;
01692    Private *d;
01693 };
01694 
01704 class LabelSSTRecord : public Record, public CellInfo
01705 {
01706 public:
01707 
01708   static const unsigned int id;
01709 
01710   unsigned int rtti(){
01711       return this->id;
01712   }
01713 
01717   LabelSSTRecord();
01718 
01722   virtual ~LabelSSTRecord();
01723 
01728   unsigned sstIndex() const;
01729 
01730   virtual void setData( unsigned size, const unsigned char* data );
01731 
01732   virtual const char* name(){ return "LABELSST"; }
01733   
01734   virtual void dump( std::ostream& out ) const;
01735 
01736 private:
01737    // no copy or assign
01738    LabelSSTRecord( const LabelSSTRecord& );
01739    LabelSSTRecord& operator=( const LabelSSTRecord& );
01740 
01741    class Private;
01742    Private *d;
01743 };
01744 
01749 class LeftMarginRecord : public Record
01750 {
01751 public:
01752 
01753   static const unsigned int id;
01754 
01755   unsigned int rtti(){
01756       return this->id;
01757   }
01758 
01762   LeftMarginRecord();
01763   
01767   ~LeftMarginRecord();
01768   
01772   double leftMargin() const;
01773   
01777   void setLeftMargin( double m );
01778 
01779   virtual void setData( unsigned size, const unsigned char* data );
01780 
01781   virtual const char* name(){ return "LEFTMARGIN"; }
01782 
01783   virtual void dump( std::ostream& out ) const;
01784 
01785 private:
01786   // no copy or assign
01787   LeftMarginRecord( const LeftMarginRecord& );
01788   LeftMarginRecord& operator=( const LeftMarginRecord& );
01789 
01790   class Private;
01791   Private* d;
01792 };
01793 
01794 
01802 class MergedCellsRecord : public Record
01803 {
01804 public:
01805 
01806   static const unsigned int id;
01807 
01808   unsigned int rtti(){
01809       return this->id;
01810   }
01811 
01815   MergedCellsRecord();
01816 
01820   virtual ~MergedCellsRecord();
01821   
01825   unsigned count() const;
01826   
01830   unsigned firstRow( unsigned i ) const;
01831   
01835   unsigned lastRow( unsigned i ) const;
01836   
01840   unsigned firstColumn( unsigned i ) const;
01841   
01845   unsigned lastColumn( unsigned i ) const;
01846 
01847   virtual void setData( unsigned size, const unsigned char* data );
01848   
01849   virtual const char* name(){ return "MERGEDCELLS"; }
01850 
01851   virtual void dump( std::ostream& out ) const;
01852 
01853 private:
01854    // no copy or assign
01855    MergedCellsRecord( const MergedCellsRecord& );
01856    MergedCellsRecord& operator=( const MergedCellsRecord& );
01857 
01858    class Private;
01859    Private *d;
01860 };
01861 
01869 class MulBlankRecord : public Record, public CellInfo, public ColumnSpanInfo
01870 {
01871 public:
01872 
01873   static const unsigned int id;
01874 
01875   unsigned int rtti(){
01876       return this->id;
01877   }
01878 
01882   MulBlankRecord();
01883 
01887   virtual ~MulBlankRecord();
01888 
01889   virtual void setData( unsigned size, const unsigned char* data );
01890 
01894   unsigned xfIndex( unsigned i ) const;
01895 
01896   virtual const char* name(){ return "MULBLANK"; }
01897 
01898   virtual void dump( std::ostream& out ) const;
01899 
01900 private:
01901    // no copy or assign
01902    MulBlankRecord( const MulBlankRecord& );
01903    MulBlankRecord& operator=( const MulBlankRecord& );
01904 
01905    class Private;
01906    Private *d;
01907 
01908    // from CellInfo, we don't need it
01909    // mark as private so nobody can call them
01910    virtual unsigned column() const { return CellInfo::column(); }
01911    virtual unsigned xfIndex() const { return CellInfo::xfIndex(); }
01912 };
01913 
01921 class MulRKRecord : public Record, public CellInfo, public ColumnSpanInfo
01922 {
01923 public:
01924 
01925   static const unsigned int id;
01926 
01927   unsigned int rtti(){
01928       return this->id;
01929   }
01930 
01934   MulRKRecord();
01935 
01939   virtual ~MulRKRecord();
01940 
01941   virtual void setData( unsigned size, const unsigned char* data );
01942 
01946   unsigned xfIndex( unsigned i ) const;
01947   
01953   bool isInteger( unsigned i ) const;
01954   
01961   int asInteger( unsigned i ) const;
01962   
01969   double asFloat( unsigned i ) const;
01970   
01971   unsigned encodedRK( unsigned i ) const;
01972   
01973   virtual const char* name(){ return "MULRK"; }
01974 
01975   virtual void dump( std::ostream& out ) const;
01976 
01977 private:
01978    // no copy or assign
01979    MulRKRecord( const MulRKRecord& );
01980    MulRKRecord& operator=( const MulRKRecord& );
01981 
01982    class Private;
01983    Private *d;
01984 
01985    // from CellInfo, we don't need it
01986    // mark as private so nobody can call them
01987    virtual unsigned column() const { return CellInfo::column(); }
01988    virtual unsigned xfIndex() const { return CellInfo::xfIndex(); }
01989 };
01990 
01991 
01992 class NameRecord : public Record
01993 {
01994 public:
01995 
01996   static const unsigned int id;
01997 
01998   unsigned int rtti(){
01999     return this->id;
02000   }
02001 
02002   NameRecord();
02003 
02004   ~NameRecord();
02005 
02006   UString definedName() const;
02007 
02008   void setDefinedName( const UString& name );
02009 
02010   virtual void setData( unsigned size, const unsigned char* data );
02011 
02012   virtual const char* name(){ return "NAME"; }
02013 
02014   virtual void dump( std::ostream& out ) const;
02015 
02016 private:
02017    // no copy or assign
02018    NameRecord( const NameRecord& );
02019    NameRecord& operator=( const NameRecord& );
02020    
02021    class Private;
02022    Private *d;
02023 };
02024 
02025 
02030 class NumberRecord : public Record, public CellInfo
02031 {
02032 public:
02033 
02034   static const unsigned int id;
02035 
02036   unsigned int rtti(){
02037       return this->id;
02038   }
02039 
02043   NumberRecord();
02044 
02048   virtual ~NumberRecord();
02049 
02050   virtual void setData( unsigned size, const unsigned char* data );
02051   
02057   double number() const;
02058   
02064   void setNumber( double f );
02065 
02066   virtual const char* name(){ return "NUMBER"; }
02067   
02068   virtual void dump( std::ostream& out ) const;
02069 
02070 private:
02071    // no copy or assign
02072    NumberRecord( const NumberRecord& );
02073    NumberRecord& operator=( const NumberRecord& );
02074 
02075    class Private;
02076    Private *d;
02077 };
02078 
02083 class PaletteRecord : public Record
02084 {
02085 public:
02086 
02087   static const unsigned int id;
02088 
02089   unsigned int rtti(){
02090       return this->id;
02091   }
02092 
02096   PaletteRecord();
02097   
02101   ~PaletteRecord();
02102 
02106   Color color( unsigned i ) const;
02107 
02111   unsigned count() const;
02112   
02113   virtual void setData( unsigned size, const unsigned char* data );
02114 
02115   virtual const char* name(){ return "PALETTE"; }
02116 
02117   virtual void dump( std::ostream& out ) const;
02118 
02119 private:
02120   // no copy or assign
02121   PaletteRecord( const PaletteRecord& );
02122   PaletteRecord& operator=( const PaletteRecord& );
02123 
02124   class Private;
02125   Private* d;
02126 };
02127 
02128 
02129 
02134 class RightMarginRecord : public Record
02135 {
02136 public:
02137 
02138   static const unsigned int id;
02139 
02140   unsigned int rtti(){
02141       return this->id;
02142   }
02143 
02147   RightMarginRecord();
02148   
02152   ~RightMarginRecord();
02153   
02157   double rightMargin() const;
02158   
02162   void setRightMargin( double m );
02163 
02164   virtual void setData( unsigned size, const unsigned char* data );
02165 
02166   virtual const char* name(){ return "RIGHTMARGIN"; }
02167 
02168   virtual void dump( std::ostream& out ) const;
02169 
02170 private:
02171   // no copy or assign
02172   RightMarginRecord( const RightMarginRecord& );
02173   RightMarginRecord& operator=( const RightMarginRecord& );
02174 
02175   class Private;
02176   Private* d;
02177 };
02178 
02179 
02180 
02186 class RKRecord : public Record, public CellInfo
02187 {
02188 public:
02189 
02190   static const unsigned int id;
02191 
02192   unsigned int rtti(){
02193       return this->id;
02194   }
02195 
02199   RKRecord();
02200 
02204   virtual ~RKRecord();
02205 
02206   virtual void setData( unsigned size, const unsigned char* data );
02207   
02213   bool isInteger() const;
02214   
02220   bool isFloat() const;
02221     
02228   int asInteger() const;
02229   
02236   double asFloat() const;
02237   
02243   void setInteger( int i );
02244   
02250   void setFloat( double f );
02251 
02252   unsigned encodedRK() const;
02253   
02254   virtual const char* name(){ return "RK"; }
02255   
02256   virtual void dump( std::ostream& out ) const;
02257 
02258 private:
02259    // no copy or assign
02260    RKRecord( const RKRecord& );
02261    RKRecord& operator=( const RKRecord& );
02262 
02263    class Private;
02264    Private *d;
02265 };
02266 
02271 class RowRecord : public Record, public ColumnSpanInfo
02272 {
02273 public:
02274 
02275   static const unsigned int id;
02276 
02277   unsigned int rtti(){
02278       return this->id;
02279   }
02280 
02284   RowRecord();
02285 
02289   virtual ~RowRecord();
02290   
02296   unsigned row() const;
02297   
02303   void setRow( unsigned r );
02304     
02310   unsigned xfIndex() const;
02311   
02317   void setXfIndex( unsigned i );
02318   
02324   unsigned height() const;
02325   
02331   void setHeight( unsigned h );
02332   
02338   bool hidden() const;
02339   
02345   void setHidden( bool h );
02346 
02347   virtual void setData( unsigned size, const unsigned char* data );
02348 
02349   virtual const char* name(){ return "ROW"; }
02350 
02351   virtual void dump( std::ostream& out ) const;
02352 
02353 private:
02354    // no copy or assign
02355    RowRecord( const RowRecord& );
02356    RowRecord& operator=( const RowRecord& );
02357 
02358    class Private;
02359    Private *d;
02360 };
02361 
02362 
02373 class RStringRecord : public Record, public CellInfo
02374 {
02375 public:
02376 
02377   static const unsigned int id;
02378 
02379   unsigned int rtti(){
02380       return this->id;
02381   }
02382 
02386   RStringRecord();
02387 
02391   virtual ~RStringRecord();
02392 
02398   UString label() const;
02399   
02405   void setLabel( const UString& l );
02406 
02407   virtual void setData( unsigned size, const unsigned char* data );
02408 
02409   virtual const char* name(){ return "RSTRING"; }
02410   
02411   virtual void dump( std::ostream& out ) const;
02412 
02413 private:
02414    // no copy or assign
02415    RStringRecord( const RStringRecord& );
02416    RStringRecord& operator=( const RStringRecord& );
02417 
02418    class Private;
02419    Private *d;
02420 };
02421 
02422 
02430 class SSTRecord : public Record
02431 {
02432 public:
02433 
02434   static const unsigned int id;
02435   
02436   unsigned int rtti(){
02437       return this->id;
02438   }
02439 
02443   SSTRecord();
02444   
02448   virtual ~SSTRecord();
02449 
02450   virtual void setData( unsigned size, const unsigned char* data );
02451   
02455   unsigned count() const;
02456   
02462   UString stringAt( unsigned index ) const;
02463   
02464   virtual const char* name(){ return "SST"; }
02465   
02466   virtual void dump( std::ostream& out ) const;
02467   
02468 private:
02469    // no copy or assign
02470    SSTRecord( const SSTRecord& );
02471    SSTRecord& operator=( const SSTRecord& );
02472 
02473    class Private;
02474    Private *d;
02475 };
02476 
02477 
02486 class StringRecord : public Record
02487 {
02488 public:
02489 
02490   static const unsigned int id;
02491   
02492   unsigned int rtti(){ return this->id; }
02493 
02497   StringRecord();
02498   
02502   virtual ~StringRecord();
02503 
02504   virtual void setData( unsigned size, const unsigned char* data );
02505   
02509   UString ustring() const;
02510   
02514   Value value() const;
02515   
02516   virtual const char* name(){ return "STRING"; }
02517   
02518   virtual void dump( std::ostream& out ) const;
02519   
02520 private:
02521    // no copy or assign
02522    StringRecord( const SSTRecord& );
02523    StringRecord& operator=( const SSTRecord& );
02524 
02525    class Private;
02526    Private *d;
02527 };
02528 
02533 class TopMarginRecord : public Record
02534 {
02535 public:
02536 
02537   static const unsigned int id;
02538 
02539   unsigned int rtti(){
02540       return this->id;
02541   }
02542 
02546   TopMarginRecord();
02547   
02551   ~TopMarginRecord();
02552   
02556   double topMargin() const;
02557   
02561   void setTopMargin( double m );
02562 
02563   virtual void setData( unsigned size, const unsigned char* data );
02564 
02565   virtual const char* name(){ return "TOPMARGIN"; }
02566 
02567   virtual void dump( std::ostream& out ) const;
02568 
02569 private:
02570   // no copy or assign
02571   TopMarginRecord( const TopMarginRecord& );
02572   TopMarginRecord& operator=( const TopMarginRecord& );
02573 
02574   class Private;
02575   Private* d;
02576 };
02577 
02584 class XFRecord : public Record
02585 {
02586 public:
02587 
02588   static const unsigned int id;
02589 
02590   unsigned int rtti(){
02591       return this->id;
02592   }
02593 
02597   XFRecord();
02598   
02602   XFRecord( const XFRecord& xf );
02603   
02607   XFRecord& operator=( const XFRecord& xf );
02608   
02612   ~XFRecord();
02613   
02620   unsigned fontIndex() const;
02621   
02628   void setFontIndex( unsigned fi );
02629 
02636   unsigned formatIndex() const;
02637   
02644   void setFormatIndex( unsigned fi );
02645   
02651   bool locked() const;
02652   
02658   void setLocked( bool l );
02659   
02666   bool formulaHidden() const;
02667 
02674   void setFormulaHidden( bool f );
02675   
02683   unsigned parentStyle() const;
02684   
02692   void setParentStyle( unsigned ps );
02693 
02694   enum { 
02695     General = 0, 
02696     Left, 
02697     Centered, 
02698     Right, 
02699     Filled, 
02700     Justified,
02701     CenteredSelection,
02702     Distributed };
02703   
02707   unsigned horizontalAlignment() const;
02708   
02712   void setHorizontalAlignment( unsigned ha );
02713   
02718   const char* horizontalAlignmentAsString() const; 
02719   
02720   enum { 
02721     Top = 0, 
02722     VCentered = 1, 
02723     Bottom = 2, 
02724     VJustified = 3, 
02725     VDistributed = 4 };
02726   
02732   unsigned verticalAlignment() const;
02733   
02739   void setVerticalAlignment( unsigned va );
02740   
02745   const char* verticalAlignmentAsString() const; 
02746   
02752   bool textWrap() const;
02753   
02759   void setTextWrap( bool wrap );
02760   
02768   unsigned rotationAngle() const;
02769   
02777   void setRotationAngle( unsigned angle );
02778   
02785   bool stackedLetters() const;
02786   
02792   void setStackedLetters( bool stacked );
02793 
02799   unsigned indentLevel() const;
02800   
02806   void setIndentLevel( unsigned i );
02807   
02813   bool shrinkContent() const;
02814   
02820   void setShrinkContent( bool s );
02821   
02822   enum
02823   {
02824     NoLine = 0,
02825     Thin = 1,
02826     Medium = 2,
02827     Dashed = 3,
02828     Dotted = 4,
02829     Thick = 5,
02830     Double = 6,
02831     Hair = 7,
02832     MediumDashed = 8,
02833     ThinDashDotted = 9,
02834     MediumDashDotted = 10,
02835     ThinDashDotDotted = 11,
02836     MediumDashDotDotted = 12,
02837     SlantedMediumDashDotted = 13    
02838   };
02839   
02845   unsigned leftBorderStyle() const;
02846   
02852   void setLeftBorderStyle( unsigned style );
02853   
02860   unsigned leftBorderColor() const;
02861   
02868   void setLeftBorderColor( unsigned color );
02869 
02875   unsigned rightBorderStyle() const;
02876   
02882   void setRightBorderStyle( unsigned style );
02883   
02890   unsigned rightBorderColor() const;
02891   
02898   void setRightBorderColor( unsigned color );
02899   
02905   unsigned topBorderStyle() const;
02906   
02912   void setTopBorderStyle( unsigned style );
02913   
02920   unsigned topBorderColor() const;
02921   
02928   void setTopBorderColor( unsigned color );
02929   
02935   unsigned bottomBorderStyle() const;
02936   
02942   void setBottomBorderStyle( unsigned style );
02943   
02950   unsigned bottomBorderColor() const;
02951   
02958   void setBottomBorderColor( unsigned color );
02959   
02965   bool diagonalTopLeft() const;
02966   
02972   void setDiagonalTopLeft( bool d );
02973   
02979   bool diagonalBottomLeft() const;
02980   
02986   void setDiagonalBottomLeft( bool d );
02987   
02993   unsigned diagonalStyle() const;
02994   
03000   void setDiagonalStyle( unsigned style );
03001   
03008   unsigned diagonalColor() const;
03009   
03016   void setDiagonalColor( unsigned color );
03017   
03023   unsigned fillPattern() const;
03024   
03030   void setFillPattern( unsigned pattern );
03031   
03038   unsigned patternForeColor() const;
03039   
03046   void setPatternForeColor( unsigned color );
03047   
03054   unsigned patternBackColor() const;    
03055   
03062   void setPatternBackColor( unsigned color );
03063   
03064   virtual const char* name(){ return "XF"; }
03065   
03066   virtual void setData( unsigned size, const unsigned char* data );
03067   
03068   virtual void dump( std::ostream& out ) const;
03069 
03070 private:
03071   class Private;
03072   Private* d;
03073 };
03074 
03075 
03076 class ExcelReader
03077 {
03078 public:
03079   ExcelReader();
03080   virtual ~ExcelReader();
03081   bool load( Workbook* workbook, const char* filename );
03082   
03083 protected:  
03084   virtual void handleRecord( Record* record );
03085     
03086 private:  
03087   void handleBoundSheet( BoundSheetRecord* record );
03088   void handleBOF( BOFRecord* record );
03089   void handleBoolErr( BoolErrRecord* record );
03090   void handleBottomMargin( BottomMarginRecord* record );
03091   void handleBlank( BlankRecord* record );
03092   void handleCalcMode( CalcModeRecord* record );
03093   void handleColInfo( ColInfoRecord* record );
03094   void handleDateMode( DateModeRecord* record );
03095   void handleDimension( DimensionRecord* record );
03096   void handleExternName( ExternNameRecord* record );
03097   void handleFilepass( FilepassRecord* record );
03098   void handleFormat( FormatRecord* record );
03099   void handleFormula( FormulaRecord* record );
03100   void handleFont( FontRecord* record );
03101   void handleFooter( FooterRecord* record );
03102   void handleHeader( HeaderRecord* record );
03103   void handleLabel( LabelRecord* record );
03104   void handleLabelSST( LabelSSTRecord* record );
03105   void handleLeftMargin( LeftMarginRecord* record );
03106   void handleMergedCells( MergedCellsRecord* record );
03107   void handleMulBlank( MulBlankRecord* record );
03108   void handleMulRK( MulRKRecord* record );
03109   void handleName( NameRecord* record );
03110   void handleNumber( NumberRecord* record );
03111   void handlePalette( PaletteRecord* record );
03112   void handleRightMargin( RightMarginRecord* record );
03113   void handleRString( RStringRecord* record );
03114   void handleRK( RKRecord* record );
03115   void handleRow( RowRecord* record );
03116   void handleSST( SSTRecord* record );
03117   void handleString( StringRecord* record );
03118   void handleTopMargin( TopMarginRecord* record );
03119   void handleXF( XFRecord* record );    
03120   
03121   Color convertColor( unsigned colorIndex );
03122   FormatFont convertFont( unsigned fontIndex );
03123   Format convertFormat( unsigned xfIndex );
03124   UString decodeFormula( unsigned row, unsigned col, const FormulaTokens& tokens );
03125   
03126   // no copy or assign
03127   ExcelReader( const ExcelReader& );
03128   ExcelReader& operator=( const ExcelReader& );
03129   
03130   class Private;
03131   Private* d;
03132 };
03133 
03134 
03135 } // namespace Swinder
03136 
03137 
03138 
03139 #endif // SWINDER_EXCEL_H
KDE Home | KDE Accessibility Home | Description of Access Keys