sc/inc/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.13.32.4 $
  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 #include "global.hxx"
  35 #include "address.hxx"
  36 #include "formula/grammar.hxx"
  37 #include <svtools/svarray.hxx>
  38 #include "scdllapi.h"
  39
  40 class ScBaseCell;
  41 class ScFormulaCell;
  42 class ScTokenArray;
  43 class ScRangeList;
  44
  45
  46 #define SC_COND_GROW 16
  47
  48 //      nOptions Flags
  49 #define SC_COND_NOBLANKS        1
  50
  51
  52             // Reihenfolge von ScConditionMode wie ScQueryOp,
  53             // damit einmal zusammengefasst werden kann:
  54
  55 enum ScConditionMode
  56 {
  57     SC_COND_EQUAL,
  58     SC_COND_LESS,
  59     SC_COND_GREATER,
  60     SC_COND_EQLESS,
  61     SC_COND_EQGREATER,
  62     SC_COND_NOTEQUAL,
  63     SC_COND_BETWEEN,
  64     SC_COND_NOTBETWEEN,
  65     SC_COND_DIRECT,
  66     SC_COND_NONE
  67 };
  68
  69 enum ScConditionValType
  70 {
  71     SC_VAL_VALUE,
  72     SC_VAL_STRING,
  73     SC_VAL_FORMULA
  74 };
  75
  76 class SC_DLLPUBLIC ScConditionEntry
  77 {
  78                                         // gespeicherte Daten:
  79     ScConditionMode             eOp;
  80     USHORT                              nOptions;
  81     double                              nVal1;                  // eingegeben oder berechnet
  82     double                              nVal2;
  83     String                              aStrVal1;               // eingegeben oder berechnet
  84     String                              aStrVal2;
  85     String              aStrNmsp1;      // namespace to be used on (re)compilation, e.g. in XML import
  86     String              aStrNmsp2;      // namespace to be used on (re)compilation, e.g. in XML import
  87     formula::FormulaGrammar::Grammar eTempGrammar1;  // grammar to be used on (re)compilation, e.g. in XML import
  88     formula::FormulaGrammar::Grammar eTempGrammar2;  // grammar to be used on (re)compilation, e.g. in XML import
  89     BOOL                                bIsStr1;                // um auch leere Strings zu erkennen
  90     BOOL                                bIsStr2;
  91     ScTokenArray*               pFormula1;              // eingegebene Formel
  92     ScTokenArray*               pFormula2;
  93     ScAddress           aSrcPos;        // source position for formulas
  94                                         // temporary data:
  95     String              aSrcString;     // formula source position as text during XML import
  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,
 105                         const String& rExprNmsp1, const String& rExprNmsp2,
 106                         formula::FormulaGrammar::Grammar eGrammar1,
 107                         formula::FormulaGrammar::Grammar eGrammar2,
 108                         BOOL bTextToReal );
 109     void        Interpret( const ScAddress& rPos );
 110
 111     BOOL        IsValid( double nArg ) const;
 112     BOOL        IsValidStr( const String& rArg ) const;
 113
 114 public:
 115             ScConditionEntry( ScConditionMode eOper,
 116                                 const String& rExpr1, const String& rExpr2,
 117                                 ScDocument* pDocument, const ScAddress& rPos,
 118                                 const String& rExprNmsp1, const String& rExprNmsp2,
 119                                 formula::FormulaGrammar::Grammar eGrammar1,
 120                                 formula::FormulaGrammar::Grammar eGrammar2 );
 121             ScConditionEntry( ScConditionMode eOper,
 122                                 const ScTokenArray* pArr1, const ScTokenArray* pArr2,
 123                                 ScDocument* pDocument, const ScAddress& rPos );
 124             ScConditionEntry( const ScConditionEntry& r );      // flache Kopie der Formeln
 125             // echte Kopie der Formeln (fuer Ref-Undo):
 126             ScConditionEntry( ScDocument* pDocument, const ScConditionEntry& r );
 127     virtual ~ScConditionEntry();
 128
 129     int                         operator== ( const ScConditionEntry& r ) const;
 130
 131     BOOL                        IsCellValid( ScBaseCell* pCell, const ScAddress& rPos ) const;
 132
 133     ScConditionMode     GetOperation() const            { return eOp; }
 134     BOOL                        IsIgnoreBlank() const           { return ( nOptions & SC_COND_NOBLANKS ) == 0; }
 135     void                        SetIgnoreBlank(BOOL bSet);
 136     ScAddress           GetSrcPos() const                       { return aSrcPos; }
 137
 138     ScAddress       GetValidSrcPos() const;     // adjusted to allow textual representation of expressions
 139
 140     void            SetSrcString( const String& rNew );     // for XML import
 141
 142     void            SetFormula1( const ScTokenArray& rArray );
 143     void            SetFormula2( const ScTokenArray& rArray );
 144
 145     String                      GetExpression( const ScAddress& rCursor, USHORT nPos, ULONG nNumFmt = 0,
 146                                     const formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_DEFAULT ) const;
 147
 148     ScTokenArray*       CreateTokenArry( USHORT nPos ) const;
 149
 150     void                        CompileAll();
 151     void                        CompileXML();
 152     void                        UpdateReference( UpdateRefMode eUpdateRefMode,
 153                                 const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz );
 154     void                        UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos );
 155
 156     void                        SourceChanged( const ScAddress& rChanged );
 157
 158     bool            MarkUsedExternalReferences() const;
 159
 160 protected:
 161     virtual void        DataChanged( const ScRange* pModified ) const;
 162     ScDocument*         GetDocument() const             { return pDoc; }
 163 };
 164
 165 //
 166 //      einzelner Eintrag fuer bedingte Formatierung
 167 //
 168
 169 class ScConditionalFormat;
 170
 171 class SC_DLLPUBLIC ScCondFormatEntry : public ScConditionEntry
 172 {
 173     String                                      aStyleName;
 174     ScConditionalFormat*        pParent;
 175
 176     using ScConditionEntry::operator==;
 177
 178 public:
 179             ScCondFormatEntry( ScConditionMode eOper,
 180                                 const String& rExpr1, const String& rExpr2,
 181                                 ScDocument* pDocument, const ScAddress& rPos,
 182                                 const String& rStyle,
 183                                 const String& rExprNmsp1 = EMPTY_STRING,
 184                                 const String& rExprNmsp2 = EMPTY_STRING,
 185                                 formula::FormulaGrammar::Grammar eGrammar1 = formula::FormulaGrammar::GRAM_DEFAULT,
 186                                 formula::FormulaGrammar::Grammar eGrammar2 = formula::FormulaGrammar::GRAM_DEFAULT );
 187             ScCondFormatEntry( ScConditionMode eOper,
 188                                 const ScTokenArray* pArr1, const ScTokenArray* pArr2,
 189                                 ScDocument* pDocument, const ScAddress& rPos,
 190                                 const String& rStyle );
 191             ScCondFormatEntry( const ScCondFormatEntry& r );
 192             ScCondFormatEntry( ScDocument* pDocument, const ScCondFormatEntry& r );
 193     virtual     ~ScCondFormatEntry();
 194
 195     void                        SetParent( ScConditionalFormat* pNew )  { pParent = pNew; }
 196
 197     int                         operator== ( const ScCondFormatEntry& r ) const;
 198
 199     const String&       GetStyle() const                { return aStyleName; }
 200     void                        UpdateStyleName(const String& rNew)  { aStyleName=rNew; }
 201
 202 protected:
 203     virtual void        DataChanged( const ScRange* pModified ) const;
 204 };
 205
 206 //
 207 //      komplette bedingte Formatierung
 208 //
 209
 210 class SC_DLLPUBLIC ScConditionalFormat
 211 {
 212     ScDocument*                 pDoc;
 213     ScRangeList*                pAreas;                         // Bereiche fuer Paint
 214     sal_uInt32                  nKey;                           // Index in Attributen
 215     ScCondFormatEntry** ppEntries;
 216     USHORT                              nEntryCount;
 217     BOOL                                bIsUsed;                        // temporaer beim Speichern
 218
 219 public:
 220             ScConditionalFormat(sal_uInt32 nNewKey, ScDocument* pDocument);
 221             ScConditionalFormat(const ScConditionalFormat& r);
 222             ~ScConditionalFormat();
 223
 224     // echte Kopie der Formeln (fuer Ref-Undo / zwischen Dokumenten)
 225     ScConditionalFormat* Clone(ScDocument* pNewDoc = NULL) const;
 226
 227     void                        AddEntry( const ScCondFormatEntry& rNew );
 228
 229     BOOL                        IsEmpty() const                 { return (nEntryCount == 0); }
 230     USHORT                      Count() const                   { return nEntryCount; }
 231
 232     void                        CompileAll();
 233     void                        CompileXML();
 234     void                        UpdateReference( UpdateRefMode eUpdateRefMode,
 235                                 const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz );
 236     void                        UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos );
 237     void                        RenameCellStyle( const String& rOld, const String& rNew );
 238
 239     void                        SourceChanged( const ScAddress& rAddr );
 240
 241     const ScCondFormatEntry* GetEntry( USHORT nPos ) const;
 242
 243     const String&       GetCellStyle( ScBaseCell* pCell, const ScAddress& rPos ) const;
 244
 245     BOOL                        EqualEntries( const ScConditionalFormat& r ) const;
 246
 247     void                        DoRepaint( const ScRange* pModified );
 248     void                        InvalidateArea();
 249
 250     sal_uInt32          GetKey() const                  { return nKey; }
 251     void                        SetKey(sal_uInt32 nNew) { nKey = nNew; }        // nur wenn nicht eingefuegt!
 252
 253     void                        SetUsed(BOOL bSet)              { bIsUsed = bSet; }
 254     BOOL                        IsUsed() const                  { return bIsUsed; }
 255
 256     bool            MarkUsedExternalReferences() const;
 257
 258     //  sortiert (per PTRARR) nach Index
 259     //  operator== nur fuer die Sortierung
 260     BOOL operator ==( const ScConditionalFormat& r ) const      { return nKey == r.nKey; }
 261     BOOL operator < ( const ScConditionalFormat& r ) const      { return nKey <  r.nKey; }
 262 };
 263
 264 //
 265 //      Liste der Bereiche und Formate:
 266 //
 267
 268 typedef ScConditionalFormat* ScConditionalFormatPtr;
 269
 270 SV_DECL_PTRARR_SORT(ScConditionalFormats_Impl, ScConditionalFormatPtr,
 271                         SC_COND_GROW, SC_COND_GROW)
 272
 273 class ScConditionalFormatList : public ScConditionalFormats_Impl
 274 {
 275 public:
 276         ScConditionalFormatList() {}
 277         ScConditionalFormatList(const ScConditionalFormatList& rList);
 278         ScConditionalFormatList(ScDocument* pNewDoc, const ScConditionalFormatList& rList);
 279         ~ScConditionalFormatList() {}
 280
 281     void        InsertNew( ScConditionalFormat* pNew )
 282                 { if (!Insert(pNew)) delete pNew; }
 283
 284     ScConditionalFormat* GetFormat( sal_uInt32 nKey );
 285
 286     void        CompileAll();
 287     void        CompileXML();
 288     void        UpdateReference( UpdateRefMode eUpdateRefMode,
 289                                 const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz );
 290     void        RenameCellStyle( const String& rOld, const String& rNew );
 291     void        UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos );
 292
 293     void        SourceChanged( const ScAddress& rAddr );
 294
 295     /** Temporarily during save, returns RefManager's decision whether ALL
 296      *  references are marked now. */
 297     bool    MarkUsedExternalReferences() const;
 298
 299     BOOL        operator==( const ScConditionalFormatList& r ) const;           // fuer Ref-Undo
 300 };
 301
 302 #endif
 303
 304