Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

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

1 files changed, 546 insertions, 0 deletions

diff --git a/sc/source/core/tool/consoli.cxx b/sc/source/core/tool/consoli.cxx
new file mode 100644
index 000000000..d134a9e45
--- /dev/null
+++ b/sc/source/core/tool/consoli.cxx
@@ -0,0 +1,546 @@
+/* -*- 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 <consoli.hxx>
+#include <document.hxx>
+#include <olinetab.hxx>
+#include <subtotal.hxx>
+#include <formula/errorcodes.hxx>
+#include <formulacell.hxx>
+#include <tokenarray.hxx>
+#include <osl/diagnose.h>
+#include <refdata.hxx>
+
+#include <math.h>
+#include <string.h>
+#include <memory>
+
+#define SC_CONS_NOTFOUND    -1
+
+static const OpCode eOpCodeTable[] = {      //  order as for enum ScSubTotalFunc
+        ocBad,                              //  none
+        ocAverage,
+        ocCount,
+        ocCount2,
+        ocMax,
+        ocMin,
+        ocProduct,
+        ocStDev,
+        ocStDevP,
+        ocSum,
+        ocVar,
+        ocVarP };
+
+template< typename T >
+static void lcl_AddString( ::std::vector<OUString>& rData, T& nCount, const OUString& rInsert )
+{
+    rData.push_back( rInsert);
+    ++nCount;
+}
+
+ScConsData::ScConsData() :
+    eFunction(SUBTOTAL_FUNC_SUM),
+    bReference(false),
+    bColByName(false),
+    bRowByName(false),
+    nColCount(0),
+    nRowCount(0),
+    nDataCount(0),
+    bCornerUsed(false)
+{
+}
+
+ScConsData::~ScConsData()
+{
+}
+
+void ScConsData::DeleteData()
+{
+    ppRefs.reset();
+    ppFunctionData.reset();
+    ppUsed.reset();
+    ppTitlePos.reset();
+    ::std::vector<OUString>().swap( maColHeaders);
+    ::std::vector<OUString>().swap( maRowHeaders);
+    ::std::vector<OUString>().swap( maTitles);
+    nDataCount = 0;
+
+    if (bColByName) nColCount = 0;                  // otherwise maColHeaders is wrong
+    if (bRowByName) nRowCount = 0;
+
+    bCornerUsed = false;
+    aCornerText.clear();
+}
+
+void ScConsData::InitData()
+{
+    if (bReference && nColCount && !ppRefs)
+    {
+        ppRefs.reset(new std::unique_ptr<ScReferenceList[]>[nColCount]);
+        for (SCSIZE i=0; i<nColCount; i++)
+            ppRefs[i].reset(new ScReferenceList[nRowCount]);
+    }
+    else if (nColCount && !ppFunctionData)
+    {
+        ppFunctionData.reset( new std::unique_ptr<ScFunctionData[]>[nColCount] );
+        for (SCSIZE i=0; i<nColCount; i++)
+        {
+            ppFunctionData[i].reset( new ScFunctionData[nRowCount] );
+        }
+    }
+
+    if (nColCount && !ppUsed)
+    {
+        ppUsed.reset( new std::unique_ptr<bool[]>[nColCount] );
+        for (SCSIZE i=0; i<nColCount; i++)
+        {
+            ppUsed[i].reset( new bool[nRowCount] );
+            memset( ppUsed[i].get(), 0, nRowCount * sizeof(bool) );
+        }
+    }
+
+    if (nRowCount && nDataCount && !ppTitlePos)
+    {
+        ppTitlePos.reset( new std::unique_ptr<SCSIZE[]>[nRowCount] );
+        for (SCSIZE i=0; i<nRowCount; i++)
+        {
+            ppTitlePos[i].reset( new SCSIZE[nDataCount] );
+            memset( ppTitlePos[i].get(), 0, nDataCount * sizeof(SCSIZE) );    //TODO: not necessary ?
+        }
+    }
+
+    //  CornerText: single String
+}
+
+void ScConsData::DoneFields()
+{
+    InitData();
+}
+
+void ScConsData::SetSize( SCCOL nCols, SCROW nRows )
+{
+    DeleteData();
+    nColCount = static_cast<SCSIZE>(nCols);
+    nRowCount = static_cast<SCSIZE>(nRows);
+}
+
+void ScConsData::GetSize( SCCOL& rCols, SCROW& rRows ) const
+{
+    rCols = static_cast<SCCOL>(nColCount);
+    rRows = static_cast<SCROW>(nRowCount);
+}
+
+void ScConsData::SetFlags( ScSubTotalFunc eFunc, bool bColName, bool bRowName, bool bRef )
+{
+    DeleteData();
+    bReference = bRef;
+    bColByName = bColName;
+    if (bColName) nColCount = 0;
+    bRowByName = bRowName;
+    if (bRowName) nRowCount = 0;
+    eFunction = eFunc;
+}
+
+void ScConsData::AddFields( const ScDocument* pSrcDoc, SCTAB nTab,
+                            SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
+{
+    ++nDataCount;
+
+    OUString aTitle;
+
+    SCCOL nStartCol = nCol1;
+    SCROW nStartRow = nRow1;
+    if (bColByName) ++nStartRow;
+    if (bRowByName) ++nStartCol;
+
+    if (bColByName)
+    {
+        for (SCCOL nCol=nStartCol; nCol<=nCol2; nCol++)
+        {
+            aTitle = pSrcDoc->GetString(nCol, nRow1, nTab);
+            if (!aTitle.isEmpty())
+            {
+                bool bFound = false;
+                for (SCSIZE i=0; i<nColCount && !bFound; i++)
+                    if ( maColHeaders[i] == aTitle )
+                        bFound = true;
+                if (!bFound)
+                    lcl_AddString( maColHeaders, nColCount, aTitle );
+            }
+        }
+    }
+
+    if (bRowByName)
+    {
+        for (SCROW nRow=nStartRow; nRow<=nRow2; nRow++)
+        {
+            aTitle = pSrcDoc->GetString(nCol1, nRow, nTab);
+            if (!aTitle.isEmpty())
+            {
+                bool bFound = false;
+                for (SCSIZE i=0; i<nRowCount && !bFound; i++)
+                    if ( maRowHeaders[i] == aTitle )
+                        bFound = true;
+                if (!bFound)
+                    lcl_AddString( maRowHeaders, nRowCount, aTitle );
+            }
+        }
+    }
+}
+
+void ScConsData::AddName( const OUString& rName )
+{
+    SCSIZE nArrX;
+    SCSIZE nArrY;
+
+    if (bReference)
+    {
+        maTitles.push_back( rName);
+        size_t nTitleCount = maTitles.size();
+
+        for (nArrY=0; nArrY<nRowCount; nArrY++)
+        {
+            //  set all data to same length
+
+            SCSIZE nMax = 0;
+            for (nArrX=0; nArrX<nColCount; nArrX++)
+                nMax = std::max( nMax, ppRefs[nArrX][nArrY].size() );
+
+            for (nArrX=0; nArrX<nColCount; nArrX++)
+            {
+                ppUsed[nArrX][nArrY] = true;
+                ppRefs[nArrX][nArrY].resize( nMax, { SC_CONS_NOTFOUND, SC_CONS_NOTFOUND, SC_CONS_NOTFOUND });
+            }
+
+            //  store positions
+
+            if (ppTitlePos)
+                if (nTitleCount < nDataCount)
+                    ppTitlePos[nArrY][nTitleCount] = nMax;
+        }
+    }
+}
+
+void ScConsData::AddData( ScDocument* pSrcDoc, SCTAB nTab,
+                            SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
+{
+    PutInOrder(nCol1,nCol2);
+    PutInOrder(nRow1,nRow2);
+    if ( nCol2 >= sal::static_int_cast<SCCOL>(nCol1 + nColCount) && !bColByName )
+    {
+        OSL_FAIL("range too big");
+        nCol2 = sal::static_int_cast<SCCOL>( nCol1 + nColCount - 1 );
+    }
+    if ( nRow2 >= sal::static_int_cast<SCROW>(nRow1 + nRowCount) && !bRowByName )
+    {
+        OSL_FAIL("range too big");
+        nRow2 = sal::static_int_cast<SCROW>( nRow1 + nRowCount - 1 );
+    }
+
+    SCCOL nCol;
+    SCROW nRow;
+
+    // left top corner
+
+    if ( bColByName && bRowByName )
+    {
+        OUString aThisCorner = pSrcDoc->GetString(nCol1, nRow1, nTab);
+        if (bCornerUsed)
+        {
+            if (aCornerText != aThisCorner)
+                aCornerText.clear();
+        }
+        else
+        {
+            aCornerText = aThisCorner;
+            bCornerUsed = true;
+        }
+    }
+
+    // search title
+
+    SCCOL nStartCol = nCol1;
+    SCROW nStartRow = nRow1;
+    if (bColByName) ++nStartRow;
+    if (bRowByName) ++nStartCol;
+    OUString aTitle;
+    std::unique_ptr<SCCOL[]> pDestCols;
+    std::unique_ptr<SCROW[]> pDestRows;
+    if (bColByName)
+    {
+        pDestCols.reset(new SCCOL[nCol2-nStartCol+1]);
+        for (nCol=nStartCol; nCol<=nCol2; nCol++)
+        {
+            aTitle = pSrcDoc->GetString(nCol, nRow1, nTab);
+            SCCOL nPos = SC_CONS_NOTFOUND;
+            if (!aTitle.isEmpty())
+            {
+                bool bFound = false;
+                for (SCSIZE i=0; i<nColCount && !bFound; i++)
+                    if ( maColHeaders[i] == aTitle )
+                    {
+                        nPos = static_cast<SCCOL>(i);
+                        bFound = true;
+                    }
+                OSL_ENSURE(bFound, "column not found");
+            }
+            pDestCols[nCol-nStartCol] = nPos;
+        }
+    }
+    if (bRowByName)
+    {
+        pDestRows.reset(new SCROW[nRow2-nStartRow+1]);
+        for (nRow=nStartRow; nRow<=nRow2; nRow++)
+        {
+            aTitle = pSrcDoc->GetString(nCol1, nRow, nTab);
+            SCROW nPos = SC_CONS_NOTFOUND;
+            if (!aTitle.isEmpty())
+            {
+                bool bFound = false;
+                for (SCSIZE i=0; i<nRowCount && !bFound; i++)
+                    if ( maRowHeaders[i] == aTitle )
+                    {
+                        nPos = static_cast<SCROW>(i);
+                        bFound = true;
+                    }
+                OSL_ENSURE(bFound, "row not found");
+            }
+            pDestRows[nRow-nStartRow] = nPos;
+        }
+    }
+    nCol1 = nStartCol;
+    nRow1 = nStartRow;
+
+    // data
+
+    bool bAnyCell = ( eFunction == SUBTOTAL_FUNC_CNT2 );
+    for (nCol=nCol1; nCol<=nCol2; nCol++)
+    {
+        SCCOL nArrX = nCol-nCol1;
+        if (bColByName) nArrX = pDestCols[nArrX];
+        if (nArrX != SC_CONS_NOTFOUND)
+        {
+            for (nRow=nRow1; nRow<=nRow2; nRow++)
+            {
+                SCROW nArrY = nRow-nRow1;
+                if (bRowByName) nArrY = pDestRows[nArrY];
+                if ( nArrY != SC_CONS_NOTFOUND && (
+                        bAnyCell ? pSrcDoc->HasData( nCol, nRow, nTab )
+                                 : pSrcDoc->HasValueData( nCol, nRow, nTab ) ) )
+                {
+                    if (bReference)
+                    {
+                        ppUsed[nArrX][nArrY] = true;
+                        ppRefs[nArrX][nArrY].push_back( { nCol, nRow, nTab } );
+                    }
+                    else
+                    {
+                        double nVal;
+                        pSrcDoc->GetValue( nCol, nRow, nTab, nVal );
+                        if (!ppUsed[nArrX][nArrY])
+                        {
+                            ppUsed[nArrX][nArrY] = true;
+                            ppFunctionData[nArrX][nArrY] = ScFunctionData( eFunction);
+                        }
+                        ppFunctionData[nArrX][nArrY].update( nVal);
+                    }
+                }
+            }
+        }
+    }
+}
+
+// check before, how many rows to insert (for Undo)
+
+SCROW ScConsData::GetInsertCount() const
+{
+    SCROW nInsert = 0;
+    SCSIZE nArrX;
+    SCSIZE nArrY;
+    if ( ppRefs && ppUsed )
+    {
+        for (nArrY=0; nArrY<nRowCount; nArrY++)
+        {
+            SCSIZE nNeeded = 0;
+            for (nArrX=0; nArrX<nColCount; nArrX++)
+                nNeeded = std::max( nNeeded, ppRefs[nArrX][nArrY].size() );
+
+            nInsert += nNeeded;
+        }
+    }
+    return nInsert;
+}
+
+// store completed data to document
+//TODO: optimize on columns?
+
+void ScConsData::OutputToDocument( ScDocument* pDestDoc, SCCOL nCol, SCROW nRow, SCTAB nTab )
+{
+    OpCode eOpCode = eOpCodeTable[eFunction];
+
+    SCSIZE nArrX;
+    SCSIZE nArrY;
+
+    // left top corner
+
+    if ( bColByName && bRowByName && !aCornerText.isEmpty() )
+        pDestDoc->SetString( nCol, nRow, nTab, aCornerText );
+
+    // title
+
+    SCCOL nStartCol = nCol;
+    SCROW nStartRow = nRow;
+    if (bColByName) ++nStartRow;
+    if (bRowByName) ++nStartCol;
+
+    if (bColByName)
+        for (SCSIZE i=0; i<nColCount; i++)
+            pDestDoc->SetString( sal::static_int_cast<SCCOL>(nStartCol+i), nRow, nTab, maColHeaders[i] );
+    if (bRowByName)
+        for (SCSIZE j=0; j<nRowCount; j++)
+            pDestDoc->SetString( nCol, sal::static_int_cast<SCROW>(nStartRow+j), nTab, maRowHeaders[j] );
+
+    nCol = nStartCol;
+    nRow = nStartRow;
+
+    // data
+
+    if ( ppFunctionData && ppUsed )    // insert values directly
+    {
+        for (nArrX=0; nArrX<nColCount; nArrX++)
+            for (nArrY=0; nArrY<nRowCount; nArrY++)
+                if (ppUsed[nArrX][nArrY])
+                {
+                    double fVal = ppFunctionData[nArrX][nArrY].getResult();
+                    if (ppFunctionData[nArrX][nArrY].getError())
+                        pDestDoc->SetError( sal::static_int_cast<SCCOL>(nCol+nArrX),
+                                            sal::static_int_cast<SCROW>(nRow+nArrY), nTab, FormulaError::NoValue );
+                    else
+                        pDestDoc->SetValue( sal::static_int_cast<SCCOL>(nCol+nArrX),
+                                            sal::static_int_cast<SCROW>(nRow+nArrY), nTab, fVal );
+                }
+    }
+
+    if ( ppRefs && ppUsed )     // insert Reference
+    {
+                                //TODO: differentiate, if split into categories
+        OUString aString;
+
+        ScSingleRefData aSRef;  // data for Reference formula cells
+        aSRef.InitFlags();      // this reference is absolute at all times
+        aSRef.SetFlag3D(true);
+
+        ScComplexRefData aCRef; // data for Sum cells
+        aCRef.InitFlags();
+        aCRef.Ref1.SetColRel(true); aCRef.Ref1.SetRowRel(true); aCRef.Ref1.SetTabRel(true);
+        aCRef.Ref2.SetColRel(true); aCRef.Ref2.SetRowRel(true); aCRef.Ref2.SetTabRel(true);
+
+        for (nArrY=0; nArrY<nRowCount; nArrY++)
+        {
+            SCSIZE nNeeded = 0;
+            for (nArrX=0; nArrX<nColCount; nArrX++)
+                nNeeded = std::max( nNeeded, ppRefs[nArrX][nArrY].size() );
+
+            if (nNeeded)
+            {
+                pDestDoc->InsertRow( 0,nTab, pDestDoc->MaxCol(),nTab, nRow+nArrY, nNeeded );
+
+                for (nArrX=0; nArrX<nColCount; nArrX++)
+                    if (ppUsed[nArrX][nArrY])
+                    {
+                        SCSIZE nCount = ppRefs[nArrX][nArrY].size();
+                        if (nCount)
+                        {
+                            for (SCSIZE nPos=0; nPos<nCount; nPos++)
+                            {
+                                ScReferenceEntry aRef = ppRefs[nArrX][nArrY][nPos];
+                                if (aRef.nTab != SC_CONS_NOTFOUND)
+                                {
+                                    // insert reference (absolute, 3d)
+
+                                    aSRef.SetAddress(pDestDoc->GetSheetLimits(), ScAddress(aRef.nCol,aRef.nRow,aRef.nTab), ScAddress());
+
+                                    ScTokenArray aRefArr(pDestDoc);
+                                    aRefArr.AddSingleReference(aSRef);
+                                    aRefArr.AddOpCode(ocStop);
+                                    ScAddress aDest( sal::static_int_cast<SCCOL>(nCol+nArrX),
+                                                     sal::static_int_cast<SCROW>(nRow+nArrY+nPos), nTab );
+                                    ScFormulaCell* pCell = new ScFormulaCell(pDestDoc, aDest, aRefArr);
+                                    pDestDoc->SetFormulaCell(aDest, pCell);
+                                }
+                            }
+
+                            // insert sum (relative, not 3d)
+
+                            ScAddress aDest( sal::static_int_cast<SCCOL>(nCol+nArrX),
+                                             sal::static_int_cast<SCROW>(nRow+nArrY+nNeeded), nTab );
+
+                            ScRange aRange(sal::static_int_cast<SCCOL>(nCol+nArrX), nRow+nArrY, nTab);
+                            aRange.aEnd.SetRow(nRow+nArrY+nNeeded-1);
+                            aCRef.SetRange(pDestDoc->GetSheetLimits(), aRange, aDest);
+
+                            ScTokenArray aArr(pDestDoc);
+                            aArr.AddOpCode(eOpCode);            // selected function
+                            aArr.AddOpCode(ocOpen);
+                            aArr.AddDoubleReference(aCRef);
+                            aArr.AddOpCode(ocClose);
+                            aArr.AddOpCode(ocStop);
+                            ScFormulaCell* pCell = new ScFormulaCell(pDestDoc, aDest, aArr);
+                            pDestDoc->SetFormulaCell(aDest, pCell);
+                        }
+                    }
+
+                // insert outline
+
+                ScOutlineArray& rOutArr = pDestDoc->GetOutlineTable( nTab, true )->GetRowArray();
+                SCROW nOutStart = nRow+nArrY;
+                SCROW nOutEnd = nRow+nArrY+nNeeded-1;
+                bool bSize = false;
+                rOutArr.Insert( nOutStart, nOutEnd, bSize );
+                for (SCROW nOutRow=nOutStart; nOutRow<=nOutEnd; nOutRow++)
+                    pDestDoc->ShowRow( nOutRow, nTab, false );
+                pDestDoc->SetDrawPageSize(nTab);
+                pDestDoc->UpdateOutlineRow( nOutStart, nOutEnd, nTab, false );
+
+                // sub title
+
+                if (ppTitlePos && !maTitles.empty() && !maRowHeaders.empty())
+                {
+                    for (SCSIZE nPos=0; nPos<nDataCount; nPos++)
+                    {
+                        SCSIZE nTPos = ppTitlePos[nArrY][nPos];
+                        bool bDo = true;
+                        if (nPos+1<nDataCount)
+                            if (ppTitlePos[nArrY][nPos+1] == nTPos)
+                                bDo = false;                                    // empty
+                        if ( bDo && nTPos < nNeeded )
+                        {
+                            aString = maRowHeaders[nArrY] + " / " + maTitles[nPos];
+                            pDestDoc->SetString( nCol-1, nRow+nArrY+nTPos, nTab, aString );
+                        }
+                    }
+                }
+
+                nRow += nNeeded;
+            }
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */