sc/source/filter/inc/excrecds.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: excrecds.hxx,v $
  10  * $Revision: 1.51 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef SC_EXCRECDS_HXX
  32 #define SC_EXCRECDS_HXX
  33
  34 #include <tools/solar.h>
  35 #include <svtools/zforlist.hxx>
  36 #include <tools/string.hxx>
  37 #include <vcl/vclenum.hxx>
  38 #include <tools/color.hxx>
  39
  40
  41 #include <vector>
  42 #include "olinetab.hxx"
  43 #include "filter.hxx"
  44 #include "rangelst.hxx"
  45 #include "xerecord.hxx"
  46 #include "xeroot.hxx"
  47 #include "xeformula.hxx"
  48 #include "xestring.hxx"
  49 #include "root.hxx"
  50 #include "excdefs.hxx"
  51 #include "cell.hxx"
  52
  53 //------------------------------------------------------------------ Forwards -
  54
  55 class SvxBorderLine;
  56
  57 class SvStream;
  58 class Font;
  59 class List;
  60 class ScPatternAttr;
  61 class ScTokenArray;
  62 class ScRangeData;
  63 class ScDBData;
  64 class ScEditCell;
  65 class SfxItemSet;
  66 class EditTextObject;
  67 class ScPageHFItem;
  68 class ScProgress;
  69
  70 class ExcTable;
  71
  72 //----------------------------------------------------------- class ExcRecord -
  73
  74 class ExcRecord : public XclExpRecord
  75 {
  76 public:
  77     virtual void                        Save( XclExpStream& rStrm );
  78
  79     virtual UINT16                      GetNum() const = 0;
  80     virtual sal_Size        GetLen() const = 0;
  81
  82 protected:
  83     virtual void                        SaveCont( XclExpStream& rStrm );
  84
  85 private:
  86     /** Writes the body of the record. */
  87     virtual void            WriteBody( XclExpStream& rStrm );
  88 };
  89
  90
  91 //--------------------------------------------------------- class ExcEmptyRec -
  92
  93 class ExcEmptyRec : public ExcRecord
  94 {
  95 private:
  96 protected:
  97 public:
  98     virtual void                        Save( XclExpStream& rStrm );
  99     virtual UINT16                      GetNum() const;
 100     virtual sal_Size        GetLen() const;
 101 };
 102
 103
 104 //------------------------------------------------------- class ExcRecordList -
 105
 106 class ExcRecordList : protected List, public ExcEmptyRec
 107 {
 108 private:
 109 protected:
 110 public:
 111     virtual                                     ~ExcRecordList();
 112
 113     using                   List::Count;
 114
 115     inline ExcRecord*           First( void )                           { return ( ExcRecord* ) List::First(); }
 116     inline ExcRecord*           Next( void )                            { return ( ExcRecord* ) List::Next(); }
 117
 118     inline void                         Append( ExcRecord* pNew )       { if( pNew ) List::Insert( pNew, LIST_APPEND ); }
 119     inline const ExcRecord*     Get( UINT32 nNum ) const        { return ( ExcRecord* ) List::GetObject( nNum ); }
 120
 121     virtual void                        Save( XclExpStream& rStrm );
 122 };
 123
 124
 125 //--------------------------------------------------------- class ExcDummyRec -
 126
 127 class ExcDummyRec : public ExcRecord
 128 {
 129 protected:
 130 public:
 131     virtual void                        Save( XclExpStream& rStrm );
 132     virtual UINT16                      GetNum() const;
 133     virtual     const BYTE*             GetData() const = 0;    // byte data must contain header and body
 134 };
 135
 136
 137 //------------------------------------------------------- class ExcBoolRecord -
 138 // stores BOOL as 16bit val ( 0x0000 | 0x0001 )
 139
 140 class ExcBoolRecord : public ExcRecord
 141 {
 142 private:
 143     virtual void                        SaveCont( XclExpStream& rStrm );
 144
 145 protected:
 146     BOOL                                        bVal;
 147
 148     inline                                      ExcBoolRecord() : bVal( FALSE ) {}
 149
 150 public:
 151     inline                                      ExcBoolRecord( const BOOL bDefault ) : bVal( bDefault ) {}
 152
 153     virtual sal_Size        GetLen( void ) const;
 154 };
 155
 156
 157 //--------------------------------------------------------- class ExcBof_Base -
 158
 159 class ExcBof_Base : public ExcRecord
 160 {
 161 private:
 162 protected:
 163     UINT16                                      nDocType;
 164     UINT16                                      nVers;
 165     UINT16                                      nRupBuild;
 166     UINT16                                      nRupYear;
 167 public:
 168                             ExcBof_Base( void );
 169 };
 170
 171
 172 //-------------------------------------------------------------- class ExcBof -
 173 // Header Record fuer WORKSHEETS
 174
 175 class ExcBof : public ExcBof_Base
 176 {
 177 private:
 178     virtual void                        SaveCont( XclExpStream& rStrm );
 179 public:
 180                             ExcBof( void );
 181
 182     virtual UINT16                      GetNum( void ) const;
 183     virtual sal_Size        GetLen( void ) const;
 184 };
 185
 186
 187 //------------------------------------------------------------- class ExcBofW -
 188 // Header Record fuer WORKBOOKS
 189
 190 class ExcBofW : public ExcBof_Base
 191 {
 192 private:
 193     virtual void                        SaveCont( XclExpStream& rStrm );
 194 public:
 195                             ExcBofW( void );
 196
 197     virtual UINT16                      GetNum( void ) const;
 198     virtual sal_Size        GetLen( void ) const;
 199 };
 200
 201
 202 //-------------------------------------------------------------- class ExcEof -
 203
 204 class ExcEof : public ExcRecord
 205 {
 206 private:
 207 public:
 208     virtual UINT16                      GetNum( void ) const;
 209     virtual sal_Size        GetLen( void ) const;
 210 };
 211
 212
 213 //--------------------------------------------------------- class ExcDummy_00 -
 214 // INTERFACEHDR to FNGROUPCOUNT (see excrecds.cxx)
 215
 216 class ExcDummy_00 : public ExcDummyRec
 217 {
 218 private:
 219     static const BYTE           pMyData[];
 220     static const sal_Size   nMyLen;
 221 public:
 222     virtual sal_Size        GetLen( void ) const;
 223     virtual     const BYTE*             GetData( void ) const;
 224 };
 225
 226 // EXC_ID_WINDOWPROTECTION
 227 class XclExpWindowProtection : public   XclExpBoolRecord
 228 {
 229     public:
 230         XclExpWindowProtection(bool bValue);
 231
 232     virtual void            SaveXml( XclExpXmlStream& rStrm );
 233 };
 234
 235 // EXC_ID_PROTECT  Document Protection
 236 class XclExpProtection : public XclExpBoolRecord
 237 {
 238     public:
 239         XclExpProtection(bool bValue);
 240 };
 241
 242 class XclExpPassHash : public XclExpRecord
 243 {
 244 public:
 245     XclExpPassHash(const ::com::sun::star::uno::Sequence<sal_Int8>& aHash);
 246     virtual ~XclExpPassHash();
 247
 248 private:
 249     virtual void    WriteBody(XclExpStream& rStrm);
 250
 251 private:
 252     sal_uInt16  mnHash;
 253 };
 254
 255
 256 //-------------------------------------------------------- class ExcDummy_04x -
 257 // PASSWORD to BOOKBOOL (see excrecds.cxx), no 1904
 258
 259 class ExcDummy_040 : public ExcDummyRec
 260 {
 261 private:
 262     static const BYTE           pMyData[];
 263     static const sal_Size   nMyLen;
 264 public:
 265     virtual sal_Size        GetLen( void ) const;
 266     virtual     const BYTE*             GetData( void ) const;
 267 };
 268
 269
 270
 271 class ExcDummy_041 : public ExcDummyRec
 272 {
 273 private:
 274     static const BYTE           pMyData[];
 275     static const sal_Size   nMyLen;
 276 public:
 277     virtual sal_Size        GetLen( void ) const;
 278     virtual     const BYTE*             GetData( void ) const;
 279 };
 280
 281
 282 //------------------------------------------------------------- class Exc1904 -
 283
 284 class Exc1904 : public ExcBoolRecord
 285 {
 286 public:
 287                             Exc1904( ScDocument& rDoc );
 288     virtual UINT16                      GetNum( void ) const;
 289
 290     virtual void            SaveXml( XclExpXmlStream& rStrm );
 291 };
 292
 293
 294 //------------------------------------------------------ class ExcBundlesheet -
 295
 296 class ExcBundlesheetBase : public ExcRecord
 297 {
 298 protected:
 299     sal_Size                nStrPos;
 300     sal_Size                nOwnPos;    // Position NACH # und Len
 301     UINT16                                      nGrbit;
 302     SCTAB                   nTab;
 303
 304                             ExcBundlesheetBase();
 305
 306 public:
 307                             ExcBundlesheetBase( RootData& rRootData, SCTAB nTab );
 308
 309     inline void             SetStreamPos( sal_Size nNewStrPos ) { nStrPos = nNewStrPos; }
 310     void                                        UpdateStreamPos( XclExpStream& rStrm );
 311
 312     virtual UINT16                      GetNum() const;
 313 };
 314
 315
 316
 317 class ExcBundlesheet : public ExcBundlesheetBase
 318 {
 319 private:
 320     ByteString                          aName;
 321
 322     virtual void                        SaveCont( XclExpStream& rStrm );
 323
 324 public:
 325                             ExcBundlesheet( RootData& rRootData, SCTAB nTab );
 326     virtual sal_Size        GetLen() const;
 327 };
 328
 329 //--------------------------------------------------------- class ExcDummy_02 -
 330 // sheet dummies: CALCMODE to SETUP
 331
 332 class ExcDummy_02a : public ExcDummyRec
 333 {
 334 private:
 335     static const BYTE           pMyData[];
 336     static const sal_Size   nMyLen;
 337 public:
 338     virtual sal_Size        GetLen( void ) const;
 339     virtual     const BYTE*             GetData( void ) const;
 340 };
 341
 342
 343 // ----------------------------------------------------------------------------
 344
 345 /** This record contains the Windows country IDs for the UI and document language. */
 346 class XclExpCountry : public XclExpRecord
 347 {
 348 public:
 349     explicit                    XclExpCountry( const XclExpRoot& rRoot );
 350
 351 private:
 352     sal_uInt16                  mnUICountry;        /// The UI country ID.
 353     sal_uInt16                  mnDocCountry;       /// The document country ID.
 354
 355     /** Writes the body of the COUNTRY record. */
 356     virtual void                WriteBody( XclExpStream& rStrm );
 357 };
 358
 359
 360 // XclExpWsbool ===============================================================
 361
 362 class XclExpWsbool : public XclExpUInt16Record
 363 {
 364 public:
 365     explicit                    XclExpWsbool( bool bFitToPages, SCTAB nScTab = -1, XclExpFilterManager* pManager = NULL );
 366
 367     virtual void                SaveXml( XclExpXmlStream& rStrm );
 368 private:
 369     SCTAB                       mnScTab;
 370     XclExpFilterManager*        mpManager;
 371 };
 372
 373
 374 // ============================================================================
 375
 376 class XclExpFiltermode : public XclExpEmptyRecord
 377 {
 378 public:
 379     explicit            XclExpFiltermode();
 380 };
 381
 382 // ----------------------------------------------------------------------------
 383
 384 class XclExpAutofilterinfo : public XclExpUInt16Record
 385 {
 386 public:
 387     explicit            XclExpAutofilterinfo( const ScAddress& rStartPos, SCCOL nScCol );
 388
 389     inline const ScAddress GetStartPos() const { return maStartPos; }
 390     inline SCCOL        GetColCount() const { return static_cast< SCCOL >( GetValue() ); }
 391
 392 private:
 393     ScAddress           maStartPos;
 394 };
 395
 396 // ----------------------------------------------------------------------------
 397
 398 class ExcFilterCondition
 399 {
 400 private:
 401     UINT8                                       nType;
 402     UINT8                                       nOper;
 403     double                                      fVal;
 404     XclExpString*           pText;
 405
 406 protected:
 407 public:
 408                             ExcFilterCondition();
 409                             ~ExcFilterCondition();
 410
 411     inline BOOL                         IsEmpty() const         { return (nType == EXC_AFTYPE_NOTUSED); }
 412     inline BOOL                         HasEqual() const        { return (nOper == EXC_AFOPER_EQUAL); }
 413     ULONG                                       GetTextBytes() const;
 414
 415     void                                        SetCondition( UINT8 nTp, UINT8 nOp, double fV, String* pT );
 416
 417     void                                        Save( XclExpStream& rStrm );
 418     void                                        SaveXml( XclExpXmlStream& rStrm );
 419     void                                        SaveText( XclExpStream& rStrm );
 420 };
 421
 422 // ----------------------------------------------------------------------------
 423
 424 class XclExpAutofilter : public XclExpRecord, protected XclExpRoot
 425 {
 426 private:
 427     UINT16                                      nCol;
 428     UINT16                                      nFlags;
 429     ExcFilterCondition          aCond[ 2 ];
 430
 431     BOOL                                        AddCondition( ScQueryConnect eConn, UINT8 nType,
 432                                 UINT8 nOp, double fVal, String* pText,
 433                                 BOOL bSimple = FALSE );
 434
 435     virtual void            WriteBody( XclExpStream& rStrm );
 436
 437 protected:
 438 public:
 439                             XclExpAutofilter( const XclExpRoot& rRoot, UINT16 nC );
 440
 441     inline UINT16                       GetCol() const                  { return nCol; }
 442     inline BOOL                         HasCondition() const    { return !aCond[ 0 ].IsEmpty(); }
 443     inline BOOL             HasTop10() const        { return ::get_flag( nFlags, EXC_AFFLAG_TOP10 ); }
 444
 445     BOOL                    AddEntry( const ScQueryEntry& rEntry );
 446
 447     virtual void            SaveXml( XclExpXmlStream& rStrm );
 448 };
 449
 450 // ----------------------------------------------------------------------------
 451
 452 class ExcAutoFilterRecs : public XclExpRecordBase, protected XclExpRoot
 453 {
 454 public:
 455     explicit            ExcAutoFilterRecs( const XclExpRoot& rRoot, SCTAB nTab );
 456     virtual             ~ExcAutoFilterRecs();
 457
 458     void                AddObjRecs();
 459
 460     virtual void        Save( XclExpStream& rStrm );
 461     virtual void        SaveXml( XclExpXmlStream& rStrm );
 462
 463     bool                HasFilterMode() const;
 464
 465 private:
 466     XclExpAutofilter*   GetByCol( SCCOL nCol ); // always 0-based
 467     BOOL                IsFiltered( SCCOL nCol );
 468
 469 private:
 470     typedef XclExpRecordList< XclExpAutofilter >    XclExpAutofilterList;
 471     typedef XclExpAutofilterList::RecordRefType     XclExpAutofilterRef;
 472
 473     XclExpAutofilterList maFilterList;
 474     XclExpFiltermode*   pFilterMode;
 475     XclExpAutofilterinfo* pFilterInfo;
 476     ScRange                 maRef;
 477 };
 478
 479 // ----------------------------------------------------------------------------
 480
 481 /** Sheet filter manager. Contains auto filters or advanced filters from all sheets. */
 482 class XclExpFilterManager : protected XclExpRoot
 483 {
 484 public:
 485     explicit            XclExpFilterManager( const XclExpRoot& rRoot );
 486
 487     /** Creates the filter records for the specified sheet.
 488         @descr  Creates and inserts related built-in NAME records. Therefore this
 489             function is called from the name buffer itself. */
 490     void                InitTabFilter( SCTAB nScTab );
 491
 492     /** Returns a record object containing all filter records for the specified sheet. */
 493     XclExpRecordRef     CreateRecord( SCTAB nScTab );
 494
 495     /** Returns whether or not FilterMode is present */
 496     bool                HasFilterMode( SCTAB nScTab );
 497
 498 private:
 499     using               XclExpRoot::CreateRecord;
 500
 501     typedef ScfRef< ExcAutoFilterRecs >             XclExpTabFilterRef;
 502     typedef ::std::map< SCTAB, XclExpTabFilterRef > XclExpTabFilterMap;
 503
 504     XclExpTabFilterMap  maFilterMap;
 505 };
 506
 507
 508 #endif
 509