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