Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 420 insertions, 0 deletions

diff --git a/sc/source/core/data/dputil.cxx b/sc/source/core/data/dputil.cxx
new file mode 100644
index 000000000..651d55093
--- /dev/null
+++ b/sc/source/core/data/dputil.cxx
@@ -0,0 +1,420 @@
+/* -*- 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/.
+ */
+
+#include <dputil.hxx>
+#include <dpitemdata.hxx>
+#include <dpnumgroupinfo.hxx>
+#include <globstr.hrc>
+#include <scresid.hxx>
+#include <generalfunction.hxx>
+
+#include <comphelper/string.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <unotools/calendarwrapper.hxx>
+#include <svl/numformat.hxx>
+#include <svl/zforlist.hxx>
+#include <rtl/math.hxx>
+#include <o3tl/string_view.hxx>
+#include <osl/diagnose.h>
+
+#include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
+#include <com/sun/star/i18n/CalendarDisplayIndex.hpp>
+
+using namespace com::sun::star;
+
+namespace {
+
+const sal_uInt16 SC_DP_LEAPYEAR = 1648;     // arbitrary leap year for date calculations
+
+OUString getTwoDigitString(sal_Int32 nValue)
+{
+    OUString aRet = OUString::number( nValue );
+    if ( aRet.getLength() < 2 )
+        aRet = "0" + aRet;
+    return aRet;
+}
+
+void appendDateStr(OUStringBuffer& rBuffer, double fValue, SvNumberFormatter* pFormatter)
+{
+    sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, ScGlobal::eLnge );
+    OUString aString;
+    pFormatter->GetInputLineString(fValue, nFormat, aString);
+    rBuffer.append(aString);
+}
+
+OUString getSpecialDateName(double fValue, bool bFirst, SvNumberFormatter* pFormatter)
+{
+    OUStringBuffer aBuffer;
+    aBuffer.append( bFirst ? '<' : '>' );
+    appendDateStr(aBuffer, fValue, pFormatter);
+    return aBuffer.makeStringAndClear();
+}
+
+}
+
+bool ScDPUtil::isDuplicateDimension(std::u16string_view rName)
+{
+    return o3tl::ends_with(rName, u"*");
+}
+
+OUString ScDPUtil::getSourceDimensionName(std::u16string_view rName)
+{
+    return OUString(comphelper::string::stripEnd(rName, '*'));
+}
+
+sal_uInt8 ScDPUtil::getDuplicateIndex(const OUString& rName)
+{
+    // Count all trailing '*'s.
+
+    sal_Int32 n = rName.getLength();
+    if (!n)
+        return 0;
+
+    sal_uInt8 nDupCount = 0;
+    const sal_Unicode* p = rName.getStr();
+    const sal_Unicode* pStart = p;
+    p += n-1; // Set it to the last char.
+    for (; p != pStart; --p, ++nDupCount)
+    {
+        if (*p != '*')
+            break;
+    }
+
+    return nDupCount;
+}
+
+OUString ScDPUtil::createDuplicateDimensionName(const OUString& rOriginal, size_t nDupCount)
+{
+    if (!nDupCount)
+        return rOriginal;
+
+    OUStringBuffer aBuf(rOriginal);
+    for (size_t i = 0; i < nDupCount; ++i)
+        aBuf.append('*');
+
+    return aBuf.makeStringAndClear();
+}
+
+OUString ScDPUtil::getDateGroupName(
+        sal_Int32 nDatePart, sal_Int32 nValue, SvNumberFormatter* pFormatter,
+        double fStart, double fEnd)
+{
+    if (nValue == ScDPItemData::DateFirst)
+        return getSpecialDateName(fStart, true, pFormatter);
+    if (nValue == ScDPItemData::DateLast)
+        return getSpecialDateName(fEnd, false, pFormatter);
+
+    switch ( nDatePart )
+    {
+        case sheet::DataPilotFieldGroupBy::YEARS:
+            return OUString::number(nValue);
+        case sheet::DataPilotFieldGroupBy::QUARTERS:
+            return ScGlobal::getLocaleData().getQuarterAbbreviation(sal_Int16(nValue-1));    // nValue is 1-based
+        case css::sheet::DataPilotFieldGroupBy::MONTHS:
+            return ScGlobal::GetCalendar().getDisplayName(
+                        i18n::CalendarDisplayIndex::MONTH, sal_Int16(nValue-1), 0);    // 0-based, get short name
+        case sheet::DataPilotFieldGroupBy::DAYS:
+        {
+            Date aDate(1, 1, SC_DP_LEAPYEAR);
+            aDate.AddDays(nValue - 1);            // nValue is 1-based
+            tools::Long nDays = aDate - pFormatter->GetNullDate();
+
+            const sal_uInt32 nFormat = pFormatter->GetFormatIndex(NF_DATE_SYS_DDMMM, ScGlobal::eLnge);
+            const Color* pColor;
+            OUString aStr;
+            pFormatter->GetOutputString(nDays, nFormat, aStr, &pColor);
+            return aStr;
+        }
+        case sheet::DataPilotFieldGroupBy::HOURS:
+        {
+            //TODO: allow am/pm format?
+            return getTwoDigitString(nValue);
+        }
+        break;
+        case sheet::DataPilotFieldGroupBy::MINUTES:
+        case sheet::DataPilotFieldGroupBy::SECONDS:
+        {
+            return ScGlobal::getLocaleData().getTimeSep() + getTwoDigitString(nValue);
+        }
+        break;
+        default:
+            OSL_FAIL("invalid date part");
+    }
+
+    return "FIXME: unhandled value";
+}
+
+double ScDPUtil::getNumGroupStartValue(double fValue, const ScDPNumGroupInfo& rInfo)
+{
+    if (fValue < rInfo.mfStart && !rtl::math::approxEqual(fValue, rInfo.mfStart))
+        return -std::numeric_limits<double>::infinity();
+
+    if (fValue > rInfo.mfEnd && !rtl::math::approxEqual(fValue, rInfo.mfEnd))
+        return std::numeric_limits<double>::infinity();
+
+    double fDiff = fValue - rInfo.mfStart;
+    double fDiv = rtl::math::approxFloor( fDiff / rInfo.mfStep );
+    double fGroupStart = rInfo.mfStart + fDiv * rInfo.mfStep;
+
+    if (rtl::math::approxEqual(fGroupStart, rInfo.mfEnd) &&
+        !rtl::math::approxEqual(fGroupStart, rInfo.mfStart))
+    {
+        if (!rInfo.mbDateValues)
+        {
+            // A group that would consist only of the end value is not
+            // created, instead the value is included in the last group
+            // before. So the previous group is used if the calculated group
+            // start value is the selected end value.
+
+            fDiv -= 1.0;
+            return rInfo.mfStart + fDiv * rInfo.mfStep;
+        }
+
+        // For date values, the end value is instead treated as above the
+        // limit if it would be a group of its own.
+
+        return rInfo.mfEnd + rInfo.mfStep;
+    }
+
+    return fGroupStart;
+}
+
+namespace {
+
+void lcl_AppendDateStr( OUStringBuffer& rBuffer, double fValue, SvNumberFormatter* pFormatter )
+{
+    sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, ScGlobal::eLnge );
+    OUString aString;
+    pFormatter->GetInputLineString( fValue, nFormat, aString );
+    rBuffer.append( aString );
+}
+
+OUString lcl_GetSpecialNumGroupName( double fValue, bool bFirst, sal_Unicode cDecSeparator,
+    bool bDateValues, SvNumberFormatter* pFormatter )
+{
+    OSL_ENSURE( cDecSeparator != 0, "cDecSeparator not initialized" );
+
+    OUStringBuffer aBuffer;
+    aBuffer.append( bFirst ? '<' : '>' );
+    if ( bDateValues )
+        lcl_AppendDateStr( aBuffer, fValue, pFormatter );
+    else
+        rtl::math::doubleToUStringBuffer( aBuffer, fValue, rtl_math_StringFormat_Automatic,
+        rtl_math_DecimalPlaces_Max, cDecSeparator, true );
+    return aBuffer.makeStringAndClear();
+}
+
+OUString lcl_GetNumGroupName(
+    double fStartValue, const ScDPNumGroupInfo& rInfo, sal_Unicode cDecSep,
+    SvNumberFormatter* pFormatter)
+{
+    OSL_ENSURE( cDecSep != 0, "cDecSeparator not initialized" );
+
+    double fStep = rInfo.mfStep;
+    double fEndValue = fStartValue + fStep;
+    if (rInfo.mbIntegerOnly && (rInfo.mbDateValues || !rtl::math::approxEqual(fEndValue, rInfo.mfEnd)))
+    {
+        //  The second number of the group label is
+        //  (first number + size - 1) if there are only integer numbers,
+        //  (first number + size) if any non-integer numbers are involved.
+        //  Exception: The last group (containing the end value) is always
+        //  shown as including the end value (but not for dates).
+
+        fEndValue -= 1.0;
+    }
+
+    if ( fEndValue > rInfo.mfEnd && !rInfo.mbAutoEnd )
+    {
+        // limit the last group to the end value
+
+        fEndValue = rInfo.mfEnd;
+    }
+
+    OUStringBuffer aBuffer;
+    if ( rInfo.mbDateValues )
+    {
+        lcl_AppendDateStr( aBuffer, fStartValue, pFormatter );
+        aBuffer.append( " - " );   // with spaces
+        lcl_AppendDateStr( aBuffer, fEndValue, pFormatter );
+    }
+    else
+    {
+        rtl::math::doubleToUStringBuffer( aBuffer, fStartValue, rtl_math_StringFormat_Automatic,
+            rtl_math_DecimalPlaces_Max, cDecSep, true );
+        aBuffer.append( '-' );
+        rtl::math::doubleToUStringBuffer( aBuffer, fEndValue, rtl_math_StringFormat_Automatic,
+            rtl_math_DecimalPlaces_Max, cDecSep, true );
+    }
+
+    return aBuffer.makeStringAndClear();
+}
+
+}
+
+OUString ScDPUtil::getNumGroupName(
+    double fValue, const ScDPNumGroupInfo& rInfo, sal_Unicode cDecSep, SvNumberFormatter* pFormatter)
+{
+    if ( fValue < rInfo.mfStart && !rtl::math::approxEqual( fValue, rInfo.mfStart ) )
+        return lcl_GetSpecialNumGroupName( rInfo.mfStart, true, cDecSep, rInfo.mbDateValues, pFormatter );
+
+    if ( fValue > rInfo.mfEnd && !rtl::math::approxEqual( fValue, rInfo.mfEnd ) )
+        return lcl_GetSpecialNumGroupName( rInfo.mfEnd, false, cDecSep, rInfo.mbDateValues, pFormatter );
+
+    double fDiff = fValue - rInfo.mfStart;
+    double fDiv = rtl::math::approxFloor( fDiff / rInfo.mfStep );
+    double fGroupStart = rInfo.mfStart + fDiv * rInfo.mfStep;
+
+    if ( rtl::math::approxEqual( fGroupStart, rInfo.mfEnd ) &&
+        !rtl::math::approxEqual( fGroupStart, rInfo.mfStart ) )
+    {
+        if (rInfo.mbDateValues)
+        {
+            //  For date values, the end value is instead treated as above the limit
+            //  if it would be a group of its own.
+            return lcl_GetSpecialNumGroupName( rInfo.mfEnd, false, cDecSep, rInfo.mbDateValues, pFormatter );
+        }
+    }
+
+    return lcl_GetNumGroupName(fGroupStart, rInfo, cDecSep, pFormatter);
+}
+
+sal_Int32 ScDPUtil::getDatePartValue(
+    double fValue, const ScDPNumGroupInfo* pInfo, sal_Int32 nDatePart,
+    const SvNumberFormatter* pFormatter)
+{
+    // Start and end are inclusive
+    // (End date without a time value is included, with a time value it's not)
+
+    if (pInfo)
+    {
+        if (fValue < pInfo->mfStart && !rtl::math::approxEqual(fValue, pInfo->mfStart))
+            return ScDPItemData::DateFirst;
+        if (fValue > pInfo->mfEnd && !rtl::math::approxEqual(fValue, pInfo->mfEnd))
+            return ScDPItemData::DateLast;
+    }
+
+    sal_Int32 nResult = 0;
+
+    if (nDatePart == sheet::DataPilotFieldGroupBy::HOURS ||
+        nDatePart == sheet::DataPilotFieldGroupBy::MINUTES ||
+        nDatePart == sheet::DataPilotFieldGroupBy::SECONDS)
+    {
+        // handle time
+        // (do as in the cell functions, ScInterpreter::ScGetHour() etc.)
+
+        sal_uInt16 nHour, nMinute, nSecond;
+        double fFractionOfSecond;
+        tools::Time::GetClock( fValue, nHour, nMinute, nSecond, fFractionOfSecond, 0);
+
+        switch (nDatePart)
+        {
+            case sheet::DataPilotFieldGroupBy::HOURS:
+                nResult = nHour;
+                break;
+            case sheet::DataPilotFieldGroupBy::MINUTES:
+                nResult = nMinute;
+                break;
+            case sheet::DataPilotFieldGroupBy::SECONDS:
+                nResult = nSecond;
+                break;
+        }
+    }
+    else
+    {
+        Date aDate = pFormatter->GetNullDate();
+        aDate.AddDays(::rtl::math::approxFloor(fValue));
+
+        switch ( nDatePart )
+        {
+            case css::sheet::DataPilotFieldGroupBy::YEARS:
+                nResult = aDate.GetYear();
+                break;
+            case css::sheet::DataPilotFieldGroupBy::QUARTERS:
+                nResult = 1 + (aDate.GetMonth() - 1) / 3;     // 1..4
+                break;
+            case css::sheet::DataPilotFieldGroupBy::MONTHS:
+                nResult = aDate.GetMonth();     // 1..12
+                break;
+            case css::sheet::DataPilotFieldGroupBy::DAYS:
+                {
+                    Date aYearStart(1, 1, aDate.GetYear());
+                    nResult = (aDate - aYearStart) + 1;       // Jan 01 has value 1
+                    if (nResult >= 60 && !aDate.IsLeapYear())
+                    {
+                        // days are counted from 1 to 366 - if not from a leap year, adjust
+                        ++nResult;
+                    }
+                }
+                break;
+            default:
+                OSL_FAIL("invalid date part");
+        }
+    }
+
+    return nResult;
+}
+
+namespace {
+
+const TranslateId aFuncStrIds[] = {
+    {},                             // SUBTOTAL_FUNC_NONE
+    STR_FUN_TEXT_AVG,               // SUBTOTAL_FUNC_AVE
+    STR_FUN_TEXT_COUNT,             // SUBTOTAL_FUNC_CNT
+    STR_FUN_TEXT_COUNT,             // SUBTOTAL_FUNC_CNT2
+    STR_FUN_TEXT_MAX,               // SUBTOTAL_FUNC_MAX
+    STR_FUN_TEXT_MIN,               // SUBTOTAL_FUNC_MIN
+    STR_FUN_TEXT_PRODUCT,           // SUBTOTAL_FUNC_PROD
+    STR_FUN_TEXT_STDDEV,            // SUBTOTAL_FUNC_STD
+    STR_FUN_TEXT_STDDEV,            // SUBTOTAL_FUNC_STDP
+    STR_FUN_TEXT_SUM,               // SUBTOTAL_FUNC_SUM
+    STR_FUN_TEXT_VAR,               // SUBTOTAL_FUNC_VAR
+    STR_FUN_TEXT_VAR,               // SUBTOTAL_FUNC_VARP
+    STR_FUN_TEXT_MEDIAN,            // SUBTOTAL_FUNC_MED
+    {}                              // SUBTOTAL_FUNC_SELECTION_COUNT - not used for pivot table
+};
+
+}
+
+OUString ScDPUtil::getDisplayedMeasureName(const OUString& rName, ScSubTotalFunc eFunc)
+{
+    assert(unsigned(eFunc) < SAL_N_ELEMENTS(aFuncStrIds));
+    TranslateId pId = aFuncStrIds[eFunc];
+    if (!pId)
+        return rName;
+    return ScResId(pId) +        // function name
+            " - " +
+            rName;                   // field name
+}
+
+ScSubTotalFunc ScDPUtil::toSubTotalFunc(ScGeneralFunction eGenFunc)
+{
+    ScSubTotalFunc eSubTotal = SUBTOTAL_FUNC_NONE;
+    switch (eGenFunc)
+    {
+        case ScGeneralFunction::NONE:       eSubTotal = SUBTOTAL_FUNC_NONE; break;
+        case ScGeneralFunction::SUM:        eSubTotal = SUBTOTAL_FUNC_SUM;  break;
+        case ScGeneralFunction::COUNT:      eSubTotal = SUBTOTAL_FUNC_CNT2; break;
+        case ScGeneralFunction::AVERAGE:    eSubTotal = SUBTOTAL_FUNC_AVE;  break;
+        case ScGeneralFunction::MEDIAN:     eSubTotal = SUBTOTAL_FUNC_MED;  break;
+        case ScGeneralFunction::MAX:        eSubTotal = SUBTOTAL_FUNC_MAX;  break;
+        case ScGeneralFunction::MIN:        eSubTotal = SUBTOTAL_FUNC_MIN;  break;
+        case ScGeneralFunction::PRODUCT:    eSubTotal = SUBTOTAL_FUNC_PROD; break;
+        case ScGeneralFunction::COUNTNUMS:  eSubTotal = SUBTOTAL_FUNC_CNT;  break;
+        case ScGeneralFunction::STDEV:      eSubTotal = SUBTOTAL_FUNC_STD;  break;
+        case ScGeneralFunction::STDEVP:     eSubTotal = SUBTOTAL_FUNC_STDP; break;
+        case ScGeneralFunction::VAR:        eSubTotal = SUBTOTAL_FUNC_VAR;  break;
+        case ScGeneralFunction::VARP:       eSubTotal = SUBTOTAL_FUNC_VARP; break;
+        case ScGeneralFunction::AUTO:       eSubTotal = SUBTOTAL_FUNC_NONE; break;
+        default:
+            assert(false);
+    }
+    return eSubTotal;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */