sc/source/core/tool/chartarr.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 "scitems.hxx"
  21 #include <svl/intitem.hxx>
  22 #include <svl/zforlist.hxx>
  23 #include <float.h>
  24
  25 #include "chartarr.hxx"
  26 #include "document.hxx"
  27 #include "rechead.hxx"
  28 #include "globstr.hrc"
  29 #include "formulacell.hxx"
  30 #include "docoptio.hxx"
  31
  32 #include <vector>
  33
  34 using ::std::vector;
  35
  36 ScMemChart::ScMemChart(short nCols, short nRows)
  37 {
  38     nRowCnt = nRows;
  39     nColCnt = nCols;
  40     pData   = new double[nColCnt * nRowCnt];
  41
  42     if (pData)
  43     {
  44         double *pFill = pData;
  45
  46         for (short i = 0; i < nColCnt; i++)
  47             for (short j = 0; j < nRowCnt; j++)
  48                 *(pFill ++) = 0.0;
  49     }
  50
  51     pColText = new OUString[nColCnt];
  52     pRowText = new OUString[nRowCnt];
  53 }
  54
  55 ScMemChart::~ScMemChart()
  56 {
  57     delete[] pRowText;
  58     delete[] pColText;
  59     delete[] pData;
  60 }
  61
  62 ScChartArray::ScChartArray( ScDocument* pDoc, SCTAB nTab,
  63                     SCCOL nStartColP, SCROW nStartRowP, SCCOL nEndColP, SCROW nEndRowP,
  64                     const OUString& rChartName ) :
  65         aName( rChartName ),
  66         pDocument( pDoc ),
  67         aPositioner(pDoc, nTab, nStartColP, nStartRowP, nEndColP, nEndRowP),
  68         bValid( true )
  69 {
  70 }
  71
  72 ScChartArray::ScChartArray(
  73     ScDocument* pDoc, const ScRangeListRef& rRangeList, const OUString& rChartName ) :
  74     aName( rChartName ),
  75     pDocument( pDoc ),
  76     aPositioner(pDoc, rRangeList),
  77     bValid( true ) {}
  78
  79 ScChartArray::ScChartArray( const ScChartArray& rArr ) :
  80     aName(rArr.aName),
  81     pDocument(rArr.pDocument),
  82     aPositioner(rArr.aPositioner),
  83     bValid(rArr.bValid) {}
  84
  85 ScChartArray::~ScChartArray() {}
  86
  87 bool ScChartArray::operator==(const ScChartArray& rCmp) const
  88 {
  89     return aPositioner == rCmp.aPositioner
  90         && aName == rCmp.aName;
  91 }
  92
  93 ScMemChart* ScChartArray::CreateMemChart()
  94 {
  95     ScRangeListRef aRangeListRef(GetRangeList());
  96     size_t nCount = aRangeListRef->size();
  97     if ( nCount > 1 )
  98         return CreateMemChartMulti();
  99     else if ( nCount == 1 )
 100     {
 101         ScRange* pR = aRangeListRef->front();
 102         if ( pR->aStart.Tab() != pR->aEnd.Tab() )
 103             return CreateMemChartMulti();
 104         else
 105             return CreateMemChartSingle();
 106     }
 107     else
 108         return CreateMemChartMulti(); // Can handle 0 range better than Single
 109 }
 110
 111 namespace {
 112
 113 double getCellValue( ScDocument& rDoc, const ScAddress& rPos, double fDefault, bool bCalcAsShown )
 114 {
 115     double fRet = fDefault;
 116
 117     CellType eType = rDoc.GetCellType(rPos);
 118     switch (eType)
 119     {
 120         case CELLTYPE_VALUE:
 121         {
 122             fRet = rDoc.GetValue(rPos);
 123             if (bCalcAsShown && fRet != 0.0)
 124             {
 125                 sal_uInt32 nFormat = rDoc.GetNumberFormat(rPos);
 126                 fRet = rDoc.RoundValueAsShown(fRet, nFormat);
 127             }
 128         }
 129         break;
 130         case CELLTYPE_FORMULA:
 131         {
 132             ScFormulaCell* pFCell = rDoc.GetFormulaCell(rPos);
 133             if (!pFCell->GetErrCode() && pFCell->IsValue())
 134                 fRet = pFCell->GetValue();
 135         }
 136         break;
 137         default:
 138             ;
 139     }
 140     return fRet;
 141 }
 142
 143 }
 144
 145 ScMemChart* ScChartArray::CreateMemChartSingle()
 146 {
 147     SCSIZE nCol;
 148     SCSIZE nRow;
 149
 150         //
 151         //  real size (without hidden rows/columns)
 152         //
 153
 154     SCCOL nColAdd = HasRowHeaders() ? 1 : 0;
 155     SCROW nRowAdd = HasColHeaders() ? 1 : 0;
 156
 157     SCCOL nCol1;
 158     SCROW nRow1;
 159     SCTAB nTab1;
 160     SCCOL nCol2;
 161     SCROW nRow2;
 162     SCTAB nTab2;
 163     ScRangeListRef aRangeListRef(GetRangeList());
 164     aRangeListRef->front()->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
 165
 166     SCCOL nStrCol = nCol1; // remember for labeling
 167     SCROW nStrRow = nRow1;
 168     // Skip hidden columns.
 169     // TODO: make use of last column value once implemented.
 170     SCCOL nLastCol = -1;
 171     while (pDocument->ColHidden(nCol1, nTab1, NULL, &nLastCol))
 172         ++nCol1;
 173
 174     // Skip hidden rows.
 175     SCROW nLastRow = -1;
 176     if (pDocument->RowHidden(nRow1, nTab1, NULL, &nLastRow))
 177         nRow1 = nLastRow + 1;
 178
 179     // if everything is hidden then the label remains at the beginning
 180     if ( nCol1 <= nCol2 )
 181     {
 182         nStrCol = nCol1;
 183         nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nColAdd );
 184     }
 185     if ( nRow1 <= nRow2 )
 186     {
 187         nStrRow = nRow1;
 188         nRow1 = sal::static_int_cast<SCROW>( nRow1 + nRowAdd );
 189     }
 190
 191     SCSIZE nTotalCols = ( nCol1 <= nCol2 ? nCol2 - nCol1 + 1 : 0 );
 192     vector<SCCOL> aCols;
 193     aCols.reserve(nTotalCols);
 194     for (SCSIZE i=0; i<nTotalCols; i++)
 195     {
 196         SCCOL nThisCol = sal::static_int_cast<SCCOL>(nCol1+i);
 197         if (!pDocument->ColHidden(nThisCol, nTab1, NULL, &nLastCol))
 198             aCols.push_back(nThisCol);
 199     }
 200     SCSIZE nColCount = aCols.size();
 201
 202     SCSIZE nTotalRows = ( nRow1 <= nRow2 ? nRow2 - nRow1 + 1 : 0 );
 203     vector<SCROW> aRows;
 204     aRows.reserve(nTotalRows);
 205     if (nRow1 <= nRow2)
 206     {
 207         // Get all visible rows between nRow1 and nRow2.
 208         SCROW nThisRow = nRow1;
 209         while (nThisRow <= nRow2)
 210         {
 211             if (pDocument->RowHidden(nThisRow, nTab1, NULL, &nLastRow))
 212                 nThisRow = nLastRow;
 213             else
 214                 aRows.push_back(nThisRow);
 215             ++nThisRow;
 216         }
 217     }
 218     SCSIZE nRowCount = aRows.size();
 219
 220     // May happen at least with more than 32k rows.
 221     if (nColCount > SHRT_MAX || nRowCount > SHRT_MAX)
 222     {
 223         nColCount = 0;
 224         nRowCount = 0;
 225     }
 226
 227     bool bValidData = true;
 228     if ( !nColCount )
 229     {
 230         bValidData = false;
 231         nColCount = 1;
 232         aCols.push_back(nStrCol);
 233     }
 234     if ( !nRowCount )
 235     {
 236         bValidData = false;
 237         nRowCount = 1;
 238         aRows.push_back(nStrRow);
 239     }
 240
 241         //
 242         //  Data
 243         //
 244
 245     ScMemChart* pMemChart = new ScMemChart(
 246             static_cast<short>(nColCount), static_cast<short>(nRowCount) );
 247     if (pMemChart)
 248     {
 249         if ( bValidData )
 250         {
 251             bool bCalcAsShown = pDocument->GetDocOptions().IsCalcAsShown();
 252             for (nCol=0; nCol<nColCount; nCol++)
 253             {
 254                 for (nRow=0; nRow<nRowCount; nRow++)
 255                 {
 256                     // DBL_MIN is a Hack for Chart to recognize empty cells.
 257                     ScAddress aPos(aCols[nCol], aRows[nRow], nTab1);
 258                     double nVal = getCellValue(*pDocument, aPos, DBL_MIN, bCalcAsShown);
 259                     pMemChart->SetData(static_cast<short>(nCol), static_cast<short>(nRow), nVal);
 260                 }
 261             }
 262         }
 263         else
 264         {
 265             // Flag marking data as invalid?
 266             for (nCol=0; nCol<nColCount; nCol++)
 267                 for (nRow=0; nRow<nRowCount; nRow++)
 268                     pMemChart->SetData( static_cast<short>(nCol), static_cast<short>(nRow), DBL_MIN );
 269         }
 270
 271         //
 272         //  Column Header
 273         //
 274         for (nCol=0; nCol<nColCount; nCol++)
 275         {
 276             OUString aString;
 277             if (HasColHeaders())
 278                 aString = pDocument->GetString(aCols[nCol], nStrRow, nTab1);
 279             if (aString.isEmpty())
 280             {
 281                 OUStringBuffer aBuf;
 282                 aBuf.append(ScGlobal::GetRscString(STR_COLUMN));
 283                 aBuf.append(' ');
 284
 285                 ScAddress aPos( aCols[ nCol ], 0, 0 );
 286                 aBuf.append(aPos.Format(SCA_VALID_COL, NULL));
 287
 288                 aString = aBuf.makeStringAndClear();
 289             }
 290             pMemChart->SetColText( static_cast<short>(nCol), aString);
 291         }
 292
 293         //
 294         //  Row Header
 295         //
 296         for (nRow=0; nRow<nRowCount; nRow++)
 297         {
 298             OUString aString;
 299             if (HasRowHeaders())
 300             {
 301                 ScAddress aAddr( nStrCol, aRows[nRow], nTab1 );
 302                 aString = pDocument->GetString(nStrCol, aRows[nRow], nTab1);
 303             }
 304             if (aString.isEmpty())
 305             {
 306                 OUStringBuffer aBuf;
 307                 aBuf.append(ScGlobal::GetRscString(STR_ROW));
 308                 aBuf.append(' ');
 309                 aBuf.append(static_cast<sal_Int32>(aRows[nRow]+1));
 310                 aString = aBuf.makeStringAndClear();
 311             }
 312             pMemChart->SetRowText( static_cast<short>(nRow), aString);
 313         }
 314     }
 315
 316     return pMemChart;
 317 }
 318
 319 ScMemChart* ScChartArray::CreateMemChartMulti()
 320 {
 321     SCSIZE nColCount = GetPositionMap()->GetColCount();
 322     SCSIZE nRowCount = GetPositionMap()->GetRowCount();
 323
 324     // May happen at least with more than 32k rows.
 325     if (nColCount > SHRT_MAX || nRowCount > SHRT_MAX)
 326     {
 327         nColCount = 0;
 328         nRowCount = 0;
 329     }
 330
 331     bool bValidData = true;
 332     if ( !nColCount )
 333     {
 334         bValidData = false;
 335         nColCount = 1;
 336     }
 337     if ( !nRowCount )
 338     {
 339         bValidData = false;
 340         nRowCount = 1;
 341     }
 342
 343     //
 344     //  Data
 345     //
 346
 347     ScMemChart* pMemChart = new ScMemChart(
 348             static_cast<short>(nColCount), static_cast<short>(nRowCount) );
 349     if (pMemChart)
 350     {
 351         SCSIZE nCol = 0;
 352         SCSIZE nRow = 0;
 353         bool bCalcAsShown = pDocument->GetDocOptions().IsCalcAsShown();
 354         sal_uLong nIndex = 0;
 355         if (bValidData)
 356         {
 357             for ( nCol = 0; nCol < nColCount; nCol++ )
 358             {
 359                 for ( nRow = 0; nRow < nRowCount; nRow++, nIndex++ )
 360                 {
 361                     double nVal = DBL_MIN; // Hack for Chart to recognize empty cells
 362                     const ScAddress* pPos = GetPositionMap()->GetPosition( nIndex );
 363                     if (pPos)
 364                         // otherwise: Gap
 365                         nVal = getCellValue(*pDocument, *pPos, DBL_MIN, bCalcAsShown);
 366
 367                     pMemChart->SetData(static_cast<short>(nCol), static_cast<short>(nRow), nVal);
 368                 }
 369             }
 370         }
 371         else
 372         {
 373             for ( nRow = 0; nRow < nRowCount; nRow++, nIndex++ )
 374             {
 375                 double nVal = DBL_MIN; // Hack for Chart to recognize empty cells
 376                 const ScAddress* pPos = GetPositionMap()->GetPosition( nIndex );
 377                 if (pPos)
 378                     // otherwise: Gap
 379                     nVal = getCellValue(*pDocument, *pPos, DBL_MIN, bCalcAsShown);
 380
 381                 pMemChart->SetData(static_cast<short>(nCol), static_cast<short>(nRow), nVal);
 382             }
 383         }
 384
 385         //TODO: Label when gaps
 386
 387         //
 388         //  Column header
 389         //
 390
 391         SCCOL nPosCol = 0;
 392         for ( nCol = 0; nCol < nColCount; nCol++ )
 393         {
 394             OUString aString;
 395             const ScAddress* pPos = GetPositionMap()->GetColHeaderPosition( static_cast<SCCOL>(nCol) );
 396             if ( HasColHeaders() && pPos )
 397                 aString = pDocument->GetString(pPos->Col(), pPos->Row(), pPos->Tab());
 398
 399             if (aString.isEmpty())
 400             {
 401                 OUStringBuffer aBuf(ScGlobal::GetRscString(STR_COLUMN));
 402                 aBuf.append(' ');
 403                 if ( pPos )
 404                     nPosCol = pPos->Col() + 1;
 405                 else
 406                     nPosCol++;
 407                 ScAddress aPos( nPosCol - 1, 0, 0 );
 408                 aBuf.append(aPos.Format(SCA_VALID_COL, NULL));
 409                 aString = aBuf.makeStringAndClear();
 410             }
 411             pMemChart->SetColText( static_cast<short>(nCol), aString);
 412         }
 413
 414         //
 415         //  Row header
 416         //
 417
 418         SCROW nPosRow = 0;
 419         for ( nRow = 0; nRow < nRowCount; nRow++ )
 420         {
 421             OUString aString;
 422             const ScAddress* pPos = GetPositionMap()->GetRowHeaderPosition( nRow );
 423             if ( HasRowHeaders() && pPos )
 424                 aString = pDocument->GetString(pPos->Col(), pPos->Row(), pPos->Tab());
 425
 426             if (aString.isEmpty())
 427             {
 428                 OUStringBuffer aBuf(ScGlobal::GetRscString(STR_ROW));
 429                 aBuf.append(' ');
 430                 if ( pPos )
 431                     nPosRow = pPos->Row() + 1;
 432                 else
 433                     nPosRow++;
 434                 aBuf.append(static_cast<sal_Int32>(nPosRow));
 435                 aString = aBuf.makeStringAndClear();
 436             }
 437             pMemChart->SetRowText( static_cast<short>(nRow), aString);
 438         }
 439     }
 440
 441     return pMemChart;
 442 }
 443
 444 ScChartCollection::ScChartCollection() {}
 445 ScChartCollection::ScChartCollection(const ScChartCollection& r) :
 446     maData(r.maData) {}
 447
 448 void ScChartCollection::push_back(ScChartArray* p)
 449 {
 450     maData.push_back(p);
 451 }
 452
 453 void ScChartCollection::clear()
 454 {
 455     maData.clear();
 456 }
 457
 458 size_t ScChartCollection::size() const
 459 {
 460     return maData.size();
 461 }
 462
 463 bool ScChartCollection::empty() const
 464 {
 465     return maData.empty();
 466 }
 467
 468 ScChartArray* ScChartCollection::operator[](size_t nIndex)
 469 {
 470     if (maData.size() <= nIndex)
 471         return NULL;
 472     return &maData[nIndex];
 473 }
 474
 475 const ScChartArray* ScChartCollection::operator[](size_t nIndex) const
 476 {
 477     if (maData.size() <= nIndex)
 478         return NULL;
 479     return &maData[nIndex];
 480 }
 481
 482 bool ScChartCollection::operator==(const ScChartCollection& rCmp) const
 483 {
 484     return maData == rCmp.maData;
 485 }
 486
 487 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */