sc/source/core/data/colorscale.cxx

   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
  10 #include <memory>
  11 #include <colorscale.hxx>
  12 #include <document.hxx>
  13 #include <formulacell.hxx>
  14 #include <fillinfo.hxx>
  15 #include <bitmaps.hlst>
  16 #include <tokenarray.hxx>
  17 #include <refupdatecontext.hxx>
  18 #include <refdata.hxx>
  19
  20 #include <formula/token.hxx>
  21 #include <vcl/bitmapex.hxx>
  22
  23 #include <algorithm>
  24 #include <cassert>
  25 #include <string_view>
  26
  27 ScFormulaListener::ScFormulaListener(ScFormulaCell* pCell):
  28     mbDirty(false),
  29     mrDoc(pCell->GetDocument())
  30 {
  31     startListening( pCell->GetCode(), pCell->aPos );
  32 }
  33
  34 ScFormulaListener::ScFormulaListener(ScDocument& rDoc):
  35     mbDirty(false),
  36     mrDoc(rDoc)
  37 {
  38 }
  39
  40 ScFormulaListener::ScFormulaListener(ScDocument& rDoc, const ScRangeList& rRange):
  41     mbDirty(false),
  42     mrDoc(rDoc)
  43 {
  44     startListening(rRange);
  45 }
  46
  47 void ScFormulaListener::startListening(const ScTokenArray* pArr, const ScRange& rRange)
  48 {
  49     if (!pArr || mrDoc.IsClipOrUndo())
  50         return;
  51
  52     for ( auto t: pArr->References() )
  53     {
  54         switch (t->GetType())
  55         {
  56             case formula::svSingleRef:
  57             {
  58                 ScAddress aCell = t->GetSingleRef()->toAbs(mrDoc, rRange.aStart);
  59                 ScAddress aCell2 = t->GetSingleRef()->toAbs(mrDoc, rRange.aEnd);
  60                 ScRange aRange(aCell, aCell2);
  61                 if (aRange.IsValid())
  62                     mrDoc.StartListeningArea(aRange, false, this);
  63             }
  64             break;
  65             case formula::svDoubleRef:
  66             {
  67                 const ScSingleRefData& rRef1 = *t->GetSingleRef();
  68                 const ScSingleRefData& rRef2 = *t->GetSingleRef2();
  69                 ScAddress aCell1 = rRef1.toAbs(mrDoc, rRange.aStart);
  70                 ScAddress aCell2 = rRef2.toAbs(mrDoc, rRange.aStart);
  71                 ScAddress aCell3 = rRef1.toAbs(mrDoc, rRange.aEnd);
  72                 ScAddress aCell4 = rRef2.toAbs(mrDoc, rRange.aEnd);
  73                 ScRange aRange1(aCell1, aCell3);
  74                 ScRange aRange2(aCell2, aCell4);
  75                 aRange1.ExtendTo(aRange2);
  76                 if (aRange1.IsValid())
  77                 {
  78                     if (t->GetOpCode() == ocColRowNameAuto)
  79                     {   // automagically
  80                         if ( rRef1.IsColRel() )
  81                         {   // ColName
  82                             aRange1.aEnd.SetRow(mrDoc.MaxRow());
  83                         }
  84                         else
  85                         {   // RowName
  86                             aRange1.aEnd.SetCol(mrDoc.MaxCol());
  87                         }
  88                     }
  89                     mrDoc.StartListeningArea(aRange1, false, this);
  90                 }
  91             }
  92             break;
  93             default:
  94                 ;   // nothing
  95         }
  96     }
  97 }
  98
  99 void ScFormulaListener::startListening(const ScRangeList& rRange)
 100 {
 101     if (mrDoc.IsClipOrUndo())
 102         return;
 103
 104     size_t nLength = rRange.size();
 105     for (size_t i = 0; i < nLength; ++i)
 106     {
 107         const ScRange& aRange = rRange[i];
 108         mrDoc.StartListeningArea(aRange, false, this);
 109     }
 110 }
 111
 112 void ScFormulaListener::addTokenArray(const ScTokenArray* pArray, const ScRange& rRange)
 113 {
 114     startListening(pArray, rRange);
 115 }
 116
 117 void ScFormulaListener::setCallback(const std::function<void()>& aCallback)
 118 {
 119     maCallbackFunction = aCallback;
 120 }
 121
 122 void ScFormulaListener::stopListening()
 123 {
 124     if (mrDoc.IsClipOrUndo())
 125         return;
 126
 127     EndListeningAll();
 128 }
 129
 130 ScFormulaListener::~ScFormulaListener()
 131 {
 132     stopListening();
 133 }
 134
 135 void ScFormulaListener::Notify(const SfxHint& rHint)
 136 {
 137     mbDirty = true;
 138
 139     if (rHint.GetId() == SfxHintId::Dying)
 140         return;
 141
 142     if (maCallbackFunction)
 143         maCallbackFunction();
 144 }
 145
 146 bool ScFormulaListener::NeedsRepaint() const
 147 {
 148     bool bRet = mbDirty;
 149     mbDirty = false;
 150     return bRet;
 151 }
 152
 153 ScColorScaleEntry::ScColorScaleEntry():
 154     mnVal(0),
 155     mpFormat(nullptr),
 156     meType(COLORSCALE_VALUE)
 157 {
 158 }
 159
 160 ScColorScaleEntry::ScColorScaleEntry(double nVal, const Color& rCol, ScColorScaleEntryType eType):
 161     mnVal(nVal),
 162     mpFormat(nullptr),
 163     maColor(rCol),
 164     meType(eType)
 165 {
 166 }
 167
 168 ScColorScaleEntry::ScColorScaleEntry(const ScColorScaleEntry& rEntry):
 169     mnVal(rEntry.mnVal),
 170     mpFormat(rEntry.mpFormat),
 171     maColor(rEntry.maColor),
 172     meType(rEntry.meType)
 173 {
 174     setListener();
 175     if(rEntry.mpCell)
 176     {
 177         mpCell.reset(new ScFormulaCell(*rEntry.mpCell, rEntry.mpCell->GetDocument(), rEntry.mpCell->aPos, ScCloneFlags::NoMakeAbsExternal));
 178         mpCell->StartListeningTo(mpCell->GetDocument());
 179         mpListener.reset(new ScFormulaListener(mpCell.get()));
 180     }
 181 }
 182
 183 ScColorScaleEntry::ScColorScaleEntry(ScDocument* pDoc, const ScColorScaleEntry& rEntry):
 184     mnVal(rEntry.mnVal),
 185     mpFormat(rEntry.mpFormat),
 186     maColor(rEntry.maColor),
 187     meType(rEntry.meType)
 188 {
 189     setListener();
 190     if(rEntry.mpCell)
 191     {
 192         mpCell.reset(new ScFormulaCell(*rEntry.mpCell, *pDoc, rEntry.mpCell->aPos, ScCloneFlags::NoMakeAbsExternal));
 193         mpCell->StartListeningTo( *pDoc );
 194         mpListener.reset(new ScFormulaListener(mpCell.get()));
 195         if (mpFormat)
 196             mpListener->setCallback([&]() { mpFormat->DoRepaint();});
 197     }
 198 }
 199
 200 ScColorScaleEntry::~ScColorScaleEntry() COVERITY_NOEXCEPT_FALSE
 201 {
 202     if(mpCell)
 203         mpCell->EndListeningTo(mpCell->GetDocument());
 204 }
 205
 206 void ScColorScaleEntry::SetFormula( const OUString& rFormula, ScDocument& rDoc, const ScAddress& rAddr, formula::FormulaGrammar::Grammar eGrammar )
 207 {
 208     mpCell.reset(new ScFormulaCell( rDoc, rAddr, rFormula, eGrammar ));
 209     mpCell->StartListeningTo( rDoc );
 210     mpListener.reset(new ScFormulaListener(mpCell.get()));
 211     if (mpFormat)
 212         mpListener->setCallback([&]() { mpFormat->DoRepaint();});
 213 }
 214
 215 const ScTokenArray* ScColorScaleEntry::GetFormula() const
 216 {
 217     if(mpCell)
 218     {
 219         return mpCell->GetCode();
 220     }
 221
 222     return nullptr;
 223 }
 224
 225 OUString ScColorScaleEntry::GetFormula( formula::FormulaGrammar::Grammar eGrammar ) const
 226 {
 227     if(mpCell)
 228     {
 229         return mpCell->GetFormula(eGrammar);
 230     }
 231
 232     return OUString();
 233 }
 234
 235 double ScColorScaleEntry::GetValue() const
 236 {
 237     if(mpCell)
 238     {
 239         mpCell->Interpret();
 240         if(mpCell->IsValue())
 241             return mpCell->GetValue();
 242
 243         return std::numeric_limits<double>::max();
 244     }
 245
 246     return mnVal;
 247 }
 248
 249 void ScColorScaleEntry::SetValue(double nValue)
 250 {
 251     mnVal = nValue;
 252     mpCell.reset();
 253     setListener();
 254 }
 255
 256 void ScColorScaleEntry::UpdateReference( const sc::RefUpdateContext& rCxt )
 257 {
 258     if (!mpCell)
 259     {
 260         setListener();
 261         return;
 262     }
 263
 264     mpCell->UpdateReference(rCxt);
 265     mpListener.reset(new ScFormulaListener(mpCell.get()));
 266     SetRepaintCallback(mpFormat);
 267 }
 268
 269 void ScColorScaleEntry::UpdateInsertTab( const sc::RefUpdateInsertTabContext& rCxt )
 270 {
 271     if (!mpCell)
 272     {
 273         setListener();
 274         return;
 275     }
 276
 277     mpCell->UpdateInsertTab(rCxt);
 278     mpListener.reset(new ScFormulaListener(mpCell.get()));
 279     SetRepaintCallback(mpFormat);
 280 }
 281
 282 void ScColorScaleEntry::UpdateDeleteTab( const sc::RefUpdateDeleteTabContext& rCxt )
 283 {
 284     if (!mpCell)
 285     {
 286         setListener();
 287         return;
 288     }
 289
 290     mpCell->UpdateDeleteTab(rCxt);
 291     mpListener.reset(new ScFormulaListener(mpCell.get()));
 292     SetRepaintCallback(mpFormat);
 293 }
 294
 295 void ScColorScaleEntry::UpdateMoveTab( const sc::RefUpdateMoveTabContext& rCxt )
 296 {
 297     if (!mpCell)
 298     {
 299         setListener();
 300         return;
 301     }
 302
 303     SCTAB nTabNo = rCxt.getNewTab(mpCell->aPos.Tab());
 304     mpCell->UpdateMoveTab(rCxt, nTabNo);
 305     mpListener.reset(new ScFormulaListener(mpCell.get()));
 306     SetRepaintCallback(mpFormat);
 307 }
 308
 309 void ScColorScaleEntry::SetColor(const Color& rColor)
 310 {
 311     maColor = rColor;
 312 }
 313
 314 void ScColorScaleEntry::SetRepaintCallback(ScConditionalFormat* pFormat)
 315 {
 316     mpFormat = pFormat;
 317     setListener();
 318     if (mpFormat && mpListener)
 319         mpListener->setCallback([&]() { mpFormat->DoRepaint();});
 320 }
 321
 322 void ScColorScaleEntry::SetType( ScColorScaleEntryType eType )
 323 {
 324     meType = eType;
 325     if(eType != COLORSCALE_FORMULA)
 326     {
 327         mpCell.reset();
 328         mpListener.reset();
 329     }
 330
 331     setListener();
 332 }
 333
 334 void ScColorScaleEntry::setListener()
 335 {
 336     if (!mpFormat)
 337         return;
 338
 339     if (meType == COLORSCALE_PERCENT || meType == COLORSCALE_PERCENTILE
 340             || meType == COLORSCALE_MIN || meType == COLORSCALE_MAX
 341             || meType == COLORSCALE_AUTO)
 342     {
 343         mpListener.reset(new ScFormulaListener(*mpFormat->GetDocument(), mpFormat->GetRange()));
 344         mpListener->setCallback([&]() { mpFormat->DoRepaint();});
 345     }
 346 }
 347
 348 void ScColorScaleEntry::SetRepaintCallback(const std::function<void()>& func)
 349 {
 350     mpListener->setCallback(func);
 351 }
 352
 353 ScColorFormat::ScColorFormat(ScDocument* pDoc)
 354     : ScFormatEntry(pDoc)
 355     , mpParent(nullptr)
 356 {
 357 }
 358
 359 ScColorFormat::~ScColorFormat()
 360 {
 361 }
 362
 363 void ScColorFormat::SetParent( ScConditionalFormat* pParent )
 364 {
 365     mpParent = pParent;
 366 }
 367
 368 ScColorScaleFormat::ScColorScaleFormat(ScDocument* pDoc):
 369     ScColorFormat(pDoc)
 370 {
 371 }
 372
 373 ScColorScaleFormat::ScColorScaleFormat(ScDocument* pDoc, const ScColorScaleFormat& rFormat):
 374     ScColorFormat(pDoc)
 375 {
 376     for(const auto& rxEntry : rFormat)
 377     {
 378         maColorScales.emplace_back(new ScColorScaleEntry(pDoc, *rxEntry));
 379     }
 380 }
 381
 382 ScColorFormat* ScColorScaleFormat::Clone(ScDocument* pDoc) const
 383 {
 384     return new ScColorScaleFormat(pDoc, *this);
 385 }
 386
 387 ScColorScaleFormat::~ScColorScaleFormat()
 388 {
 389 }
 390
 391 void ScColorScaleFormat::SetParent(ScConditionalFormat* pFormat)
 392 {
 393     for (auto itr = begin(), itrEnd = end(); itr != itrEnd; ++itr)
 394     {
 395         (*itr)->SetRepaintCallback(pFormat);
 396     }
 397     ScColorFormat::SetParent(pFormat);
 398 }
 399
 400 void ScColorScaleFormat::AddEntry( ScColorScaleEntry* pEntry )
 401 {
 402     maColorScales.push_back(std::unique_ptr<ScColorScaleEntry, o3tl::default_delete<ScColorScaleEntry>>(pEntry));
 403     maColorScales.back()->SetRepaintCallback(mpParent);
 404 }
 405
 406 double ScColorScaleFormat::GetMinValue() const
 407 {
 408     ScColorScaleEntries::const_iterator itr = maColorScales.begin();
 409
 410     if((*itr)->GetType() == COLORSCALE_VALUE || (*itr)->GetType() == COLORSCALE_FORMULA)
 411         return (*itr)->GetValue();
 412     else
 413     {
 414         return getMinValue();
 415     }
 416 }
 417
 418 double ScColorScaleFormat::GetMaxValue() const
 419 {
 420     ScColorScaleEntries::const_reverse_iterator itr = maColorScales.rbegin();
 421
 422     if((*itr)->GetType() == COLORSCALE_VALUE || (*itr)->GetType() == COLORSCALE_FORMULA)
 423         return (*itr)->GetValue();
 424     else
 425     {
 426         return getMaxValue();
 427     }
 428 }
 429
 430 void ScColorScaleFormat::calcMinMax(double& rMin, double& rMax) const
 431 {
 432     rMin = GetMinValue();
 433     rMax = GetMaxValue();
 434 }
 435
 436 const ScRangeList& ScColorFormat::GetRange() const
 437 {
 438     return mpParent->GetRange();
 439 }
 440
 441 std::vector<double>& ScColorFormat::getValues() const
 442 {
 443     if(!mpCache)
 444     {
 445         mpCache.reset(new ScColorFormatCache);
 446         std::vector<double>& rValues = mpCache->maValues;
 447
 448         size_t n = GetRange().size();
 449         const ScRangeList& aRanges = GetRange();
 450         for(size_t i = 0; i < n; ++i)
 451         {
 452             const ScRange & rRange = aRanges[i];
 453             SCTAB nTab = rRange.aStart.Tab();
 454
 455             SCCOL nColStart = rRange.aStart.Col();
 456             SCROW nRowStart = rRange.aStart.Row();
 457             SCCOL nColEnd = rRange.aEnd.Col();
 458             SCROW nRowEnd = rRange.aEnd.Row();
 459
 460             if(nRowEnd == MAXROW)
 461             {
 462                 bool bShrunk = false;
 463                 mpDoc->ShrinkToUsedDataArea(bShrunk, nTab, nColStart, nRowStart,
 464                         nColEnd, nRowEnd, false);
 465             }
 466             for(SCCOL nCol = nColStart; nCol <= nColEnd; ++nCol)
 467             {
 468                 for(SCROW nRow = nRowStart; nRow <= nRowEnd; ++nRow)
 469                 {
 470                     ScAddress aAddr(nCol, nRow, nTab);
 471                     ScRefCellValue rCell(*mpDoc, aAddr);
 472                     if(rCell.hasNumeric())
 473                     {
 474                         double aVal = rCell.getValue();
 475                         rValues.push_back(aVal);
 476                     }
 477                 }
 478             }
 479         }
 480
 481         std::sort(rValues.begin(), rValues.end());
 482     }
 483
 484     return mpCache->maValues;
 485 }
 486
 487 double ScColorFormat::getMinValue() const
 488 {
 489     std::vector<double>& rValues = getValues();
 490     if(rValues.empty())
 491         return 0;
 492     return rValues[0];
 493 }
 494
 495 double ScColorFormat::getMaxValue() const
 496 {
 497     std::vector<double>& rValues = getValues();
 498     if(rValues.empty())
 499         return 0;
 500     return rValues[rValues.size()-1];
 501 }
 502
 503 void ScColorFormat::startRendering()
 504 {
 505     mpCache.reset();
 506 }
 507
 508 void ScColorFormat::endRendering()
 509 {
 510     mpCache.reset();
 511 }
 512
 513 void ScColorFormat::updateValues()
 514 {
 515     getMinValue();
 516     getMaxValue();
 517 }
 518
 519 namespace {
 520
 521 sal_uInt8 GetColorValue( double nVal, double nVal1, sal_uInt8 nColVal1, double nVal2, sal_uInt8 nColVal2 )
 522 {
 523     if (nVal <= nVal1)
 524         return nColVal1;
 525
 526     if (nVal >= nVal2)
 527         return nColVal2;
 528
 529     sal_uInt8 nColVal = static_cast<int>((nVal - nVal1)/(nVal2-nVal1)*(nColVal2-nColVal1))+nColVal1;
 530     return nColVal;
 531 }
 532
 533 Color CalcColor( double nVal, double nVal1, const Color& rCol1, double nVal2, const Color& rCol2)
 534 {
 535     sal_uInt8 nColRed = GetColorValue(nVal, nVal1, rCol1.GetRed(), nVal2, rCol2.GetRed());
 536     sal_uInt8 nColBlue = GetColorValue(nVal, nVal1, rCol1.GetBlue(), nVal2, rCol2.GetBlue());
 537     sal_uInt8 nColGreen = GetColorValue(nVal, nVal1, rCol1.GetGreen(), nVal2, rCol2.GetGreen());
 538
 539     return Color(nColRed, nColGreen, nColBlue);
 540 }
 541
 542 /**
 543  * @param rVector sorted vector of the array
 544  * @param fPercentile percentile
 545  */
 546 double GetPercentile( const std::vector<double>& rArray, double fPercentile )
 547 {
 548     size_t nSize = rArray.size();
 549     double fFloor = ::rtl::math::approxFloor(fPercentile * (nSize-1));
 550     SAL_WARN_IF(fFloor < 0, "sc", "negative percentile");
 551     size_t nIndex = fFloor >= 0 ? static_cast<size_t>(fFloor) : 0;
 552     double fDiff = fPercentile * (nSize-1) - fFloor;
 553     std::vector<double>::const_iterator iter = rArray.begin() + nIndex;
 554     if (fDiff == 0.0)
 555         return *iter;
 556     else
 557     {
 558         double fVal = *iter;
 559         iter = rArray.begin() + nIndex+1;
 560         return fVal + fDiff * (*iter - fVal);
 561     }
 562 }
 563
 564 }
 565
 566 double ScColorScaleFormat::CalcValue(double nMin, double nMax, const ScColorScaleEntries::const_iterator& itr) const
 567 {
 568     switch((*itr)->GetType())
 569     {
 570         case COLORSCALE_PERCENT:
 571             return nMin + (nMax-nMin)*((*itr)->GetValue()/100);
 572         case COLORSCALE_MIN:
 573             return nMin;
 574         case COLORSCALE_MAX:
 575             return nMax;
 576         case COLORSCALE_PERCENTILE:
 577         {
 578             std::vector<double>& rValues = getValues();
 579             if(rValues.size() == 1)
 580                 return rValues[0];
 581             else
 582             {
 583                 double fPercentile = (*itr)->GetValue()/100.0;
 584                 return GetPercentile(rValues, fPercentile);
 585             }
 586         }
 587
 588         default:
 589         break;
 590     }
 591
 592     return (*itr)->GetValue();
 593 }
 594
 595 std::optional<Color> ScColorScaleFormat::GetColor( const ScAddress& rAddr ) const
 596 {
 597     ScRefCellValue rCell(*mpDoc, rAddr);
 598     if(!rCell.hasNumeric())
 599         return std::optional<Color>();
 600
 601     // now we have for sure a value
 602     double nVal = rCell.getValue();
 603
 604     if (maColorScales.size() < 2)
 605         return std::optional<Color>();
 606
 607     double nMin = std::numeric_limits<double>::max();
 608     double nMax = std::numeric_limits<double>::min();
 609     calcMinMax(nMin, nMax);
 610
 611     // this check is for safety
 612     if(nMin >= nMax)
 613         return std::optional<Color>();
 614
 615     ScColorScaleEntries::const_iterator itr = begin();
 616     double nValMin = CalcValue(nMin, nMax, itr);
 617     Color rColMin = (*itr)->GetColor();
 618     ++itr;
 619     double nValMax = CalcValue(nMin, nMax, itr);
 620     Color rColMax = (*itr)->GetColor();
 621
 622     ++itr;
 623     while(itr != end() && nVal > nValMax)
 624     {
 625         rColMin = rColMax;
 626         nValMin = nValMax;
 627         rColMax = (*itr)->GetColor();
 628         nValMax = CalcValue(nMin, nMax, itr);
 629         ++itr;
 630     }
 631
 632     Color aColor = CalcColor(nVal, nValMin, rColMin, nValMax, rColMax);
 633
 634     return aColor;
 635 }
 636
 637 void ScColorScaleFormat::UpdateReference( sc::RefUpdateContext& rCxt )
 638 {
 639     for(ScColorScaleEntries::iterator itr = begin(); itr != end(); ++itr)
 640         (*itr)->UpdateReference(rCxt);
 641 }
 642
 643 void ScColorScaleFormat::UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt )
 644 {
 645     for (ScColorScaleEntries::iterator it = begin(); it != end(); ++it)
 646         (*it)->UpdateInsertTab(rCxt);
 647 }
 648
 649 void ScColorScaleFormat::UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt )
 650 {
 651     for (ScColorScaleEntries::iterator it = begin(); it != end(); ++it)
 652         (*it)->UpdateDeleteTab(rCxt);
 653 }
 654
 655 void ScColorScaleFormat::UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt )
 656 {
 657     for (ScColorScaleEntries::iterator it = begin(); it != end(); ++it)
 658         (*it)->UpdateMoveTab(rCxt);
 659 }
 660
 661 ScFormatEntry::Type ScColorScaleFormat::GetType() const
 662 {
 663     return Type::Colorscale;
 664 }
 665
 666 ScColorScaleEntries::iterator ScColorScaleFormat::begin()
 667 {
 668     return maColorScales.begin();
 669 }
 670
 671 ScColorScaleEntries::const_iterator ScColorScaleFormat::begin() const
 672 {
 673     return maColorScales.begin();
 674 }
 675
 676 ScColorScaleEntries::iterator ScColorScaleFormat::end()
 677 {
 678     return maColorScales.end();
 679 }
 680
 681 ScColorScaleEntries::const_iterator ScColorScaleFormat::end() const
 682 {
 683     return maColorScales.end();
 684 }
 685
 686 ScColorScaleEntry* ScColorScaleFormat::GetEntry(size_t nPos)
 687 {
 688     if (maColorScales.size() <= nPos)
 689         return nullptr;
 690
 691     return maColorScales[nPos].get();
 692 }
 693
 694 const ScColorScaleEntry* ScColorScaleFormat::GetEntry(size_t nPos) const
 695 {
 696     if (maColorScales.size() <= nPos)
 697         return nullptr;
 698
 699     return maColorScales[nPos].get();
 700 }
 701
 702 size_t ScColorScaleFormat::size() const
 703 {
 704     return maColorScales.size();
 705 }
 706
 707 void ScColorScaleFormat::EnsureSize()
 708 {
 709     if (maColorScales.size() < 2)
 710     {
 711         // TODO: create 2 valid entries
 712     }
 713 }
 714
 715 ScDataBarFormat::ScDataBarFormat(ScDocument* pDoc):
 716     ScColorFormat(pDoc),
 717     mpFormatData(new ScDataBarFormatData())
 718 {
 719 }
 720
 721 ScDataBarFormat::ScDataBarFormat(ScDocument* pDoc, const ScDataBarFormat& rFormat):
 722     ScColorFormat(pDoc),
 723     mpFormatData(new ScDataBarFormatData(*rFormat.mpFormatData))
 724 {
 725 }
 726
 727 void ScDataBarFormat::SetDataBarData( ScDataBarFormatData* pData )
 728 {
 729     mpFormatData.reset(pData);
 730     if (mpParent)
 731     {
 732         mpFormatData->mpUpperLimit->SetRepaintCallback(mpParent);
 733         mpFormatData->mpLowerLimit->SetRepaintCallback(mpParent);
 734     }
 735 }
 736
 737 ScDataBarFormatData* ScDataBarFormat::GetDataBarData()
 738 {
 739     return mpFormatData.get();
 740 }
 741
 742 const ScDataBarFormatData* ScDataBarFormat::GetDataBarData() const
 743 {
 744     return mpFormatData.get();
 745 }
 746
 747 ScColorFormat* ScDataBarFormat::Clone(ScDocument* pDoc) const
 748 {
 749     return new ScDataBarFormat(pDoc, *this);
 750 }
 751
 752 void ScDataBarFormat::SetParent(ScConditionalFormat* pFormat)
 753 {
 754     if (mpFormatData)
 755     {
 756         mpFormatData->mpUpperLimit->SetRepaintCallback(pFormat);
 757         mpFormatData->mpLowerLimit->SetRepaintCallback(pFormat);
 758     }
 759     ScColorFormat::SetParent(pFormat);
 760 }
 761
 762 ScFormatEntry::Type ScDataBarFormat::GetType() const
 763 {
 764     return Type::Databar;
 765 }
 766
 767 void ScDataBarFormat::UpdateReference( sc::RefUpdateContext& rCxt )
 768 {
 769     mpFormatData->mpUpperLimit->UpdateReference(rCxt);
 770     mpFormatData->mpLowerLimit->UpdateReference(rCxt);
 771 }
 772
 773 void ScDataBarFormat::UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt )
 774 {
 775     mpFormatData->mpUpperLimit->UpdateInsertTab(rCxt);
 776     mpFormatData->mpLowerLimit->UpdateInsertTab(rCxt);
 777 }
 778
 779 void ScDataBarFormat::UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt )
 780 {
 781     mpFormatData->mpUpperLimit->UpdateDeleteTab(rCxt);
 782     mpFormatData->mpLowerLimit->UpdateDeleteTab(rCxt);
 783 }
 784
 785 void ScDataBarFormat::UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt )
 786 {
 787     mpFormatData->mpUpperLimit->UpdateMoveTab(rCxt);
 788     mpFormatData->mpLowerLimit->UpdateMoveTab(rCxt);
 789 }
 790
 791 double ScDataBarFormat::getMin(double nMin, double nMax) const
 792 {
 793     switch(mpFormatData->mpLowerLimit->GetType())
 794     {
 795         case COLORSCALE_MIN:
 796             return nMin;
 797
 798         case COLORSCALE_AUTO:
 799             return std::min<double>(0, nMin);
 800
 801         case COLORSCALE_PERCENT:
 802             return nMin + (nMax-nMin)/100*mpFormatData->mpLowerLimit->GetValue();
 803
 804         case COLORSCALE_PERCENTILE:
 805         {
 806             double fPercentile = mpFormatData->mpLowerLimit->GetValue()/100.0;
 807             std::vector<double>& rValues = getValues();
 808             return GetPercentile(rValues, fPercentile);
 809         }
 810
 811         default:
 812         break;
 813     }
 814
 815     return mpFormatData->mpLowerLimit->GetValue();
 816 }
 817
 818 double ScDataBarFormat::getMax(double nMin, double nMax) const
 819 {
 820     switch(mpFormatData->mpUpperLimit->GetType())
 821     {
 822         case COLORSCALE_MAX:
 823             return nMax;
 824         case COLORSCALE_AUTO:
 825             return std::max<double>(0, nMax);
 826         case COLORSCALE_PERCENT:
 827             return nMin + (nMax-nMin)/100*mpFormatData->mpUpperLimit->GetValue();
 828         case COLORSCALE_PERCENTILE:
 829         {
 830             double fPercentile = mpFormatData->mpUpperLimit->GetValue()/100.0;
 831             std::vector<double>& rValues = getValues();
 832             return GetPercentile(rValues, fPercentile);
 833         }
 834
 835         default:
 836             break;
 837     }
 838
 839     return mpFormatData->mpUpperLimit->GetValue();
 840 }
 841
 842 std::unique_ptr<ScDataBarInfo> ScDataBarFormat::GetDataBarInfo(const ScAddress& rAddr) const
 843 {
 844     ScRefCellValue rCell(*mpDoc, rAddr);
 845     if(!rCell.hasNumeric())
 846         return nullptr;
 847
 848     // now we have for sure a value
 849
 850     double nValMin = getMinValue();
 851     double nValMax = getMaxValue();
 852     double nMin = getMin(nValMin, nValMax);
 853     double nMax = getMax(nValMin, nValMax);
 854     double nMinLength = mpFormatData->mnMinLength;
 855     double nMaxLength = mpFormatData->mnMaxLength;
 856
 857     double nValue = rCell.getValue();
 858
 859     std::unique_ptr<ScDataBarInfo> pInfo(new ScDataBarInfo);
 860     if(mpFormatData->meAxisPosition == databar::NONE)
 861     {
 862         if(nValue <= nMin)
 863         {
 864             pInfo->mnLength = nMinLength;
 865         }
 866         else if(nValue >= nMax)
 867         {
 868             pInfo->mnLength = nMaxLength;
 869         }
 870         else
 871         {
 872             double nDiff = nMax - nMin;
 873             pInfo->mnLength = nMinLength + (nValue - nMin)/nDiff * (nMaxLength-nMinLength);
 874         }
 875         pInfo->mnZero = 0;
 876     }
 877     else if (mpFormatData->meAxisPosition == databar::AUTOMATIC)
 878     {
 879         // if auto is used we may need to adjust it
 880         // for the length calculation
 881         if (mpFormatData->mpLowerLimit->GetType() == COLORSCALE_AUTO && nMin > 0)
 882             nMin = 0;
 883         if (mpFormatData->mpUpperLimit->GetType() == COLORSCALE_MAX && nMax < 0)
 884             nMax = 0;
 885
 886         //calculate the zero position first
 887         if(nMin < 0)
 888         {
 889             if(nMax < 0)
 890                 pInfo->mnZero = 100;
 891             else
 892             {
 893                 pInfo->mnZero = -100*nMin/(nMax-nMin);
 894             }
 895         }
 896         else
 897             pInfo->mnZero = 0;
 898
 899         double nMinNonNegative = std::max(0.0, nMin);
 900         double nMaxNonPositive = std::min(0.0, nMax);
 901         //calculate the length
 902         if(nValue < 0 && nMin < 0)
 903         {
 904             if (nValue < nMin)
 905                 pInfo->mnLength = -100;
 906             else
 907                 pInfo->mnLength = -100 * (nValue-nMaxNonPositive)/(nMin-nMaxNonPositive);
 908         }
 909         else
 910         {
 911             if ( nValue > nMax )
 912                 pInfo->mnLength = 100;
 913             else if (nValue <= nMin)
 914                 pInfo->mnLength = 0;
 915             else
 916                 pInfo->mnLength = 100 * (nValue-nMinNonNegative)/(nMax-nMinNonNegative);
 917         }
 918     }
 919     else if( mpFormatData->meAxisPosition == databar::MIDDLE)
 920     {
 921         pInfo->mnZero = 50;
 922         double nAbsMax = std::max(std::abs(nMin), std::abs(nMax));
 923         if (nValue < 0 && nMin < 0)
 924         {
 925             if (nValue < nMin)
 926                 pInfo->mnLength = nMaxLength * (nMin/nAbsMax);
 927             else
 928                 pInfo->mnLength = nMaxLength * (nValue/nAbsMax);
 929         }
 930         else
 931         {
 932             if (nValue > nMax)
 933                 pInfo->mnLength = nMaxLength * (nMax/nAbsMax);
 934             else
 935                 pInfo->mnLength = nMaxLength * (std::max(nValue, nMin)/nAbsMax);
 936         }
 937     }
 938     else
 939         assert(false);
 940
 941     // set color
 942     if(mpFormatData->mbNeg && nValue < 0)
 943     {
 944         if(mpFormatData->mxNegativeColor)
 945         {
 946             pInfo->maColor = *mpFormatData->mxNegativeColor;
 947         }
 948         else
 949         {
 950             // default negative color is red
 951             pInfo->maColor = COL_LIGHTRED;
 952         }
 953
 954     }
 955     else
 956         pInfo->maColor = mpFormatData->maPositiveColor;
 957
 958     pInfo->mbGradient = mpFormatData->mbGradient;
 959     pInfo->mbShowValue = !mpFormatData->mbOnlyBar;
 960     pInfo->maAxisColor = mpFormatData->maAxisColor;
 961
 962     return pInfo;
 963 }
 964
 965 void ScDataBarFormat::EnsureSize()
 966 {
 967     if (!mpFormatData->mpLowerLimit)
 968     {
 969         // TODO: implement
 970     }
 971     if (!mpFormatData->mpUpperLimit)
 972     {
 973         // TODO: implement
 974     }
 975 }
 976
 977 ScIconSetFormatData::ScIconSetFormatData(ScIconSetFormatData const& rOther)
 978     : eIconSetType(rOther.eIconSetType)
 979     , mbShowValue(rOther.mbShowValue)
 980     , mbReverse(rOther.mbReverse)
 981     , mbCustom(rOther.mbCustom)
 982     , maCustomVector(rOther.maCustomVector)
 983 {
 984     m_Entries.reserve(rOther.m_Entries.size());
 985     for (auto const& it : rOther.m_Entries)
 986     {
 987         m_Entries.emplace_back(new ScColorScaleEntry(*it));
 988     }
 989 }
 990
 991 ScIconSetFormat::ScIconSetFormat(ScDocument* pDoc):
 992     ScColorFormat(pDoc),
 993     mpFormatData(new ScIconSetFormatData)
 994 {
 995 }
 996
 997 ScIconSetFormat::ScIconSetFormat(ScDocument* pDoc, const ScIconSetFormat& rFormat):
 998     ScColorFormat(pDoc),
 999     mpFormatData(new ScIconSetFormatData(*rFormat.mpFormatData))
1000 {
1001 }
1002
1003 ScColorFormat* ScIconSetFormat::Clone( ScDocument* pDoc ) const
1004 {
1005     return new ScIconSetFormat(pDoc, *this);
1006 }
1007
1008 void ScIconSetFormat::SetParent(ScConditionalFormat* pFormat)
1009 {
1010     for(iterator itr = begin(); itr != end(); ++itr)
1011     {
1012         (*itr)->SetRepaintCallback(pFormat);
1013     }
1014     ScColorFormat::SetParent(pFormat);
1015 }
1016
1017 void ScIconSetFormat::SetIconSetData( ScIconSetFormatData* pFormatData )
1018 {
1019     mpFormatData.reset( pFormatData );
1020     SetParent(mpParent);
1021 }
1022
1023 ScIconSetFormatData* ScIconSetFormat::GetIconSetData()
1024 {
1025     return mpFormatData.get();
1026 }
1027
1028 const ScIconSetFormatData* ScIconSetFormat::GetIconSetData() const
1029 {
1030     return mpFormatData.get();
1031 }
1032
1033 std::unique_ptr<ScIconSetInfo> ScIconSetFormat::GetIconSetInfo(const ScAddress& rAddr) const
1034 {
1035     ScRefCellValue rCell(*mpDoc, rAddr);
1036     if(!rCell.hasNumeric())
1037         return nullptr;
1038
1039     // now we have for sure a value
1040     double nVal = rCell.getValue();
1041
1042     if (mpFormatData->m_Entries.size() < 2)
1043         return nullptr;
1044
1045     double nMin = GetMinValue();
1046     double nMax = GetMaxValue();
1047
1048     sal_Int32 nIndex = 0;
1049     const_iterator itr = begin();
1050     ++itr;
1051     double nValMax = CalcValue(nMin, nMax, itr);
1052
1053     ++itr;
1054     while(itr != end() && nVal >= nValMax)
1055     {
1056         ++nIndex;
1057         nValMax = CalcValue(nMin, nMax, itr);
1058         ++itr;
1059     }
1060
1061     if(nVal >= nValMax)
1062         ++nIndex;
1063
1064     std::unique_ptr<ScIconSetInfo> pInfo(new ScIconSetInfo);
1065
1066     if(mpFormatData->mbReverse)
1067     {
1068         sal_Int32 nMaxIndex = mpFormatData->m_Entries.size() - 1;
1069         nIndex = nMaxIndex - nIndex;
1070     }
1071
1072     if (mpFormatData->mbCustom && sal_Int32(mpFormatData->maCustomVector.size()) > nIndex)
1073     {
1074         ScIconSetType eCustomType = mpFormatData->maCustomVector[nIndex].first;
1075         sal_Int32 nCustomIndex = mpFormatData->maCustomVector[nIndex].second;
1076         if (nCustomIndex == -1)
1077         {
1078             return nullptr;
1079         }
1080
1081         pInfo->eIconSetType = eCustomType;
1082         pInfo->nIconIndex = nCustomIndex;
1083     }
1084     else
1085     {
1086         pInfo->nIconIndex = nIndex;
1087         pInfo->eIconSetType = mpFormatData->eIconSetType;
1088     }
1089
1090     pInfo->mbShowValue = mpFormatData->mbShowValue;
1091     return pInfo;
1092 }
1093
1094 ScFormatEntry::Type ScIconSetFormat::GetType() const
1095 {
1096     return Type::Iconset;
1097 }
1098
1099 void ScIconSetFormat::UpdateReference( sc::RefUpdateContext& rCxt )
1100 {
1101     for(iterator itr = begin(); itr != end(); ++itr)
1102     {
1103         (*itr)->UpdateReference(rCxt);
1104     }
1105 }
1106
1107 void ScIconSetFormat::UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt )
1108 {
1109     for(iterator itr = begin(); itr != end(); ++itr)
1110     {
1111         (*itr)->UpdateInsertTab(rCxt);
1112     }
1113 }
1114
1115 void ScIconSetFormat::UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt )
1116 {
1117     for(iterator itr = begin(); itr != end(); ++itr)
1118     {
1119         (*itr)->UpdateDeleteTab(rCxt);
1120     }
1121 }
1122
1123 void ScIconSetFormat::UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt )
1124 {
1125     for(iterator itr = begin(); itr != end(); ++itr)
1126     {
1127         (*itr)->UpdateMoveTab(rCxt);
1128     }
1129 }
1130
1131 ScIconSetFormat::iterator ScIconSetFormat::begin()
1132 {
1133     return mpFormatData->m_Entries.begin();
1134 }
1135
1136 ScIconSetFormat::const_iterator ScIconSetFormat::begin() const
1137 {
1138     return mpFormatData->m_Entries.begin();
1139 }
1140
1141 ScIconSetFormat::iterator ScIconSetFormat::end()
1142 {
1143     return mpFormatData->m_Entries.end();
1144 }
1145
1146 ScIconSetFormat::const_iterator ScIconSetFormat::end() const
1147 {
1148     return mpFormatData->m_Entries.end();
1149 }
1150
1151 double ScIconSetFormat::GetMinValue() const
1152 {
1153     const_iterator itr = begin();
1154
1155     if ((*itr)->GetType() == COLORSCALE_VALUE || (*itr)->GetType() == COLORSCALE_FORMULA)
1156         return (*itr)->GetValue();
1157     else
1158     {
1159         return getMinValue();
1160     }
1161 }
1162
1163 double ScIconSetFormat::GetMaxValue() const
1164 {
1165     auto const itr = mpFormatData->m_Entries.rbegin();
1166
1167     if ((*itr)->GetType() == COLORSCALE_VALUE || (*itr)->GetType() == COLORSCALE_FORMULA)
1168         return (*itr)->GetValue();
1169     else
1170     {
1171         return getMaxValue();
1172     }
1173 }
1174
1175 double ScIconSetFormat::CalcValue(double nMin, double nMax, const ScIconSetFormat::const_iterator& itr) const
1176 {
1177     switch ((*itr)->GetType())
1178     {
1179         case COLORSCALE_PERCENT:
1180             return nMin + (nMax-nMin)*((*itr)->GetValue()/100);
1181         case COLORSCALE_MIN:
1182             return nMin;
1183         case COLORSCALE_MAX:
1184             return nMax;
1185         case COLORSCALE_PERCENTILE:
1186         {
1187             std::vector<double>& rValues = getValues();
1188             if(rValues.size() == 1)
1189                 return rValues[0];
1190             else
1191             {
1192                 double fPercentile = (*itr)->GetValue()/100.0;
1193                 return GetPercentile(rValues, fPercentile);
1194             }
1195         }
1196
1197         default:
1198         break;
1199     }
1200
1201     return (*itr)->GetValue();
1202 }
1203
1204 const ScIconSetMap ScIconSetFormat::g_IconSetMap[] = {
1205     { "3Arrows", IconSet_3Arrows, 3 },
1206     { "3ArrowsGray", IconSet_3ArrowsGray, 3 },
1207     { "3Flags", IconSet_3Flags, 3 },
1208     { "3TrafficLights1", IconSet_3TrafficLights1, 3 },
1209     { "3TrafficLights2", IconSet_3TrafficLights2, 3 },
1210     { "3Signs", IconSet_3Signs, 3 },
1211     { "3Symbols", IconSet_3Symbols, 3 },
1212     { "3Symbols2", IconSet_3Symbols2, 3 },
1213     { "3Smilies", IconSet_3Smilies, 3 },
1214     { "3ColorSmilies", IconSet_3ColorSmilies, 3 },
1215     { "3Stars", IconSet_3Stars, 3 },
1216     { "3Triangles", IconSet_3Triangles, 3 },
1217     { "4Arrows", IconSet_4Arrows, 4 },
1218     { "4ArrowsGray", IconSet_4ArrowsGray, 4 },
1219     { "4RedToBlack", IconSet_4RedToBlack, 4 },
1220     { "4Rating", IconSet_4Rating, 4 },
1221     { "4TrafficLights", IconSet_4TrafficLights, 4 },
1222     { "5Arrows", IconSet_5Arrows, 5 },
1223     { "5ArrowsGray", IconSet_5ArrowsGray, 5 },
1224     { "5Rating", IconSet_5Ratings, 5 },
1225     { "5Quarters", IconSet_5Quarters, 5 },
1226     { "5Boxes", IconSet_5Boxes, 5 },
1227     { nullptr, IconSet_3Arrows, 0 }
1228 };
1229
1230 size_t ScIconSetFormat::size() const
1231 {
1232     return mpFormatData->m_Entries.size();
1233 }
1234
1235
1236 namespace {
1237
1238 const std::u16string_view a3TrafficLights1[] = {
1239     u"" BMP_ICON_SET_CIRCLES1_RED, u"" BMP_ICON_SET_CIRCLES1_YELLOW, u"" BMP_ICON_SET_CIRCLES1_GREEN
1240 };
1241
1242 const std::u16string_view a3TrafficLights2[] = {
1243     u"" BMP_ICON_SET_TRAFFICLIGHTS_RED, u"" BMP_ICON_SET_TRAFFICLIGHTS_YELLOW, u"" BMP_ICON_SET_TRAFFICLIGHTS_GREEN
1244 };
1245
1246 const std::u16string_view a3Arrows[] = {
1247     u"" BMP_ICON_SET_COLORARROWS_DOWN, u"" BMP_ICON_SET_COLORARROWS_SAME, u"" BMP_ICON_SET_COLORARROWS_UP
1248 };
1249
1250 const std::u16string_view a3ArrowsGray[] = {
1251     u"" BMP_ICON_SET_GRAYARROWS_DOWN, u"" BMP_ICON_SET_GRAYARROWS_SAME, u"" BMP_ICON_SET_GRAYARROWS_UP
1252 };
1253
1254 const std::u16string_view a3Flags[] = {
1255     u"" BMP_ICON_SET_FLAGS_RED, u"" BMP_ICON_SET_FLAGS_YELLOW, u"" BMP_ICON_SET_FLAGS_GREEN
1256 };
1257
1258 const std::u16string_view a3Smilies[] = {
1259     u"" BMP_ICON_SET_POSITIVE_YELLOW_SMILIE, u"" BMP_ICON_SET_NEUTRAL_YELLOW_SMILIE, u"" BMP_ICON_SET_NEGATIVE_YELLOW_SMILIE
1260 };
1261
1262 const std::u16string_view a3ColorSmilies[] = {
1263     u"" BMP_ICON_SET_POSITIVE_GREEN_SMILIE, u"" BMP_ICON_SET_NEUTRAL_YELLOW_SMILIE, u"" BMP_ICON_SET_NEGATIVE_RED_SMILIE
1264 };
1265
1266 const std::u16string_view a3Stars[] = {
1267     u"" BMP_ICON_SET_STARS_EMPTY, u"" BMP_ICON_SET_STARS_HALF, u"" BMP_ICON_SET_STARS_FULL
1268 };
1269
1270 const std::u16string_view a3Triangles[] = {
1271     u"" BMP_ICON_SET_TRIANGLES_DOWN, u"" BMP_ICON_SET_TRIANGLES_SAME, u"" BMP_ICON_SET_TRIANGLES_UP
1272 };
1273
1274 const std::u16string_view a4Arrows[] = {
1275     u"" BMP_ICON_SET_COLORARROWS_DOWN, u"" BMP_ICON_SET_COLORARROWS_SLIGHTLY_DOWN, u"" BMP_ICON_SET_COLORARROWS_SLIGHTLY_UP, u"" BMP_ICON_SET_COLORARROWS_UP
1276 };
1277
1278 const std::u16string_view a4ArrowsGray[] = {
1279     u"" BMP_ICON_SET_GRAYARROWS_DOWN, u"" BMP_ICON_SET_GRAYARROWS_SLIGHTLY_DOWN, u"" BMP_ICON_SET_GRAYARROWS_SLIGHTLY_UP, u"" BMP_ICON_SET_GRAYARROWS_UP
1280 };
1281
1282 const std::u16string_view a5Arrows[] = {
1283     u"" BMP_ICON_SET_COLORARROWS_DOWN, u"" BMP_ICON_SET_COLORARROWS_SLIGHTLY_DOWN,
1284     u"" BMP_ICON_SET_COLORARROWS_SAME, u"" BMP_ICON_SET_COLORARROWS_SLIGHTLY_UP, u"" BMP_ICON_SET_COLORARROWS_UP
1285 };
1286
1287 const std::u16string_view a5ArrowsGray[] = {
1288     u"" BMP_ICON_SET_GRAYARROWS_DOWN, u"" BMP_ICON_SET_GRAYARROWS_SLIGHTLY_DOWN,
1289     u"" BMP_ICON_SET_GRAYARROWS_SAME, u"" BMP_ICON_SET_GRAYARROWS_SLIGHTLY_UP, u"" BMP_ICON_SET_GRAYARROWS_UP
1290 };
1291
1292 const std::u16string_view a4TrafficLights[] = {
1293     u"" BMP_ICON_SET_CIRCLES1_GRAY, u"" BMP_ICON_SET_CIRCLES1_RED,
1294     u"" BMP_ICON_SET_CIRCLES1_YELLOW, u"" BMP_ICON_SET_CIRCLES1_GREEN
1295 };
1296
1297 const std::u16string_view a5Quarters[] = {
1298     u"" BMP_ICON_SET_PIES_EMPTY, u"" BMP_ICON_SET_PIES_ONE_QUARTER, u"" BMP_ICON_SET_PIES_HALF,
1299     u"" BMP_ICON_SET_PIES_THREE_QUARTER, u"" BMP_ICON_SET_PIES_FULL,
1300 };
1301
1302 const std::u16string_view a5Boxes[] = {
1303     u"" BMP_ICON_SET_SQUARES_EMPTY, u"" BMP_ICON_SET_SQUARES_ONE_QUARTER,
1304     u"" BMP_ICON_SET_SQUARES_HALF, u"" BMP_ICON_SET_SQUARES_THREE_QUARTER,
1305     u"" BMP_ICON_SET_SQUARES_FULL
1306 };
1307
1308 const std::u16string_view a3Symbols1[] = {
1309     u"" BMP_ICON_SET_SYMBOLS1_CROSS, u"" BMP_ICON_SET_SYMBOLS1_EXCLAMATION_MARK, u"" BMP_ICON_SET_SYMBOLS1_CHECK
1310 };
1311
1312 const std::u16string_view a3Signs[] = {
1313     u"" BMP_ICON_SET_SHAPES_DIAMOND, u"" BMP_ICON_SET_SHAPES_TRIANGLE, u"" BMP_ICON_SET_SHAPES_CIRCLE
1314 };
1315
1316 const std::u16string_view a4RedToBlack[] = {
1317     u"" BMP_ICON_SET_CIRCLES2_DARK_GRAY, u"" BMP_ICON_SET_CIRCLES2_LIGHT_GRAY,
1318     u"" BMP_ICON_SET_CIRCLES2_LIGHT_RED, u"" BMP_ICON_SET_CIRCLES2_DARK_RED
1319 };
1320
1321 const std::u16string_view a4Ratings[] = {
1322     u"" BMP_ICON_SET_BARS_ONE_QUARTER, u"" BMP_ICON_SET_BARS_HALF,
1323     u"" BMP_ICON_SET_BARS_THREE_QUARTER, u"" BMP_ICON_SET_BARS_FULL
1324 };
1325
1326 const std::u16string_view a5Ratings[] = {
1327     u"" BMP_ICON_SET_BARS_EMPTY, u"" BMP_ICON_SET_BARS_ONE_QUARTER, u"" BMP_ICON_SET_BARS_HALF,
1328     u"" BMP_ICON_SET_BARS_THREE_QUARTER, u"" BMP_ICON_SET_BARS_FULL
1329 };
1330
1331 struct ScIconSetBitmapMap {
1332     ScIconSetType eType;
1333     const std::u16string_view* pBitmaps;
1334 };
1335
1336 const ScIconSetBitmapMap aBitmapMap[] = {
1337     { IconSet_3Arrows, a3Arrows },
1338     { IconSet_3ArrowsGray, a3ArrowsGray },
1339     { IconSet_3Flags, a3Flags },
1340     { IconSet_3Signs, a3Signs },
1341     { IconSet_3Symbols, a3Symbols1 },
1342     { IconSet_3Symbols2, a3Symbols1 },
1343     { IconSet_3TrafficLights1, a3TrafficLights1 },
1344     { IconSet_3TrafficLights2, a3TrafficLights2 },
1345     { IconSet_3Smilies, a3Smilies },
1346     { IconSet_3ColorSmilies, a3ColorSmilies },
1347     { IconSet_3Triangles, a3Triangles },
1348     { IconSet_3Stars, a3Stars },
1349     { IconSet_4Arrows, a4Arrows },
1350     { IconSet_4ArrowsGray, a4ArrowsGray },
1351     { IconSet_4Rating, a4Ratings },
1352     { IconSet_4RedToBlack, a4RedToBlack },
1353     { IconSet_4TrafficLights, a4TrafficLights },
1354     { IconSet_5Arrows, a5Arrows },
1355     { IconSet_5ArrowsGray, a5ArrowsGray },
1356     { IconSet_5Quarters, a5Quarters },
1357     { IconSet_5Ratings, a5Ratings },
1358     { IconSet_5Boxes, a5Boxes }
1359 };
1360
1361 const ScIconSetMap* findIconSetType(ScIconSetType eType)
1362 {
1363     const ScIconSetMap* pMap = ScIconSetFormat::g_IconSetMap;
1364     for (; pMap->pName; ++pMap)
1365     {
1366         if (pMap->eType == eType)
1367             return pMap;
1368     }
1369
1370     return nullptr;
1371 }
1372
1373 }
1374
1375 const char* ScIconSetFormat::getIconSetName( ScIconSetType eType )
1376 {
1377     const ScIconSetMap* pMap = findIconSetType(eType);
1378     if (pMap)
1379         return pMap->pName;
1380
1381     return "";
1382 }
1383
1384 sal_Int32 ScIconSetFormat::getIconSetElements( ScIconSetType eType )
1385 {
1386     const ScIconSetMap* pMap = findIconSetType(eType);
1387     if (pMap)
1388         return pMap->nElements;
1389
1390     return 0;
1391 }
1392
1393 OUString ScIconSetFormat::getIconName(ScIconSetType const eType, sal_Int32 const nIndex)
1394 {
1395     OUString sBitmap;
1396
1397     for(const ScIconSetBitmapMap & i : aBitmapMap)
1398     {
1399         if(i.eType == eType)
1400         {
1401             sBitmap = *(i.pBitmaps + nIndex);
1402             break;
1403         }
1404     }
1405
1406     assert(!sBitmap.isEmpty());
1407
1408     return sBitmap;
1409 }
1410
1411 BitmapEx& ScIconSetFormat::getBitmap(sc::IconSetBitmapMap & rIconSetBitmapMap,
1412         ScIconSetType const eType, sal_Int32 const nIndex)
1413 {
1414     OUString sBitmap(ScIconSetFormat::getIconName(eType, nIndex));
1415
1416     std::map<OUString, BitmapEx>::iterator itr = rIconSetBitmapMap.find(sBitmap);
1417     if (itr != rIconSetBitmapMap.end())
1418         return itr->second;
1419
1420     BitmapEx aBitmap(sBitmap);
1421     std::pair<OUString, BitmapEx> aPair(sBitmap, aBitmap);
1422     std::pair<std::map<OUString, BitmapEx>::iterator, bool> itrNew = rIconSetBitmapMap.insert(aPair);
1423     assert(itrNew.second);
1424
1425     return itrNew.first->second;
1426 }
1427
1428 void ScIconSetFormat::EnsureSize()
1429 {
1430     ScIconSetType eType = mpFormatData->eIconSetType;
1431     for (const ScIconSetMap & i : g_IconSetMap)
1432     {
1433         if (i.eType == eType)
1434         {
1435             // size_t nElements = aIconSetMap[i].nElements;
1436             // TODO: implement
1437             break;
1438         }
1439     }
1440 }
1441
1442 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */