sc/source/ui/unoobj/PivotTableDataProvider.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 <limits>
  11 #include <memory>
  12 #include <sal/config.h>
  13
  14 #include <PivotTableDataProvider.hxx>
  15 #include <PivotTableDataSource.hxx>
  16 #include <PivotTableDataSequence.hxx>
  17
  18 #include <miscuno.hxx>
  19 #include <document.hxx>
  20 #include <docsh.hxx>
  21 #include <unonames.hxx>
  22 #include <scresid.hxx>
  23 #include <globstr.hrc>
  24 #include <strings.hrc>
  25 #include <dpobject.hxx>
  26 #include <hints.hxx>
  27
  28 #include <o3tl/safeint.hxx>
  29 #include <vcl/svapp.hxx>
  30 #include <comphelper/propertysequence.hxx>
  31 #include <comphelper/sequence.hxx>
  32 #include <comphelper/processfactory.hxx>
  33
  34 #include <com/sun/star/chart2/data/LabeledDataSequence.hpp>
  35 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  36 #include <com/sun/star/frame/XModel.hpp>
  37
  38 #include <com/sun/star/sheet/XDataPilotResults.hpp>
  39 #include <com/sun/star/sheet/DataResultFlags.hpp>
  40
  41 #include <com/sun/star/sheet/XDimensionsSupplier.hpp>
  42 #include <com/sun/star/sheet/XHierarchiesSupplier.hpp>
  43 #include <com/sun/star/sheet/XLevelsSupplier.hpp>
  44 #include <com/sun/star/sheet/XDataPilotMemberResults.hpp>
  45 #include <com/sun/star/sheet/MemberResultFlags.hpp>
  46 #include <com/sun/star/sheet/XMembersSupplier.hpp>
  47
  48 #include <com/sun/star/chart/ChartDataChangeEvent.hpp>
  49 #include <com/sun/star/container/XNamed.hpp>
  50
  51 #include <unordered_map>
  52
  53 using namespace css;
  54
  55 namespace sc
  56 {
  57 namespace
  58 {
  59 constexpr OUStringLiteral constIdCategories(u"categories");
  60 constexpr OUStringLiteral constIdLabel(u"label");
  61 constexpr OUStringLiteral constIdData(u"data");
  62
  63 std::span<const SfxItemPropertyMapEntry> lcl_GetDataProviderPropertyMap()
  64 {
  65     static const SfxItemPropertyMapEntry aDataProviderPropertyMap_Impl[] =
  66     {
  67         { SC_UNONAME_INCLUDEHIDDENCELLS, 0, cppu::UnoType<bool>::get(), 0, 0 },
  68         { SC_UNONAME_USE_INTERNAL_DATA_PROVIDER, 0, cppu::UnoType<bool>::get(), 0, 0 },
  69     };
  70     return aDataProviderPropertyMap_Impl;
  71 }
  72
  73 uno::Reference<frame::XModel> lcl_GetXModel(const ScDocument * pDoc)
  74 {
  75     uno::Reference<frame::XModel> xModel;
  76     ScDocShell* pObjSh(pDoc ? pDoc->GetDocumentShell() : nullptr);
  77     if (pObjSh)
  78         xModel.set(pObjSh->GetModel());
  79     return xModel;
  80 }
  81
  82 OUString lcl_identifierForData(sal_Int32 index)
  83 {
  84     return "PT@" + constIdData + " " + OUString::number(index);
  85 }
  86
  87 OUString lcl_identifierForLabel(sal_Int32 index)
  88 {
  89     return "PT@" + constIdLabel + " " + OUString::number(index);
  90 }
  91
  92 OUString lcl_identifierForCategories()
  93 {
  94     return "PT@" + constIdCategories;
  95 }
  96
  97 std::vector<OUString> lcl_getVisiblePageMembers(const uno::Reference<uno::XInterface> & xLevel)
  98 {
  99     std::vector<OUString> aResult;
 100     if (!xLevel.is())
 101         return aResult;
 102
 103     uno::Reference<sheet::XMembersSupplier> xMembersSupplier(xLevel, uno::UNO_QUERY);
 104     if (!xMembersSupplier.is())
 105         return aResult;
 106
 107     uno::Reference<sheet::XMembersAccess> xMembersAccess = xMembersSupplier->getMembers();
 108     if (!xMembersAccess.is())
 109         return aResult;
 110
 111     const css::uno::Sequence<OUString> aMembersNames = xMembersAccess->getElementNames();
 112     for (OUString const & rMemberNames : aMembersNames)
 113     {
 114         uno::Reference<beans::XPropertySet> xProperties(xMembersAccess->getByName(rMemberNames), uno::UNO_QUERY);
 115         if (!xProperties.is())
 116             continue;
 117
 118         OUString aCaption = ScUnoHelpFunctions::GetStringProperty(xProperties, SC_UNO_DP_LAYOUTNAME, OUString());
 119         if (aCaption.isEmpty())
 120             aCaption = rMemberNames;
 121
 122         bool bVisible = ScUnoHelpFunctions::GetBoolProperty(xProperties, SC_UNO_DP_ISVISIBLE);
 123
 124         if (bVisible)
 125             aResult.push_back(aCaption);
 126     }
 127
 128     return aResult;
 129 }
 130
 131 } // end anonymous namespace
 132
 133 SC_SIMPLE_SERVICE_INFO(PivotTableDataProvider, u"PivotTableDataProvider"_ustr, SC_SERVICENAME_CHART_PIVOTTABLE_DATAPROVIDER)
 134
 135 // DataProvider ==============================================================
 136
 137 PivotTableDataProvider::PivotTableDataProvider(ScDocument& rDoc)
 138     : m_pDocument(&rDoc)
 139     , m_aPropSet(lcl_GetDataProviderPropertyMap())
 140     , m_bIncludeHiddenCells(true)
 141     , m_bNeedsUpdate(true)
 142     , m_xContext(comphelper::getProcessComponentContext())
 143 {
 144     rDoc.AddUnoObject(*this);
 145 }
 146
 147 PivotTableDataProvider::~PivotTableDataProvider()
 148 {
 149     SolarMutexGuard g;
 150
 151     if (m_pDocument)
 152         m_pDocument->RemoveUnoObject( *this);
 153 }
 154
 155 void PivotTableDataProvider::Notify(SfxBroadcaster& /*rBroadcaster*/, const SfxHint& rHint)
 156 {
 157     if (rHint.GetId() == SfxHintId::Dying)
 158     {
 159         m_pDocument = nullptr;
 160     }
 161     else if (m_pDocument)
 162     {
 163         if (rHint.GetId() == SfxHintId::ScDataPilotModified)
 164         {
 165             auto pDataPilotHint = static_cast<const ScDataPilotModifiedHint*>(&rHint);
 166             if (pDataPilotHint->GetName() == m_sPivotTableName)
 167             {
 168                 m_bNeedsUpdate = true;
 169                 for (uno::Reference<util::XModifyListener> const & xListener : m_aValueListeners)
 170                 {
 171                     css::chart::ChartDataChangeEvent aEvent(getXWeak(),
 172                                                             css::chart::ChartDataChangeType_ALL,
 173                                                             0, 0, 0, 0);
 174                     xListener->modified(aEvent);
 175                 }
 176             }
 177         }
 178     }
 179 }
 180
 181 sal_Bool SAL_CALL PivotTableDataProvider::createDataSourcePossible(const uno::Sequence<beans::PropertyValue>& /*aArguments*/)
 182 {
 183     SolarMutexGuard aGuard;
 184     if (!m_pDocument)
 185         return false;
 186
 187     if (m_sPivotTableName.isEmpty())
 188         return false;
 189
 190     ScDPCollection* pDPCollection = m_pDocument->GetDPCollection();
 191     return bool(pDPCollection->GetByName(m_sPivotTableName));
 192 }
 193
 194 uno::Reference<chart2::data::XDataSource> SAL_CALL
 195     PivotTableDataProvider::createDataSource(const uno::Sequence<beans::PropertyValue>& aArguments)
 196 {
 197     SolarMutexGuard aGuard;
 198
 199     if (!m_pDocument)
 200         throw uno::RuntimeException();
 201
 202     bool bOrientCol = true;
 203     OUString aRangeRepresentation;
 204
 205     for (beans::PropertyValue const & rProperty : aArguments)
 206     {
 207         if (rProperty.Name == "DataRowSource")
 208         {
 209             chart::ChartDataRowSource eSource = chart::ChartDataRowSource_COLUMNS;
 210             if (!(rProperty.Value >>= eSource))
 211             {
 212                 sal_Int32 nSource(0);
 213                 if (rProperty.Value >>= nSource)
 214                     eSource = chart::ChartDataRowSource(nSource);
 215             }
 216             bOrientCol = (eSource == chart::ChartDataRowSource_COLUMNS);
 217         }
 218         else if (rProperty.Name == "CellRangeRepresentation")
 219             rProperty.Value >>= aRangeRepresentation;
 220     }
 221
 222     uno::Reference<chart2::data::XDataSource> xResult;
 223
 224     if (aRangeRepresentation == lcl_identifierForCategories())
 225         xResult = createCategoriesDataSource(bOrientCol);
 226     else
 227         xResult = createValuesDataSource();
 228
 229     return xResult;
 230 }
 231
 232 uno::Reference<chart2::data::XLabeledDataSequence>
 233     PivotTableDataProvider::newLabeledDataSequence()
 234 {
 235     uno::Reference<chart2::data::XLabeledDataSequence> xResult;
 236     if (!m_xContext.is())
 237         return xResult;
 238     xResult.set(chart2::data::LabeledDataSequence::create(m_xContext), uno::UNO_QUERY_THROW);
 239     return xResult;
 240 }
 241
 242 uno::Reference<chart2::data::XDataSource>
 243 PivotTableDataProvider::createCategoriesDataSource(bool bOrientationIsColumn)
 244 {
 245     if (m_bNeedsUpdate)
 246         collectPivotTableData();
 247
 248     uno::Reference<chart2::data::XDataSource> xDataSource;
 249     std::vector<uno::Reference<chart2::data::XLabeledDataSequence>> aLabeledSequences;
 250
 251     std::vector<std::vector<ValueAndFormat>> const & rCategoriesVector = bOrientationIsColumn ? m_aCategoriesColumnOrientation
 252                                                                                               : m_aCategoriesRowOrientation;
 253
 254     for (std::vector<ValueAndFormat> const & rCategories : rCategoriesVector)
 255     {
 256         uno::Reference<chart2::data::XLabeledDataSequence> xResult = newLabeledDataSequence();
 257         rtl::Reference<PivotTableDataSequence> pSequence(new PivotTableDataSequence(m_pDocument,
 258                                                    lcl_identifierForCategories(), std::vector(rCategories)));
 259         pSequence->setRole(u"categories"_ustr);
 260         xResult->setValues(uno::Reference<chart2::data::XDataSequence>(pSequence));
 261
 262         aLabeledSequences.push_back(xResult);
 263     }
 264
 265     xDataSource.set(new PivotTableDataSource(std::move(aLabeledSequences)));
 266     return xDataSource;
 267 }
 268
 269 void PivotTableDataProvider::collectPivotTableData()
 270 {
 271     ScDPCollection* pDPCollection = m_pDocument->GetDPCollection();
 272     ScDPObject* pDPObject = pDPCollection->GetByName(m_sPivotTableName);
 273     if (!pDPObject)
 274         return;
 275
 276     m_aCategoriesColumnOrientation.clear();
 277     m_aCategoriesRowOrientation.clear();
 278     m_aLabels.clear();
 279     m_aDataRowVector.clear();
 280     m_aColumnFields.clear();
 281     m_aRowFields.clear();
 282     m_aPageFields.clear();
 283     m_aDataFields.clear();
 284     m_aFieldOutputDescriptionMap.clear();
 285
 286     uno::Reference<sheet::XDataPilotResults> xDPResults(pDPObject->GetSource(), uno::UNO_QUERY);
 287     if (!xDPResults.is())
 288         return;
 289     const uno::Sequence<uno::Sequence<sheet::DataResult>> xDataResultsSequence = xDPResults->getResults();
 290
 291     std::unordered_set<size_t> aValidRowIndex;
 292
 293     size_t nRowIndex = 0;
 294     for (uno::Sequence<sheet::DataResult> const & xDataResults : xDataResultsSequence)
 295     {
 296         std::vector<ValueAndFormat> aRow;
 297         bool bRowEmpty = true;
 298         // First pass - collect a row of valid data and track if the row is empty
 299         for (sheet::DataResult const & rDataResult : xDataResults)
 300         {
 301             if (rDataResult.Flags & css::sheet::DataResultFlags::SUBTOTAL)
 302                 continue;
 303             if (rDataResult.Flags == 0 || rDataResult.Flags & css::sheet::DataResultFlags::HASDATA)
 304             {
 305                 aRow.emplace_back(rDataResult.Flags ? rDataResult.Value
 306                                                     : std::numeric_limits<double>::quiet_NaN(), 0);
 307                 if (rDataResult.Flags != 0) // set as valid only if we have data
 308                 {
 309                     bRowEmpty = false;
 310                     // We need to remember all valid (non-empty) row indices
 311                     aValidRowIndex.insert(nRowIndex);
 312                 }
 313             }
 314         }
 315         // Second pass: add to collection only non-empty rows
 316         if (!bRowEmpty)
 317         {
 318             size_t nColumnIndex = 0;
 319             for (ValueAndFormat const & aValue : aRow)
 320             {
 321                 if (nColumnIndex >= m_aDataRowVector.size())
 322                     m_aDataRowVector.resize(nColumnIndex + 1);
 323                 m_aDataRowVector[nColumnIndex].push_back(aValue);
 324                 nColumnIndex++;
 325             }
 326         }
 327         nRowIndex++;
 328     }
 329
 330     uno::Reference<sheet::XDimensionsSupplier> xDimensionsSupplier(pDPObject->GetSource());
 331     uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess(xDimensionsSupplier->getDimensions());
 332
 333     std::unordered_map<OUString, sal_Int32> aDataFieldNumberFormatMap;
 334     std::vector<OUString> aDataFieldNamesVectors;
 335
 336     std::unordered_map<OUString, OUString> aDataFieldCaptionNames;
 337
 338     sheet::DataPilotFieldOrientation eDataFieldOrientation = sheet::DataPilotFieldOrientation_HIDDEN;
 339
 340     for (sal_Int32 nDim = 0; nDim < xDims->getCount(); nDim++)
 341     {
 342         uno::Reference<uno::XInterface> xDim(xDims->getByIndex(nDim), uno::UNO_QUERY);
 343         uno::Reference<beans::XPropertySet> xDimProp(xDim, uno::UNO_QUERY);
 344         uno::Reference<sheet::XHierarchiesSupplier> xDimSupp(xDim, uno::UNO_QUERY);
 345
 346         if (!xDimProp.is() || !xDimSupp.is())
 347             continue;
 348
 349         sheet::DataPilotFieldOrientation eDimOrient =
 350             ScUnoHelpFunctions::GetEnumProperty(xDimProp, SC_UNO_DP_ORIENTATION,
 351                                                 sheet::DataPilotFieldOrientation_HIDDEN);
 352
 353         if (eDimOrient == sheet::DataPilotFieldOrientation_HIDDEN)
 354             continue;
 355
 356         uno::Reference<container::XIndexAccess> xHierarchies = new ScNameToIndexAccess(xDimSupp->getHierarchies());
 357         sal_Int32 nHierarchy = ScUnoHelpFunctions::GetLongProperty(xDimProp, SC_UNO_DP_USEDHIERARCHY);
 358         if (nHierarchy >= xHierarchies->getCount())
 359             nHierarchy = 0;
 360
 361         uno::Reference<sheet::XLevelsSupplier> xLevelsSupplier(xHierarchies->getByIndex(nHierarchy),
 362                                                                uno::UNO_QUERY);
 363
 364         if (!xLevelsSupplier.is())
 365             continue;
 366
 367         uno::Reference<container::XIndexAccess> xLevels = new ScNameToIndexAccess(xLevelsSupplier->getLevels());
 368
 369         for (tools::Long nLevel = 0; nLevel < xLevels->getCount(); nLevel++)
 370         {
 371             uno::Reference<uno::XInterface> xLevel(xLevels->getByIndex(nLevel), uno::UNO_QUERY);
 372             uno::Reference<container::XNamed> xLevelName(xLevel, uno::UNO_QUERY);
 373             uno::Reference<sheet::XDataPilotMemberResults> xLevelResult(xLevel, uno::UNO_QUERY );
 374
 375             if (xLevelName.is() && xLevelResult.is())
 376             {
 377                 bool bIsDataLayout = ScUnoHelpFunctions::GetBoolProperty(xDimProp, SC_UNO_DP_ISDATALAYOUT);
 378                 sal_Int32 nDimPos = ScUnoHelpFunctions::GetLongProperty(xDimProp, SC_UNO_DP_POSITION);
 379                 sal_Int32 nNumberFormat = ScUnoHelpFunctions::GetLongProperty(xDimProp, SC_UNO_DP_NUMBERFO);
 380                 bool bHasHiddenMember = ScUnoHelpFunctions::GetBoolProperty(xDimProp, SC_UNO_DP_HAS_HIDDEN_MEMBER);
 381
 382                 switch (eDimOrient)
 383                 {
 384                     case sheet::DataPilotFieldOrientation_COLUMN:
 385                     {
 386                         m_aColumnFields.emplace_back(xLevelName->getName(), nDim, nDimPos, bHasHiddenMember);
 387
 388                         const uno::Sequence<sheet::MemberResult> aSequence = xLevelResult->getResults();
 389                         size_t i = 0;
 390                         OUString sCaption;
 391                         OUString sName;
 392                         for (sheet::MemberResult const & rMember : aSequence)
 393                         {
 394                             // Skip grandtotals and subtotals
 395                             if (rMember.Flags & sheet::MemberResultFlags::SUBTOTAL ||
 396                                 rMember.Flags & sheet::MemberResultFlags::GRANDTOTAL)
 397                                     continue;
 398                             if (rMember.Flags & sheet::MemberResultFlags::HASMEMBER ||
 399                                 rMember.Flags & sheet::MemberResultFlags::CONTINUE)
 400                             {
 401                                 if (!(rMember.Flags & sheet::MemberResultFlags::CONTINUE))
 402                                 {
 403                                     sCaption = rMember.Caption;
 404                                     sName = rMember.Name;
 405                                 }
 406
 407                                 if (i >= m_aLabels.size())
 408                                     m_aLabels.resize(i + 1);
 409
 410                                 if (o3tl::make_unsigned(nDimPos) >= m_aLabels[i].size())
 411                                     m_aLabels[i].resize(nDimPos + 1);
 412                                 m_aLabels[i][nDimPos] = ValueAndFormat(sCaption);
 413
 414                                 if (bIsDataLayout)
 415                                 {
 416                                     // Remember data fields to determine the number format of data
 417                                     aDataFieldNamesVectors.push_back(sName);
 418                                     eDataFieldOrientation = sheet::DataPilotFieldOrientation_COLUMN;
 419                                     // Remember the caption name
 420                                     aDataFieldCaptionNames[rMember.Name] = rMember.Caption;
 421                                 }
 422                                 i++;
 423                             }
 424                         }
 425                     }
 426                     break;
 427
 428                     case sheet::DataPilotFieldOrientation_ROW:
 429                     {
 430                         m_aRowFields.emplace_back(xLevelName->getName(), nDim, nDimPos, bHasHiddenMember);
 431
 432                         const uno::Sequence<sheet::MemberResult> aSequence = xLevelResult->getResults();
 433
 434                         size_t i = 0;
 435                         size_t nEachIndex = 0;
 436                         std::unique_ptr<ValueAndFormat> pItem;
 437
 438                         for (sheet::MemberResult const & rMember : aSequence)
 439                         {
 440                             bool bFound = aValidRowIndex.find(nEachIndex) != aValidRowIndex.end();
 441
 442                             nEachIndex++;
 443
 444                             bool bHasContinueFlag = rMember.Flags & sheet::MemberResultFlags::CONTINUE;
 445
 446                             if (rMember.Flags & sheet::MemberResultFlags::HASMEMBER || bHasContinueFlag)
 447                             {
 448                                 if (!bHasContinueFlag)
 449                                 {
 450                                     // Chart2 does not use number format for labels, so use the display string.
 451                                     pItem.reset(new ValueAndFormat(rMember.Caption));
 452                                 }
 453
 454                                 if (bFound)
 455                                 {
 456                                     assert(pItem && "bHasContinueFlag must be false on this or some preceding element");
 457
 458                                     if (i >= m_aCategoriesRowOrientation.size())
 459                                         m_aCategoriesRowOrientation.resize(i + 1);
 460
 461                                     if (o3tl::make_unsigned(nDimPos) >= m_aCategoriesColumnOrientation.size())
 462                                         m_aCategoriesColumnOrientation.resize(nDimPos + 1);
 463                                     m_aCategoriesColumnOrientation[nDimPos].push_back(*pItem);
 464
 465                                     if (o3tl::make_unsigned(nDimPos) >= m_aCategoriesRowOrientation[i].size())
 466                                         m_aCategoriesRowOrientation[i].resize(nDimPos + 1);
 467                                     m_aCategoriesRowOrientation[i][nDimPos] = *pItem;
 468
 469                                     if (bIsDataLayout)
 470                                     {
 471                                         // Remember data fields to determine the number format of data
 472                                         aDataFieldNamesVectors.push_back(rMember.Name);
 473                                         eDataFieldOrientation = sheet::DataPilotFieldOrientation_ROW;
 474
 475                                         // Remember the caption name
 476                                         aDataFieldCaptionNames[rMember.Name] = rMember.Caption;
 477                                     }
 478
 479                                     // Set to empty so the sub categories are set to empty when they continue
 480                                     pItem.reset(new ValueAndFormat);
 481                                     i++;
 482                                 }
 483                             }
 484                         }
 485                     }
 486                     break;
 487
 488                     case sheet::DataPilotFieldOrientation_PAGE:
 489                     {
 490                         m_aPageFields.emplace_back(xLevelName->getName(), nDim, nDimPos, bHasHiddenMember);
 491
 492                         // Resolve filtering
 493                         OUString aFieldOutputDescription;
 494                         if (bHasHiddenMember)
 495                         {
 496                             std::vector<OUString> aMembers = lcl_getVisiblePageMembers(xLevel);
 497
 498                             if (aMembers.size() == 1)
 499                                 aFieldOutputDescription = aMembers[0];
 500                             else
 501                                 aFieldOutputDescription = ScResId(SCSTR_MULTIPLE);
 502                         }
 503                         else
 504                         {
 505                             aFieldOutputDescription = ScResId(SCSTR_ALL);
 506                         }
 507                         m_aFieldOutputDescriptionMap[nDim] = aFieldOutputDescription;
 508                     }
 509                     break;
 510
 511                     case sheet::DataPilotFieldOrientation_DATA:
 512                     {
 513                         aDataFieldNumberFormatMap[xLevelName->getName()] = nNumberFormat;
 514                         m_aDataFields.emplace_back(xLevelName->getName(), nDim, nDimPos, bHasHiddenMember);
 515                     }
 516                     break;
 517
 518                     default:
 519                         break;
 520                 }
 521             }
 522         }
 523     }
 524
 525     // Transform the name of data fields
 526     for (chart2::data::PivotTableFieldEntry& rDataFields : m_aDataFields)
 527     {
 528         rDataFields.Name = aDataFieldCaptionNames[rDataFields.Name];
 529     }
 530
 531     // Apply number format to the data
 532     if (eDataFieldOrientation == sheet::DataPilotFieldOrientation_ROW)
 533     {
 534         for (std::vector<ValueAndFormat> & rDataRow : m_aDataRowVector)
 535         {
 536             size_t i = 0;
 537             for (ValueAndFormat & rItem : rDataRow)
 538             {
 539                 const OUString& sName = aDataFieldNamesVectors[i];
 540                 sal_Int32 nNumberFormat = aDataFieldNumberFormatMap[sName];
 541                 rItem.m_nNumberFormat = nNumberFormat;
 542                 i++;
 543             }
 544         }
 545     }
 546     else if (eDataFieldOrientation == sheet::DataPilotFieldOrientation_COLUMN)
 547     {
 548         size_t i = 0;
 549         for (std::vector<ValueAndFormat> & rDataRow : m_aDataRowVector)
 550         {
 551             const OUString& sName = aDataFieldNamesVectors[i];
 552             sal_Int32 nNumberFormat = aDataFieldNumberFormatMap[sName];
 553             for (ValueAndFormat & rItem : rDataRow)
 554             {
 555                 rItem.m_nNumberFormat = nNumberFormat;
 556             }
 557             i++;
 558         }
 559     }
 560
 561     // Sort fields so it respects the order of how it is represented in the pivot table
 562
 563     auto funcDimensionPositionSortCompare = [] (chart2::data::PivotTableFieldEntry const & entry1,
 564                                                 chart2::data::PivotTableFieldEntry const & entry2)
 565     {
 566         return entry1.DimensionPositionIndex < entry2.DimensionPositionIndex;
 567     };
 568
 569     std::sort(m_aColumnFields.begin(), m_aColumnFields.end(), funcDimensionPositionSortCompare);
 570     std::sort(m_aRowFields.begin(),    m_aRowFields.end(),    funcDimensionPositionSortCompare);
 571     std::sort(m_aPageFields.begin(),   m_aPageFields.end(),   funcDimensionPositionSortCompare);
 572     std::sort(m_aDataFields.begin(),   m_aDataFields.end(),   funcDimensionPositionSortCompare);
 573
 574     // Mark that we updated the data
 575     m_bNeedsUpdate = false;
 576 }
 577
 578 uno::Reference<chart2::data::XDataSequence>
 579 PivotTableDataProvider::assignValuesToDataSequence(size_t nIndex)
 580 {
 581     uno::Reference<chart2::data::XDataSequence> xDataSequence;
 582     if (nIndex >= m_aDataRowVector.size())
 583         return xDataSequence;
 584
 585     OUString sDataID = lcl_identifierForData(nIndex);
 586
 587     std::vector<ValueAndFormat> const & rRowOfData = m_aDataRowVector[nIndex];
 588     rtl::Reference<PivotTableDataSequence> pSequence(new PivotTableDataSequence(m_pDocument, sDataID, std::vector(rRowOfData)));
 589     pSequence->setRole(u"values-y"_ustr);
 590     xDataSequence = pSequence;
 591     return xDataSequence;
 592 }
 593
 594 uno::Reference<chart2::data::XDataSequence>
 595 PivotTableDataProvider::assignLabelsToDataSequence(size_t nIndex)
 596 {
 597     uno::Reference<chart2::data::XDataSequence> xDataSequence;
 598
 599     OUString sLabelID = lcl_identifierForLabel(nIndex);
 600
 601     OUStringBuffer aLabel;
 602     bool bFirst = true;
 603
 604     if (m_aLabels.empty())
 605     {
 606         aLabel = ScResId(STR_PIVOT_TOTAL);
 607     }
 608     else if (nIndex < m_aLabels.size())
 609     {
 610         for (ValueAndFormat const & rItem : m_aLabels[nIndex])
 611         {
 612             if (bFirst)
 613             {
 614                 aLabel.append(rItem.m_aString);
 615                 bFirst = false;
 616             }
 617             else
 618             {
 619                 aLabel.append(" - " + rItem.m_aString);
 620             }
 621         }
 622     }
 623
 624     std::vector<ValueAndFormat> aLabelVector { ValueAndFormat(aLabel.makeStringAndClear()) };
 625
 626     rtl::Reference<PivotTableDataSequence> pSequence(new PivotTableDataSequence(m_pDocument,
 627                                                std::move(sLabelID), std::move(aLabelVector)));
 628     pSequence->setRole(u"values-y"_ustr);
 629     xDataSequence = pSequence;
 630     return xDataSequence;
 631 }
 632
 633 css::uno::Reference<css::chart2::data::XDataSequence>
 634     PivotTableDataProvider::assignFirstCategoriesToDataSequence()
 635 {
 636     uno::Reference<chart2::data::XDataSequence> xDataSequence;
 637
 638     if (m_aCategoriesColumnOrientation.empty())
 639         return xDataSequence;
 640
 641     std::vector<ValueAndFormat> const & rCategories = m_aCategoriesColumnOrientation.back();
 642
 643     rtl::Reference<PivotTableDataSequence> pSequence(new PivotTableDataSequence(m_pDocument,
 644                                                lcl_identifierForCategories(), std::vector(rCategories)));
 645     pSequence->setRole(u"categories"_ustr);
 646     xDataSequence = pSequence;
 647
 648     return xDataSequence;
 649 }
 650
 651 uno::Reference<chart2::data::XDataSource>
 652     PivotTableDataProvider::createValuesDataSource()
 653 {
 654     if (m_bNeedsUpdate)
 655         collectPivotTableData();
 656
 657     uno::Reference<chart2::data::XDataSource> xDataSource;
 658     std::vector<uno::Reference<chart2::data::XLabeledDataSequence>> aLabeledSequences;
 659
 660     // Fill first sequence of categories
 661     {
 662         uno::Reference<chart2::data::XLabeledDataSequence> xResult = newLabeledDataSequence();
 663         xResult->setValues(assignFirstCategoriesToDataSequence());
 664         aLabeledSequences.push_back(xResult);
 665     }
 666
 667     // Fill values and labels
 668     {
 669         for (size_t i = 0; i < m_aDataRowVector.size(); ++i)
 670         {
 671             uno::Reference<chart2::data::XLabeledDataSequence> xResult = newLabeledDataSequence();
 672             xResult->setValues(assignValuesToDataSequence(i));
 673             xResult->setLabel(assignLabelsToDataSequence(i));
 674             aLabeledSequences.push_back(xResult);
 675         }
 676     }
 677
 678     xDataSource.set(new PivotTableDataSource(std::move(aLabeledSequences)));
 679     return xDataSource;
 680 }
 681
 682
 683 uno::Sequence<beans::PropertyValue> SAL_CALL PivotTableDataProvider::detectArguments(
 684             const uno::Reference<chart2::data::XDataSource> & xDataSource)
 685 {
 686     if (!m_pDocument ||!xDataSource.is())
 687         return uno::Sequence<beans::PropertyValue>();
 688
 689     return comphelper::InitPropertySequence({
 690         { "CellRangeRepresentation", uno::Any(u"PivotChart"_ustr) },
 691         { "DataRowSource", uno::Any(chart::ChartDataRowSource_COLUMNS) },
 692         { "FirstCellAsLabel", uno::Any(false) },
 693         { "HasCategories", uno::Any(true) }
 694     });
 695 }
 696
 697 sal_Bool SAL_CALL PivotTableDataProvider::createDataSequenceByRangeRepresentationPossible(const OUString& /*aRangeRepresentation*/)
 698 {
 699     return false;
 700 }
 701
 702 uno::Reference<chart2::data::XDataSequence> SAL_CALL
 703     PivotTableDataProvider::createDataSequenceByRangeRepresentation(const OUString& /*rRangeRepresentation*/)
 704 {
 705     uno::Reference<chart2::data::XDataSequence> xDataSequence;
 706     return xDataSequence;
 707 }
 708
 709 uno::Reference<chart2::data::XDataSequence> SAL_CALL
 710     PivotTableDataProvider::createDataSequenceByValueArray(const OUString& /*aRole*/,
 711                                                            const OUString& /*aRangeRepresentation*/,
 712                                                            const OUString& /*aRoleQualifier*/)
 713 {
 714     return uno::Reference<chart2::data::XDataSequence>();
 715 }
 716
 717 uno::Reference<sheet::XRangeSelection> SAL_CALL PivotTableDataProvider::getRangeSelection()
 718 {
 719     uno::Reference<sheet::XRangeSelection> xResult;
 720
 721     uno::Reference<frame::XModel> xModel(lcl_GetXModel(m_pDocument));
 722     if (xModel.is())
 723         xResult.set(xModel->getCurrentController(), uno::UNO_QUERY);
 724
 725     return xResult;
 726 }
 727
 728 // XPivotTableDataProvider ========================================================
 729
 730 uno::Sequence<chart2::data::PivotTableFieldEntry> PivotTableDataProvider::getColumnFields()
 731 {
 732     return comphelper::containerToSequence(m_aColumnFields);
 733 }
 734
 735 uno::Sequence<chart2::data::PivotTableFieldEntry> PivotTableDataProvider::getRowFields()
 736 {
 737     return comphelper::containerToSequence(m_aRowFields);
 738 }
 739
 740 uno::Sequence<chart2::data::PivotTableFieldEntry> PivotTableDataProvider::getPageFields()
 741 {
 742     return comphelper::containerToSequence(m_aPageFields);
 743 }
 744
 745 uno::Sequence<chart2::data::PivotTableFieldEntry> PivotTableDataProvider::getDataFields()
 746 {
 747     return comphelper::containerToSequence(m_aDataFields);
 748 }
 749
 750 OUString PivotTableDataProvider::getPivotTableName()
 751 {
 752     return m_sPivotTableName;
 753 }
 754
 755 void PivotTableDataProvider::setPivotTableName(const OUString& sPivotTableName)
 756 {
 757     ScDPCollection* pDPCollection = m_pDocument->GetDPCollection();
 758     ScDPObject* pDPObject = pDPCollection->GetByName(sPivotTableName);
 759     if (pDPObject)
 760         m_sPivotTableName = sPivotTableName;
 761 }
 762
 763 sal_Bool PivotTableDataProvider::hasPivotTable()
 764 {
 765     if (m_sPivotTableName.isEmpty())
 766         return false;
 767
 768     ScDPCollection* pDPCollection = m_pDocument->GetDPCollection();
 769     ScDPObject* pDPObject = pDPCollection->GetByName(m_sPivotTableName);
 770
 771     if (pDPObject)
 772         return true;
 773
 774     return false;
 775 }
 776
 777 uno::Reference<chart2::data::XDataSequence>
 778     PivotTableDataProvider::createDataSequenceOfValuesByIndex(sal_Int32 nIndex)
 779 {
 780     SolarMutexGuard aGuard;
 781
 782     if (m_bNeedsUpdate)
 783         collectPivotTableData();
 784
 785     return assignValuesToDataSequence(size_t(nIndex));
 786 }
 787
 788 uno::Reference<css::chart2::data::XDataSequence>
 789     PivotTableDataProvider::createDataSequenceOfLabelsByIndex(sal_Int32 nIndex)
 790 {
 791     SolarMutexGuard aGuard;
 792
 793     if (m_bNeedsUpdate)
 794         collectPivotTableData();
 795
 796     return assignLabelsToDataSequence(size_t(nIndex));
 797 }
 798
 799 uno::Reference<css::chart2::data::XDataSequence>
 800     PivotTableDataProvider::createDataSequenceOfCategories()
 801 {
 802     SolarMutexGuard aGuard;
 803
 804     if (m_bNeedsUpdate)
 805         collectPivotTableData();
 806
 807     return assignFirstCategoriesToDataSequence();
 808 }
 809
 810 OUString PivotTableDataProvider::getFieldOutputDescription(sal_Int32 nDimensionIndex)
 811 {
 812     if (nDimensionIndex < 0)
 813         return OUString();
 814     return m_aFieldOutputDescriptionMap[size_t(nDimensionIndex)];
 815 }
 816
 817 // XModifyBroadcaster ========================================================
 818
 819 void SAL_CALL PivotTableDataProvider::addModifyListener(const uno::Reference< util::XModifyListener>& aListener)
 820 {
 821     SolarMutexGuard aGuard;
 822
 823     m_aValueListeners.emplace_back(aListener);
 824 }
 825
 826 void SAL_CALL PivotTableDataProvider::removeModifyListener(const uno::Reference<util::XModifyListener>& aListener )
 827 {
 828     SolarMutexGuard aGuard;
 829
 830     sal_uInt16 nCount = m_aValueListeners.size();
 831     for (sal_uInt16 n = nCount; n--;)
 832     {
 833         uno::Reference<util::XModifyListener>& rObject = m_aValueListeners[n];
 834         if (rObject == aListener)
 835         {
 836             m_aValueListeners.erase(m_aValueListeners.begin() + n);
 837         }
 838     }
 839 }
 840
 841 // DataProvider XPropertySet ========================================================
 842
 843 uno::Reference< beans::XPropertySetInfo> SAL_CALL
 844     PivotTableDataProvider::getPropertySetInfo()
 845 {
 846     SolarMutexGuard aGuard;
 847     static uno::Reference<beans::XPropertySetInfo> aRef =
 848         new SfxItemPropertySetInfo( m_aPropSet.getPropertyMap() );
 849     return aRef;
 850 }
 851
 852 void SAL_CALL PivotTableDataProvider::setPropertyValue(const OUString& rPropertyName, const uno::Any& rValue)
 853 {
 854     if (rPropertyName != SC_UNONAME_INCLUDEHIDDENCELLS)
 855         throw beans::UnknownPropertyException(rPropertyName);
 856
 857     if (!(rValue >>= m_bIncludeHiddenCells))
 858         throw lang::IllegalArgumentException();
 859 }
 860
 861 uno::Any SAL_CALL PivotTableDataProvider::getPropertyValue(const OUString& rPropertyName)
 862 {
 863     uno::Any aRet;
 864     if (rPropertyName == SC_UNONAME_INCLUDEHIDDENCELLS)
 865         aRet <<= m_bIncludeHiddenCells;
 866     else if (rPropertyName == SC_UNONAME_USE_INTERNAL_DATA_PROVIDER)
 867     {
 868         // This is a read-only property.
 869         aRet <<= m_pDocument->PastingDrawFromOtherDoc();
 870     }
 871     else
 872         throw beans::UnknownPropertyException(rPropertyName);
 873     return aRet;
 874 }
 875
 876 void SAL_CALL PivotTableDataProvider::addPropertyChangeListener(
 877         const OUString& /*rPropertyName*/,
 878         const uno::Reference<beans::XPropertyChangeListener>& /*xListener*/)
 879 {
 880     OSL_FAIL("Not yet implemented");
 881 }
 882
 883 void SAL_CALL PivotTableDataProvider::removePropertyChangeListener(
 884         const OUString& /*rPropertyName*/,
 885         const uno::Reference<beans::XPropertyChangeListener>& /*rListener*/)
 886 {
 887     OSL_FAIL("Not yet implemented");
 888 }
 889
 890 void SAL_CALL PivotTableDataProvider::addVetoableChangeListener(
 891         const OUString& /*rPropertyName*/,
 892         const uno::Reference<beans::XVetoableChangeListener>& /*rListener*/)
 893 {
 894     OSL_FAIL("Not yet implemented");
 895 }
 896
 897 void SAL_CALL PivotTableDataProvider::removeVetoableChangeListener(
 898         const OUString& /*rPropertyName*/,
 899         const uno::Reference<beans::XVetoableChangeListener>& /*rListener*/ )
 900 {
 901     OSL_FAIL("Not yet implemented");
 902 }
 903
 904 } // end sc namespace
 905
 906 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */