LCOV - code coverage report
Current view: top level - libreoffice/sc/source/core/tool - chartpos.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 290 0.0 %
Date: 2012-12-27 Functions: 0 14 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "chartpos.hxx"
      21             : #include "document.hxx"
      22             : #include "rechead.hxx"
      23             : 
      24             : namespace
      25             : {
      26           0 :     bool lcl_hasValueDataButNoDates( ScDocument* pDocument, SCCOL nCol, SCROW nRow, SCTAB nTab )
      27             :     {
      28           0 :         bool bReturn = false;
      29           0 :         if (pDocument->HasValueData( nCol, nRow, nTab ))
      30             :         {
      31             :             //treat dates like text #i25706#
      32           0 :             sal_uInt32 nNumberFormat = pDocument->GetNumberFormat( ScAddress( nCol, nRow, nTab ) );
      33           0 :             short nType = pDocument->GetFormatTable()->GetType(nNumberFormat);
      34           0 :             bool bIsDate = (nType & NUMBERFORMAT_DATE);
      35           0 :             bReturn = !bIsDate;
      36             :         }
      37           0 :         return bReturn;
      38             :     }
      39             : }
      40             : 
      41           0 : ScChartPositioner::ScChartPositioner( ScDocument* pDoc, SCTAB nTab,
      42             :                     SCCOL nStartColP, SCROW nStartRowP, SCCOL nEndColP, SCROW nEndRowP) :
      43             :         pDocument( pDoc ),
      44             :         pPositionMap( NULL ),
      45             :         eGlue( SC_CHARTGLUE_NA ),
      46             :         nStartCol(0),
      47             :         nStartRow(0),
      48             :         bColHeaders( false ),
      49             :         bRowHeaders( false ),
      50           0 :         bDummyUpperLeft( false )
      51             : {
      52           0 :     SetRangeList( ScRange( nStartColP, nStartRowP, nTab, nEndColP, nEndRowP, nTab ) );
      53           0 :     CheckColRowHeaders();
      54           0 : }
      55             : 
      56           0 : ScChartPositioner::ScChartPositioner( ScDocument* pDoc, const ScRangeListRef& rRangeList ) :
      57             :         aRangeListRef( rRangeList ),
      58             :         pDocument( pDoc ),
      59             :         pPositionMap( NULL ),
      60             :         eGlue( SC_CHARTGLUE_NA ),
      61             :         nStartCol(0),
      62             :         nStartRow(0),
      63             :         bColHeaders( false ),
      64             :         bRowHeaders( false ),
      65           0 :         bDummyUpperLeft( false )
      66             : {
      67           0 :     if ( aRangeListRef.Is() )
      68           0 :         CheckColRowHeaders();
      69           0 : }
      70             : 
      71           0 : ScChartPositioner::ScChartPositioner( const ScChartPositioner& rPositioner ) :
      72             :         aRangeListRef( rPositioner.aRangeListRef ),
      73             :         pDocument(rPositioner.pDocument),
      74             :         pPositionMap( NULL ),
      75             :         eGlue(rPositioner.eGlue),
      76             :         nStartCol(rPositioner.nStartCol),
      77             :         nStartRow(rPositioner.nStartRow),
      78             :         bColHeaders(rPositioner.bColHeaders),
      79             :         bRowHeaders(rPositioner.bRowHeaders),
      80           0 :         bDummyUpperLeft( rPositioner.bDummyUpperLeft )
      81             : {
      82           0 : }
      83             : 
      84           0 : ScChartPositioner::~ScChartPositioner()
      85             : {
      86           0 :     delete pPositionMap;
      87           0 : }
      88             : 
      89           0 : sal_Bool ScChartPositioner::operator==(const ScChartPositioner& rCmp) const
      90             : {
      91             :     return bColHeaders == rCmp.bColHeaders
      92             :         && bRowHeaders == rCmp.bRowHeaders
      93           0 :         && *aRangeListRef == *rCmp.aRangeListRef;
      94             : }
      95             : 
      96           0 : void ScChartPositioner::SetRangeList( const ScRange& rRange )
      97             : {
      98           0 :     aRangeListRef = new ScRangeList;
      99           0 :     aRangeListRef->Append( rRange );
     100           0 :     InvalidateGlue();
     101           0 : }
     102             : 
     103           0 : void ScChartPositioner::GlueState()
     104             : {
     105           0 :     if ( eGlue != SC_CHARTGLUE_NA )
     106           0 :         return;
     107           0 :     bDummyUpperLeft = false;
     108             :     ScRange* pR;
     109           0 :     if ( aRangeListRef->size() <= 1 )
     110             :     {
     111           0 :         if (  !aRangeListRef->empty() )
     112             :         {
     113           0 :             pR = aRangeListRef->front();
     114           0 :             if ( pR->aStart.Tab() == pR->aEnd.Tab() )
     115           0 :                 eGlue = SC_CHARTGLUE_NONE;
     116             :             else
     117           0 :                 eGlue = SC_CHARTGLUE_COLS;  // several tables column by column
     118           0 :             nStartCol = pR->aStart.Col();
     119           0 :             nStartRow = pR->aStart.Row();
     120             :         }
     121             :         else
     122             :         {
     123           0 :             InvalidateGlue();
     124           0 :             nStartCol = 0;
     125           0 :             nStartRow = 0;
     126             :         }
     127           0 :         return;
     128             :     }
     129             : 
     130           0 :     pR = aRangeListRef->front();
     131           0 :     nStartCol = pR->aStart.Col();
     132           0 :     nStartRow = pR->aStart.Row();
     133             :     SCCOL nMaxCols, nEndCol;
     134             :     SCROW nMaxRows, nEndRow;
     135           0 :     nMaxCols = nEndCol = 0;
     136           0 :     nMaxRows = nEndRow = 0;
     137           0 :     for ( size_t i = 1, nRanges = aRangeListRef->size(); i <= nRanges; ++i )     // <= so 1 extra pass after last item
     138             :     {   // detect spanning/surrounding area etc.
     139             :         SCCOLROW nTmp, n1, n2;
     140           0 :         if ( (n1 = pR->aStart.Col()) < nStartCol ) nStartCol = static_cast<SCCOL>(n1  );
     141           0 :         if ( (n2 = pR->aEnd.Col()  ) > nEndCol   ) nEndCol   = static_cast<SCCOL>(n2  );
     142           0 :         if ( (nTmp = n2 - n1 + 1   ) > nMaxCols  ) nMaxCols  = static_cast<SCCOL>(nTmp);
     143           0 :         if ( (n1 = pR->aStart.Row()) < nStartRow ) nStartRow = static_cast<SCROW>(n1  );
     144           0 :         if ( (n2 = pR->aEnd.Row()  ) > nEndRow   ) nEndRow   = static_cast<SCROW>(n2  );
     145           0 :         if ( (nTmp = n2 - n1 + 1   ) > nMaxRows  ) nMaxRows  = static_cast<SCROW>(nTmp);
     146           0 :         if ( i < nRanges )                      // in last pass; i = nRanges so don't use at()
     147           0 :             pR = (*aRangeListRef)[i];
     148             :     }
     149           0 :     SCCOL nC = nEndCol - nStartCol + 1;
     150           0 :     if ( nC == 1 )
     151             :     {
     152           0 :         eGlue = SC_CHARTGLUE_ROWS;
     153           0 :         return;
     154             :     }
     155           0 :     SCROW nR = nEndRow - nStartRow + 1;
     156           0 :     if ( nR == 1 )
     157             :     {
     158           0 :         eGlue = SC_CHARTGLUE_COLS;
     159           0 :         return;
     160             :     }
     161           0 :     sal_uLong nCR = (sal_uLong)nC * nR;
     162             : //2do:
     163             : /*
     164             :     First do it simple without bit masking. A maximum of 8MB could be allocated
     165             :     this way (256 Cols x 32000 Rows). That could be reduced to 2MB by
     166             :     using 2 Bits per entry, but it is faster this way.
     167             :     Another optimizing would be to store only used rows/columns in the array, but
     168             :     would mean another iteration of the RangeList indirect access to the array.
     169             :  */
     170           0 :     const sal_uInt8 nHole = 0;
     171           0 :     const sal_uInt8 nOccu = 1;
     172           0 :     const sal_uInt8 nFree = 2;
     173           0 :     const sal_uInt8 nGlue = 3;
     174             :     sal_uInt8* p;
     175           0 :     sal_uInt8* pA = new sal_uInt8[ nCR ];
     176           0 :     memset( pA, 0, nCR * sizeof(sal_uInt8) );
     177             : 
     178             :     SCCOL nCol, nCol1, nCol2;
     179             :     SCROW nRow, nRow1, nRow2;
     180           0 :     for ( size_t i = 0, nRanges = aRangeListRef->size(); i < nRanges; ++i )
     181             :     {   // mark selections as used in 2D
     182           0 :         pR = (*aRangeListRef)[i];
     183           0 :         nCol1 = pR->aStart.Col() - nStartCol;
     184           0 :         nCol2 = pR->aEnd.Col() - nStartCol;
     185           0 :         nRow1 = pR->aStart.Row() - nStartRow;
     186           0 :         nRow2 = pR->aEnd.Row() - nStartRow;
     187           0 :         for ( nCol = nCol1; nCol <= nCol2; nCol++ )
     188             :         {
     189           0 :             p = pA + (sal_uLong)nCol * nR + nRow1;
     190           0 :             for ( nRow = nRow1; nRow <= nRow2; nRow++, p++ )
     191           0 :                 *p = nOccu;
     192             :         }
     193             :     }
     194           0 :     sal_Bool bGlue = sal_True;
     195             : 
     196           0 :     sal_Bool bGlueCols = false;
     197           0 :     for ( nCol = 0; bGlue && nCol < nC; nCol++ )
     198             :     {   // iterate columns and try to mark as unused
     199           0 :         p = pA + (sal_uLong)nCol * nR;
     200           0 :         for ( nRow = 0; bGlue && nRow < nR; nRow++, p++ )
     201             :         {
     202           0 :             if ( *p == nOccu )
     203             :             {   // Wenn einer mittendrin liegt ist keine Zusammenfassung
     204             :                 // moeglich. Am Rand koennte ok sein, wenn in dieser Spalte
     205             :                 // in jeder belegten Zeile einer belegt ist.
     206           0 :                 if ( nRow > 0 && nCol > 0 )
     207           0 :                     bGlue = false;      // nCol==0 can be DummyUpperLeft
     208             :                 else
     209           0 :                     nRow = nR;
     210             :             }
     211             :             else
     212           0 :                 *p = nFree;
     213             :         }
     214           0 :         if ( bGlue && *(p = (pA + ((((sal_uLong)nCol+1) * nR) - 1))) == nFree )
     215             :         {   // mark column as totally unused
     216           0 :             *p = nGlue;
     217           0 :             bGlueCols = sal_True;       // one unused column at least
     218             :         }
     219             :     }
     220             : 
     221           0 :     sal_Bool bGlueRows = false;
     222           0 :     for ( nRow = 0; bGlue && nRow < nR; nRow++ )
     223             :     {   // iterate rows and try to mark as unused
     224           0 :         p = pA + nRow;
     225           0 :         for ( nCol = 0; bGlue && nCol < nC; nCol++, p+=nR )
     226             :         {
     227           0 :             if ( *p == nOccu )
     228             :             {
     229           0 :                 if ( nCol > 0 && nRow > 0 )
     230           0 :                     bGlue = false;      // nRow==0 can be DummyUpperLeft
     231             :                 else
     232           0 :                     nCol = nC;
     233             :             }
     234             :             else
     235           0 :                 *p = nFree;
     236             :         }
     237           0 :         if ( bGlue && *(p = (pA + ((((sal_uLong)nC-1) * nR) + nRow))) == nFree )
     238             :         {   // mark row as totally unused
     239           0 :             *p = nGlue;
     240           0 :             bGlueRows = sal_True;       // one unused row at least
     241             :         }
     242             :     }
     243             : 
     244             :     // n=1: die linke obere Ecke koennte bei Beschriftung automagisch
     245             :     // hinzugezogen werden
     246           0 :     p = pA + 1;
     247           0 :     for ( sal_uLong n = 1; bGlue && n < nCR; n++, p++ )
     248             :     {   // ein unberuehrtes Feld heisst, dass es weder spaltenweise noch
     249             :         // zeilenweise zu erreichen war, also nichts zusamenzufassen
     250           0 :         if ( *p == nHole )
     251           0 :             bGlue = false;
     252             :     }
     253           0 :     if ( bGlue )
     254             :     {
     255           0 :         if ( bGlueCols && bGlueRows )
     256           0 :             eGlue = SC_CHARTGLUE_BOTH;
     257           0 :         else if ( bGlueRows )
     258           0 :             eGlue = SC_CHARTGLUE_ROWS;
     259             :         else
     260           0 :             eGlue = SC_CHARTGLUE_COLS;
     261           0 :         if ( *pA != nOccu )
     262           0 :             bDummyUpperLeft = sal_True;
     263             :     }
     264             :     else
     265             :     {
     266           0 :         eGlue = SC_CHARTGLUE_NONE;
     267             :     }
     268             : 
     269           0 :     delete [] pA;
     270             : }
     271             : 
     272           0 : void ScChartPositioner::CheckColRowHeaders()
     273             : {
     274             :     SCCOL nCol1, nCol2, iCol;
     275             :     SCROW nRow1, nRow2, iRow;
     276             :     SCTAB nTab1, nTab2;
     277             : 
     278           0 :     sal_Bool bColStrings = sal_True;
     279           0 :     sal_Bool bRowStrings = sal_True;
     280           0 :     GlueState();
     281           0 :     if ( aRangeListRef->size() == 1 )
     282             :     {
     283           0 :         aRangeListRef->front()->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
     284           0 :         if ( nCol1 > nCol2 || nRow1 > nRow2 )
     285           0 :             bColStrings = bRowStrings = false;
     286             :         else
     287             :         {
     288           0 :             for (iCol=nCol1; iCol<=nCol2 && bColStrings; iCol++)
     289             :             {
     290           0 :                 if (lcl_hasValueDataButNoDates( pDocument, iCol, nRow1, nTab1 ))
     291           0 :                         bColStrings = false;
     292             :             }
     293           0 :             for (iRow=nRow1; iRow<=nRow2 && bRowStrings; iRow++)
     294             :             {
     295           0 :                 if (lcl_hasValueDataButNoDates( pDocument, nCol1, iRow, nTab1 ))
     296           0 :                         bRowStrings = false;
     297             :             }
     298             :         }
     299             :     }
     300             :     else
     301             :     {
     302           0 :         sal_Bool bVert = (eGlue == SC_CHARTGLUE_NONE || eGlue == SC_CHARTGLUE_ROWS);
     303           0 :         for ( size_t i = 0, nRanges = aRangeListRef->size();
     304             :               (i < nRanges) && (bColStrings || bRowStrings);
     305             :               ++i
     306             :             )
     307             :         {
     308           0 :             ScRange* pR = (*aRangeListRef)[i];
     309           0 :             pR->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
     310           0 :             sal_Bool bTopRow = (nRow1 == nStartRow);
     311           0 :             if ( bRowStrings && (bVert || nCol1 == nStartCol) )
     312             :             {   // NONE or ROWS: RowStrings in every selection possible
     313             :                 // COLS or BOTH: only from first column
     314           0 :                 if ( nCol1 <= nCol2 )
     315           0 :                     for (iRow=nRow1; iRow<=nRow2 && bRowStrings; iRow++)
     316             :                     {
     317           0 :                         if (lcl_hasValueDataButNoDates( pDocument, nCol1, iRow, nTab1 ))
     318           0 :                                 bRowStrings = false;
     319             :                     }
     320             :             }
     321           0 :             if ( bColStrings && bTopRow )
     322             :             {   // ColStrings only from first row
     323           0 :                 if ( nRow1 <= nRow2 )
     324           0 :                     for (iCol=nCol1; iCol<=nCol2 && bColStrings; iCol++)
     325             :                     {
     326           0 :                         if (lcl_hasValueDataButNoDates( pDocument, iCol, nRow1, nTab1 ))
     327           0 :                                 bColStrings = false;
     328             :                     }
     329             :             }
     330             :         }
     331             :     }
     332           0 :     bColHeaders = bColStrings;
     333           0 :     bRowHeaders = bRowStrings;
     334           0 : }
     335             : 
     336           0 : const ScChartPositionMap* ScChartPositioner::GetPositionMap()
     337             : {
     338           0 :     CreatePositionMap();
     339           0 :     return pPositionMap;
     340             : }
     341             : 
     342             : 
     343           0 : void ScChartPositioner::CreatePositionMap()
     344             : {
     345           0 :     if ( eGlue == SC_CHARTGLUE_NA && pPositionMap )
     346             :     {
     347           0 :         delete pPositionMap;
     348           0 :         pPositionMap = NULL;
     349             :     }
     350             : 
     351           0 :     if ( pPositionMap )
     352           0 :         return ;
     353             : 
     354           0 :     SCSIZE nColAdd = bRowHeaders ? 1 : 0;
     355           0 :     SCSIZE nRowAdd = bColHeaders ? 1 : 0;
     356             : 
     357             :     SCCOL nCol, nCol1, nCol2;
     358             :     SCROW nRow, nRow1, nRow2;
     359             :     SCTAB nTab, nTab1, nTab2;
     360             : 
     361             :     //
     362             :     //  real size (without hidden rows/columns)
     363             :     //
     364             : 
     365           0 :     SCSIZE nColCount = 0;
     366           0 :     SCSIZE nRowCount = 0;
     367             : 
     368           0 :     GlueState();
     369             : 
     370           0 :     const sal_Bool bNoGlue = (eGlue == SC_CHARTGLUE_NONE);
     371           0 :     ColumnMap* pCols = new ColumnMap;
     372           0 :     SCROW nNoGlueRow = 0;
     373           0 :     for ( size_t i = 0, nRanges = aRangeListRef->size(); i < nRanges; ++i )
     374             :     {
     375           0 :         ScRange* pR = (*aRangeListRef)[i];
     376           0 :         pR->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
     377           0 :         for ( nTab = nTab1; nTab <= nTab2; nTab++ )
     378             :         {
     379             :             // nTab in ColKey to allow to have the same col/row in another tabe
     380             :             sal_uLong nInsCol = (static_cast<sal_uLong>(nTab) << 16) | (bNoGlue ? 0 :
     381           0 :                     static_cast<sal_uLong>(nCol1));
     382           0 :             for ( nCol = nCol1; nCol <= nCol2; ++nCol, ++nInsCol )
     383             :             {
     384           0 :                 RowMap* pCol = NULL;
     385           0 :                 ColumnMap::const_iterator it = pCols->find( nInsCol );
     386           0 :                 if ( it == pCols->end() )
     387             :                 {
     388           0 :                     pCol = new RowMap;
     389           0 :                     pCols->insert( ColumnMap::value_type( nInsCol, pCol ) );
     390             :                 }
     391             :                 else
     392           0 :                     pCol = it->second;
     393             : 
     394             :                 // in other table a new ColKey already was created,
     395             :                 // the rows must be equal to be filled with Dummy
     396           0 :                 sal_uLong nInsRow = (bNoGlue ? nNoGlueRow : nRow1);
     397           0 :                 for ( nRow = nRow1; nRow <= nRow2; nRow++, nInsRow++ )
     398             :                 {
     399           0 :                     if ( pCol->find( nInsRow ) == pCol->end() )
     400             :                     {
     401           0 :                         pCol->insert( RowMap::value_type( nInsRow, new ScAddress( nCol, nRow, nTab ) ) );
     402             :                     }
     403             :                 }
     404             :             }
     405             :         }
     406             :         // bei NoGlue werden zusammengehoerige Tabellen als ColGlue dargestellt
     407           0 :         nNoGlueRow += nRow2 - nRow1 + 1;
     408             :     }
     409             : 
     410             :     // count of data
     411           0 :     nColCount = static_cast< SCSIZE >( pCols->size());
     412           0 :     if ( !pCols->empty() )
     413             :     {
     414           0 :         RowMap* pCol = pCols->begin()->second;
     415           0 :         if ( bDummyUpperLeft )
     416           0 :             (*pCol)[ 0 ] = NULL;        // Dummy for labeling
     417           0 :         nRowCount = static_cast< SCSIZE >( pCol->size());
     418             :     }
     419             :     else
     420           0 :         nRowCount = 0;
     421           0 :     if ( nColCount > 0 )
     422           0 :         nColCount -= nColAdd;
     423           0 :     if ( nRowCount > 0 )
     424           0 :         nRowCount -= nRowAdd;
     425             : 
     426           0 :     if ( nColCount==0 || nRowCount==0 )
     427             :     {   // create an entry without data
     428             :         RowMap* pCol;
     429           0 :         if ( !pCols->empty() )
     430           0 :             pCol = pCols->begin()->second;
     431             :         else
     432             :         {
     433           0 :             pCol = new RowMap;
     434           0 :             (*pCols)[ 0 ] = pCol;
     435             :         }
     436           0 :         nColCount = 1;
     437           0 :         if ( !pCol->empty() )
     438             :         {   // cannot be if nColCount==0 || nRowCount==0
     439           0 :             ScAddress* pPos = pCol->begin()->second;
     440           0 :             if ( pPos )
     441             :             {
     442           0 :                 sal_uLong nCurrentKey = pCol->begin()->first;
     443           0 :                 delete pPos;
     444           0 :                 (*pCol)[ nCurrentKey ] = NULL;
     445             :             }
     446             :         }
     447             :         else
     448           0 :             (*pCol)[ 0 ] = NULL;
     449           0 :         nRowCount = 1;
     450           0 :         nColAdd = 0;
     451           0 :         nRowAdd = 0;
     452             :     }
     453             :     else
     454             :     {
     455           0 :         if ( bNoGlue )
     456             :         {   // fill gaps with Dummies, first column is master
     457           0 :             RowMap* pFirstCol = pCols->begin()->second;
     458           0 :             sal_uLong nCount = pFirstCol->size();
     459           0 :             RowMap::const_iterator it1 = pFirstCol->begin();
     460           0 :             for ( sal_uLong n = 0; n < nCount; n++, ++it1 )
     461             :             {
     462           0 :                 sal_uLong nKey = it1->first;
     463           0 :                 for (ColumnMap::const_iterator it2 = ++pCols->begin(); it2 != pCols->end(); ++it2 )
     464           0 :                     it2->second->insert( RowMap::value_type( nKey, (ScAddress *)NULL )); // no data
     465             :             }
     466             :         }
     467             :     }
     468             : 
     469             :     pPositionMap = new ScChartPositionMap( static_cast<SCCOL>(nColCount), static_cast<SCROW>(nRowCount),
     470           0 :         static_cast<SCCOL>(nColAdd), static_cast<SCROW>(nRowAdd), *pCols );
     471             : 
     472             :     //  cleanup
     473           0 :     for (ColumnMap::const_iterator it = pCols->begin(); it != pCols->end(); ++it )
     474             :     {   //! nur Tables loeschen, nicht die ScAddress*
     475           0 :         delete it->second;
     476             :     }
     477           0 :     delete pCols;
     478             : }
     479             : 
     480             : 
     481           0 : ScChartPositionMap::ScChartPositionMap( SCCOL nChartCols, SCROW nChartRows,
     482             :             SCCOL nColAdd, SCROW nRowAdd, ColumnMap& rCols ) :
     483           0 :         ppData( new ScAddress* [ nChartCols * nChartRows ] ),
     484           0 :         ppColHeader( new ScAddress* [ nChartCols ] ),
     485           0 :         ppRowHeader( new ScAddress* [ nChartRows ] ),
     486             :         nCount( (sal_uLong) nChartCols * nChartRows ),
     487             :         nColCount( nChartCols ),
     488           0 :         nRowCount( nChartRows )
     489             : {
     490             :     OSL_ENSURE( nColCount && nRowCount, "ScChartPositionMap without dimension" );
     491             : 
     492           0 :     ColumnMap::const_iterator pColIter = rCols.begin();
     493           0 :     RowMap* pCol1 = pColIter->second;
     494           0 :     RowMap::const_iterator pPos1Iter;
     495             : 
     496             :     // row header
     497           0 :     pPos1Iter = pCol1->begin();
     498           0 :     if ( nRowAdd )
     499           0 :         ++pPos1Iter;
     500           0 :     if ( nColAdd )
     501             :     {   // independent
     502           0 :         SCROW nRow = 0;
     503           0 :         for ( ; nRow < nRowCount && pPos1Iter != pCol1->end(); nRow++ )
     504             :         {
     505           0 :             ppRowHeader[ nRow ] = pPos1Iter->second;
     506           0 :             ++pPos1Iter;
     507             :         }
     508           0 :         for ( ; nRow < nRowCount; nRow++ )
     509           0 :             ppRowHeader[ nRow ] = NULL;
     510             :     }
     511             :     else
     512             :     {   // copy
     513           0 :         SCROW nRow = 0;
     514           0 :         for ( ; nRow < nRowCount && pPos1Iter != pCol1->end(); nRow++ )
     515             :         {
     516           0 :             ppRowHeader[ nRow ] = pPos1Iter->second ?
     517           0 :                 new ScAddress( *pPos1Iter->second ) : NULL;
     518           0 :             ++pPos1Iter;
     519             :         }
     520           0 :         for ( ; nRow < nRowCount; nRow++ )
     521           0 :             ppRowHeader[ nRow ] = NULL;
     522             :     }
     523           0 :     if ( nColAdd )
     524             :     {
     525           0 :         ++pColIter;
     526             :     }
     527             : 
     528             :     // data column by column and column-header
     529           0 :     sal_uLong nIndex = 0;
     530           0 :     for ( SCCOL nCol = 0; nCol < nColCount; nCol++ )
     531             :     {
     532           0 :         if ( pColIter != rCols.end() )
     533             :         {
     534           0 :             RowMap* pCol2 = pColIter->second;
     535           0 :             RowMap::const_iterator pPosIter = pCol2->begin();
     536           0 :             if ( pPosIter != pCol2->end() )
     537             :             {
     538           0 :                 if ( nRowAdd )
     539             :                 {
     540           0 :                     ppColHeader[ nCol ] = pPosIter->second;     // independent
     541           0 :                     ++pPosIter;
     542             :                 }
     543             :                 else
     544           0 :                     ppColHeader[ nCol ] = pPosIter->second ?
     545           0 :                         new ScAddress( *pPosIter->second ) : NULL;
     546             :             }
     547             : 
     548           0 :             SCROW nRow = 0;
     549           0 :             for ( ; nRow < nRowCount && pPosIter != pCol2->end(); nRow++, nIndex++ )
     550             :             {
     551           0 :                 ppData[ nIndex ] = pPosIter->second;
     552           0 :                 ++pPosIter;
     553             :             }
     554           0 :             for ( ; nRow < nRowCount; nRow++, nIndex++ )
     555           0 :                 ppData[ nIndex ] = NULL;
     556             : 
     557           0 :             ++pColIter;
     558             :         }
     559             :         else
     560             :         {
     561           0 :             ppColHeader[ nCol ] = NULL;
     562           0 :             for ( SCROW nRow = 0; nRow < nRowCount; nRow++, nIndex++ )
     563             :             {
     564           0 :                 ppData[ nIndex ] = NULL;
     565             :             }
     566             :         }
     567             :     }
     568           0 : }
     569             : 
     570             : 
     571           0 : ScChartPositionMap::~ScChartPositionMap()
     572             : {
     573           0 :     for ( sal_uLong nIndex=0; nIndex < nCount; nIndex++ )
     574             :     {
     575           0 :         delete ppData[nIndex];
     576             :     }
     577           0 :     delete [] ppData;
     578             : 
     579             :     SCCOL j;
     580           0 :     for ( j=0; j < nColCount; j++ )
     581             :     {
     582           0 :         delete ppColHeader[j];
     583             :     }
     584           0 :     delete [] ppColHeader;
     585             :     SCROW i;
     586           0 :     for ( i=0; i < nRowCount; i++ )
     587             :     {
     588           0 :         delete ppRowHeader[i];
     589             :     }
     590           0 :     delete [] ppRowHeader;
     591           0 : }
     592             : 
     593             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10