binfilter/inc/bf_sc/conditio.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: conditio.hxx,v $
  10  * $Revision: 1.8 $
  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_CONDITIO_HXX
  32 #define SC_CONDITIO_HXX
  33
  34 #ifndef SC_SCGLOB_HXX
  35 #include "global.hxx"
  36 #endif
  37
  38 #ifndef _SVARRAY_HXX //autogen
  39 #include <bf_svtools/svarray.hxx>
  40 #endif
  41 namespace binfilter {
  42
  43 class ScBaseCell;
  44 class ScFormulaCell;
  45 class ScTokenArray;
  46 class ScMultipleReadHeader;
  47 class ScMultipleWriteHeader;
  48 class ScRangeList;
  49
  50
  51 #define SC_COND_GROW 16
  52
  53 //      nOptions Flags
  54 #define SC_COND_NOBLANKS        1
  55
  56
  57             // Reihenfolge von ScConditionMode wie ScQueryOp,
  58             // damit einmal zusammengefasst werden kann:
  59
  60 enum ScConditionMode
  61 {
  62     SC_COND_EQUAL,
  63     SC_COND_LESS,
  64     SC_COND_GREATER,
  65     SC_COND_EQLESS,
  66     SC_COND_EQGREATER,
  67     SC_COND_NOTEQUAL,
  68     SC_COND_BETWEEN,
  69     SC_COND_NOTBETWEEN,
  70     SC_COND_DIRECT,
  71     SC_COND_NONE
  72 };
  73
  74 enum ScConditionValType
  75 {
  76     SC_VAL_VALUE,
  77     SC_VAL_STRING,
  78     SC_VAL_FORMULA
  79 };
  80
  81 class ScConditionEntry
  82 {
  83                                         // gespeicherte Daten:
  84     ScConditionMode             eOp;
  85     USHORT                              nOptions;
  86     double                              nVal1;                  // eingegeben oder berechnet
  87     double                              nVal2;
  88     String                              aStrVal1;               // eingegeben oder berechnet
  89     String                              aStrVal2;
  90     BOOL                                bIsStr1;                // um auch leere Strings zu erkennen
  91     BOOL                                bIsStr2;
  92     ScTokenArray*               pFormula1;              // eingegebene Formel
  93     ScTokenArray*               pFormula2;
  94     ScAddress                   aSrcPos;                // Quell-Adresse fuer Formeln
  95                                         // temporaere Daten:
  96     ScFormulaCell*              pFCell1;
  97     ScFormulaCell*              pFCell2;
  98     ScDocument*                 pDoc;
  99     BOOL                                bRelRef1;
 100     BOOL                                bRelRef2;
 101     BOOL                                bFirstRun;
 102
 103     void        MakeCells( const ScAddress& rPos );
 104     void        Compile( const String& rExpr1, const String& rExpr2, BOOL bEnglish,
 105                         BOOL bCompileXML, BOOL bTextToReal );
 106     void        Interpret( const ScAddress& rPos );
 107
 108     BOOL        IsValid( double nArg ) const;
 109
 110 protected:
 111             ScConditionEntry( SvStream& rStream, ScMultipleReadHeader& rHdr,
 112                                 ScDocument* pDocument );
 113     void        StoreCondition(SvStream& rStream, ScMultipleWriteHeader& rHdr) const;
 114
 115 public:
 116             ScConditionEntry( ScConditionMode eOper,
 117                                 const String& rExpr1, const String& rExpr2,
 118                                 ScDocument* pDocument, const ScAddress& rPos,
 119                                 BOOL bCompileEnglish, BOOL bCompileXML );
 120             ScConditionEntry( const ScConditionEntry& r );      // flache Kopie der Formeln
 121             // echte Kopie der Formeln (fuer Ref-Undo):
 122             ScConditionEntry( ScDocument* pDocument, const ScConditionEntry& r );
 123             ~ScConditionEntry();
 124
 125     int                         operator== ( const ScConditionEntry& r ) const;
 126
 127     BOOL                        IsCellValid( ScBaseCell* pCell, const ScAddress& rPos ) const;
 128
 129     ScConditionMode     GetOperation() const            { return eOp; }
 130     BOOL                        IsIgnoreBlank() const           { return ( nOptions & SC_COND_NOBLANKS ) == 0; }
 131     void                        SetIgnoreBlank(BOOL bSet);
 132     ScAddress           GetSrcPos() const                       { return aSrcPos; }
 133
 134     String                      GetExpression( const ScAddress& rCursor, USHORT nPos, ULONG nNumFmt = 0,
 135                                     BOOL bEnglish = FALSE, BOOL bCompileXML = FALSE,
 136                                     BOOL bTextToReal = FALSE ) const;
 137
 138
 139     void                        CompileXML();
 140     void                        UpdateReference( UpdateRefMode eUpdateRefMode,
 141                                 const ScRange& rRange, short nDx, short nDy, short nDz );
 142
 143     void                        SourceChanged( const ScAddress& rChanged );
 144
 145 protected:
 146     virtual void        DataChanged( const ScRange* pModified ) const;
 147     ScDocument*         GetDocument() const             { return pDoc; }
 148 };
 149
 150 //
 151 //      einzelner Eintrag fuer bedingte Formatierung
 152 //
 153
 154 class ScConditionalFormat;
 155
 156 class ScCondFormatEntry : public ScConditionEntry
 157 {
 158     String                                      aStyleName;
 159     ScConditionalFormat*        pParent;
 160
 161 public:
 162             ScCondFormatEntry( ScConditionMode eOper,
 163                                 const String& rExpr1, const String& rExpr2,
 164                                 ScDocument* pDocument, const ScAddress& rPos,
 165                                 const String& rStyle,
 166                                 BOOL bCompileEnglish = FALSE, BOOL bCompileXML = FALSE );
 167             ScCondFormatEntry( const ScCondFormatEntry& r );
 168             ScCondFormatEntry( ScDocument* pDocument, const ScCondFormatEntry& r );
 169             ScCondFormatEntry( SvStream& rStream, ScMultipleReadHeader& rHdr,
 170                                 ScDocument* pDocument );
 171             ~ScCondFormatEntry();
 172
 173     void                        SetParent( ScConditionalFormat* pNew )  { pParent = pNew; }
 174
 175     void                        Store(SvStream& rStream, ScMultipleWriteHeader& rHdr) const;
 176
 177     int                         operator== ( const ScCondFormatEntry& r ) const;
 178
 179     const String&       GetStyle() const                { return aStyleName; }
 180
 181 protected:
 182     virtual void        DataChanged( const ScRange* pModified ) const;
 183 };
 184
 185 //
 186 //      komplette bedingte Formatierung
 187 //
 188
 189 class ScConditionalFormat
 190 {
 191     ScDocument*                 pDoc;
 192     ScRangeList*                pAreas;                         // Bereiche fuer Paint
 193     sal_uInt32                  nKey;                           // Index in Attributen
 194     ScCondFormatEntry** ppEntries;
 195     USHORT                              nEntryCount;
 196     BOOL                                bIsUsed;                        // temporaer beim Speichern
 197
 198 public:
 199             ScConditionalFormat(sal_uInt32 nNewKey, ScDocument* pDocument);
 200             ScConditionalFormat(const ScConditionalFormat& r);
 201             ScConditionalFormat(SvStream& rStream, ScMultipleReadHeader& rHdr,
 202                                 ScDocument* pDocument);
 203             ~ScConditionalFormat();
 204
 205     // echte Kopie der Formeln (fuer Ref-Undo / zwischen Dokumenten)
 206     ScConditionalFormat* Clone(ScDocument* pNewDoc = NULL) const;
 207
 208     void                        Store(SvStream& rStream, ScMultipleWriteHeader& rHdr) const;
 209
 210     void                        AddEntry( const ScCondFormatEntry& rNew );
 211
 212     BOOL                        IsEmpty() const                 { return (nEntryCount == 0); }
 213     USHORT                      Count() const                   { return nEntryCount; }
 214
 215     void                        CompileXML();
 216     void                        UpdateReference( UpdateRefMode eUpdateRefMode,
 217                                 const ScRange& rRange, short nDx, short nDy, short nDz );
 218
 219     void                        SourceChanged( const ScAddress& rAddr );
 220
 221     const ScCondFormatEntry* GetEntry( USHORT nPos ) const;
 222
 223     const String&       GetCellStyle( ScBaseCell* pCell, const ScAddress& rPos ) const;
 224
 225     BOOL                        EqualEntries( const ScConditionalFormat& r ) const;
 226
 227     void                        DoRepaint( const ScRange* pModified );
 228     void                        InvalidateArea();
 229
 230     sal_uInt32          GetKey() const                  { return nKey; }
 231     void                        SetKey(sal_uInt32 nNew) { nKey = nNew; }        // nur wenn nicht eingefuegt!
 232
 233     void                        SetUsed(BOOL bSet)              { bIsUsed = bSet; }
 234     BOOL                        IsUsed() const                  { return bIsUsed; }
 235
 236     //  sortiert (per PTRARR) nach Index
 237     //  operator== nur fuer die Sortierung
 238     BOOL operator ==( const ScConditionalFormat& r ) const      { return nKey == r.nKey; }
 239     BOOL operator < ( const ScConditionalFormat& r ) const      { return nKey <  r.nKey; }
 240 };
 241
 242 //
 243 //      Liste der Bereiche und Formate:
 244 //
 245
 246 typedef ScConditionalFormat* ScConditionalFormatPtr;
 247
 248 SV_DECL_PTRARR_SORT(ScConditionalFormats_Impl, ScConditionalFormatPtr,
 249                         SC_COND_GROW, SC_COND_GROW)//STRIP008 ;
 250
 251 class ScConditionalFormatList : public ScConditionalFormats_Impl
 252 {
 253 public:
 254         ScConditionalFormatList() {}
 255         ScConditionalFormatList(const ScConditionalFormatList& rList);
 256         ~ScConditionalFormatList() {}
 257
 258     void        InsertNew( ScConditionalFormat* pNew )
 259                 { if (!Insert(pNew)) delete pNew; }
 260
 261     ScConditionalFormat* GetFormat( sal_uInt32 nKey );
 262
 263     void        Load( SvStream& rStream, ScDocument* pDocument );
 264     void        Store( SvStream& rStream ) const;
 265     void        ResetUsed();
 266
 267     void        CompileXML();
 268     void        UpdateReference( UpdateRefMode eUpdateRefMode,
 269                                 const ScRange& rRange, short nDx, short nDy, short nDz );
 270
 271     void        SourceChanged( const ScAddress& rAddr );
 272
 273 };
 274
 275 } //namespace binfilter
 276 #endif
 277
 278