sc/inc/conditio.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SC_INC_CONDITIO_HXX
  21 #define INCLUDED_SC_INC_CONDITIO_HXX
  22
  23 #include "global.hxx"
  24 #include "address.hxx"
  25 #include <formula/grammar.hxx>
  26 #include "scdllapi.h"
  27 #include "rangelst.hxx"
  28
  29 #include <svl/hint.hxx>
  30 #include <svl/listener.hxx>
  31 #include <svl/broadcast.hxx>
  32
  33 #include <comphelper/stl_types.hxx>
  34
  35 #include <rtl/math.hxx>
  36 #include <tools/date.hxx>
  37
  38 #include <map>
  39 #include <memory>
  40 #include <set>
  41
  42 class ScFormulaCell;
  43 class ScTokenArray;
  44 struct ScRefCellValue;
  45
  46 namespace sc {
  47
  48 struct RefUpdateContext;
  49 struct RefUpdateInsertTabContext;
  50 struct RefUpdateDeleteTabContext;
  51 struct RefUpdateMoveTabContext;
  52
  53 }
  54
  55 //  nOptions Flags
  56 #define SC_COND_NOBLANKS    1
  57
  58 enum ScConditionMode
  59 {
  60     SC_COND_EQUAL,
  61     SC_COND_LESS,
  62     SC_COND_GREATER,
  63     SC_COND_EQLESS,
  64     SC_COND_EQGREATER,
  65     SC_COND_NOTEQUAL,
  66     SC_COND_BETWEEN,
  67     SC_COND_NOTBETWEEN,
  68     SC_COND_DUPLICATE,
  69     SC_COND_NOTDUPLICATE,
  70     SC_COND_DIRECT,
  71     SC_COND_TOP10,
  72     SC_COND_BOTTOM10,
  73     SC_COND_TOP_PERCENT,
  74     SC_COND_BOTTOM_PERCENT,
  75     SC_COND_ABOVE_AVERAGE,
  76     SC_COND_BELOW_AVERAGE,
  77     SC_COND_ABOVE_EQUAL_AVERAGE,
  78     SC_COND_BELOW_EQUAL_AVERAGE,
  79     SC_COND_ERROR,
  80     SC_COND_NOERROR,
  81     SC_COND_BEGINS_WITH,
  82     SC_COND_ENDS_WITH,
  83     SC_COND_CONTAINS_TEXT,
  84     SC_COND_NOT_CONTAINS_TEXT,
  85     SC_COND_NONE
  86 };
  87
  88 class ScFormulaListener : public SvtListener
  89 {
  90 private:
  91     std::vector<ScRange> maCells;
  92     mutable bool mbDirty;
  93     ScDocument* mpDoc;
  94     std::function<void()> maCallbackFunction;
  95
  96     void startListening(ScTokenArray* pTokens, const ScRange& rPos);
  97
  98 public:
  99     explicit ScFormulaListener(ScFormulaCell* pCell);
 100     explicit ScFormulaListener(ScDocument* pDoc);
 101     virtual ~ScFormulaListener() override;
 102
 103     void Notify( const SfxHint& rHint ) override;
 104
 105     bool NeedsRepaint() const;
 106
 107     void addTokenArray(ScTokenArray* pTokens, const ScRange& rRange);
 108     void stopListening();
 109     void setCallback(const std::function<void()>& aCallbackFunction);
 110 };
 111
 112 class ScConditionalFormat;
 113 struct ScDataBarInfo;
 114 struct ScIconSetInfo;
 115
 116 namespace condformat
 117 {
 118
 119 enum ScFormatEntryType
 120 {
 121     CONDITION,
 122     COLORSCALE,
 123     DATABAR,
 124     ICONSET,
 125     DATE
 126 };
 127
 128 }
 129
 130 struct ScCondFormatData
 131 {
 132     ScCondFormatData():
 133         pColorScale(nullptr),
 134         pDataBar(nullptr),
 135         pIconSet(nullptr) {}
 136
 137     Color* pColorScale;
 138     ScDataBarInfo* pDataBar;
 139     ScIconSetInfo* pIconSet;
 140     OUString aStyleName;
 141 };
 142
 143 class SC_DLLPUBLIC ScFormatEntry
 144 {
 145 public:
 146     ScFormatEntry(ScDocument* pDoc);
 147     virtual ~ScFormatEntry() {}
 148
 149     virtual condformat::ScFormatEntryType GetType() const = 0;
 150     virtual void UpdateReference( sc::RefUpdateContext& rCxt ) = 0;
 151     virtual void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt ) = 0;
 152     virtual void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt ) = 0;
 153     virtual void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt ) = 0;
 154
 155     virtual ScFormatEntry* Clone( ScDocument* pDoc ) const = 0;
 156
 157     virtual void SetParent( ScConditionalFormat* pNew ) = 0;
 158
 159     bool operator==( const ScFormatEntry& ) const;
 160
 161     virtual void startRendering();
 162     virtual void endRendering();
 163 protected:
 164     ScDocument* mpDoc;
 165
 166 };
 167
 168 class approx_less : public std::binary_function<double, double, bool>
 169 {
 170 public:
 171     bool operator() (double nVal1, double nVal2) const
 172     {
 173         if(nVal1 < nVal2 && !rtl::math::approxEqual(nVal1, nVal2))
 174             return true;
 175
 176         return false;
 177     }
 178 };
 179
 180 class SC_DLLPUBLIC ScConditionEntry : public ScFormatEntry
 181 {
 182                                         // stored data:
 183     ScConditionMode     eOp;
 184     sal_uInt16              nOptions;
 185     double              nVal1;          // input or calculated
 186     double              nVal2;
 187     OUString              aStrVal1;       // input or calculated
 188     OUString              aStrVal2;
 189     OUString              aStrNmsp1;      // namespace to be used on (re)compilation, e.g. in XML import
 190     OUString              aStrNmsp2;      // namespace to be used on (re)compilation, e.g. in XML import
 191     formula::FormulaGrammar::Grammar eTempGrammar1;  // grammar to be used on (re)compilation, e.g. in XML import
 192     formula::FormulaGrammar::Grammar eTempGrammar2;  // grammar to be used on (re)compilation, e.g. in XML import
 193     bool                bIsStr1;        // for recognition of empty strings
 194     bool                bIsStr2;
 195     ScTokenArray*       pFormula1;      // entered formula
 196     ScTokenArray*       pFormula2;
 197     ScAddress           aSrcPos;        // source position for formulas
 198                                         // temporary data:
 199     OUString              aSrcString;     // formula source position as text during XML import
 200     ScFormulaCell*      pFCell1;
 201     ScFormulaCell*      pFCell2;
 202     bool                bRelRef1;
 203     bool                bRelRef2;
 204     bool                bFirstRun;
 205     std::unique_ptr<ScFormulaListener> mpListener;
 206
 207     void    MakeCells( const ScAddress& rPos );
 208     void    Compile( const OUString& rExpr1, const OUString& rExpr2,
 209                         const OUString& rExprNmsp1, const OUString& rExprNmsp2,
 210                         formula::FormulaGrammar::Grammar eGrammar1,
 211                         formula::FormulaGrammar::Grammar eGrammar2,
 212                         bool bTextToReal );
 213     void    Interpret( const ScAddress& rPos );
 214
 215     bool    IsValid( double nArg, const ScAddress& rPos ) const;
 216     bool    IsValidStr( const OUString& rArg, const ScAddress& rPos ) const;
 217     void    StartListening();
 218
 219 public:
 220             ScConditionEntry( ScConditionMode eOper,
 221                                 const OUString& rExpr1, const OUString& rExpr2,
 222                                 ScDocument* pDocument, const ScAddress& rPos,
 223                                 const OUString& rExprNmsp1, const OUString& rExprNmsp2,
 224                                 formula::FormulaGrammar::Grammar eGrammar1,
 225                                 formula::FormulaGrammar::Grammar eGrammar2 );
 226             ScConditionEntry( ScConditionMode eOper,
 227                                 const ScTokenArray* pArr1, const ScTokenArray* pArr2,
 228                                 ScDocument* pDocument, const ScAddress& rPos );
 229             ScConditionEntry( const ScConditionEntry& r );  // flat copy of formulas
 230             // true copy of formulas (for Ref-Undo):
 231             ScConditionEntry( ScDocument* pDocument, const ScConditionEntry& r );
 232     virtual ~ScConditionEntry() override;
 233
 234     bool            operator== ( const ScConditionEntry& r ) const;
 235
 236     virtual void SetParent( ScConditionalFormat* pNew ) override;
 237
 238     bool IsCellValid( ScRefCellValue& rCell, const ScAddress& rPos ) const;
 239
 240     ScConditionMode GetOperation() const        { return eOp; }
 241     void SetOperation(ScConditionMode eMode);
 242     bool            IsIgnoreBlank() const       { return ( nOptions & SC_COND_NOBLANKS ) == 0; }
 243     void            SetIgnoreBlank(bool bSet);
 244     const ScAddress& GetSrcPos() const           { return aSrcPos; }
 245
 246     ScAddress       GetValidSrcPos() const;     // adjusted to allow textual representation of expressions
 247
 248     void            SetSrcString( const OUString& rNew );     // for XML import
 249
 250     void            SetFormula1( const ScTokenArray& rArray );
 251     void            SetFormula2( const ScTokenArray& rArray );
 252
 253     OUString          GetExpression( const ScAddress& rCursor, sal_uInt16 nPos, sal_uLong nNumFmt = 0,
 254                                     const formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_DEFAULT ) const;
 255
 256                     /** Create a flat copy using ScTokenArray copy-ctor with
 257                         shared tokens. */
 258     ScTokenArray*   CreateFlatCopiedTokenArray( sal_uInt16 nPos ) const;
 259
 260     void            CompileAll();
 261     void            CompileXML();
 262     virtual void UpdateReference( sc::RefUpdateContext& rCxt ) override;
 263     virtual void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt ) override;
 264     virtual void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt ) override;
 265     virtual void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt ) override;
 266
 267     bool            MarkUsedExternalReferences() const;
 268
 269     virtual condformat::ScFormatEntryType GetType() const override { return condformat::CONDITION; }
 270
 271     virtual ScFormatEntry* Clone(ScDocument* pDoc) const override;
 272
 273     static ScConditionMode GetModeFromApi(sal_Int32 nOperator);
 274
 275     virtual void endRendering() override;
 276     virtual void startRendering() override;
 277
 278     bool NeedsRepaint() const;
 279
 280 protected:
 281     virtual void    DataChanged() const;
 282     ScDocument*     GetDocument() const     { return mpDoc; }
 283     ScConditionalFormat*    pCondFormat;
 284
 285 private:
 286
 287     bool IsDuplicate(double nArg, const OUString& rStr) const;
 288     bool IsTopNElement( double nArg ) const;
 289     bool IsTopNPercent( double nArg ) const;
 290     bool IsBottomNElement( double nArg ) const;
 291     bool IsBottomNPercent( double nArg ) const;
 292     bool IsAboveAverage( double nArg, bool bEqual ) const;
 293     bool IsBelowAverage( double nArg, bool bEqual ) const;
 294
 295     bool IsError( const ScAddress& rPos ) const;
 296
 297     void FillCache() const;
 298
 299     struct ScConditionEntryCache
 300     {
 301         typedef std::map<OUString, sal_Int32> StringCacheType;
 302         StringCacheType maStrings;
 303         typedef std::map<double, sal_Int32, approx_less> ValueCacheType;
 304         ValueCacheType maValues;
 305
 306         // cache them for easier access
 307         size_t nValueItems;
 308
 309         ScConditionEntryCache():
 310             nValueItems(0) {}
 311     };
 312
 313     mutable std::unique_ptr<ScConditionEntryCache> mpCache;
 314 };
 315
 316 //  single condition entry for conditional formatting
 317 class SC_DLLPUBLIC ScCondFormatEntry : public ScConditionEntry
 318 {
 319     OUString                  aStyleName;
 320
 321     using ScConditionEntry::operator==;
 322
 323 public:
 324             ScCondFormatEntry( ScConditionMode eOper,
 325                                 const OUString& rExpr1, const OUString& rExpr2,
 326                                 ScDocument* pDocument, const ScAddress& rPos,
 327                                 const OUString& rStyle,
 328                                 const OUString& rExprNmsp1 = EMPTY_OUSTRING,
 329                                 const OUString& rExprNmsp2 = EMPTY_OUSTRING,
 330                                 formula::FormulaGrammar::Grammar eGrammar1 = formula::FormulaGrammar::GRAM_DEFAULT,
 331                                 formula::FormulaGrammar::Grammar eGrammar2 = formula::FormulaGrammar::GRAM_DEFAULT );
 332             ScCondFormatEntry( ScConditionMode eOper,
 333                                 const ScTokenArray* pArr1, const ScTokenArray* pArr2,
 334                                 ScDocument* pDocument, const ScAddress& rPos,
 335                                 const OUString& rStyle );
 336             ScCondFormatEntry( const ScCondFormatEntry& r );
 337             ScCondFormatEntry( ScDocument* pDocument, const ScCondFormatEntry& r );
 338     virtual ~ScCondFormatEntry() override;
 339
 340     bool            operator== ( const ScCondFormatEntry& r ) const;
 341
 342     const OUString&   GetStyle() const        { return aStyleName; }
 343     void            UpdateStyleName(const OUString& rNew)  { aStyleName=rNew; }
 344     virtual ScFormatEntry* Clone(ScDocument* pDoc) const override;
 345
 346 protected:
 347     virtual void    DataChanged() const override;
 348 };
 349
 350 namespace condformat {
 351
 352 enum ScCondFormatDateType
 353 {
 354     TODAY,
 355     YESTERDAY,
 356     TOMORROW,
 357     LAST7DAYS,
 358     THISWEEK,
 359     LASTWEEK,
 360     NEXTWEEK,
 361     THISMONTH,
 362     LASTMONTH,
 363     NEXTMONTH,
 364     THISYEAR,
 365     LASTYEAR,
 366     NEXTYEAR
 367 };
 368
 369 }
 370
 371 class SC_DLLPUBLIC ScCondDateFormatEntry : public ScFormatEntry
 372 {
 373 public:
 374     ScCondDateFormatEntry(ScDocument* pDoc);
 375     ScCondDateFormatEntry(ScDocument* pDoc, const ScCondDateFormatEntry& rEntry);
 376
 377     bool IsValid( const ScAddress& rPos ) const;
 378
 379     void SetDateType(condformat::ScCondFormatDateType eType);
 380     condformat::ScCondFormatDateType GetDateType() const { return meType;}
 381
 382     const OUString& GetStyleName() const { return maStyleName;}
 383     void SetStyleName( const OUString& rStyleName );
 384
 385     virtual condformat::ScFormatEntryType GetType() const override { return condformat::DATE; }
 386     virtual void UpdateReference( sc::RefUpdateContext& ) override {}
 387     virtual void UpdateInsertTab( sc::RefUpdateInsertTabContext& ) override {}
 388     virtual void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& ) override {}
 389     virtual void UpdateMoveTab( sc::RefUpdateMoveTabContext& ) override {}
 390
 391     virtual ScFormatEntry* Clone( ScDocument* pDoc ) const override;
 392
 393     virtual void SetParent( ScConditionalFormat* ) override {}
 394
 395     virtual void startRendering() override;
 396     virtual void endRendering() override;
 397
 398 private:
 399     condformat::ScCondFormatDateType meType;
 400
 401     mutable std::unique_ptr<Date> mpCache;
 402
 403     OUString maStyleName;
 404 };
 405
 406 //  complete conditional formatting
 407 class SC_DLLPUBLIC ScConditionalFormat
 408 {
 409     ScDocument*         pDoc;
 410     sal_uInt32          nKey;               // Index in attributes
 411
 412     typedef std::vector<std::unique_ptr<ScFormatEntry>> CondFormatContainer;
 413     CondFormatContainer maEntries;
 414     ScRangeList maRanges;            // Ranges for conditional format
 415
 416 public:
 417     ScConditionalFormat(sal_uInt32 nNewKey, ScDocument* pDocument);
 418     ~ScConditionalFormat();
 419      ScConditionalFormat(const ScConditionalFormat&) = delete;
 420      const ScConditionalFormat& operator=(const ScConditionalFormat&) = delete;
 421
 422     // true copy of formulas (for Ref-Undo / between documents)
 423     ScConditionalFormat* Clone(ScDocument* pNewDoc = nullptr) const;
 424
 425     void            AddEntry( ScFormatEntry* pNew );
 426     void RemoveEntry(size_t nIndex);
 427     void            SetRange( const ScRangeList& rRanges );
 428     const ScRangeList&  GetRange() const  { return maRanges; }
 429     // don't use the same name as for the const version
 430     ScRangeList& GetRangeList() { return maRanges; }
 431
 432     bool IsEmpty() const;
 433     size_t size() const;
 434
 435     void            CompileAll();
 436     void            CompileXML();
 437     void UpdateReference( sc::RefUpdateContext& rCxt, bool bCopyAsMove = false );
 438     void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt );
 439     void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt );
 440     void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt );
 441
 442     void InsertRow(SCTAB nTab, SCCOL nColStart, SCCOL nColEnd, SCROW nRowStart, SCSIZE nSize);
 443     void InsertCol(SCTAB nTab, SCROW nRowStart, SCROW nRowEnd, SCCOL nColStart, SCSIZE nSize);
 444
 445     void            DeleteArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
 446     void            RenameCellStyle( const OUString& rOld, const OUString& rNew );
 447
 448     const ScFormatEntry* GetEntry( sal_uInt16 nPos ) const;
 449
 450     const OUString& GetCellStyle( ScRefCellValue& rCell, const ScAddress& rPos ) const;
 451
 452     ScCondFormatData GetData( ScRefCellValue& rCell, const ScAddress& rPos ) const;
 453
 454     bool            EqualEntries( const ScConditionalFormat& r ) const;
 455
 456     void            DoRepaint();
 457
 458     sal_uInt32      GetKey() const          { return nKey; }
 459     void            SetKey(sal_uInt32 nNew) { nKey = nNew; }    // only if not inserted!
 460
 461     bool            MarkUsedExternalReferences() const;
 462
 463     //  sorted (via std::set) by Index
 464     bool operator < ( const ScConditionalFormat& r ) const  { return nKey <  r.nKey; }
 465
 466     void startRendering();
 467     void endRendering();
 468 };
 469
 470 //  List of all conditional formats in a sheet
 471 class SC_DLLPUBLIC ScConditionalFormatList
 472 {
 473 private:
 474     typedef std::set<std::unique_ptr<ScConditionalFormat>,
 475         comphelper::UniquePtrValueLess<ScConditionalFormat>> ConditionalFormatContainer;
 476     ConditionalFormatContainer m_ConditionalFormats;
 477
 478     void operator =(ScConditionalFormatList const &) = delete;
 479
 480 public:
 481     ScConditionalFormatList() {}
 482     ScConditionalFormatList(const ScConditionalFormatList& rList);
 483     ScConditionalFormatList(ScDocument* pDoc, const ScConditionalFormatList& rList);
 484     ~ScConditionalFormatList() {}
 485
 486     void    InsertNew( ScConditionalFormat* pNew );
 487
 488     /**
 489      * Checks that all cond formats have a non empty range.
 490      * Deletes empty cond formats.
 491      * @return true if all cond formats were valid
 492      */
 493     bool    CheckAllEntries();
 494
 495     ScConditionalFormat* GetFormat( sal_uInt32 nKey );
 496     const ScConditionalFormat* GetFormat( sal_uInt32 nKey ) const;
 497
 498     void    CompileAll();
 499     void    CompileXML();
 500     void UpdateReference( sc::RefUpdateContext& rCxt );
 501     void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt );
 502     void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt );
 503     void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt );
 504
 505     void InsertRow(SCTAB nTab, SCCOL nColStart, SCCOL nColEnd, SCROW nRowStart, SCSIZE nSize);
 506     void InsertCol(SCTAB nTab, SCROW nRowStart, SCROW nRowEnd, SCCOL nColStart, SCSIZE nSize);
 507
 508     void    RenameCellStyle( const OUString& rOld, const OUString& rNew );
 509     void    DeleteArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
 510
 511     typedef ConditionalFormatContainer::iterator iterator;
 512     typedef ConditionalFormatContainer::const_iterator const_iterator;
 513
 514     iterator begin();
 515     const_iterator begin() const;
 516     iterator end();
 517     const_iterator end() const;
 518
 519     size_t size() const;
 520
 521     void erase(sal_uLong nIndex);
 522     void clear();
 523
 524     void startRendering();
 525     void endRendering();
 526
 527     sal_uInt32 getMaxKey() const;
 528 };
 529
 530 #endif
 531
 532 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */