diff options
Diffstat (limited to 'sc/source/core/data/dptabsrc.cxx')
| -rw-r--r-- | sc/source/core/data/dptabsrc.cxx | 2613 |
1 files changed, 2613 insertions, 0 deletions
diff --git a/sc/source/core/data/dptabsrc.cxx b/sc/source/core/data/dptabsrc.cxx new file mode 100644 index 000000000..cab605f69 --- /dev/null +++ b/sc/source/core/data/dptabsrc.cxx @@ -0,0 +1,2613 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <dptabsrc.hxx> + +#include <algorithm> +#include <vector> + +#include <comphelper/sequence.hxx> +#include <o3tl/any.hxx> +#include <o3tl/safeint.hxx> +#include <osl/diagnose.h> +#include <rtl/math.hxx> +#include <sal/log.hxx> +#include <svl/itemprop.hxx> +#include <vcl/svapp.hxx> + +#include <dpcache.hxx> +#include <dptabres.hxx> +#include <dptabdat.hxx> +#include <global.hxx> +#include <miscuno.hxx> +#include <unonames.hxx> +#include <dpitemdata.hxx> +#include <dputil.hxx> +#include <dpresfilter.hxx> +#include <calcmacros.hxx> +#include <generalfunction.hxx> + +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/sheet/DataPilotFieldFilter.hpp> +#include <com/sun/star/sheet/DataPilotFieldReferenceType.hpp> +#include <com/sun/star/sheet/DataPilotFieldSortMode.hpp> +#include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp> +#include <com/sun/star/sheet/DataPilotFieldAutoShowInfo.hpp> +#include <com/sun/star/sheet/GeneralFunction2.hpp> +#include <com/sun/star/sheet/TableFilterField.hpp> + +#include <unotools/calendarwrapper.hxx> +#include <com/sun/star/i18n/CalendarDisplayIndex.hpp> + +using namespace com::sun::star; +using ::std::vector; +using ::com::sun::star::uno::Sequence; +using ::com::sun::star::uno::Any; +using ::com::sun::star::sheet::DataPilotFieldAutoShowInfo; + +#define SC_MINCOUNT_LIMIT 1000000 + +SC_SIMPLE_SERVICE_INFO( ScDPSource, "ScDPSource", "com.sun.star.sheet.DataPilotSource" ) +SC_SIMPLE_SERVICE_INFO( ScDPDimensions, "ScDPDimensions", "com.sun.star.sheet.DataPilotSourceDimensions" ) +SC_SIMPLE_SERVICE_INFO( ScDPDimension, "ScDPDimension", "com.sun.star.sheet.DataPilotSourceDimension" ) + +// Typos are on purpose here, quote from Eike Rathke (see https://gerrit.libreoffice.org/c/core/+/101116): +// "The typo is exactly why the SC_SIMPLE_SERVICE_INFO_COMPAT() lists both service names, +// the old with the typo and the new corrected one. Correcting the typo in the old name +// will make all extensions fail that use it. This is not to be changed." +SC_SIMPLE_SERVICE_INFO_COMPAT( ScDPHierarchies, "ScDPHierarchies", + "com.sun.star.sheet.DataPilotSourceHierarchies", "com.sun.star.sheet.DataPilotSourceHierarcies" ) +SC_SIMPLE_SERVICE_INFO_COMPAT( ScDPHierarchy, "ScDPHierarchy", + "com.sun.star.sheet.DataPilotSourceHierarchy", "com.sun.star.sheet.DataPilotSourceHierarcy" ) + +SC_SIMPLE_SERVICE_INFO( ScDPLevels, "ScDPLevels", "com.sun.star.sheet.DataPilotSourceLevels" ) +SC_SIMPLE_SERVICE_INFO( ScDPLevel, "ScDPLevel", "com.sun.star.sheet.DataPilotSourceLevel" ) +SC_SIMPLE_SERVICE_INFO( ScDPMembers, "ScDPMembers", "com.sun.star.sheet.DataPilotSourceMembers" ) +SC_SIMPLE_SERVICE_INFO( ScDPMember, "ScDPMember", "com.sun.star.sheet.DataPilotSourceMember" ) + +// property maps for PropertySetInfo +// DataDescription / NumberFormat are internal + +//TODO: move to a header? +static bool lcl_GetBoolFromAny( const uno::Any& aAny ) +{ + auto b = o3tl::tryAccess<bool>(aAny); + return b && *b; +} + +ScDPSource::ScDPSource( ScDPTableData* pD ) : + pData( pD ), + bColumnGrand( true ), // default is true + bRowGrand( true ), + bIgnoreEmptyRows( false ), + bRepeatIfEmpty( false ), + nDupCount( 0 ), + bResultOverflow( false ), + bPageFiltered( false ) +{ + pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty ); +} + +ScDPSource::~ScDPSource() +{ + // free lists + + pColResults.reset(); + pRowResults.reset(); + + pColResRoot.reset(); + pRowResRoot.reset(); + pResData.reset(); +} + +const std::optional<OUString> & ScDPSource::GetGrandTotalName() const +{ + return mpGrandTotalName; +} + +sheet::DataPilotFieldOrientation ScDPSource::GetOrientation(sal_Int32 nColumn) +{ + if (std::find(maColDims.begin(), maColDims.end(), nColumn) != maColDims.end()) + return sheet::DataPilotFieldOrientation_COLUMN; + + if (std::find(maRowDims.begin(), maRowDims.end(), nColumn) != maRowDims.end()) + return sheet::DataPilotFieldOrientation_ROW; + + if (std::find(maDataDims.begin(), maDataDims.end(), nColumn) != maDataDims.end()) + return sheet::DataPilotFieldOrientation_DATA; + + if (std::find(maPageDims.begin(), maPageDims.end(), nColumn) != maPageDims.end()) + return sheet::DataPilotFieldOrientation_PAGE; + + return sheet::DataPilotFieldOrientation_HIDDEN; +} + +sal_Int32 ScDPSource::GetDataDimensionCount() const +{ + return maDataDims.size(); +} + +ScDPDimension* ScDPSource::GetDataDimension(sal_Int32 nIndex) +{ + if (nIndex < 0 || o3tl::make_unsigned(nIndex) >= maDataDims.size()) + return nullptr; + + sal_Int32 nDimIndex = maDataDims[nIndex]; + return GetDimensionsObject()->getByIndex(nDimIndex); +} + +OUString ScDPSource::GetDataDimName(sal_Int32 nIndex) +{ + OUString aRet; + ScDPDimension* pDim = GetDataDimension(nIndex); + if (pDim) + aRet = pDim->getName(); + return aRet; +} + +sal_Int32 ScDPSource::GetPosition(sal_Int32 nColumn) +{ + std::vector<sal_Int32>::const_iterator it, itBeg = maColDims.begin(), itEnd = maColDims.end(); + it = std::find(itBeg, itEnd, nColumn); + if (it != itEnd) + return std::distance(itBeg, it); + + itBeg = maRowDims.begin(); + itEnd = maRowDims.end(); + it = std::find(itBeg, itEnd, nColumn); + if (it != itEnd) + return std::distance(itBeg, it); + + itBeg = maDataDims.begin(); + itEnd = maDataDims.end(); + it = std::find(itBeg, itEnd, nColumn); + if (it != itEnd) + return std::distance(itBeg, it); + + itBeg = maPageDims.begin(); + itEnd = maPageDims.end(); + it = std::find(itBeg, itEnd, nColumn); + if (it != itEnd) + return std::distance(itBeg, it); + + return 0; +} + +namespace { + +bool testSubTotal( bool& rAllowed, sal_Int32 nColumn, const std::vector<sal_Int32>& rDims, ScDPSource* pSource ) +{ + rAllowed = true; + std::vector<sal_Int32>::const_iterator it = rDims.begin(), itEnd = rDims.end(); + for (; it != itEnd; ++it) + { + if (*it != nColumn) + continue; + + if ( pSource->IsDataLayoutDimension(nColumn) ) + { + // no subtotals for data layout dim, no matter where + rAllowed = false; + return true; + } + + // no subtotals if no other dim but data layout follows + ++it; + if (it != itEnd && pSource->IsDataLayoutDimension(*it)) + ++it; + if (it == itEnd) + rAllowed = false; + + return true; // found + } + + return false; +} + +void removeDim( sal_Int32 nRemove, std::vector<sal_Int32>& rDims ) +{ + std::vector<sal_Int32>::iterator it = std::find(rDims.begin(), rDims.end(), nRemove); + if (it != rDims.end()) + rDims.erase(it); +} + +} + +bool ScDPSource::SubTotalAllowed(sal_Int32 nColumn) +{ + //TODO: cache this at ScDPResultData + bool bAllowed = true; + if ( testSubTotal(bAllowed, nColumn, maColDims, this) ) + return bAllowed; + if ( testSubTotal(bAllowed, nColumn, maRowDims, this) ) + return bAllowed; + return bAllowed; +} + +void ScDPSource::SetOrientation(sal_Int32 nColumn, sheet::DataPilotFieldOrientation nNew) +{ + //TODO: change to no-op if new orientation is equal to old? + + // remove from old list + removeDim(nColumn, maColDims); + removeDim(nColumn, maRowDims); + removeDim(nColumn, maDataDims); + removeDim(nColumn, maPageDims); + + // add to new list + switch (nNew) + { + case sheet::DataPilotFieldOrientation_COLUMN: + maColDims.push_back(nColumn); + break; + case sheet::DataPilotFieldOrientation_ROW: + maRowDims.push_back(nColumn); + break; + case sheet::DataPilotFieldOrientation_DATA: + maDataDims.push_back(nColumn); + break; + case sheet::DataPilotFieldOrientation_PAGE: + maPageDims.push_back(nColumn); + break; + // DataPilot Migration - Cache&&Performance + case sheet::DataPilotFieldOrientation_HIDDEN: + break; + default: + OSL_FAIL( "ScDPSource::SetOrientation: unexpected orientation" ); + break; + } +} + +bool ScDPSource::IsDataLayoutDimension(sal_Int32 nDim) +{ + return nDim == pData->GetColumnCount(); +} + +sheet::DataPilotFieldOrientation ScDPSource::GetDataLayoutOrientation() +{ + return GetOrientation(pData->GetColumnCount()); +} + +bool ScDPSource::IsDateDimension(sal_Int32 nDim) +{ + return pData->IsDateDimension(nDim); +} + +ScDPDimensions* ScDPSource::GetDimensionsObject() +{ + if (!pDimensions.is()) + { + pDimensions = new ScDPDimensions(this); + } + return pDimensions.get(); +} + +uno::Reference<container::XNameAccess> SAL_CALL ScDPSource::getDimensions() +{ + return GetDimensionsObject(); +} + +void ScDPSource::SetDupCount( tools::Long nNew ) +{ + nDupCount = nNew; +} + +ScDPDimension* ScDPSource::AddDuplicated(std::u16string_view rNewName) +{ + OSL_ENSURE( pDimensions.is(), "AddDuplicated without dimensions?" ); + + // re-use + + tools::Long nOldDimCount = pDimensions->getCount(); + for (tools::Long i=0; i<nOldDimCount; i++) + { + ScDPDimension* pDim = pDimensions->getByIndex(i); + if (pDim && pDim->getName() == rNewName) + { + //TODO: test if pDim is a duplicate of source + return pDim; + } + } + + SetDupCount( nDupCount + 1 ); + pDimensions->CountChanged(); // uses nDupCount + + return pDimensions->getByIndex( pDimensions->getCount() - 1 ); +} + +sal_Int32 ScDPSource::GetSourceDim(sal_Int32 nDim) +{ + // original source dimension or data layout dimension? + if ( nDim <= pData->GetColumnCount() ) + return nDim; + + if ( nDim < pDimensions->getCount() ) + { + ScDPDimension* pDimObj = pDimensions->getByIndex( nDim ); + if ( pDimObj ) + { + tools::Long nSource = pDimObj->GetSourceDim(); + if ( nSource >= 0 ) + return nSource; + } + } + + OSL_FAIL("GetSourceDim: wrong dim"); + return nDim; +} + +uno::Sequence< uno::Sequence<sheet::DataResult> > SAL_CALL ScDPSource::getResults() +{ + CreateRes_Impl(); // create pColResRoot and pRowResRoot + + if ( bResultOverflow ) // set in CreateRes_Impl + { + // no results available + throw uno::RuntimeException(); + } + + sal_Int32 nColCount = pColResRoot->GetSize(pResData->GetColStartMeasure()); + sal_Int32 nRowCount = pRowResRoot->GetSize(pResData->GetRowStartMeasure()); + + // allocate full sequence + //TODO: leave out empty rows??? + + uno::Sequence< uno::Sequence<sheet::DataResult> > aSeq( nRowCount ); + uno::Sequence<sheet::DataResult>* pRowAry = aSeq.getArray(); + for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++) + { + uno::Sequence<sheet::DataResult> aColSeq( nColCount ); + // use default values of DataResult + pRowAry[nRow] = aColSeq; + } + + ScDPResultFilterContext aFilterCxt; + pRowResRoot->FillDataResults( + pColResRoot.get(), aFilterCxt, aSeq, pResData->GetRowStartMeasure()); + + maResFilterSet.swap(aFilterCxt.maFilterSet); // Keep this data for GETPIVOTDATA. + + return aSeq; +} + +uno::Sequence<double> ScDPSource::getFilteredResults( + const uno::Sequence<sheet::DataPilotFieldFilter>& aFilters ) +{ + if (maResFilterSet.empty()) + getResults(); // Build result tree first. + + // Get result values from the tree. + const ScDPResultTree::ValuesType* pVals = maResFilterSet.getResults(aFilters); + if (pVals && !pVals->empty()) + { + return comphelper::containerToSequence(*pVals); + } + + if (aFilters.getLength() == 1) + { + // Try to get result from the leaf nodes. + double fVal = maResFilterSet.getLeafResult(aFilters[0]); + if (!std::isnan(fVal)) + { + return { fVal }; + } + } + + return uno::Sequence<double>(); +} + +void SAL_CALL ScDPSource::refresh() +{ + disposeData(); +} + +void SAL_CALL ScDPSource::addRefreshListener( const uno::Reference<util::XRefreshListener >& ) +{ + OSL_FAIL("not implemented"); //TODO: exception? +} + +void SAL_CALL ScDPSource::removeRefreshListener( const uno::Reference<util::XRefreshListener >& ) +{ + OSL_FAIL("not implemented"); //TODO: exception? +} + +Sequence< Sequence<Any> > SAL_CALL ScDPSource::getDrillDownData(const Sequence<sheet::DataPilotFieldFilter>& aFilters) +{ + sal_Int32 nColumnCount = GetData()->GetColumnCount(); + + vector<ScDPFilteredCache::Criterion> aFilterCriteria; + for (const sheet::DataPilotFieldFilter& rFilter : aFilters) + { + const OUString& aFieldName = rFilter.FieldName; + for (sal_Int32 nCol = 0; nCol < nColumnCount; ++nCol) + { + if (aFieldName == pData->getDimensionName(nCol)) + { + ScDPDimension* pDim = GetDimensionsObject()->getByIndex( nCol ); + ScDPMembers* pMembers = pDim->GetHierarchiesObject()->getByIndex(0)-> + GetLevelsObject()->getByIndex(0)->GetMembersObject(); + sal_Int32 nIndex = pMembers->GetIndexFromName( rFilter.MatchValueName ); + if ( nIndex >= 0 ) + { + ScDPItemData aItem(pMembers->getByIndex(nIndex)->FillItemData()); + aFilterCriteria.emplace_back( ); + aFilterCriteria.back().mnFieldIndex = nCol; + aFilterCriteria.back().mpFilter = + std::make_shared<ScDPFilteredCache::SingleFilter>(aItem); + } + } + } + } + + // Take into account the visibilities of field members. + ScDPResultVisibilityData aResVisData(this); + pRowResRoot->FillVisibilityData(aResVisData); + pColResRoot->FillVisibilityData(aResVisData); + aResVisData.fillFieldFilters(aFilterCriteria); + + Sequence< Sequence<Any> > aTabData; + std::unordered_set<sal_Int32> aCatDims; + GetCategoryDimensionIndices(aCatDims); + pData->GetDrillDownData(std::move(aFilterCriteria), std::move(aCatDims), aTabData); + return aTabData; +} + +OUString ScDPSource::getDataDescription() +{ + CreateRes_Impl(); // create pResData + + OUString aRet; + if ( pResData->GetMeasureCount() == 1 ) + { + bool bTotalResult = false; + aRet = pResData->GetMeasureString(0, true, SUBTOTAL_FUNC_NONE, bTotalResult); + } + + // empty for more than one measure + + return aRet; +} + +void ScDPSource::setIgnoreEmptyRows(bool bSet) +{ + bIgnoreEmptyRows = bSet; + pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty ); +} + +void ScDPSource::setRepeatIfEmpty(bool bSet) +{ + bRepeatIfEmpty = bSet; + pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty ); +} + +void ScDPSource::disposeData() +{ + maResFilterSet.clear(); + + if ( pResData ) + { + // reset all data... + + pColResRoot.reset(); + pRowResRoot.reset(); + pResData.reset(); + pColResults.reset(); + pRowResults.reset(); + aColLevelList.clear(); + aRowLevelList.clear(); + } + + pDimensions.clear(); // settings have to be applied (from SaveData) again! + SetDupCount( 0 ); + + maColDims.clear(); + maRowDims.clear(); + maDataDims.clear(); + maPageDims.clear(); + + pData->DisposeData(); // cached entries etc. + bPageFiltered = false; + bResultOverflow = false; +} + +static tools::Long lcl_CountMinMembers(const vector<ScDPDimension*>& ppDim, const vector<ScDPLevel*>& ppLevel, tools::Long nLevels ) +{ + // Calculate the product of the member count for those consecutive levels that + // have the "show all" flag, one following level, and the data layout dimension. + + tools::Long nTotal = 1; + tools::Long nDataCount = 1; + bool bWasShowAll = true; + tools::Long nPos = nLevels; + while ( nPos > 0 ) + { + --nPos; + + if ( nPos+1 < nLevels && ppDim[nPos] == ppDim[nPos+1] ) + { + OSL_FAIL("lcl_CountMinMembers: multiple levels from one dimension not implemented"); + return 0; + } + + bool bDo = false; + if ( ppDim[nPos]->getIsDataLayoutDimension() ) + { + // data layout dim doesn't interfere with "show all" flags + nDataCount = ppLevel[nPos]->GetMembersObject()->getCount(); + if ( nDataCount == 0 ) + nDataCount = 1; + } + else if ( bWasShowAll ) // "show all" set for all following levels? + { + bDo = true; + if ( !ppLevel[nPos]->getShowEmpty() ) + { + // this level is counted, following ones are not + bWasShowAll = false; + } + } + if ( bDo ) + { + tools::Long nThisCount = ppLevel[nPos]->GetMembersObject()->getMinMembers(); + if ( nThisCount == 0 ) + { + nTotal = 1; // empty level -> start counting from here + //TODO: start with visible elements in this level? + } + else + { + if ( nTotal >= LONG_MAX / nThisCount ) + return LONG_MAX; // overflow + nTotal *= nThisCount; + } + } + } + + // always include data layout dim, even after restarting + if ( nTotal >= LONG_MAX / nDataCount ) + return LONG_MAX; // overflow + nTotal *= nDataCount; + + return nTotal; +} + +void ScDPSource::FillCalcInfo(bool bIsRow, ScDPTableData::CalcInfo& rInfo, bool &rHasAutoShow) +{ + const std::vector<sal_Int32>& rDims = bIsRow ? maRowDims : maColDims; + for (const auto& rDimIndex : rDims) + { + ScDPDimension* pDim = GetDimensionsObject()->getByIndex(rDimIndex); + tools::Long nHierarchy = ScDPDimension::getUsedHierarchy(); + if ( nHierarchy >= ScDPHierarchies::getCount() ) + nHierarchy = 0; + ScDPLevels* pLevels = pDim->GetHierarchiesObject()->getByIndex(nHierarchy)->GetLevelsObject(); + sal_Int32 nCount = pLevels->getCount(); + + //TODO: Test + if (pDim->getIsDataLayoutDimension() && maDataDims.size() < 2) + nCount = 0; + //TODO: Test + + for (sal_Int32 j = 0; j < nCount; ++j) + { + ScDPLevel* pLevel = pLevels->getByIndex(j); + pLevel->EvaluateSortOrder(); + + // no layout flags for column fields, only for row fields + pLevel->SetEnableLayout( bIsRow ); + + if ( pLevel->GetAutoShow().IsEnabled ) + rHasAutoShow = true; + + if (bIsRow) + { + rInfo.aRowLevelDims.push_back(rDimIndex); + rInfo.aRowDims.push_back(pDim); + rInfo.aRowLevels.push_back(pLevel); + } + else + { + rInfo.aColLevelDims.push_back(rDimIndex); + rInfo.aColDims.push_back(pDim); + rInfo.aColLevels.push_back(pLevel); + } + + pLevel->GetMembersObject(); // initialize for groups + } + } +} + +namespace { + +class CategoryDimInserter +{ + ScDPSource& mrSource; + std::unordered_set<sal_Int32>& mrCatDims; +public: + CategoryDimInserter(ScDPSource& rSource, std::unordered_set<sal_Int32>& rCatDims) : + mrSource(rSource), + mrCatDims(rCatDims) {} + + void operator() (tools::Long nDim) + { + if (!mrSource.IsDataLayoutDimension(nDim)) + mrCatDims.insert(nDim); + } +}; + +} + +void ScDPSource::GetCategoryDimensionIndices(std::unordered_set<sal_Int32>& rCatDims) +{ + std::unordered_set<sal_Int32> aCatDims; + + CategoryDimInserter aInserter(*this, aCatDims); + std::for_each(maColDims.begin(), maColDims.end(), aInserter); + std::for_each(maRowDims.begin(), maRowDims.end(), aInserter); + std::for_each(maPageDims.begin(), maPageDims.end(), aInserter); + + rCatDims.swap(aCatDims); +} + +void ScDPSource::FilterCacheByPageDimensions() +{ + // #i117661# Repeated calls to ScDPFilteredCache::filterByPageDimension + // are invalid because rows are only hidden, never shown again. If + // FilterCacheByPageDimensions is called again, the cache table must + // be re-initialized. Currently, CreateRes_Impl always uses a fresh cache + // because ScDBDocFunc::DataPilotUpdate calls InvalidateData. + + if (bPageFiltered) + { + SAL_WARN( "sc.core","tried to apply page field filters several times"); + + pData->DisposeData(); + pData->CreateCacheTable(); // re-initialize the cache table + bPageFiltered = false; + } + + // filter table by page dimensions. + vector<ScDPFilteredCache::Criterion> aCriteria; + for (const auto& rDimIndex : maPageDims) + { + ScDPDimension* pDim = GetDimensionsObject()->getByIndex(rDimIndex); + tools::Long nField = pDim->GetDimension(); + + ScDPMembers* pMems = pDim->GetHierarchiesObject()->getByIndex(0)-> + GetLevelsObject()->getByIndex(0)->GetMembersObject(); + + tools::Long nMemCount = pMems->getCount(); + ScDPFilteredCache::Criterion aFilter; + aFilter.mnFieldIndex = static_cast<sal_Int32>(nField); + aFilter.mpFilter = std::make_shared<ScDPFilteredCache::GroupFilter>(); + ScDPFilteredCache::GroupFilter* pGrpFilter = + static_cast<ScDPFilteredCache::GroupFilter*>(aFilter.mpFilter.get()); + for (tools::Long j = 0; j < nMemCount; ++j) + { + ScDPMember* pMem = pMems->getByIndex(j); + if (pMem->isVisible()) + { + ScDPItemData aData(pMem->FillItemData()); + pGrpFilter->addMatchItem(aData); + } + } + if (pGrpFilter->getMatchItemCount() < o3tl::make_unsigned(nMemCount)) + // there is at least one invisible item. Add this filter criterion to the mix. + aCriteria.push_back(aFilter); + + if (!pDim->HasSelectedPage()) + continue; + + const ScDPItemData& rData = pDim->GetSelectedData(); + aCriteria.emplace_back(); + ScDPFilteredCache::Criterion& r = aCriteria.back(); + r.mnFieldIndex = static_cast<sal_Int32>(nField); + r.mpFilter = std::make_shared<ScDPFilteredCache::SingleFilter>(rData); + } + if (!aCriteria.empty()) + { + std::unordered_set<sal_Int32> aCatDims; + GetCategoryDimensionIndices(aCatDims); + pData->FilterCacheTable(std::move(aCriteria), std::move(aCatDims)); + bPageFiltered = true; + } +} + +void ScDPSource::CreateRes_Impl() +{ + if (pResData) + return; + + sheet::DataPilotFieldOrientation nDataOrient = GetDataLayoutOrientation(); + if (maDataDims.size() > 1 && ( nDataOrient != sheet::DataPilotFieldOrientation_COLUMN && + nDataOrient != sheet::DataPilotFieldOrientation_ROW ) ) + { + // if more than one data dimension, data layout orientation must be set + SetOrientation( pData->GetColumnCount(), sheet::DataPilotFieldOrientation_ROW ); + nDataOrient = sheet::DataPilotFieldOrientation_ROW; + } + + // TODO: Aggregate pDataNames, pDataRefValues, nDataRefOrient, and + // eDataFunctions into a structure and use vector instead of static + // or pointer arrays. + vector<OUString> aDataNames; + vector<sheet::DataPilotFieldReference> aDataRefValues; + vector<ScSubTotalFunc> aDataFunctions; + vector<sheet::DataPilotFieldOrientation> aDataRefOrient; + + ScDPTableData::CalcInfo aInfo; + + // LateInit (initialize only those rows/children that are used) can be used unless + // any data dimension needs reference values from column/row dimensions + bool bLateInit = true; + + // Go through all data dimensions (i.e. fields) and build their meta data + // so that they can be passed on to ScDPResultData instance later. + // TODO: aggregate all of data dimension info into a structure. + for (const tools::Long nDimIndex : maDataDims) + { + // Get function for each data field. + ScDPDimension* pDim = GetDimensionsObject()->getByIndex(nDimIndex); + ScGeneralFunction eUser = pDim->getFunction(); + if (eUser == ScGeneralFunction::AUTO) + { + //TODO: test for numeric data + eUser = ScGeneralFunction::SUM; + } + + // Map UNO's enum to internal enum ScSubTotalFunc. + aDataFunctions.push_back(ScDPUtil::toSubTotalFunc(eUser)); + + // Get reference field/item information. + aDataRefValues.push_back(pDim->GetReferenceValue()); + sheet::DataPilotFieldOrientation nDataRefOrient = sheet::DataPilotFieldOrientation_HIDDEN; // default if not used + sal_Int32 eRefType = aDataRefValues.back().ReferenceType; + if ( eRefType == sheet::DataPilotFieldReferenceType::ITEM_DIFFERENCE || + eRefType == sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE || + eRefType == sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE || + eRefType == sheet::DataPilotFieldReferenceType::RUNNING_TOTAL ) + { + sal_Int32 nColumn = comphelper::findValue( + GetDimensionsObject()->getElementNames(), aDataRefValues.back().ReferenceField); + if ( nColumn >= 0 ) + { + nDataRefOrient = GetOrientation(nColumn); + // need fully initialized results to find reference values + // (both in column or row dimensions), so updated values or + // differences to 0 can be displayed even for empty results. + bLateInit = false; + } + } + + aDataRefOrient.push_back(nDataRefOrient); + + aDataNames.push_back(pDim->getName()); + + //TODO: modify user visible strings as in ScDPResultData::GetMeasureString instead! + + aDataNames.back() = ScDPUtil::getSourceDimensionName(aDataNames.back()); + + //TODO: if the name is overridden by user, a flag must be set + //TODO: so the user defined name replaces the function string and field name. + + //TODO: the complete name (function and field) must be stored at the dimension + + tools::Long nSource = pDim->GetSourceDim(); + if (nSource >= 0) + aInfo.aDataSrcCols.push_back(nSource); + else + aInfo.aDataSrcCols.push_back(nDimIndex); + } + + pResData.reset( new ScDPResultData(*this) ); + pResData->SetMeasureData(aDataFunctions, aDataRefValues, aDataRefOrient, aDataNames); + pResData->SetDataLayoutOrientation(nDataOrient); + pResData->SetLateInit( bLateInit ); + + bool bHasAutoShow = false; + + ScDPInitState aInitState; + + // Page field selections restrict the members shown in related fields + // (both in column and row fields). aInitState is filled with the page + // field selections, they are kept across the data iterator loop. + + for (const auto& rDimIndex : maPageDims) + { + ScDPDimension* pDim = GetDimensionsObject()->getByIndex(rDimIndex); + if ( pDim->HasSelectedPage() ) + aInitState.AddMember(rDimIndex, GetCache()->GetIdByItemData(rDimIndex, pDim->GetSelectedData())); + } + + // Show grand total columns only when the option is set *and* there is at + // least one column field. Same for the grand total rows. + sheet::DataPilotFieldOrientation nDataLayoutOrient = GetDataLayoutOrientation(); + tools::Long nColDimCount2 = maColDims.size() - (nDataLayoutOrient == sheet::DataPilotFieldOrientation_COLUMN ? 1 : 0); + tools::Long nRowDimCount2 = maRowDims.size() - (nDataLayoutOrient == sheet::DataPilotFieldOrientation_ROW ? 1 : 0); + bool bShowColGrand = bColumnGrand && nColDimCount2 > 0; + bool bShowRowGrand = bRowGrand && nRowDimCount2 > 0; + pColResRoot.reset( new ScDPResultMember(pResData.get(), bShowColGrand) ); + pRowResRoot.reset( new ScDPResultMember(pResData.get(), bShowRowGrand) ); + + FillCalcInfo(false, aInfo, bHasAutoShow); + tools::Long nColLevelCount = aInfo.aColLevels.size(); + + pColResRoot->InitFrom( aInfo.aColDims, aInfo.aColLevels, 0, aInitState ); + pColResRoot->SetHasElements(); + + FillCalcInfo(true, aInfo, bHasAutoShow); + tools::Long nRowLevelCount = aInfo.aRowLevels.size(); + + if ( nRowLevelCount > 0 ) + { + // disable layout flags for the innermost row field (level) + aInfo.aRowLevels[nRowLevelCount-1]->SetEnableLayout( false ); + } + + pRowResRoot->InitFrom( aInfo.aRowDims, aInfo.aRowLevels, 0, aInitState ); + pRowResRoot->SetHasElements(); + + // initialize members object also for all page dimensions (needed for numeric groups) + for (const auto& rDimIndex : maPageDims) + { + ScDPDimension* pDim = GetDimensionsObject()->getByIndex(rDimIndex); + tools::Long nHierarchy = ScDPDimension::getUsedHierarchy(); + if ( nHierarchy >= ScDPHierarchies::getCount() ) + nHierarchy = 0; + + ScDPLevels* pLevels = pDim->GetHierarchiesObject()->getByIndex(nHierarchy)->GetLevelsObject(); + tools::Long nCount = pLevels->getCount(); + for (tools::Long j=0; j<nCount; j++) + pLevels->getByIndex(j)->GetMembersObject(); // initialize for groups + } + + // pre-check: calculate minimum number of result columns / rows from + // levels that have the "show all" flag set + + tools::Long nMinColMembers = lcl_CountMinMembers( aInfo.aColDims, aInfo.aColLevels, nColLevelCount ); + tools::Long nMinRowMembers = lcl_CountMinMembers( aInfo.aRowDims, aInfo.aRowLevels, nRowLevelCount ); + + if ( nMinColMembers > MAXCOLCOUNT/*SC_MINCOUNT_LIMIT*/ || nMinRowMembers > SC_MINCOUNT_LIMIT ) + { + // resulting table is too big -> abort before calculating + // (this relies on late init, so no members are allocated in InitFrom above) + + bResultOverflow = true; + return; + } + + FilterCacheByPageDimensions(); + + aInfo.aPageDims = maPageDims; + aInfo.pInitState = &aInitState; + aInfo.pColRoot = pColResRoot.get(); + aInfo.pRowRoot = pRowResRoot.get(); + pData->CalcResults(aInfo, false); + + pColResRoot->CheckShowEmpty(); + pRowResRoot->CheckShowEmpty(); + + // With all data processed, calculate the final results: + + // UpdateDataResults calculates all original results from the collected values, + // and stores them as reference values if needed. + pRowResRoot->UpdateDataResults( pColResRoot.get(), pResData->GetRowStartMeasure() ); + + if ( bHasAutoShow ) // do the double calculation only if AutoShow is used + { + // Find the desired members and set bAutoHidden flag for the others + pRowResRoot->DoAutoShow( pColResRoot.get() ); + + // Reset all results to empty, so they can be built again with data for the + // desired members only. + pColResRoot->ResetResults(); + pRowResRoot->ResetResults(); + pData->CalcResults(aInfo, true); + + // Call UpdateDataResults again, with the new (limited) values. + pRowResRoot->UpdateDataResults( pColResRoot.get(), pResData->GetRowStartMeasure() ); + } + + // SortMembers does the sorting by a result dimension, using the original results, + // but not running totals etc. + pRowResRoot->SortMembers( pColResRoot.get() ); + + // UpdateRunningTotals calculates running totals along column/row dimensions, + // differences from other members (named or relative), and column/row percentages + // or index values. + // Running totals and relative differences need to be done using the sorted values. + // Column/row percentages and index values must be done after sorting, because the + // results may no longer be in the right order (row total for percentage of row is + // always 1). + ScDPRunningTotalState aRunning( pColResRoot.get(), pRowResRoot.get() ); + ScDPRowTotals aTotals; + pRowResRoot->UpdateRunningTotals( pColResRoot.get(), pResData->GetRowStartMeasure(), aRunning, aTotals ); + +#if DUMP_PIVOT_TABLE + DumpResults(); +#endif +} + +void ScDPSource::FillLevelList( sheet::DataPilotFieldOrientation nOrientation, std::vector<ScDPLevel*> &rList ) +{ + rList.clear(); + + std::vector<sal_Int32>* pDimIndex = nullptr; + switch (nOrientation) + { + case sheet::DataPilotFieldOrientation_COLUMN: + pDimIndex = &maColDims; + break; + case sheet::DataPilotFieldOrientation_ROW: + pDimIndex = &maRowDims; + break; + case sheet::DataPilotFieldOrientation_DATA: + pDimIndex = &maDataDims; + break; + case sheet::DataPilotFieldOrientation_PAGE: + pDimIndex = &maPageDims; + break; + default: + OSL_FAIL( "ScDPSource::FillLevelList: unexpected orientation" ); + break; + } + if (!pDimIndex) + { + OSL_FAIL("invalid orientation"); + return; + } + + ScDPDimensions* pDims = GetDimensionsObject(); + for (const auto& rIndex : *pDimIndex) + { + ScDPDimension* pDim = pDims->getByIndex(rIndex); + OSL_ENSURE( pDim->getOrientation() == nOrientation, "orientations are wrong" ); + + ScDPHierarchies* pHiers = pDim->GetHierarchiesObject(); + sal_Int32 nHierarchy = ScDPDimension::getUsedHierarchy(); + if ( nHierarchy >= ScDPHierarchies::getCount() ) + nHierarchy = 0; + ScDPHierarchy* pHier = pHiers->getByIndex(nHierarchy); + ScDPLevels* pLevels = pHier->GetLevelsObject(); + sal_Int32 nLevCount = pLevels->getCount(); + for (sal_Int32 nLev=0; nLev<nLevCount; nLev++) + { + ScDPLevel* pLevel = pLevels->getByIndex(nLev); + rList.push_back(pLevel); + } + } +} + +void ScDPSource::FillMemberResults() +{ + if ( pColResults || pRowResults ) + return; + + CreateRes_Impl(); + + if ( bResultOverflow ) // set in CreateRes_Impl + { + // no results available -> abort (leave empty) + // exception is thrown in ScDPSource::getResults + return; + } + + FillLevelList( sheet::DataPilotFieldOrientation_COLUMN, aColLevelList ); + sal_Int32 nColLevelCount = aColLevelList.size(); + if (nColLevelCount) + { + tools::Long nColDimSize = pColResRoot->GetSize(pResData->GetColStartMeasure()); + pColResults.reset(new uno::Sequence<sheet::MemberResult>[nColLevelCount]); + for (tools::Long i=0; i<nColLevelCount; i++) + pColResults[i].realloc(nColDimSize); + + tools::Long nPos = 0; + pColResRoot->FillMemberResults( pColResults.get(), nPos, pResData->GetColStartMeasure(), + true, nullptr, nullptr ); + } + + FillLevelList( sheet::DataPilotFieldOrientation_ROW, aRowLevelList ); + tools::Long nRowLevelCount = aRowLevelList.size(); + if (nRowLevelCount) + { + tools::Long nRowDimSize = pRowResRoot->GetSize(pResData->GetRowStartMeasure()); + pRowResults.reset( new uno::Sequence<sheet::MemberResult>[nRowLevelCount] ); + for (tools::Long i=0; i<nRowLevelCount; i++) + pRowResults[i].realloc(nRowDimSize); + + tools::Long nPos = 0; + pRowResRoot->FillMemberResults( pRowResults.get(), nPos, pResData->GetRowStartMeasure(), + true, nullptr, nullptr ); + } +} + +const uno::Sequence<sheet::MemberResult>* ScDPSource::GetMemberResults( const ScDPLevel* pLevel ) +{ + FillMemberResults(); + + sal_Int32 i = 0; + sal_Int32 nColCount = aColLevelList.size(); + for (i=0; i<nColCount; i++) + { + ScDPLevel* pColLevel = aColLevelList[i]; + if ( pColLevel == pLevel ) + return &pColResults[i]; + } + sal_Int32 nRowCount = aRowLevelList.size(); + for (i=0; i<nRowCount; i++) + { + ScDPLevel* pRowLevel = aRowLevelList[i]; + if ( pRowLevel == pLevel ) + return &pRowResults[i]; + } + return nullptr; +} + +// XPropertySet + +uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPSource::getPropertySetInfo() +{ + using beans::PropertyAttribute::READONLY; + + static const SfxItemPropertyMapEntry aDPSourceMap_Impl[] = + { + { SC_UNO_DP_COLGRAND, 0, cppu::UnoType<bool>::get(), 0, 0 }, + { SC_UNO_DP_DATADESC, 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::READONLY, 0 }, + { SC_UNO_DP_IGNOREEMPTY, 0, cppu::UnoType<bool>::get(), 0, 0 }, // for sheet data only + { SC_UNO_DP_REPEATEMPTY, 0, cppu::UnoType<bool>::get(), 0, 0 }, // for sheet data only + { SC_UNO_DP_ROWGRAND, 0, cppu::UnoType<bool>::get(), 0, 0 }, + { SC_UNO_DP_ROWFIELDCOUNT, 0, cppu::UnoType<sal_Int32>::get(), READONLY, 0 }, + { SC_UNO_DP_COLUMNFIELDCOUNT, 0, cppu::UnoType<sal_Int32>::get(), READONLY, 0 }, + { SC_UNO_DP_DATAFIELDCOUNT, 0, cppu::UnoType<sal_Int32>::get(), READONLY, 0 }, + { SC_UNO_DP_GRANDTOTAL_NAME, 0, cppu::UnoType<OUString>::get(), 0, 0 }, + { u"", 0, css::uno::Type(), 0, 0 } + }; + static uno::Reference<beans::XPropertySetInfo> aRef = + new SfxItemPropertySetInfo( aDPSourceMap_Impl ); + return aRef; +} + +void SAL_CALL ScDPSource::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue ) +{ + if (aPropertyName == SC_UNO_DP_COLGRAND) + bColumnGrand = lcl_GetBoolFromAny(aValue); + else if (aPropertyName == SC_UNO_DP_ROWGRAND) + bRowGrand = lcl_GetBoolFromAny(aValue); + else if (aPropertyName == SC_UNO_DP_IGNOREEMPTY) + setIgnoreEmptyRows( lcl_GetBoolFromAny( aValue ) ); + else if (aPropertyName == SC_UNO_DP_REPEATEMPTY) + setRepeatIfEmpty( lcl_GetBoolFromAny( aValue ) ); + else if (aPropertyName == SC_UNO_DP_GRANDTOTAL_NAME) + { + OUString aName; + if (aValue >>= aName) + mpGrandTotalName = aName; + } + else + { + OSL_FAIL("unknown property"); + //TODO: THROW( UnknownPropertyException() ); + } +} + +uno::Any SAL_CALL ScDPSource::getPropertyValue( const OUString& aPropertyName ) +{ + uno::Any aRet; + if ( aPropertyName == SC_UNO_DP_COLGRAND ) + aRet <<= bColumnGrand; + else if ( aPropertyName == SC_UNO_DP_ROWGRAND ) + aRet <<= bRowGrand; + else if ( aPropertyName == SC_UNO_DP_IGNOREEMPTY ) + aRet <<= bIgnoreEmptyRows; + else if ( aPropertyName == SC_UNO_DP_REPEATEMPTY ) + aRet <<= bRepeatIfEmpty; + else if ( aPropertyName == SC_UNO_DP_DATADESC ) // read-only + aRet <<= getDataDescription(); + else if ( aPropertyName == SC_UNO_DP_ROWFIELDCOUNT ) // read-only + aRet <<= static_cast<sal_Int32>(maRowDims.size()); + else if ( aPropertyName == SC_UNO_DP_COLUMNFIELDCOUNT ) // read-only + aRet <<= static_cast<sal_Int32>(maColDims.size()); + else if ( aPropertyName == SC_UNO_DP_DATAFIELDCOUNT ) // read-only + aRet <<= static_cast<sal_Int32>(maDataDims.size()); + else if (aPropertyName == SC_UNO_DP_GRANDTOTAL_NAME) + { + if (mpGrandTotalName) + aRet <<= *mpGrandTotalName; + } + else + { + OSL_FAIL("unknown property"); + //TODO: THROW( UnknownPropertyException() ); + } + return aRet; +} + +#if DUMP_PIVOT_TABLE +void ScDPSource::DumpResults() const +{ + std::cout << "+++++ column root" << std::endl; + pColResRoot->Dump(1); + std::cout << "+++++ row root" << std::endl; + pRowResRoot->Dump(1); +} +#endif + +SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPSource ) + +ScDPDimensions::ScDPDimensions( ScDPSource* pSrc ) : + pSource( pSrc ) +{ + //TODO: hold pSource + + // include data layout dimension and duplicated dimensions + nDimCount = pSource->GetData()->GetColumnCount() + 1 + pSource->GetDupCount(); +} + +ScDPDimensions::~ScDPDimensions() +{ + //TODO: release pSource +} + +void ScDPDimensions::CountChanged() +{ + // include data layout dimension and duplicated dimensions + sal_Int32 nNewCount = pSource->GetData()->GetColumnCount() + 1 + pSource->GetDupCount(); + if ( ppDims ) + { + sal_Int32 i; + sal_Int32 nCopy = std::min( nNewCount, nDimCount ); + rtl::Reference<ScDPDimension>* ppNew = new rtl::Reference<ScDPDimension>[nNewCount]; + + for (i=0; i<nCopy; i++) // copy existing dims + ppNew[i] = ppDims[i]; + for (i=nCopy; i<nNewCount; i++) // clear additional pointers + ppNew[i] = nullptr; + + ppDims.reset( ppNew ); + } + nDimCount = nNewCount; +} + +// very simple XNameAccess implementation using getCount/getByIndex + +uno::Any SAL_CALL ScDPDimensions::getByName( const OUString& aName ) +{ + sal_Int32 nCount = getCount(); + for (sal_Int32 i=0; i<nCount; i++) + if ( getByIndex(i)->getName() == aName ) + { + uno::Reference<container::XNamed> xNamed = getByIndex(i); + uno::Any aRet; + aRet <<= xNamed; + return aRet; + } + + throw container::NoSuchElementException(); +// return uno::Any(); +} + +uno::Sequence<OUString> SAL_CALL ScDPDimensions::getElementNames() +{ + tools::Long nCount = getCount(); + uno::Sequence<OUString> aSeq(nCount); + OUString* pArr = aSeq.getArray(); + for (tools::Long i=0; i<nCount; i++) + pArr[i] = getByIndex(i)->getName(); + return aSeq; +} + +sal_Bool SAL_CALL ScDPDimensions::hasByName( const OUString& aName ) +{ + tools::Long nCount = getCount(); + for (tools::Long i=0; i<nCount; i++) + if ( getByIndex(i)->getName() == aName ) + return true; + return false; +} + +uno::Type SAL_CALL ScDPDimensions::getElementType() +{ + return cppu::UnoType<container::XNamed>::get(); +} + +sal_Bool SAL_CALL ScDPDimensions::hasElements() +{ + return ( getCount() > 0 ); +} + +// end of XNameAccess implementation + +tools::Long ScDPDimensions::getCount() const +{ + // in tabular data, every column of source data is a dimension + + return nDimCount; +} + +ScDPDimension* ScDPDimensions::getByIndex(tools::Long nIndex) const +{ + if ( nIndex >= 0 && nIndex < nDimCount ) + { + if ( !ppDims ) + { + const_cast<ScDPDimensions*>(this)->ppDims.reset(new rtl::Reference<ScDPDimension>[nDimCount] ); + for (tools::Long i=0; i<nDimCount; i++) + ppDims[i] = nullptr; + } + if ( !ppDims[nIndex].is() ) + { + ppDims[nIndex] = new ScDPDimension( pSource, nIndex ); + } + + return ppDims[nIndex].get(); + } + + return nullptr; //TODO: exception? +} + +ScDPDimension::ScDPDimension( ScDPSource* pSrc, tools::Long nD ) : + pSource( pSrc ), + nDim( nD ), + nFunction( ScGeneralFunction::SUM ), // sum is default + nSourceDim( -1 ), + bHasSelectedPage( false ), + mbHasHiddenMember(false) +{ + //TODO: hold pSource +} + +ScDPDimension::~ScDPDimension() +{ + //TODO: release pSource +} + +ScDPHierarchies* ScDPDimension::GetHierarchiesObject() +{ + if (!mxHierarchies.is()) + { + mxHierarchies = new ScDPHierarchies( pSource, nDim ); + } + return mxHierarchies.get(); +} + +const std::optional<OUString> & ScDPDimension::GetLayoutName() const +{ + return mpLayoutName; +} + +const std::optional<OUString> & ScDPDimension::GetSubtotalName() const +{ + return mpSubtotalName; +} + +uno::Reference<container::XNameAccess> SAL_CALL ScDPDimension::getHierarchies() +{ + return GetHierarchiesObject(); +} + +OUString SAL_CALL ScDPDimension::getName() +{ + if (!aName.isEmpty()) + return aName; + else + return pSource->GetData()->getDimensionName( nDim ); +} + +void SAL_CALL ScDPDimension::setName( const OUString& rNewName ) +{ + // used after cloning + aName = rNewName; +} + +sheet::DataPilotFieldOrientation ScDPDimension::getOrientation() const +{ + return pSource->GetOrientation( nDim ); +} + +bool ScDPDimension::getIsDataLayoutDimension() const +{ + return pSource->GetData()->getIsDataLayoutDimension( nDim ); +} + +void ScDPDimension::setFunction(ScGeneralFunction nNew) +{ + nFunction = nNew; +} + +ScDPDimension* ScDPDimension::CreateCloneObject() +{ + OSL_ENSURE( nSourceDim < 0, "recursive duplicate - not implemented" ); + + //TODO: set new name here, or temporary name ??? + OUString aNewName = aName; + + ScDPDimension* pNew = pSource->AddDuplicated( aNewName ); + + pNew->aName = aNewName; //TODO: here or in source? + pNew->nSourceDim = nDim; //TODO: recursive? + + return pNew; +} + +uno::Reference<util::XCloneable> SAL_CALL ScDPDimension::createClone() +{ + return CreateCloneObject(); +} + +const ScDPItemData& ScDPDimension::GetSelectedData() +{ + if ( !pSelectedData ) + { + // find the named member to initialize pSelectedData from it, with name and value + + tools::Long nLevel = 0; + + tools::Long nHierarchy = getUsedHierarchy(); + if ( nHierarchy >= ScDPHierarchies::getCount() ) + nHierarchy = 0; + ScDPLevels* pLevels = GetHierarchiesObject()->getByIndex(nHierarchy)->GetLevelsObject(); + tools::Long nLevCount = pLevels->getCount(); + if ( nLevel < nLevCount ) + { + ScDPMembers* pMembers = pLevels->getByIndex(nLevel)->GetMembersObject(); + + //TODO: merge with ScDPMembers::getByName + tools::Long nCount = pMembers->getCount(); + for (tools::Long i=0; i<nCount && !pSelectedData; i++) + { + ScDPMember* pMember = pMembers->getByIndex(i); + if (aSelectedPage == pMember->GetNameStr(false)) + { + pSelectedData.reset( new ScDPItemData(pMember->FillItemData()) ); + } + } + } + + if ( !pSelectedData ) + pSelectedData.reset( new ScDPItemData(aSelectedPage) ); // default - name only + } + + return *pSelectedData; +} + +// XPropertySet + +uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPDimension::getPropertySetInfo() +{ + static const SfxItemPropertyMapEntry aDPDimensionMap_Impl[] = + { + { SC_UNO_DP_FILTER, 0, cppu::UnoType<uno::Sequence<sheet::TableFilterField>>::get(), 0, 0 }, + { SC_UNO_DP_FLAGS, 0, cppu::UnoType<sal_Int32>::get(), beans::PropertyAttribute::READONLY, 0 }, + { SC_UNO_DP_FUNCTION, 0, cppu::UnoType<sheet::GeneralFunction>::get(), 0, 0 }, + { SC_UNO_DP_FUNCTION2, 0, cppu::UnoType<sal_Int16>::get(), 0, 0 }, + { SC_UNO_DP_ISDATALAYOUT, 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::READONLY, 0 }, + { SC_UNO_DP_NUMBERFO, 0, cppu::UnoType<sal_Int32>::get(), beans::PropertyAttribute::READONLY, 0 }, + { SC_UNO_DP_ORIENTATION, 0, cppu::UnoType<sheet::DataPilotFieldOrientation>::get(), 0, 0 }, + { SC_UNO_DP_ORIGINAL, 0, cppu::UnoType<container::XNamed>::get(), beans::PropertyAttribute::READONLY, 0 }, + { SC_UNO_DP_ORIGINAL_POS, 0, cppu::UnoType<sal_Int32>::get(), 0, 0 }, + { SC_UNO_DP_POSITION, 0, cppu::UnoType<sal_Int32>::get(), 0, 0 }, + { SC_UNO_DP_REFVALUE, 0, cppu::UnoType<sheet::DataPilotFieldReference>::get(), 0, 0 }, + { SC_UNO_DP_USEDHIERARCHY, 0, cppu::UnoType<sal_Int32>::get(), 0, 0 }, + { SC_UNO_DP_LAYOUTNAME, 0, cppu::UnoType<OUString>::get(), 0, 0 }, + { SC_UNO_DP_FIELD_SUBTOTALNAME, 0, cppu::UnoType<OUString>::get(), 0, 0 }, + { SC_UNO_DP_HAS_HIDDEN_MEMBER, 0, cppu::UnoType<bool>::get(), 0, 0 }, + { u"", 0, css::uno::Type(), 0, 0 } + }; + static uno::Reference<beans::XPropertySetInfo> aRef = + new SfxItemPropertySetInfo( aDPDimensionMap_Impl ); + return aRef; +} + +void SAL_CALL ScDPDimension::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue ) +{ + if ( aPropertyName == SC_UNO_DP_USEDHIERARCHY ) + { + // #i52547# don't use the incomplete date hierarchy implementation - ignore the call + } + else if ( aPropertyName == SC_UNO_DP_ORIENTATION ) + { + sheet::DataPilotFieldOrientation eEnum; + if (aValue >>= eEnum) + pSource->SetOrientation( nDim, eEnum ); + } + else if ( aPropertyName == SC_UNO_DP_FUNCTION ) + { + sheet::GeneralFunction eEnum; + if (aValue >>= eEnum) + setFunction( static_cast<ScGeneralFunction>(eEnum) ); + } + else if ( aPropertyName == SC_UNO_DP_FUNCTION2 ) + { + sal_Int16 eEnum; + if (aValue >>= eEnum) + setFunction( static_cast<ScGeneralFunction>(eEnum) ); + } + else if ( aPropertyName == SC_UNO_DP_REFVALUE ) + aValue >>= aReferenceValue; + else if ( aPropertyName == SC_UNO_DP_FILTER ) + { + bool bDone = false; + uno::Sequence<sheet::TableFilterField> aSeq; + if (aValue >>= aSeq) + { + sal_Int32 nLength = aSeq.getLength(); + if ( nLength == 0 ) + { + aSelectedPage.clear(); + bHasSelectedPage = false; + bDone = true; + } + else if ( nLength == 1 ) + { + const sheet::TableFilterField& rField = aSeq[0]; + if ( rField.Field == 0 && rField.Operator == sheet::FilterOperator_EQUAL && !rField.IsNumeric ) + { + aSelectedPage = rField.StringValue; + bHasSelectedPage = true; + bDone = true; + } + } + } + if ( !bDone ) + { + OSL_FAIL("Filter property is not a single string"); + throw lang::IllegalArgumentException(); + } + pSelectedData.reset(); // invalid after changing aSelectedPage + } + else if (aPropertyName == SC_UNO_DP_LAYOUTNAME) + { + OUString aTmpName; + if (aValue >>= aTmpName) + mpLayoutName = aTmpName; + } + else if (aPropertyName == SC_UNO_DP_FIELD_SUBTOTALNAME) + { + OUString aTmpName; + if (aValue >>= aTmpName) + mpSubtotalName = aTmpName; + } + else if (aPropertyName == SC_UNO_DP_HAS_HIDDEN_MEMBER) + { + bool b = false; + aValue >>= b; + mbHasHiddenMember = b; + } + else + { + OSL_FAIL("unknown property"); + //TODO: THROW( UnknownPropertyException() ); + } +} + +uno::Any SAL_CALL ScDPDimension::getPropertyValue( const OUString& aPropertyName ) +{ + uno::Any aRet; + if ( aPropertyName == SC_UNO_DP_POSITION ) + aRet <<= pSource->GetPosition( nDim ); + else if ( aPropertyName == SC_UNO_DP_USEDHIERARCHY ) + aRet <<= static_cast<sal_Int32>(getUsedHierarchy()); + else if ( aPropertyName == SC_UNO_DP_ORIENTATION ) + { + sheet::DataPilotFieldOrientation eVal = getOrientation(); + aRet <<= eVal; + } + else if ( aPropertyName == SC_UNO_DP_FUNCTION ) + { + ScGeneralFunction nVal = getFunction(); + if (nVal == ScGeneralFunction::MEDIAN) + nVal = ScGeneralFunction::NONE; + const int nValAsInt = static_cast<int>(nVal); + assert(nValAsInt >= int(css::sheet::GeneralFunction_NONE) && + nValAsInt <= int(css::sheet::GeneralFunction_VARP)); + aRet <<= static_cast<sheet::GeneralFunction>(nValAsInt); + } + else if ( aPropertyName == SC_UNO_DP_FUNCTION2 ) + { + ScGeneralFunction eVal = getFunction(); + aRet <<= static_cast<sal_Int16>(eVal); + } + else if ( aPropertyName == SC_UNO_DP_REFVALUE ) + aRet <<= aReferenceValue; + else if ( aPropertyName == SC_UNO_DP_ISDATALAYOUT ) // read-only properties + aRet <<= getIsDataLayoutDimension(); + else if ( aPropertyName == SC_UNO_DP_NUMBERFO ) + { + sal_Int32 nFormat = 0; + ScGeneralFunction eFunc = getFunction(); + // #i63745# don't use source format for "count" + if ( eFunc != ScGeneralFunction::COUNT && eFunc != ScGeneralFunction::COUNTNUMS ) + nFormat = pSource->GetData()->GetNumberFormat( ( nSourceDim >= 0 ) ? nSourceDim : nDim ); + + switch ( aReferenceValue.ReferenceType ) + { + case sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE: + case sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE: + case sheet::DataPilotFieldReferenceType::ROW_PERCENTAGE: + case sheet::DataPilotFieldReferenceType::COLUMN_PERCENTAGE: + case sheet::DataPilotFieldReferenceType::TOTAL_PERCENTAGE: + nFormat = pSource->GetData()->GetNumberFormatByIdx( NF_PERCENT_DEC2 ); + break; + case sheet::DataPilotFieldReferenceType::INDEX: + nFormat = pSource->GetData()->GetNumberFormatByIdx( NF_NUMBER_SYSTEM ); + break; + default: + break; + } + + aRet <<= nFormat; + } + else if ( aPropertyName == SC_UNO_DP_ORIGINAL ) + { + uno::Reference<container::XNamed> xOriginal; + if (nSourceDim >= 0) + xOriginal = pSource->GetDimensionsObject()->getByIndex(nSourceDim); + aRet <<= xOriginal; + } + else if (aPropertyName == SC_UNO_DP_ORIGINAL_POS) + { + aRet <<= nSourceDim; + } + else if ( aPropertyName == SC_UNO_DP_FILTER ) + { + if ( bHasSelectedPage ) + { + // single filter field: first field equal to selected string + sheet::TableFilterField aField( sheet::FilterConnection_AND, 0, + sheet::FilterOperator_EQUAL, false, 0.0, aSelectedPage ); + aRet <<= uno::Sequence<sheet::TableFilterField>( &aField, 1 ); + } + else + aRet <<= uno::Sequence<sheet::TableFilterField>(0); + } + else if (aPropertyName == SC_UNO_DP_LAYOUTNAME) + aRet <<= mpLayoutName ? *mpLayoutName : OUString(); + else if (aPropertyName == SC_UNO_DP_FIELD_SUBTOTALNAME) + aRet <<= mpSubtotalName ? *mpSubtotalName : OUString(); + else if (aPropertyName == SC_UNO_DP_HAS_HIDDEN_MEMBER) + aRet <<= mbHasHiddenMember; + else if (aPropertyName == SC_UNO_DP_FLAGS) + { + aRet <<= sal_Int32(0); // tabular data: all orientations are possible + } + else + { + OSL_FAIL("unknown property"); + //TODO: THROW( UnknownPropertyException() ); + } + return aRet; +} + +SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPDimension ) + +ScDPHierarchies::ScDPHierarchies( ScDPSource* pSrc, tools::Long nD ) : + pSource( pSrc ), + nDim( nD ) +{ + //TODO: hold pSource +} + +ScDPHierarchies::~ScDPHierarchies() +{ + //TODO: release pSource +} + +// very simple XNameAccess implementation using getCount/getByIndex + +uno::Any SAL_CALL ScDPHierarchies::getByName( const OUString& aName ) +{ + tools::Long nCount = getCount(); + for (tools::Long i=0; i<nCount; i++) + if ( getByIndex(i)->getName() == aName ) + { + uno::Reference<container::XNamed> xNamed = getByIndex(i); + uno::Any aRet; + aRet <<= xNamed; + return aRet; + } + + throw container::NoSuchElementException(); +} + +uno::Sequence<OUString> SAL_CALL ScDPHierarchies::getElementNames() +{ + tools::Long nCount = getCount(); + uno::Sequence<OUString> aSeq(nCount); + OUString* pArr = aSeq.getArray(); + for (tools::Long i=0; i<nCount; i++) + pArr[i] = getByIndex(i)->getName(); + return aSeq; +} + +sal_Bool SAL_CALL ScDPHierarchies::hasByName( const OUString& aName ) +{ + tools::Long nCount = getCount(); + for (tools::Long i=0; i<nCount; i++) + if ( getByIndex(i)->getName() == aName ) + return true; + return false; +} + +uno::Type SAL_CALL ScDPHierarchies::getElementType() +{ + return cppu::UnoType<container::XNamed>::get(); +} + +sal_Bool SAL_CALL ScDPHierarchies::hasElements() +{ + return ( getCount() > 0 ); +} + +// end of XNameAccess implementation + +sal_Int32 ScDPHierarchies::getCount() +{ + return nHierCount; +} + +ScDPHierarchy* ScDPHierarchies::getByIndex(tools::Long nIndex) const +{ + // pass hierarchy index to new object in case the implementation + // will be extended to more than one hierarchy + + if ( nIndex >= 0 && nIndex < nHierCount ) + { + if ( !ppHiers ) + { + const_cast<ScDPHierarchies*>(this)->ppHiers.reset( new rtl::Reference<ScDPHierarchy>[nHierCount] ); + for (sal_Int32 i=0; i<nHierCount; i++) + ppHiers[i] = nullptr; + } + if ( !ppHiers[nIndex].is() ) + { + ppHiers[nIndex] = new ScDPHierarchy( pSource, nDim, nIndex ); + } + + return ppHiers[nIndex].get(); + } + + return nullptr; //TODO: exception? +} + +ScDPHierarchy::ScDPHierarchy( ScDPSource* pSrc, sal_Int32 nD, sal_Int32 nH ) : + pSource( pSrc ), + nDim( nD ), + nHier( nH ) +{ + //TODO: hold pSource +} + +ScDPHierarchy::~ScDPHierarchy() +{ + //TODO: release pSource +} + +ScDPLevels* ScDPHierarchy::GetLevelsObject() +{ + if (!mxLevels.is()) + { + mxLevels = new ScDPLevels( pSource, nDim, nHier ); + } + return mxLevels.get(); +} + +uno::Reference<container::XNameAccess> SAL_CALL ScDPHierarchy::getLevels() +{ + return GetLevelsObject(); +} + +OUString SAL_CALL ScDPHierarchy::getName() +{ + OUString aRet; //TODO: globstr-ID !!!! + switch (nHier) + { + case SC_DAPI_HIERARCHY_FLAT: + aRet = "flat"; + break; //TODO: name ??????? + case SC_DAPI_HIERARCHY_QUARTER: + aRet = "Quarter"; + break; //TODO: name ??????? + case SC_DAPI_HIERARCHY_WEEK: + aRet = "Week"; + break; //TODO: name ??????? + default: + OSL_FAIL( "ScDPHierarchy::getName: unexpected hierarchy" ); + break; + } + return aRet; +} + +void SAL_CALL ScDPHierarchy::setName( const OUString& /* rNewName */ ) +{ + OSL_FAIL("not implemented"); //TODO: exception? +} + +ScDPLevels::ScDPLevels( ScDPSource* pSrc, sal_Int32 nD, sal_Int32 nH ) : + pSource( pSrc ), + nDim( nD ), + nHier( nH ) +{ + //TODO: hold pSource + + // text columns have only one level + + tools::Long nSrcDim = pSource->GetSourceDim( nDim ); + if ( pSource->IsDateDimension( nSrcDim ) ) + { + switch ( nHier ) + { + case SC_DAPI_HIERARCHY_FLAT: nLevCount = SC_DAPI_FLAT_LEVELS; break; + case SC_DAPI_HIERARCHY_QUARTER: nLevCount = SC_DAPI_QUARTER_LEVELS; break; + case SC_DAPI_HIERARCHY_WEEK: nLevCount = SC_DAPI_WEEK_LEVELS; break; + default: + OSL_FAIL("wrong hierarchy"); + nLevCount = 0; + } + } + else + nLevCount = 1; +} + +ScDPLevels::~ScDPLevels() +{ + //TODO: release pSource +} + +// very simple XNameAccess implementation using getCount/getByIndex + +uno::Any SAL_CALL ScDPLevels::getByName( const OUString& aName ) +{ + tools::Long nCount = getCount(); + for (tools::Long i=0; i<nCount; i++) + if ( getByIndex(i)->getName() == aName ) + { + uno::Reference<container::XNamed> xNamed = getByIndex(i); + uno::Any aRet; + aRet <<= xNamed; + return aRet; + } + + throw container::NoSuchElementException(); +} + +uno::Sequence<OUString> SAL_CALL ScDPLevels::getElementNames() +{ + tools::Long nCount = getCount(); + uno::Sequence<OUString> aSeq(nCount); + OUString* pArr = aSeq.getArray(); + for (tools::Long i=0; i<nCount; i++) + pArr[i] = getByIndex(i)->getName(); + return aSeq; +} + +sal_Bool SAL_CALL ScDPLevels::hasByName( const OUString& aName ) +{ + tools::Long nCount = getCount(); + for (tools::Long i=0; i<nCount; i++) + if ( getByIndex(i)->getName() == aName ) + return true; + return false; +} + +uno::Type SAL_CALL ScDPLevels::getElementType() +{ + return cppu::UnoType<container::XNamed>::get(); +} + +sal_Bool SAL_CALL ScDPLevels::hasElements() +{ + return ( getCount() > 0 ); +} + +// end of XNameAccess implementation + +sal_Int32 ScDPLevels::getCount() const +{ + return nLevCount; +} + +ScDPLevel* ScDPLevels::getByIndex(sal_Int32 nIndex) const +{ + if ( nIndex >= 0 && nIndex < nLevCount ) + { + if ( !ppLevs ) + { + const_cast<ScDPLevels*>(this)->ppLevs.reset(new rtl::Reference<ScDPLevel>[nLevCount] ); + for (tools::Long i=0; i<nLevCount; i++) + ppLevs[i] = nullptr; + } + if ( !ppLevs[nIndex].is() ) + { + ppLevs[nIndex] = new ScDPLevel( pSource, nDim, nHier, nIndex ); + } + + return ppLevs[nIndex].get(); + } + + return nullptr; //TODO: exception? +} + +namespace { + +class ScDPGlobalMembersOrder +{ + ScDPLevel& rLevel; + bool bAscending; + +public: + ScDPGlobalMembersOrder( ScDPLevel& rLev, bool bAsc ) : + rLevel(rLev), + bAscending(bAsc) + {} + + bool operator()( sal_Int32 nIndex1, sal_Int32 nIndex2 ) const; +}; + +} + +bool ScDPGlobalMembersOrder::operator()( sal_Int32 nIndex1, sal_Int32 nIndex2 ) const +{ + sal_Int32 nCompare = 0; + // seems that some ::std::sort() implementations pass the same index twice + if( nIndex1 != nIndex2 ) + { + ScDPMembers* pMembers = rLevel.GetMembersObject(); + ScDPMember* pMember1 = pMembers->getByIndex(nIndex1); + ScDPMember* pMember2 = pMembers->getByIndex(nIndex2); + nCompare = pMember1->Compare( *pMember2 ); + } + return bAscending ? (nCompare < 0) : (nCompare > 0); +} + +ScDPLevel::ScDPLevel( ScDPSource* pSrc, sal_Int32 nD, sal_Int32 nH, sal_Int32 nL ) : + pSource( pSrc ), + nDim( nD ), + nHier( nH ), + nLev( nL ), + aSortInfo( OUString(), true, sheet::DataPilotFieldSortMode::NAME ), // default: sort by name + nSortMeasure( 0 ), + nAutoMeasure( 0 ), + bShowEmpty( false ), + bEnableLayout( false ), + bRepeatItemLabels( false ) +{ + //TODO: hold pSource + // aSubTotals is empty +} + +ScDPLevel::~ScDPLevel() +{ + //TODO: release pSource +} + +void ScDPLevel::EvaluateSortOrder() +{ + switch (aSortInfo.Mode) + { + case sheet::DataPilotFieldSortMode::DATA: + { + // find index of measure (index among data dimensions) + + tools::Long nMeasureCount = pSource->GetDataDimensionCount(); + for (tools::Long nMeasure=0; nMeasure<nMeasureCount; nMeasure++) + { + if (pSource->GetDataDimName(nMeasure) == aSortInfo.Field) + { + nSortMeasure = nMeasure; + break; + } + } + + //TODO: error if not found? + } + break; + case sheet::DataPilotFieldSortMode::MANUAL: + case sheet::DataPilotFieldSortMode::NAME: + { + ScDPMembers* pLocalMembers = GetMembersObject(); + tools::Long nCount = pLocalMembers->getCount(); + + aGlobalOrder.resize( nCount ); + for (tools::Long nPos=0; nPos<nCount; nPos++) + aGlobalOrder[nPos] = nPos; + + // allow manual or name (manual is always ascending) + bool bAscending = ( aSortInfo.Mode == sheet::DataPilotFieldSortMode::MANUAL || aSortInfo.IsAscending ); + ScDPGlobalMembersOrder aComp( *this, bAscending ); + ::std::sort( aGlobalOrder.begin(), aGlobalOrder.end(), aComp ); + } + break; + } + + if ( !aAutoShowInfo.IsEnabled ) + return; + + // find index of measure (index among data dimensions) + + tools::Long nMeasureCount = pSource->GetDataDimensionCount(); + for (tools::Long nMeasure=0; nMeasure<nMeasureCount; nMeasure++) + { + if (pSource->GetDataDimName(nMeasure) == aAutoShowInfo.DataField) + { + nAutoMeasure = nMeasure; + break; + } + } + + //TODO: error if not found? +} + +void ScDPLevel::SetEnableLayout(bool bSet) +{ + bEnableLayout = bSet; +} + +ScDPMembers* ScDPLevel::GetMembersObject() +{ + if (!mxMembers.is()) + { + mxMembers = new ScDPMembers( pSource, nDim, nHier, nLev ); + } + return mxMembers.get(); +} + +uno::Reference<sheet::XMembersAccess> SAL_CALL ScDPLevel::getMembers() +{ + return GetMembersObject(); +} + +uno::Sequence<sheet::MemberResult> SAL_CALL ScDPLevel::getResults() +{ + const uno::Sequence<sheet::MemberResult>* pRes = pSource->GetMemberResults( this ); + if (pRes) + return *pRes; + + return {}; //TODO: Error? +} + +OUString SAL_CALL ScDPLevel::getName() +{ + tools::Long nSrcDim = pSource->GetSourceDim( nDim ); + if ( pSource->IsDateDimension( nSrcDim ) ) + { + OUString aRet; //TODO: globstr-ID !!!! + + if ( nHier == SC_DAPI_HIERARCHY_QUARTER ) + { + switch ( nLev ) + { + case SC_DAPI_LEVEL_YEAR: + aRet = "Year"; + break; + case SC_DAPI_LEVEL_QUARTER: + aRet = "Quarter"; + break; + case SC_DAPI_LEVEL_MONTH: + aRet = "Month"; + break; + case SC_DAPI_LEVEL_DAY: + aRet = "Day"; + break; + default: + OSL_FAIL( "ScDPLevel::getName: unexpected level" ); + break; + } + } + else if ( nHier == SC_DAPI_HIERARCHY_WEEK ) + { + switch ( nLev ) + { + case SC_DAPI_LEVEL_YEAR: + aRet = "Year"; + break; + case SC_DAPI_LEVEL_WEEK: + aRet = "Week"; + break; + case SC_DAPI_LEVEL_WEEKDAY: + aRet = "Weekday"; + break; + default: + OSL_FAIL( "ScDPLevel::getName: unexpected level" ); + break; + } + } + if (!aRet.isEmpty()) + return aRet; + } + + ScDPDimension* pDim = pSource->GetDimensionsObject()->getByIndex(nSrcDim); + if (!pDim) + return OUString(); + + return pDim->getName(); +} + +void SAL_CALL ScDPLevel::setName( const OUString& /* rNewName */ ) +{ + OSL_FAIL("not implemented"); //TODO: exception? +} + +uno::Sequence<sal_Int16> ScDPLevel::getSubTotals() const +{ + //TODO: separate functions for settings and evaluation? + + tools::Long nSrcDim = pSource->GetSourceDim( nDim ); + if ( !pSource->SubTotalAllowed( nSrcDim ) ) + return {}; + + return aSubTotals; +} + +// XPropertySet + +uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPLevel::getPropertySetInfo() +{ + static const SfxItemPropertyMapEntry aDPLevelMap_Impl[] = + { + //TODO: change type of AutoShow/Layout/Sorting to API struct when available + { SC_UNO_DP_AUTOSHOW, 0, cppu::UnoType<sheet::DataPilotFieldAutoShowInfo>::get(), 0, 0 }, + { SC_UNO_DP_LAYOUT, 0, cppu::UnoType<sheet::DataPilotFieldLayoutInfo>::get(), 0, 0 }, + { SC_UNO_DP_SHOWEMPTY, 0, cppu::UnoType<bool>::get(), 0, 0 }, + { SC_UNO_DP_REPEATITEMLABELS, 0, cppu::UnoType<bool>::get(), 0, 0 }, + { SC_UNO_DP_SORTING, 0, cppu::UnoType<sheet::DataPilotFieldSortInfo>::get(), 0, 0 }, + { SC_UNO_DP_SUBTOTAL, 0, cppu::UnoType<uno::Sequence<sheet::GeneralFunction>>::get(), 0, 0 }, + { SC_UNO_DP_SUBTOTAL2, 0, cppu::UnoType<uno::Sequence<sal_Int16>>::get(), 0, 0 }, + { u"", 0, css::uno::Type(), 0, 0 } + }; + static uno::Reference<beans::XPropertySetInfo> aRef = + new SfxItemPropertySetInfo( aDPLevelMap_Impl ); + return aRef; +} + +void SAL_CALL ScDPLevel::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue ) +{ + if ( aPropertyName == SC_UNO_DP_SHOWEMPTY ) + bShowEmpty = lcl_GetBoolFromAny(aValue); + else if ( aPropertyName == SC_UNO_DP_REPEATITEMLABELS ) + bRepeatItemLabels = lcl_GetBoolFromAny(aValue); + else if ( aPropertyName == SC_UNO_DP_SUBTOTAL ) + { + uno::Sequence<sheet::GeneralFunction> aSeq; + aValue >>= aSeq; + aSubTotals.realloc(aSeq.getLength()); + std::transform(std::cbegin(aSeq), std::cend(aSeq), aSubTotals.getArray(), + [](const sheet::GeneralFunction& rFunc) -> sal_Int16 { + return static_cast<sal_Int16>(rFunc); }); + } + else if ( aPropertyName == SC_UNO_DP_SUBTOTAL2 ) + aValue >>= aSubTotals; + else if ( aPropertyName == SC_UNO_DP_SORTING ) + aValue >>= aSortInfo; + else if ( aPropertyName == SC_UNO_DP_AUTOSHOW ) + aValue >>= aAutoShowInfo; + else if ( aPropertyName == SC_UNO_DP_LAYOUT ) + aValue >>= aLayoutInfo; + else + { + OSL_FAIL("unknown property"); + } +} + +uno::Any SAL_CALL ScDPLevel::getPropertyValue( const OUString& aPropertyName ) +{ + uno::Any aRet; + if ( aPropertyName == SC_UNO_DP_SHOWEMPTY ) + aRet <<= bShowEmpty; + else if ( aPropertyName == SC_UNO_DP_REPEATITEMLABELS ) + aRet <<= bRepeatItemLabels; + else if ( aPropertyName == SC_UNO_DP_SUBTOTAL ) + { + const uno::Sequence<sal_Int16> aSeq = getSubTotals(); + uno::Sequence<sheet::GeneralFunction> aNewSeq(aSeq.getLength()); + std::transform(aSeq.begin(), aSeq.end(), aNewSeq.getArray(), + [](const sal_Int16 nFunc) -> sheet::GeneralFunction { + if (nFunc == sheet::GeneralFunction2::MEDIAN) + return sheet::GeneralFunction_NONE; + return static_cast<sheet::GeneralFunction>(nFunc); + }); + + aRet <<= aNewSeq; + } + else if ( aPropertyName == SC_UNO_DP_SUBTOTAL2 ) + { + uno::Sequence<sal_Int16> aSeq = getSubTotals(); //TODO: avoid extra copy? + aRet <<= aSeq; + } + else if ( aPropertyName == SC_UNO_DP_SORTING ) + aRet <<= aSortInfo; + else if ( aPropertyName == SC_UNO_DP_AUTOSHOW ) + aRet <<= aAutoShowInfo; + else if ( aPropertyName == SC_UNO_DP_LAYOUT ) + aRet <<= aLayoutInfo; + else if (aPropertyName == SC_UNO_DP_LAYOUTNAME) + { + // read only property + tools::Long nSrcDim = pSource->GetSourceDim(nDim); + ScDPDimension* pDim = pSource->GetDimensionsObject()->getByIndex(nSrcDim); + if (!pDim) + return aRet; + + const std::optional<OUString> & pLayoutName = pDim->GetLayoutName(); + if (!pLayoutName) + return aRet; + + aRet <<= *pLayoutName; + } + else + { + OSL_FAIL("unknown property"); + } + return aRet; +} + +SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPLevel ) + +ScDPMembers::ScDPMembers( ScDPSource* pSrc, sal_Int32 nD, sal_Int32 nH, sal_Int32 nL ) : + pSource( pSrc ), + nDim( nD ), + nHier( nH ), + nLev( nL ) +{ + //TODO: hold pSource + + tools::Long nSrcDim = pSource->GetSourceDim( nDim ); + if ( pSource->IsDataLayoutDimension(nSrcDim) ) + nMbrCount = pSource->GetDataDimensionCount(); + else if ( nHier != SC_DAPI_HIERARCHY_FLAT && pSource->IsDateDimension( nSrcDim ) ) + { + nMbrCount = 0; + if ( nHier == SC_DAPI_HIERARCHY_QUARTER ) + { + switch (nLev) + { + case SC_DAPI_LEVEL_YEAR: + { + const ScDPItemData* pLastNumData = nullptr; + for ( SCROW n = 0; n < static_cast<SCROW>(pSource->GetData()->GetColumnEntries(nDim).size()); n-- ) + { + const ScDPItemData* pData = GetSrcItemDataByIndex( n ); + if ( pData && pData->HasStringData() ) + break; + else + pLastNumData = pData; + } + + if ( pLastNumData ) + { + const ScDPItemData* pFirstData = GetSrcItemDataByIndex( 0 ); + double fFirstVal = pFirstData->GetValue(); + double fLastVal = pLastNumData->GetValue(); + + tools::Long nFirstYear = pSource->GetData()->GetDatePart( + static_cast<tools::Long>(::rtl::math::approxFloor( fFirstVal )), + nHier, nLev ); + tools::Long nLastYear = pSource->GetData()->GetDatePart( + static_cast<tools::Long>(::rtl::math::approxFloor( fLastVal )), + nHier, nLev ); + + nMbrCount = nLastYear + 1 - nFirstYear; + } + else + nMbrCount = 0; // no values + } + break; + case SC_DAPI_LEVEL_QUARTER: nMbrCount = 4; break; + case SC_DAPI_LEVEL_MONTH: nMbrCount = 12; break; + case SC_DAPI_LEVEL_DAY: nMbrCount = 31; break; + default: + OSL_FAIL( "ScDPMembers::ScDPMembers: unexpected level" ); + break; + } + } + else if ( nHier == SC_DAPI_HIERARCHY_WEEK ) + { + switch (nLev) + { + case SC_DAPI_LEVEL_YEAR: nMbrCount = 1; break; //TODO: get years from source + case SC_DAPI_LEVEL_WEEK: nMbrCount = 53; break; + case SC_DAPI_LEVEL_WEEKDAY: nMbrCount = 7; break; + default: + OSL_FAIL( "ScDPMembers::ScDPMembers: unexpected level" ); + break; + } + } + } + else + nMbrCount = pSource->GetData()->GetMembersCount( nSrcDim ); +} + +ScDPMembers::~ScDPMembers() +{ +} + +// XNameAccess implementation using getCount/getByIndex + +sal_Int32 ScDPMembers::GetIndexFromName( const OUString& rName ) const +{ + if ( aHashMap.empty() ) + { + // store the index for each name + + sal_Int32 nCount = getCount(); + for (sal_Int32 i=0; i<nCount; i++) + aHashMap[ getByIndex(i)->getName() ] = i; + } + + ScDPMembersHashMap::const_iterator aIter = aHashMap.find( rName ); + if ( aIter != aHashMap.end() ) + return aIter->second; // found index + else + return -1; // not found +} + +uno::Any SAL_CALL ScDPMembers::getByName( const OUString& aName ) +{ + sal_Int32 nIndex = GetIndexFromName( aName ); + if ( nIndex >= 0 ) + { + uno::Reference<container::XNamed> xNamed = getByIndex(nIndex); + uno::Any aRet; + aRet <<= xNamed; + return aRet; + } + + throw container::NoSuchElementException(); +} + +uno::Sequence<OUString> SAL_CALL ScDPMembers::getElementNames() +{ + return getElementNames( false ); +} + +sal_Bool SAL_CALL ScDPMembers::hasByName( const OUString& aName ) +{ + return ( GetIndexFromName( aName ) >= 0 ); +} + +uno::Type SAL_CALL ScDPMembers::getElementType() +{ + return cppu::UnoType<container::XNamed>::get(); +} + +sal_Bool SAL_CALL ScDPMembers::hasElements() +{ + return ( getCount() > 0 ); +} + +// end of XNameAccess implementation + +// XMembersAccess implementation + +uno::Sequence<OUString> SAL_CALL ScDPMembers::getLocaleIndependentElementNames() +{ + return getElementNames( true ); +} + +// end of XMembersAccess implementation + +uno::Sequence<OUString> ScDPMembers::getElementNames( bool bLocaleIndependent ) const +{ + // Return list of names in sorted order, + // so it's displayed in that order in the field options dialog. + // Sorting is done at the level object (parent of this). + + ScDPLevel* pLevel = pSource->GetDimensionsObject()->getByIndex(nDim)-> + GetHierarchiesObject()->getByIndex(nHier)->GetLevelsObject()->getByIndex(nLev); + pLevel->EvaluateSortOrder(); + const std::vector<sal_Int32>& rGlobalOrder = pLevel->GetGlobalOrder(); + bool bSort = !rGlobalOrder.empty(); + + tools::Long nCount = getCount(); + uno::Sequence<OUString> aSeq(nCount); + OUString* pArr = aSeq.getArray(); + for (tools::Long i=0; i<nCount; i++) + pArr[i] = getByIndex(bSort ? rGlobalOrder[i] : i)->GetNameStr( bLocaleIndependent); + return aSeq; +} + +sal_Int32 ScDPMembers::getMinMembers() const +{ + // used in lcl_CountMinMembers + + sal_Int32 nVisCount = 0; + if (!maMembers.empty()) + { + nVisCount = std::count_if(maMembers.begin(), maMembers.end(), [](const rtl::Reference<ScDPMember>& pMbr) { + // count only visible with details (default is true for both) + return !pMbr || (pMbr->isVisible() && pMbr->getShowDetails()); }); + } + else + nVisCount = nMbrCount; // default for all + + return nVisCount; +} + +ScDPMember* ScDPMembers::getByIndex(sal_Int32 nIndex) const +{ + // result of GetColumnEntries must not change between ScDPMembers ctor + // and all calls to getByIndex + + if ( nIndex >= 0 && nIndex < nMbrCount ) + { + if (maMembers.empty()) + maMembers.resize(nMbrCount); + + if (!maMembers[nIndex]) + { + rtl::Reference<ScDPMember> pNew; + sal_Int32 nSrcDim = pSource->GetSourceDim( nDim ); + if ( pSource->IsDataLayoutDimension(nSrcDim) ) + { + // empty name (never shown, not used for lookup) + pNew.set(new ScDPMember(pSource, nDim, nHier, nLev, 0)); + } + else if ( nHier != SC_DAPI_HIERARCHY_FLAT && pSource->IsDateDimension( nSrcDim ) ) + { + sal_Int32 nGroupBy = 0; + sal_Int32 nVal = 0; + OUString aName; + + if ( nLev == SC_DAPI_LEVEL_YEAR ) // YEAR is in both hierarchies + { + //TODO: cache year range here! + + double fFirstVal = pSource->GetData()->GetMemberByIndex( nSrcDim, 0 )->GetValue(); + tools::Long nFirstYear = pSource->GetData()->GetDatePart( + static_cast<tools::Long>(::rtl::math::approxFloor( fFirstVal )), + nHier, nLev ); + + nVal = nFirstYear + nIndex; + } + else if ( nHier == SC_DAPI_HIERARCHY_WEEK && nLev == SC_DAPI_LEVEL_WEEKDAY ) + { + nVal = nIndex; // DayOfWeek is 0-based + aName = ScGlobal::GetCalendar().getDisplayName( + css::i18n::CalendarDisplayIndex::DAY, + sal::static_int_cast<sal_Int16>(nVal), 0 ); + } + else if ( nHier == SC_DAPI_HIERARCHY_QUARTER && nLev == SC_DAPI_LEVEL_MONTH ) + { + nVal = nIndex; // Month is 0-based + aName = ScGlobal::GetCalendar().getDisplayName( + css::i18n::CalendarDisplayIndex::MONTH, + sal::static_int_cast<sal_Int16>(nVal), 0 ); + } + else + nVal = nIndex + 1; // Quarter, Day, Week are 1-based + + switch (nLev) + { + case SC_DAPI_LEVEL_YEAR: + nGroupBy = sheet::DataPilotFieldGroupBy::YEARS; + break; + case SC_DAPI_LEVEL_QUARTER: + case SC_DAPI_LEVEL_WEEK: + nGroupBy = sheet::DataPilotFieldGroupBy::QUARTERS; + break; + case SC_DAPI_LEVEL_MONTH: + case SC_DAPI_LEVEL_WEEKDAY: + nGroupBy = sheet::DataPilotFieldGroupBy::MONTHS; + break; + case SC_DAPI_LEVEL_DAY: + nGroupBy = sheet::DataPilotFieldGroupBy::DAYS; + break; + default: + ; + } + if (aName.isEmpty()) + aName = OUString::number(nVal); + + ScDPItemData aData(nGroupBy, nVal); + SCROW nId = pSource->GetCache()->GetIdByItemData(nDim, aData); + pNew.set(new ScDPMember(pSource, nDim, nHier, nLev, nId)); + } + else + { + const std::vector<SCROW>& memberIndexs = pSource->GetData()->GetColumnEntries(nSrcDim); + pNew.set(new ScDPMember(pSource, nDim, nHier, nLev, memberIndexs[nIndex])); + } + maMembers[nIndex] = pNew; + } + + return maMembers[nIndex].get(); + } + + return nullptr; //TODO: exception? +} + +ScDPMember::ScDPMember( + ScDPSource* pSrc, sal_Int32 nD, sal_Int32 nH, sal_Int32 nL, SCROW nIndex) : + pSource( pSrc ), + nDim( nD ), + nHier( nH ), + nLev( nL ), + mnDataId( nIndex ), + nPosition( -1 ), + bVisible( true ), + bShowDet( true ) +{ + //TODO: hold pSource +} + +ScDPMember::~ScDPMember() +{ + //TODO: release pSource +} + +bool ScDPMember::IsNamedItem(SCROW nIndex) const +{ + sal_Int32 nSrcDim = pSource->GetSourceDim( nDim ); + if ( nHier != SC_DAPI_HIERARCHY_FLAT && pSource->IsDateDimension( nSrcDim ) ) + { + const ScDPItemData* pData = pSource->GetCache()->GetItemDataById(nDim, nIndex); + if (pData->IsValue()) + { + tools::Long nComp = pSource->GetData()->GetDatePart( + static_cast<tools::Long>(::rtl::math::approxFloor( pData->GetValue() )), + nHier, nLev ); + // fValue is converted from integer, so simple comparison works + const ScDPItemData* pData2 = GetItemData(); + return pData2 && nComp == pData2->GetValue(); + } + } + + return nIndex == mnDataId; +} + +sal_Int32 ScDPMember::Compare( const ScDPMember& rOther ) const +{ + if ( nPosition >= 0 ) + { + if ( rOther.nPosition >= 0 ) + { + OSL_ENSURE( nPosition != rOther.nPosition, "same position for two members" ); + return ( nPosition < rOther.nPosition ) ? -1 : 1; + } + else + { + // only this has a position - members with specified positions come before those without + return -1; + } + } + else if ( rOther.nPosition >= 0 ) + { + // only rOther has a position + return 1; + } + + // no positions set - compare names + return pSource->GetData()->Compare( pSource->GetSourceDim(nDim),mnDataId,rOther.GetItemDataId()); +} + +ScDPItemData ScDPMember::FillItemData() const +{ + //TODO: handle date hierarchy... + + const ScDPItemData* pData = GetItemData(); + return (pData ? *pData : ScDPItemData()); +} + +const std::optional<OUString> & ScDPMember::GetLayoutName() const +{ + return mpLayoutName; +} + +OUString ScDPMember::GetNameStr( bool bLocaleIndependent ) const +{ + const ScDPItemData* pData = GetItemData(); + if (pData) + return pSource->GetData()->GetFormattedString(nDim, *pData, bLocaleIndependent); + return OUString(); +} + +OUString SAL_CALL ScDPMember::getName() +{ + return GetNameStr( false ); +} + +void SAL_CALL ScDPMember::setName( const OUString& /* rNewName */ ) +{ + OSL_FAIL("not implemented"); //TODO: exception? +} + +// XPropertySet + +uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPMember::getPropertySetInfo() +{ + static const SfxItemPropertyMapEntry aDPMemberMap_Impl[] = + { + { SC_UNO_DP_ISVISIBLE, 0, cppu::UnoType<bool>::get(), 0, 0 }, + { SC_UNO_DP_POSITION, 0, cppu::UnoType<sal_Int32>::get(), 0, 0 }, + { SC_UNO_DP_SHOWDETAILS, 0, cppu::UnoType<bool>::get(), 0, 0 }, + { SC_UNO_DP_LAYOUTNAME, 0, cppu::UnoType<OUString>::get(), 0, 0 }, + { u"", 0, css::uno::Type(), 0, 0 } + }; + static uno::Reference<beans::XPropertySetInfo> aRef = + new SfxItemPropertySetInfo( aDPMemberMap_Impl ); + return aRef; +} + +void SAL_CALL ScDPMember::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue ) +{ + if ( aPropertyName == SC_UNO_DP_ISVISIBLE ) + bVisible = lcl_GetBoolFromAny(aValue); + else if ( aPropertyName == SC_UNO_DP_SHOWDETAILS ) + bShowDet = lcl_GetBoolFromAny(aValue); + else if ( aPropertyName == SC_UNO_DP_POSITION ) + aValue >>= nPosition; + else if (aPropertyName == SC_UNO_DP_LAYOUTNAME) + { + OUString aName; + if (aValue >>= aName) + mpLayoutName = aName; + } + else + { + OSL_FAIL("unknown property"); + } +} + +uno::Any SAL_CALL ScDPMember::getPropertyValue( const OUString& aPropertyName ) +{ + uno::Any aRet; + if ( aPropertyName == SC_UNO_DP_ISVISIBLE ) + aRet <<= bVisible; + else if ( aPropertyName == SC_UNO_DP_SHOWDETAILS ) + aRet <<= bShowDet; + else if ( aPropertyName == SC_UNO_DP_POSITION ) + aRet <<= nPosition; + else if (aPropertyName == SC_UNO_DP_LAYOUTNAME) + aRet <<= mpLayoutName ? *mpLayoutName : OUString(); + else + { + OSL_FAIL("unknown property"); + } + return aRet; +} + +SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPMember ) + +const ScDPCache* ScDPSource::GetCache() +{ + OSL_ENSURE( GetData() , "empty ScDPTableData pointer"); + return ( GetData()!=nullptr ) ? &GetData()->GetCacheTable().getCache() : nullptr ; +} + +const ScDPItemData* ScDPMember::GetItemData() const +{ + const ScDPItemData* pData = pSource->GetItemDataById(nDim, mnDataId); + SAL_WARN_IF( !pData, "sc.core", "ScDPMember::GetItemData: what data? nDim " << nDim << ", mnDataId " << mnDataId); + return pData; +} + +const ScDPItemData* ScDPSource::GetItemDataById(sal_Int32 nDim, sal_Int32 nId) +{ + return GetData()->GetMemberById(nDim, nId); +} + +const ScDPItemData* ScDPMembers::GetSrcItemDataByIndex(SCROW nIndex) +{ + const std::vector< SCROW >& memberIds = pSource->GetData()->GetColumnEntries( nDim ); + if ( nIndex < 0 || o3tl::make_unsigned(nIndex) >= memberIds.size() ) + return nullptr; + SCROW nId = memberIds[ nIndex ]; + return pSource->GetItemDataById( nDim, nId ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |