sc/source/core/tool/consoli.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <consoli.hxx>
  21 #include <document.hxx>
  22 #include <olinetab.hxx>
  23 #include <subtotal.hxx>
  24 #include <formula/errorcodes.hxx>
  25 #include <formulacell.hxx>
  26 #include <tokenarray.hxx>
  27 #include <osl/diagnose.h>
  28 #include <refdata.hxx>
  29
  30 #include <string.h>
  31 #include <memory>
  32
  33 #define SC_CONS_NOTFOUND    -1
  34
  35 const OpCode eOpCodeTable[] = {      //  order as for enum ScSubTotalFunc
  36         ocBad,                              //  none
  37         ocAverage,
  38         ocCount,
  39         ocCount2,
  40         ocMax,
  41         ocMin,
  42         ocProduct,
  43         ocStDev,
  44         ocStDevP,
  45         ocSum,
  46         ocVar,
  47         ocVarP };
  48
  49 template< typename T >
  50 static void lcl_AddString( ::std::vector<OUString>& rData, T& nCount, const OUString& rInsert )
  51 {
  52     rData.push_back( rInsert);
  53     ++nCount;
  54 }
  55
  56 ScConsData::ScConsData() :
  57     eFunction(SUBTOTAL_FUNC_SUM),
  58     bReference(false),
  59     bColByName(false),
  60     bRowByName(false),
  61     nColCount(0),
  62     nRowCount(0),
  63     nDataCount(0),
  64     bCornerUsed(false)
  65 {
  66 }
  67
  68 ScConsData::~ScConsData()
  69 {
  70 }
  71
  72 void ScConsData::DeleteData()
  73 {
  74     ppRefs.reset();
  75     ppFunctionData.reset();
  76     ppUsed.reset();
  77     ppTitlePos.reset();
  78     ::std::vector<OUString>().swap( maColHeaders);
  79     ::std::vector<OUString>().swap( maRowHeaders);
  80     ::std::vector<OUString>().swap( maTitles);
  81     nDataCount = 0;
  82
  83     if (bColByName) nColCount = 0;                  // otherwise maColHeaders is wrong
  84     if (bRowByName) nRowCount = 0;
  85
  86     bCornerUsed = false;
  87     aCornerText.clear();
  88 }
  89
  90 void ScConsData::InitData()
  91 {
  92     if (bReference && nColCount && !ppRefs)
  93     {
  94         ppRefs.reset(new std::unique_ptr<ScReferenceList[]>[nColCount]);
  95         for (SCSIZE i=0; i<nColCount; i++)
  96             ppRefs[i].reset(new ScReferenceList[nRowCount]);
  97     }
  98     else if (nColCount && !ppFunctionData)
  99     {
 100         ppFunctionData.reset( new std::unique_ptr<ScFunctionData[]>[nColCount] );
 101         for (SCSIZE i=0; i<nColCount; i++)
 102         {
 103             ppFunctionData[i].reset( new ScFunctionData[nRowCount] );
 104         }
 105     }
 106
 107     if (nColCount && !ppUsed)
 108     {
 109         ppUsed.reset( new std::unique_ptr<bool[]>[nColCount] );
 110         for (SCSIZE i=0; i<nColCount; i++)
 111         {
 112             ppUsed[i].reset( new bool[nRowCount] );
 113             memset( ppUsed[i].get(), 0, nRowCount * sizeof(bool) );
 114         }
 115     }
 116
 117     if (nRowCount && nDataCount && !ppTitlePos)
 118     {
 119         ppTitlePos.reset( new std::unique_ptr<SCSIZE[]>[nRowCount] );
 120         for (SCSIZE i=0; i<nRowCount; i++)
 121         {
 122             ppTitlePos[i].reset( new SCSIZE[nDataCount] );
 123             memset( ppTitlePos[i].get(), 0, nDataCount * sizeof(SCSIZE) );    //TODO: not necessary ?
 124         }
 125     }
 126
 127     //  CornerText: single String
 128 }
 129
 130 void ScConsData::DoneFields()
 131 {
 132     InitData();
 133 }
 134
 135 void ScConsData::SetSize( SCCOL nCols, SCROW nRows )
 136 {
 137     DeleteData();
 138     nColCount = static_cast<SCSIZE>(nCols);
 139     nRowCount = static_cast<SCSIZE>(nRows);
 140 }
 141
 142 void ScConsData::GetSize( SCCOL& rCols, SCROW& rRows ) const
 143 {
 144     rCols = static_cast<SCCOL>(nColCount);
 145     rRows = static_cast<SCROW>(nRowCount);
 146 }
 147
 148 void ScConsData::SetFlags( ScSubTotalFunc eFunc, bool bColName, bool bRowName, bool bRef )
 149 {
 150     DeleteData();
 151     bReference = bRef;
 152     bColByName = bColName;
 153     if (bColName) nColCount = 0;
 154     bRowByName = bRowName;
 155     if (bRowName) nRowCount = 0;
 156     eFunction = eFunc;
 157 }
 158
 159 void ScConsData::AddFields( const ScDocument* pSrcDoc, SCTAB nTab,
 160                             SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
 161 {
 162     ++nDataCount;
 163
 164     OUString aTitle;
 165
 166     SCCOL nStartCol = nCol1;
 167     SCROW nStartRow = nRow1;
 168     if (bColByName) ++nStartRow;
 169     if (bRowByName) ++nStartCol;
 170
 171     if (bColByName)
 172     {
 173         for (SCCOL nCol=nStartCol; nCol<=nCol2; nCol++)
 174         {
 175             aTitle = pSrcDoc->GetString(nCol, nRow1, nTab);
 176             if (!aTitle.isEmpty())
 177             {
 178                 bool bFound = false;
 179                 for (SCSIZE i=0; i<nColCount && !bFound; i++)
 180                     if ( maColHeaders[i] == aTitle )
 181                         bFound = true;
 182                 if (!bFound)
 183                     lcl_AddString( maColHeaders, nColCount, aTitle );
 184             }
 185         }
 186     }
 187
 188     if (!bRowByName)
 189         return;
 190
 191     for (SCROW nRow=nStartRow; nRow<=nRow2; nRow++)
 192     {
 193         aTitle = pSrcDoc->GetString(nCol1, nRow, nTab);
 194         if (!aTitle.isEmpty())
 195         {
 196             bool bFound = false;
 197             for (SCSIZE i=0; i<nRowCount && !bFound; i++)
 198                 if ( maRowHeaders[i] == aTitle )
 199                     bFound = true;
 200             if (!bFound)
 201                 lcl_AddString( maRowHeaders, nRowCount, aTitle );
 202         }
 203     }
 204 }
 205
 206 void ScConsData::AddName( const OUString& rName )
 207 {
 208     SCSIZE nArrX;
 209     SCSIZE nArrY;
 210
 211     if (!bReference)
 212         return;
 213
 214     maTitles.push_back( rName);
 215     size_t nTitleCount = maTitles.size();
 216
 217     for (nArrY=0; nArrY<nRowCount; nArrY++)
 218     {
 219         //  set all data to same length
 220
 221         SCSIZE nMax = 0;
 222         for (nArrX=0; nArrX<nColCount; nArrX++)
 223             nMax = std::max( nMax, ppRefs[nArrX][nArrY].size() );
 224
 225         for (nArrX=0; nArrX<nColCount; nArrX++)
 226         {
 227             ppUsed[nArrX][nArrY] = true;
 228             ppRefs[nArrX][nArrY].resize( nMax, { SC_CONS_NOTFOUND, SC_CONS_NOTFOUND, SC_CONS_NOTFOUND });
 229         }
 230
 231         //  store positions
 232
 233         if (ppTitlePos)
 234             if (nTitleCount < nDataCount)
 235                 ppTitlePos[nArrY][nTitleCount] = nMax;
 236     }
 237 }
 238
 239 void ScConsData::AddData( ScDocument* pSrcDoc, SCTAB nTab,
 240                             SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
 241 {
 242     PutInOrder(nCol1,nCol2);
 243     PutInOrder(nRow1,nRow2);
 244     if ( nCol2 >= sal::static_int_cast<SCCOL>(nCol1 + nColCount) && !bColByName )
 245     {
 246         OSL_FAIL("range too big");
 247         nCol2 = sal::static_int_cast<SCCOL>( nCol1 + nColCount - 1 );
 248     }
 249     if ( nRow2 >= sal::static_int_cast<SCROW>(nRow1 + nRowCount) && !bRowByName )
 250     {
 251         OSL_FAIL("range too big");
 252         nRow2 = sal::static_int_cast<SCROW>( nRow1 + nRowCount - 1 );
 253     }
 254
 255     SCCOL nCol;
 256     SCROW nRow;
 257
 258     // left top corner
 259
 260     if ( bColByName && bRowByName )
 261     {
 262         OUString aThisCorner = pSrcDoc->GetString(nCol1, nRow1, nTab);
 263         if (bCornerUsed)
 264         {
 265             if (aCornerText != aThisCorner)
 266                 aCornerText.clear();
 267         }
 268         else
 269         {
 270             aCornerText = aThisCorner;
 271             bCornerUsed = true;
 272         }
 273     }
 274
 275     // search title
 276
 277     SCCOL nStartCol = nCol1;
 278     SCROW nStartRow = nRow1;
 279     if (bColByName) ++nStartRow;
 280     if (bRowByName) ++nStartCol;
 281     OUString aTitle;
 282     std::unique_ptr<SCCOL[]> pDestCols;
 283     std::unique_ptr<SCROW[]> pDestRows;
 284     if (bColByName)
 285     {
 286         pDestCols.reset(new SCCOL[nCol2-nStartCol+1]);
 287         for (nCol=nStartCol; nCol<=nCol2; nCol++)
 288         {
 289             aTitle = pSrcDoc->GetString(nCol, nRow1, nTab);
 290             SCCOL nPos = SC_CONS_NOTFOUND;
 291             if (!aTitle.isEmpty())
 292             {
 293                 bool bFound = false;
 294                 for (SCSIZE i=0; i<nColCount && !bFound; i++)
 295                     if ( maColHeaders[i] == aTitle )
 296                     {
 297                         nPos = static_cast<SCCOL>(i);
 298                         bFound = true;
 299                     }
 300                 OSL_ENSURE(bFound, "column not found");
 301             }
 302             pDestCols[nCol-nStartCol] = nPos;
 303         }
 304     }
 305     if (bRowByName)
 306     {
 307         pDestRows.reset(new SCROW[nRow2-nStartRow+1]);
 308         for (nRow=nStartRow; nRow<=nRow2; nRow++)
 309         {
 310             aTitle = pSrcDoc->GetString(nCol1, nRow, nTab);
 311             SCROW nPos = SC_CONS_NOTFOUND;
 312             if (!aTitle.isEmpty())
 313             {
 314                 bool bFound = false;
 315                 for (SCSIZE i=0; i<nRowCount && !bFound; i++)
 316                     if ( maRowHeaders[i] == aTitle )
 317                     {
 318                         nPos = static_cast<SCROW>(i);
 319                         bFound = true;
 320                     }
 321                 OSL_ENSURE(bFound, "row not found");
 322             }
 323             pDestRows[nRow-nStartRow] = nPos;
 324         }
 325     }
 326     nCol1 = nStartCol;
 327     nRow1 = nStartRow;
 328
 329     // data
 330
 331     bool bAnyCell = ( eFunction == SUBTOTAL_FUNC_CNT2 );
 332     for (nCol=nCol1; nCol<=nCol2; nCol++)
 333     {
 334         SCCOL nArrX = nCol-nCol1;
 335         if (bColByName) nArrX = pDestCols[nArrX];
 336         if (nArrX != SC_CONS_NOTFOUND)
 337         {
 338             for (nRow=nRow1; nRow<=nRow2; nRow++)
 339             {
 340                 SCROW nArrY = nRow-nRow1;
 341                 if (bRowByName) nArrY = pDestRows[nArrY];
 342                 if ( nArrY != SC_CONS_NOTFOUND && (
 343                         bAnyCell ? pSrcDoc->HasData( nCol, nRow, nTab )
 344                                  : pSrcDoc->HasValueData( nCol, nRow, nTab ) ) )
 345                 {
 346                     if (bReference)
 347                     {
 348                         ppUsed[nArrX][nArrY] = true;
 349                         ppRefs[nArrX][nArrY].push_back( { nCol, nRow, nTab } );
 350                     }
 351                     else
 352                     {
 353                         double nVal = pSrcDoc->GetValue( nCol, nRow, nTab );
 354                         if (!ppUsed[nArrX][nArrY])
 355                         {
 356                             ppUsed[nArrX][nArrY] = true;
 357                             ppFunctionData[nArrX][nArrY] = ScFunctionData( eFunction);
 358                         }
 359                         ppFunctionData[nArrX][nArrY].update( nVal);
 360                     }
 361                 }
 362             }
 363         }
 364     }
 365 }
 366
 367 // check before, how many rows to insert (for Undo)
 368
 369 SCROW ScConsData::GetInsertCount() const
 370 {
 371     SCROW nInsert = 0;
 372     SCSIZE nArrX;
 373     SCSIZE nArrY;
 374     if ( ppRefs && ppUsed )
 375     {
 376         for (nArrY=0; nArrY<nRowCount; nArrY++)
 377         {
 378             SCSIZE nNeeded = 0;
 379             for (nArrX=0; nArrX<nColCount; nArrX++)
 380                 nNeeded = std::max( nNeeded, ppRefs[nArrX][nArrY].size() );
 381
 382             nInsert += nNeeded;
 383         }
 384     }
 385     return nInsert;
 386 }
 387
 388 // store completed data to document
 389 //TODO: optimize on columns?
 390
 391 void ScConsData::OutputToDocument( ScDocument& rDestDoc, SCCOL nCol, SCROW nRow, SCTAB nTab )
 392 {
 393     OpCode eOpCode = eOpCodeTable[eFunction];
 394
 395     SCSIZE nArrX;
 396     SCSIZE nArrY;
 397
 398     // left top corner
 399
 400     if ( bColByName && bRowByName && !aCornerText.isEmpty() )
 401         rDestDoc.SetString( nCol, nRow, nTab, aCornerText );
 402
 403     // title
 404
 405     SCCOL nStartCol = nCol;
 406     SCROW nStartRow = nRow;
 407     if (bColByName) ++nStartRow;
 408     if (bRowByName) ++nStartCol;
 409
 410     if (bColByName)
 411         for (SCSIZE i=0; i<nColCount; i++)
 412             rDestDoc.SetString( sal::static_int_cast<SCCOL>(nStartCol+i), nRow, nTab, maColHeaders[i] );
 413     if (bRowByName)
 414         for (SCSIZE j=0; j<nRowCount; j++)
 415             rDestDoc.SetString( nCol, sal::static_int_cast<SCROW>(nStartRow+j), nTab, maRowHeaders[j] );
 416
 417     nCol = nStartCol;
 418     nRow = nStartRow;
 419
 420     // data
 421
 422     if ( ppFunctionData && ppUsed )    // insert values directly
 423     {
 424         for (nArrX=0; nArrX<nColCount; nArrX++)
 425             for (nArrY=0; nArrY<nRowCount; nArrY++)
 426                 if (ppUsed[nArrX][nArrY])
 427                 {
 428                     double fVal = ppFunctionData[nArrX][nArrY].getResult();
 429                     if (ppFunctionData[nArrX][nArrY].getError())
 430                         rDestDoc.SetError( sal::static_int_cast<SCCOL>(nCol+nArrX),
 431                                            sal::static_int_cast<SCROW>(nRow+nArrY), nTab, FormulaError::NoValue );
 432                     else
 433                         rDestDoc.SetValue( sal::static_int_cast<SCCOL>(nCol+nArrX),
 434                                            sal::static_int_cast<SCROW>(nRow+nArrY), nTab, fVal );
 435                 }
 436     }
 437
 438     if ( !(ppRefs && ppUsed) )     // insert Reference
 439                                 return;
 440
 441                             //TODO: differentiate, if split into categories
 442     OUString aString;
 443
 444     ScSingleRefData aSRef;  // data for Reference formula cells
 445     aSRef.InitFlags();      // this reference is absolute at all times
 446     aSRef.SetFlag3D(true);
 447
 448     ScComplexRefData aCRef; // data for Sum cells
 449     aCRef.InitFlags();
 450     aCRef.Ref1.SetColRel(true); aCRef.Ref1.SetRowRel(true); aCRef.Ref1.SetTabRel(true);
 451     aCRef.Ref2.SetColRel(true); aCRef.Ref2.SetRowRel(true); aCRef.Ref2.SetTabRel(true);
 452
 453     for (nArrY=0; nArrY<nRowCount; nArrY++)
 454     {
 455         SCSIZE nNeeded = 0;
 456         for (nArrX=0; nArrX<nColCount; nArrX++)
 457             nNeeded = std::max( nNeeded, ppRefs[nArrX][nArrY].size() );
 458
 459         if (nNeeded)
 460         {
 461             rDestDoc.InsertRow( 0,nTab, rDestDoc.MaxCol(),nTab, nRow+nArrY, nNeeded );
 462
 463             for (nArrX=0; nArrX<nColCount; nArrX++)
 464                 if (ppUsed[nArrX][nArrY])
 465                 {
 466                     SCSIZE nCount = ppRefs[nArrX][nArrY].size();
 467                     if (nCount)
 468                     {
 469                         for (SCSIZE nPos=0; nPos<nCount; nPos++)
 470                         {
 471                             ScReferenceEntry aRef = ppRefs[nArrX][nArrY][nPos];
 472                             if (aRef.nTab != SC_CONS_NOTFOUND)
 473                             {
 474                                 // insert reference (absolute, 3d)
 475
 476                                 aSRef.SetAddress(rDestDoc.GetSheetLimits(), ScAddress(aRef.nCol,aRef.nRow,aRef.nTab), ScAddress());
 477
 478                                 ScTokenArray aRefArr(rDestDoc);
 479                                 aRefArr.AddSingleReference(aSRef);
 480                                 aRefArr.AddOpCode(ocStop);
 481                                 ScAddress aDest( sal::static_int_cast<SCCOL>(nCol+nArrX),
 482                                                  sal::static_int_cast<SCROW>(nRow+nArrY+nPos), nTab );
 483                                 ScFormulaCell* pCell = new ScFormulaCell(rDestDoc, aDest, aRefArr);
 484                                 rDestDoc.SetFormulaCell(aDest, pCell);
 485                             }
 486                         }
 487
 488                         // insert sum (relative, not 3d)
 489
 490                         ScAddress aDest( sal::static_int_cast<SCCOL>(nCol+nArrX),
 491                                          sal::static_int_cast<SCROW>(nRow+nArrY+nNeeded), nTab );
 492
 493                         ScRange aRange(sal::static_int_cast<SCCOL>(nCol+nArrX), nRow+nArrY, nTab);
 494                         aRange.aEnd.SetRow(nRow+nArrY+nNeeded-1);
 495                         aCRef.SetRange(rDestDoc.GetSheetLimits(), aRange, aDest);
 496
 497                         ScTokenArray aArr(rDestDoc);
 498                         aArr.AddOpCode(eOpCode);            // selected function
 499                         aArr.AddOpCode(ocOpen);
 500                         aArr.AddDoubleReference(aCRef);
 501                         aArr.AddOpCode(ocClose);
 502                         aArr.AddOpCode(ocStop);
 503                         ScFormulaCell* pCell = new ScFormulaCell(rDestDoc, aDest, aArr);
 504                         rDestDoc.SetFormulaCell(aDest, pCell);
 505                     }
 506                 }
 507
 508             // insert outline
 509
 510             ScOutlineArray& rOutArr = rDestDoc.GetOutlineTable( nTab, true )->GetRowArray();
 511             SCROW nOutStart = nRow+nArrY;
 512             SCROW nOutEnd = nRow+nArrY+nNeeded-1;
 513             bool bSize = false;
 514             rOutArr.Insert( nOutStart, nOutEnd, bSize );
 515             for (SCROW nOutRow=nOutStart; nOutRow<=nOutEnd; nOutRow++)
 516                 rDestDoc.ShowRow( nOutRow, nTab, false );
 517             rDestDoc.SetDrawPageSize(nTab);
 518             rDestDoc.UpdateOutlineRow( nOutStart, nOutEnd, nTab, false );
 519
 520             // sub title
 521
 522             if (ppTitlePos && !maTitles.empty() && !maRowHeaders.empty())
 523             {
 524                 for (SCSIZE nPos=0; nPos<nDataCount; nPos++)
 525                 {
 526                     SCSIZE nTPos = ppTitlePos[nArrY][nPos];
 527                     bool bDo = true;
 528                     if (nPos+1<nDataCount)
 529                         if (ppTitlePos[nArrY][nPos+1] == nTPos)
 530                             bDo = false;                                    // empty
 531                     if ( bDo && nTPos < nNeeded )
 532                     {
 533                         aString = maRowHeaders[nArrY] + " / " + maTitles[nPos];
 534                         rDestDoc.SetString( nCol-1, nRow+nArrY+nTPos, nTab, aString );
 535                     }
 536                 }
 537             }
 538
 539             nRow += nNeeded;
 540         }
 541     }
 542 }
 543
 544 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */