1*b3f79822SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*b3f79822SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*b3f79822SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*b3f79822SAndrew Rist * distributed with this work for additional information
6*b3f79822SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*b3f79822SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*b3f79822SAndrew Rist * "License"); you may not use this file except in compliance
9*b3f79822SAndrew Rist * with the License. You may obtain a copy of the License at
10*b3f79822SAndrew Rist *
11*b3f79822SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*b3f79822SAndrew Rist *
13*b3f79822SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*b3f79822SAndrew Rist * software distributed under the License is distributed on an
15*b3f79822SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b3f79822SAndrew Rist * KIND, either express or implied. See the License for the
17*b3f79822SAndrew Rist * specific language governing permissions and limitations
18*b3f79822SAndrew Rist * under the License.
19*b3f79822SAndrew Rist *
20*b3f79822SAndrew Rist *************************************************************/
21*b3f79822SAndrew Rist
22*b3f79822SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sc.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir
28cdf0e10cSrcweir
29cdf0e10cSrcweir // INCLUDE ---------------------------------------------------------------
30cdf0e10cSrcweir
31cdf0e10cSrcweir #include "scitems.hxx"
32cdf0e10cSrcweir #include <svl/intitem.hxx>
33cdf0e10cSrcweir #include <svl/zforlist.hxx>
34cdf0e10cSrcweir #include <float.h> // DBL_MIN
35cdf0e10cSrcweir
36cdf0e10cSrcweir #include "chartarr.hxx"
37cdf0e10cSrcweir #include "document.hxx"
38cdf0e10cSrcweir #include "rechead.hxx"
39cdf0e10cSrcweir #include "globstr.hrc"
40cdf0e10cSrcweir #include "cell.hxx"
41cdf0e10cSrcweir #include "docoptio.hxx"
42cdf0e10cSrcweir
43cdf0e10cSrcweir #include <vector>
44cdf0e10cSrcweir
45cdf0e10cSrcweir using ::std::vector;
46cdf0e10cSrcweir
47cdf0e10cSrcweir // -----------------------------------------------------------------------
48cdf0e10cSrcweir
ScMemChart(short nCols,short nRows)49cdf0e10cSrcweir ScMemChart::ScMemChart(short nCols, short nRows)
50cdf0e10cSrcweir {
51cdf0e10cSrcweir nRowCnt = nRows;
52cdf0e10cSrcweir nColCnt = nCols;
53cdf0e10cSrcweir pData = new double[nColCnt * nRowCnt];
54cdf0e10cSrcweir
55cdf0e10cSrcweir if (pData)
56cdf0e10cSrcweir {
57cdf0e10cSrcweir double *pFill = pData;
58cdf0e10cSrcweir
59cdf0e10cSrcweir for (short i = 0; i < nColCnt; i++)
60cdf0e10cSrcweir for (short j = 0; j < nRowCnt; j++)
61cdf0e10cSrcweir *(pFill ++) = 0.0;
62cdf0e10cSrcweir }
63cdf0e10cSrcweir
64cdf0e10cSrcweir pColText = new String[nColCnt];
65cdf0e10cSrcweir pRowText = new String[nRowCnt];
66cdf0e10cSrcweir }
67cdf0e10cSrcweir
~ScMemChart()68cdf0e10cSrcweir ScMemChart::~ScMemChart()
69cdf0e10cSrcweir {
70cdf0e10cSrcweir delete[] pRowText;
71cdf0e10cSrcweir delete[] pColText;
72cdf0e10cSrcweir delete[] pData;
73cdf0e10cSrcweir }
74cdf0e10cSrcweir
75cdf0e10cSrcweir // -----------------------------------------------------------------------
76cdf0e10cSrcweir
ScChartArray(ScDocument * pDoc,SCTAB nTab,SCCOL nStartColP,SCROW nStartRowP,SCCOL nEndColP,SCROW nEndRowP,const String & rChartName)77cdf0e10cSrcweir ScChartArray::ScChartArray( ScDocument* pDoc, SCTAB nTab,
78cdf0e10cSrcweir SCCOL nStartColP, SCROW nStartRowP, SCCOL nEndColP, SCROW nEndRowP,
79cdf0e10cSrcweir const String& rChartName ) :
80cdf0e10cSrcweir aName( rChartName ),
81cdf0e10cSrcweir pDocument( pDoc ),
82cdf0e10cSrcweir aPositioner(pDoc, nTab, nStartColP, nStartRowP, nEndColP, nEndRowP),
83cdf0e10cSrcweir bValid( sal_True )
84cdf0e10cSrcweir {
85cdf0e10cSrcweir }
86cdf0e10cSrcweir
ScChartArray(ScDocument * pDoc,const ScRangeListRef & rRangeList,const String & rChartName)87cdf0e10cSrcweir ScChartArray::ScChartArray( ScDocument* pDoc, const ScRangeListRef& rRangeList,
88cdf0e10cSrcweir const String& rChartName ) :
89cdf0e10cSrcweir aName( rChartName ),
90cdf0e10cSrcweir pDocument( pDoc ),
91cdf0e10cSrcweir aPositioner(pDoc, rRangeList),
92cdf0e10cSrcweir bValid( sal_True )
93cdf0e10cSrcweir {
94cdf0e10cSrcweir }
95cdf0e10cSrcweir
ScChartArray(const ScChartArray & rArr)96cdf0e10cSrcweir ScChartArray::ScChartArray( const ScChartArray& rArr ) :
97cdf0e10cSrcweir ScDataObject(),
98cdf0e10cSrcweir aName(rArr.aName),
99cdf0e10cSrcweir pDocument(rArr.pDocument),
100cdf0e10cSrcweir aPositioner(rArr.aPositioner),
101cdf0e10cSrcweir bValid(rArr.bValid)
102cdf0e10cSrcweir {
103cdf0e10cSrcweir }
104cdf0e10cSrcweir
~ScChartArray()105cdf0e10cSrcweir ScChartArray::~ScChartArray()
106cdf0e10cSrcweir {
107cdf0e10cSrcweir }
108cdf0e10cSrcweir
Clone() const109cdf0e10cSrcweir ScDataObject* ScChartArray::Clone() const
110cdf0e10cSrcweir {
111cdf0e10cSrcweir return new ScChartArray(*this);
112cdf0e10cSrcweir }
113cdf0e10cSrcweir
operator ==(const ScChartArray & rCmp) const114cdf0e10cSrcweir sal_Bool ScChartArray::operator==(const ScChartArray& rCmp) const
115cdf0e10cSrcweir {
116cdf0e10cSrcweir return aPositioner == rCmp.aPositioner
117cdf0e10cSrcweir && aName == rCmp.aName;
118cdf0e10cSrcweir }
119cdf0e10cSrcweir
120cdf0e10cSrcweir #ifdef _MSC_VER
121cdf0e10cSrcweir #pragma optimize("",off)
122cdf0e10cSrcweir #endif
123cdf0e10cSrcweir
CreateMemChart()124cdf0e10cSrcweir ScMemChart* ScChartArray::CreateMemChart()
125cdf0e10cSrcweir {
126cdf0e10cSrcweir ScRangeListRef aRangeListRef(GetRangeList());
127cdf0e10cSrcweir sal_uLong nCount = aRangeListRef->Count();
128cdf0e10cSrcweir if ( nCount > 1 )
129cdf0e10cSrcweir return CreateMemChartMulti();
130cdf0e10cSrcweir else if ( nCount == 1 )
131cdf0e10cSrcweir {
132cdf0e10cSrcweir ScRange* pR = aRangeListRef->First();
133cdf0e10cSrcweir if ( pR->aStart.Tab() != pR->aEnd.Tab() )
134cdf0e10cSrcweir return CreateMemChartMulti();
135cdf0e10cSrcweir else
136cdf0e10cSrcweir return CreateMemChartSingle();
137cdf0e10cSrcweir }
138cdf0e10cSrcweir else
139cdf0e10cSrcweir return CreateMemChartMulti(); // kann 0 Range besser ab als Single
140cdf0e10cSrcweir }
141cdf0e10cSrcweir
CreateMemChartSingle()142cdf0e10cSrcweir ScMemChart* ScChartArray::CreateMemChartSingle()
143cdf0e10cSrcweir {
144cdf0e10cSrcweir SCSIZE nCol;
145cdf0e10cSrcweir SCSIZE nRow;
146cdf0e10cSrcweir
147cdf0e10cSrcweir //
148cdf0e10cSrcweir // wirkliche Groesse (ohne versteckte Zeilen/Spalten)
149cdf0e10cSrcweir //
150cdf0e10cSrcweir
151cdf0e10cSrcweir SCCOL nColAdd = HasRowHeaders() ? 1 : 0;
152cdf0e10cSrcweir SCROW nRowAdd = HasColHeaders() ? 1 : 0;
153cdf0e10cSrcweir
154cdf0e10cSrcweir SCCOL nCol1;
155cdf0e10cSrcweir SCROW nRow1;
156cdf0e10cSrcweir SCTAB nTab1;
157cdf0e10cSrcweir SCCOL nCol2;
158cdf0e10cSrcweir SCROW nRow2;
159cdf0e10cSrcweir SCTAB nTab2;
160cdf0e10cSrcweir ScRangeListRef aRangeListRef(GetRangeList());
161cdf0e10cSrcweir aRangeListRef->First()->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
162cdf0e10cSrcweir
163cdf0e10cSrcweir SCCOL nStrCol = nCol1; // fuer Beschriftung merken
164cdf0e10cSrcweir SCROW nStrRow = nRow1;
165cdf0e10cSrcweir // Skip hidden columns.
166cdf0e10cSrcweir // TODO: make use of last column value once implemented.
167cdf0e10cSrcweir SCCOL nLastCol = -1;
168cdf0e10cSrcweir while (pDocument->ColHidden(nCol1, nTab1, nLastCol))
169cdf0e10cSrcweir ++nCol1;
170cdf0e10cSrcweir
171cdf0e10cSrcweir // Skip hidden rows.
172cdf0e10cSrcweir SCROW nLastRow = -1;
173cdf0e10cSrcweir if (pDocument->RowHidden(nRow1, nTab1, nLastRow))
174cdf0e10cSrcweir nRow1 = nLastRow + 1;
175cdf0e10cSrcweir
176cdf0e10cSrcweir // falls alles hidden ist, bleibt die Beschriftung am Anfang
177cdf0e10cSrcweir if ( nCol1 <= nCol2 )
178cdf0e10cSrcweir {
179cdf0e10cSrcweir nStrCol = nCol1;
180cdf0e10cSrcweir nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nColAdd );
181cdf0e10cSrcweir }
182cdf0e10cSrcweir if ( nRow1 <= nRow2 )
183cdf0e10cSrcweir {
184cdf0e10cSrcweir nStrRow = nRow1;
185cdf0e10cSrcweir nRow1 = sal::static_int_cast<SCROW>( nRow1 + nRowAdd );
186cdf0e10cSrcweir }
187cdf0e10cSrcweir
188cdf0e10cSrcweir SCSIZE nTotalCols = ( nCol1 <= nCol2 ? nCol2 - nCol1 + 1 : 0 );
189cdf0e10cSrcweir vector<SCCOL> aCols;
190cdf0e10cSrcweir aCols.reserve(nTotalCols);
191cdf0e10cSrcweir for (SCSIZE i=0; i<nTotalCols; i++)
192cdf0e10cSrcweir {
193cdf0e10cSrcweir SCCOL nThisCol = sal::static_int_cast<SCCOL>(nCol1+i);
194cdf0e10cSrcweir if (!pDocument->ColHidden(nThisCol, nTab1, nLastCol))
195cdf0e10cSrcweir aCols.push_back(nThisCol);
196cdf0e10cSrcweir }
197cdf0e10cSrcweir SCSIZE nColCount = aCols.size();
198cdf0e10cSrcweir
199cdf0e10cSrcweir SCSIZE nTotalRows = ( nRow1 <= nRow2 ? nRow2 - nRow1 + 1 : 0 );
200cdf0e10cSrcweir vector<SCROW> aRows;
201cdf0e10cSrcweir aRows.reserve(nTotalRows);
202cdf0e10cSrcweir if (nRow1 <= nRow2)
203cdf0e10cSrcweir {
204cdf0e10cSrcweir // Get all visible rows between nRow1 and nRow2.
205cdf0e10cSrcweir SCROW nThisRow = nRow1;
206cdf0e10cSrcweir while (nThisRow <= nRow2)
207cdf0e10cSrcweir {
208cdf0e10cSrcweir if (pDocument->RowHidden(nThisRow, nTab1, nLastRow))
209cdf0e10cSrcweir nThisRow = nLastRow;
210cdf0e10cSrcweir else
211cdf0e10cSrcweir aRows.push_back(nThisRow);
212cdf0e10cSrcweir ++nThisRow;
213cdf0e10cSrcweir }
214cdf0e10cSrcweir }
215cdf0e10cSrcweir SCSIZE nRowCount = aRows.size();
216cdf0e10cSrcweir
217cdf0e10cSrcweir // May happen at least with more than 32k rows.
218cdf0e10cSrcweir if (nColCount > SHRT_MAX || nRowCount > SHRT_MAX)
219cdf0e10cSrcweir {
220cdf0e10cSrcweir nColCount = 0;
221cdf0e10cSrcweir nRowCount = 0;
222cdf0e10cSrcweir }
223cdf0e10cSrcweir
224cdf0e10cSrcweir sal_Bool bValidData = sal_True;
225cdf0e10cSrcweir if ( !nColCount )
226cdf0e10cSrcweir {
227cdf0e10cSrcweir bValidData = sal_False;
228cdf0e10cSrcweir nColCount = 1;
229cdf0e10cSrcweir aCols.push_back(nStrCol);
230cdf0e10cSrcweir }
231cdf0e10cSrcweir if ( !nRowCount )
232cdf0e10cSrcweir {
233cdf0e10cSrcweir bValidData = sal_False;
234cdf0e10cSrcweir nRowCount = 1;
235cdf0e10cSrcweir aRows.push_back(nStrRow);
236cdf0e10cSrcweir }
237cdf0e10cSrcweir
238cdf0e10cSrcweir //
239cdf0e10cSrcweir // Daten
240cdf0e10cSrcweir //
241cdf0e10cSrcweir
242cdf0e10cSrcweir ScMemChart* pMemChart = new ScMemChart(
243cdf0e10cSrcweir static_cast<short>(nColCount), static_cast<short>(nRowCount) );
244cdf0e10cSrcweir if (pMemChart)
245cdf0e10cSrcweir {
246cdf0e10cSrcweir // SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
247cdf0e10cSrcweir // pMemChart->SetNumberFormatter( pFormatter );
248cdf0e10cSrcweir if ( bValidData )
249cdf0e10cSrcweir {
250cdf0e10cSrcweir sal_Bool bCalcAsShown = pDocument->GetDocOptions().IsCalcAsShown();
251cdf0e10cSrcweir ScBaseCell* pCell;
252cdf0e10cSrcweir for (nCol=0; nCol<nColCount; nCol++)
253cdf0e10cSrcweir {
254cdf0e10cSrcweir for (nRow=0; nRow<nRowCount; nRow++)
255cdf0e10cSrcweir {
256cdf0e10cSrcweir double nVal = DBL_MIN; // Hack fuer Chart, um leere Zellen zu erkennen
257cdf0e10cSrcweir
258cdf0e10cSrcweir pDocument->GetCell( aCols[nCol], aRows[nRow], nTab1, pCell );
259cdf0e10cSrcweir if (pCell)
260cdf0e10cSrcweir {
261cdf0e10cSrcweir CellType eType = pCell->GetCellType();
262cdf0e10cSrcweir if (eType == CELLTYPE_VALUE)
263cdf0e10cSrcweir {
264cdf0e10cSrcweir nVal = ((ScValueCell*)pCell)->GetValue();
265cdf0e10cSrcweir if ( bCalcAsShown && nVal != 0.0 )
266cdf0e10cSrcweir {
267cdf0e10cSrcweir sal_uInt32 nFormat;
268cdf0e10cSrcweir pDocument->GetNumberFormat( aCols[nCol],
269cdf0e10cSrcweir aRows[nRow], nTab1, nFormat );
270cdf0e10cSrcweir nVal = pDocument->RoundValueAsShown( nVal, nFormat );
271cdf0e10cSrcweir }
272cdf0e10cSrcweir }
273cdf0e10cSrcweir else if (eType == CELLTYPE_FORMULA)
274cdf0e10cSrcweir {
275cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
276cdf0e10cSrcweir if ( (pFCell->GetErrCode() == 0) && pFCell->IsValue() )
277cdf0e10cSrcweir nVal = pFCell->GetValue();
278cdf0e10cSrcweir }
279cdf0e10cSrcweir }
280cdf0e10cSrcweir pMemChart->SetData(static_cast<short>(nCol), static_cast<short>(nRow), nVal);
281cdf0e10cSrcweir }
282cdf0e10cSrcweir }
283cdf0e10cSrcweir }
284cdf0e10cSrcweir else
285cdf0e10cSrcweir {
286cdf0e10cSrcweir //! Flag, dass Daten ungueltig ??
287cdf0e10cSrcweir
288cdf0e10cSrcweir for (nCol=0; nCol<nColCount; nCol++)
289cdf0e10cSrcweir for (nRow=0; nRow<nRowCount; nRow++)
290cdf0e10cSrcweir pMemChart->SetData( static_cast<short>(nCol), static_cast<short>(nRow), DBL_MIN );
291cdf0e10cSrcweir }
292cdf0e10cSrcweir
293cdf0e10cSrcweir //
294cdf0e10cSrcweir // Spalten-Header
295cdf0e10cSrcweir //
296cdf0e10cSrcweir
297cdf0e10cSrcweir for (nCol=0; nCol<nColCount; nCol++)
298cdf0e10cSrcweir {
299cdf0e10cSrcweir String aString, aColStr;
300cdf0e10cSrcweir if (HasColHeaders())
301cdf0e10cSrcweir pDocument->GetString( aCols[nCol], nStrRow, nTab1, aString );
302cdf0e10cSrcweir if ( !aString.Len() )
303cdf0e10cSrcweir {
304cdf0e10cSrcweir aString = ScGlobal::GetRscString(STR_COLUMN);
305cdf0e10cSrcweir aString += ' ';
306cdf0e10cSrcweir // aString += String::CreateFromInt32( pCols[nCol]+1 );
307cdf0e10cSrcweir ScAddress aPos( aCols[ nCol ], 0, 0 );
308cdf0e10cSrcweir aPos.Format( aColStr, SCA_VALID_COL, NULL );
309cdf0e10cSrcweir aString += aColStr;
310cdf0e10cSrcweir }
311cdf0e10cSrcweir pMemChart->SetColText( static_cast<short>(nCol), aString);
312cdf0e10cSrcweir
313cdf0e10cSrcweir // sal_uLong nNumberAttr = (nTotalRows ? pDocument->GetNumberFormat(
314cdf0e10cSrcweir // ScAddress( pCols[nCol], nRow1, nTab1)) : 0);
315cdf0e10cSrcweir // pMemChart->SetNumFormatIdCol( static_cast<long>(nCol), nNumberAttr );
316cdf0e10cSrcweir }
317cdf0e10cSrcweir
318cdf0e10cSrcweir //
319cdf0e10cSrcweir // Zeilen-Header
320cdf0e10cSrcweir //
321cdf0e10cSrcweir
322cdf0e10cSrcweir for (nRow=0; nRow<nRowCount; nRow++)
323cdf0e10cSrcweir {
324cdf0e10cSrcweir String aString;
325cdf0e10cSrcweir if (HasRowHeaders())
326cdf0e10cSrcweir {
327cdf0e10cSrcweir ScAddress aAddr( nStrCol, aRows[nRow], nTab1 );
328cdf0e10cSrcweir pDocument->GetString( nStrCol, aRows[nRow], nTab1, aString );
329cdf0e10cSrcweir }
330cdf0e10cSrcweir if ( !aString.Len() )
331cdf0e10cSrcweir {
332cdf0e10cSrcweir aString = ScGlobal::GetRscString(STR_ROW);
333cdf0e10cSrcweir aString += ' ';
334cdf0e10cSrcweir aString += String::CreateFromInt32( aRows[nRow]+1 );
335cdf0e10cSrcweir }
336cdf0e10cSrcweir pMemChart->SetRowText( static_cast<short>(nRow), aString);
337cdf0e10cSrcweir
338cdf0e10cSrcweir // sal_uLong nNumberAttr = (nTotalCols ? pDocument->GetNumberFormat(
339cdf0e10cSrcweir // ScAddress( nCol1, pRows[nRow], nTab1)) : 0);
340cdf0e10cSrcweir // pMemChart->SetNumFormatIdRow( static_cast<long>(nRow), nNumberAttr );
341cdf0e10cSrcweir }
342cdf0e10cSrcweir
343cdf0e10cSrcweir //
344cdf0e10cSrcweir // Titel
345cdf0e10cSrcweir //
346cdf0e10cSrcweir
347cdf0e10cSrcweir // pMemChart->SetMainTitle(ScGlobal::GetRscString(STR_CHART_MAINTITLE));
348cdf0e10cSrcweir // pMemChart->SetSubTitle(ScGlobal::GetRscString(STR_CHART_SUBTITLE));
349cdf0e10cSrcweir // pMemChart->SetXAxisTitle(ScGlobal::GetRscString(STR_CHART_XTITLE));
350cdf0e10cSrcweir // pMemChart->SetYAxisTitle(ScGlobal::GetRscString(STR_CHART_YTITLE));
351cdf0e10cSrcweir // pMemChart->SetZAxisTitle(ScGlobal::GetRscString(STR_CHART_ZTITLE));
352cdf0e10cSrcweir
353cdf0e10cSrcweir //
354cdf0e10cSrcweir // Zahlen-Typ
355cdf0e10cSrcweir //
356cdf0e10cSrcweir
357cdf0e10cSrcweir // sal_uLong nNumberAttr = (nTotalCols && nTotalRows ?
358cdf0e10cSrcweir // pDocument->GetNumberFormat( ScAddress( nCol1, nRow1, nTab1)) :
359cdf0e10cSrcweir // 0);
360cdf0e10cSrcweir // if (pFormatter)
361cdf0e10cSrcweir // pMemChart->SetDataType(pFormatter->GetType( nNumberAttr ));
362cdf0e10cSrcweir
363cdf0e10cSrcweir //
364cdf0e10cSrcweir // Parameter-Strings
365cdf0e10cSrcweir //
366cdf0e10cSrcweir
367cdf0e10cSrcweir // SetExtraStrings( *pMemChart );
368cdf0e10cSrcweir }
369cdf0e10cSrcweir
370cdf0e10cSrcweir return pMemChart;
371cdf0e10cSrcweir }
372cdf0e10cSrcweir
CreateMemChartMulti()373cdf0e10cSrcweir ScMemChart* ScChartArray::CreateMemChartMulti()
374cdf0e10cSrcweir {
375cdf0e10cSrcweir SCSIZE nColCount = GetPositionMap()->GetColCount();
376cdf0e10cSrcweir SCSIZE nRowCount = GetPositionMap()->GetRowCount();
377cdf0e10cSrcweir
378cdf0e10cSrcweir SCSIZE nCol = 0;
379cdf0e10cSrcweir SCSIZE nRow = 0;
380cdf0e10cSrcweir
381cdf0e10cSrcweir // May happen at least with more than 32k rows.
382cdf0e10cSrcweir if (nColCount > SHRT_MAX || nRowCount > SHRT_MAX)
383cdf0e10cSrcweir {
384cdf0e10cSrcweir nColCount = 0;
385cdf0e10cSrcweir nRowCount = 0;
386cdf0e10cSrcweir }
387cdf0e10cSrcweir
388cdf0e10cSrcweir sal_Bool bValidData = sal_True;
389cdf0e10cSrcweir if ( !nColCount )
390cdf0e10cSrcweir {
391cdf0e10cSrcweir bValidData = sal_False;
392cdf0e10cSrcweir nColCount = 1;
393cdf0e10cSrcweir }
394cdf0e10cSrcweir if ( !nRowCount )
395cdf0e10cSrcweir {
396cdf0e10cSrcweir bValidData = sal_False;
397cdf0e10cSrcweir nRowCount = 1;
398cdf0e10cSrcweir }
399cdf0e10cSrcweir
400cdf0e10cSrcweir //
401cdf0e10cSrcweir // Daten
402cdf0e10cSrcweir //
403cdf0e10cSrcweir
404cdf0e10cSrcweir ScMemChart* pMemChart = new ScMemChart(
405cdf0e10cSrcweir static_cast<short>(nColCount), static_cast<short>(nRowCount) );
406cdf0e10cSrcweir if (pMemChart)
407cdf0e10cSrcweir {
408cdf0e10cSrcweir // pMemChart->SetNumberFormatter( pDocument->GetFormatTable() );
409cdf0e10cSrcweir sal_Bool bCalcAsShown = pDocument->GetDocOptions().IsCalcAsShown();
410cdf0e10cSrcweir sal_uLong nIndex = 0;
411cdf0e10cSrcweir if (bValidData)
412cdf0e10cSrcweir {
413cdf0e10cSrcweir for ( nCol = 0; nCol < nColCount; nCol++ )
414cdf0e10cSrcweir {
415cdf0e10cSrcweir for ( nRow = 0; nRow < nRowCount; nRow++, nIndex++ )
416cdf0e10cSrcweir {
417cdf0e10cSrcweir double nVal = DBL_MIN; // Hack fuer Chart, um leere Zellen zu erkennen
418cdf0e10cSrcweir const ScAddress* pPos = GetPositionMap()->GetPosition( nIndex );
419cdf0e10cSrcweir if ( pPos )
420cdf0e10cSrcweir { // sonst: Luecke
421cdf0e10cSrcweir ScBaseCell* pCell = pDocument->GetCell( *pPos );
422cdf0e10cSrcweir if (pCell)
423cdf0e10cSrcweir {
424cdf0e10cSrcweir CellType eType = pCell->GetCellType();
425cdf0e10cSrcweir if (eType == CELLTYPE_VALUE)
426cdf0e10cSrcweir {
427cdf0e10cSrcweir nVal = ((ScValueCell*)pCell)->GetValue();
428cdf0e10cSrcweir if ( bCalcAsShown && nVal != 0.0 )
429cdf0e10cSrcweir {
430cdf0e10cSrcweir sal_uLong nFormat = pDocument->GetNumberFormat( *pPos );
431cdf0e10cSrcweir nVal = pDocument->RoundValueAsShown( nVal, nFormat );
432cdf0e10cSrcweir }
433cdf0e10cSrcweir }
434cdf0e10cSrcweir else if (eType == CELLTYPE_FORMULA)
435cdf0e10cSrcweir {
436cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
437cdf0e10cSrcweir if ( (pFCell->GetErrCode() == 0) && pFCell->IsValue() )
438cdf0e10cSrcweir nVal = pFCell->GetValue();
439cdf0e10cSrcweir }
440cdf0e10cSrcweir }
441cdf0e10cSrcweir }
442cdf0e10cSrcweir pMemChart->SetData(static_cast<short>(nCol), static_cast<short>(nRow), nVal);
443cdf0e10cSrcweir }
444cdf0e10cSrcweir }
445cdf0e10cSrcweir }
446cdf0e10cSrcweir else
447cdf0e10cSrcweir {
448cdf0e10cSrcweir for ( nRow = 0; nRow < nRowCount; nRow++, nIndex++ )
449cdf0e10cSrcweir {
450cdf0e10cSrcweir double nVal = DBL_MIN; // Hack fuer Chart, um leere Zellen zu erkennen
451cdf0e10cSrcweir const ScAddress* pPos = GetPositionMap()->GetPosition( nIndex );
452cdf0e10cSrcweir if ( pPos )
453cdf0e10cSrcweir { // sonst: Luecke
454cdf0e10cSrcweir ScBaseCell* pCell = pDocument->GetCell( *pPos );
455cdf0e10cSrcweir if (pCell)
456cdf0e10cSrcweir {
457cdf0e10cSrcweir CellType eType = pCell->GetCellType();
458cdf0e10cSrcweir if (eType == CELLTYPE_VALUE)
459cdf0e10cSrcweir {
460cdf0e10cSrcweir nVal = ((ScValueCell*)pCell)->GetValue();
461cdf0e10cSrcweir if ( bCalcAsShown && nVal != 0.0 )
462cdf0e10cSrcweir {
463cdf0e10cSrcweir sal_uLong nFormat = pDocument->GetNumberFormat( *pPos );
464cdf0e10cSrcweir nVal = pDocument->RoundValueAsShown( nVal, nFormat );
465cdf0e10cSrcweir }
466cdf0e10cSrcweir }
467cdf0e10cSrcweir else if (eType == CELLTYPE_FORMULA)
468cdf0e10cSrcweir {
469cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
470cdf0e10cSrcweir if ( (pFCell->GetErrCode() == 0) && pFCell->IsValue() )
471cdf0e10cSrcweir nVal = pFCell->GetValue();
472cdf0e10cSrcweir }
473cdf0e10cSrcweir }
474cdf0e10cSrcweir }
475cdf0e10cSrcweir pMemChart->SetData(static_cast<short>(nCol), static_cast<short>(nRow), nVal);
476cdf0e10cSrcweir }
477cdf0e10cSrcweir }
478cdf0e10cSrcweir
479cdf0e10cSrcweir //2do: Beschriftung bei Luecken
480cdf0e10cSrcweir
481cdf0e10cSrcweir //
482cdf0e10cSrcweir // Spalten-Header
483cdf0e10cSrcweir //
484cdf0e10cSrcweir
485cdf0e10cSrcweir SCCOL nPosCol = 0;
486cdf0e10cSrcweir for ( nCol = 0; nCol < nColCount; nCol++ )
487cdf0e10cSrcweir {
488cdf0e10cSrcweir String aString, aColStr;
489cdf0e10cSrcweir const ScAddress* pPos = GetPositionMap()->GetColHeaderPosition( static_cast<SCCOL>(nCol) );
490cdf0e10cSrcweir if ( HasColHeaders() && pPos )
491cdf0e10cSrcweir pDocument->GetString(
492cdf0e10cSrcweir pPos->Col(), pPos->Row(), pPos->Tab(), aString );
493cdf0e10cSrcweir if ( !aString.Len() )
494cdf0e10cSrcweir {
495cdf0e10cSrcweir aString = ScGlobal::GetRscString(STR_COLUMN);
496cdf0e10cSrcweir aString += ' ';
497cdf0e10cSrcweir if ( pPos )
498cdf0e10cSrcweir nPosCol = pPos->Col() + 1;
499cdf0e10cSrcweir else
500cdf0e10cSrcweir nPosCol++;
501cdf0e10cSrcweir ScAddress aPos( nPosCol - 1, 0, 0 );
502cdf0e10cSrcweir aPos.Format( aColStr, SCA_VALID_COL, NULL );
503cdf0e10cSrcweir // aString += String::CreateFromInt32( nPosCol );
504cdf0e10cSrcweir aString += aColStr;
505cdf0e10cSrcweir }
506cdf0e10cSrcweir pMemChart->SetColText( static_cast<short>(nCol), aString);
507cdf0e10cSrcweir
508cdf0e10cSrcweir // sal_uLong nNumberAttr = 0;
509cdf0e10cSrcweir // pPos = GetPositionMap()->GetPosition( nCol, 0 );
510cdf0e10cSrcweir // if ( pPos )
511cdf0e10cSrcweir // nNumberAttr = pDocument->GetNumberFormat( *pPos );
512cdf0e10cSrcweir // pMemChart->SetNumFormatIdCol( static_cast<long>(nCol), nNumberAttr );
513cdf0e10cSrcweir }
514cdf0e10cSrcweir
515cdf0e10cSrcweir //
516cdf0e10cSrcweir // Zeilen-Header
517cdf0e10cSrcweir //
518cdf0e10cSrcweir
519cdf0e10cSrcweir SCROW nPosRow = 0;
520cdf0e10cSrcweir for ( nRow = 0; nRow < nRowCount; nRow++ )
521cdf0e10cSrcweir {
522cdf0e10cSrcweir String aString;
523cdf0e10cSrcweir const ScAddress* pPos = GetPositionMap()->GetRowHeaderPosition( nRow );
524cdf0e10cSrcweir if ( HasRowHeaders() && pPos )
525cdf0e10cSrcweir {
526cdf0e10cSrcweir pDocument->GetString(
527cdf0e10cSrcweir pPos->Col(), pPos->Row(), pPos->Tab(), aString );
528cdf0e10cSrcweir }
529cdf0e10cSrcweir if ( !aString.Len() )
530cdf0e10cSrcweir {
531cdf0e10cSrcweir aString = ScGlobal::GetRscString(STR_ROW);
532cdf0e10cSrcweir aString += ' ';
533cdf0e10cSrcweir if ( pPos )
534cdf0e10cSrcweir nPosRow = pPos->Row() + 1;
535cdf0e10cSrcweir else
536cdf0e10cSrcweir nPosRow++;
537cdf0e10cSrcweir aString += String::CreateFromInt32( nPosRow );
538cdf0e10cSrcweir }
539cdf0e10cSrcweir pMemChart->SetRowText( static_cast<short>(nRow), aString);
540cdf0e10cSrcweir
541cdf0e10cSrcweir // sal_uLong nNumberAttr = 0;
542cdf0e10cSrcweir // pPos = GetPositionMap()->GetPosition( 0, nRow );
543cdf0e10cSrcweir // if ( pPos )
544cdf0e10cSrcweir // nNumberAttr = pDocument->GetNumberFormat( *pPos );
545cdf0e10cSrcweir // pMemChart->SetNumFormatIdRow( static_cast<long>(nRow), nNumberAttr );
546cdf0e10cSrcweir }
547cdf0e10cSrcweir
548cdf0e10cSrcweir //
549cdf0e10cSrcweir // Titel
550cdf0e10cSrcweir //
551cdf0e10cSrcweir
552cdf0e10cSrcweir // pMemChart->SetMainTitle(ScGlobal::GetRscString(STR_CHART_MAINTITLE));
553cdf0e10cSrcweir // pMemChart->SetSubTitle(ScGlobal::GetRscString(STR_CHART_SUBTITLE));
554cdf0e10cSrcweir // pMemChart->SetXAxisTitle(ScGlobal::GetRscString(STR_CHART_XTITLE));
555cdf0e10cSrcweir // pMemChart->SetYAxisTitle(ScGlobal::GetRscString(STR_CHART_YTITLE));
556cdf0e10cSrcweir // pMemChart->SetZAxisTitle(ScGlobal::GetRscString(STR_CHART_ZTITLE));
557cdf0e10cSrcweir
558cdf0e10cSrcweir //
559cdf0e10cSrcweir // Zahlen-Typ
560cdf0e10cSrcweir //
561cdf0e10cSrcweir
562cdf0e10cSrcweir // SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
563cdf0e10cSrcweir // if (pFormatter)
564cdf0e10cSrcweir // {
565cdf0e10cSrcweir // sal_uLong nIndex = 0;
566cdf0e10cSrcweir // sal_uLong nCount = GetPositionMap()->GetCount();
567cdf0e10cSrcweir // const ScAddress* pPos;
568cdf0e10cSrcweir // do
569cdf0e10cSrcweir // {
570cdf0e10cSrcweir // pPos = GetPositionMap()->GetPosition( nIndex );
571cdf0e10cSrcweir // } while ( !pPos && ++nIndex < nCount );
572cdf0e10cSrcweir // sal_uLong nFormat = ( pPos ? pDocument->GetNumberFormat( *pPos ) : 0 );
573cdf0e10cSrcweir // pMemChart->SetDataType( pFormatter->GetType( nFormat ) );
574cdf0e10cSrcweir // }
575cdf0e10cSrcweir
576cdf0e10cSrcweir //
577cdf0e10cSrcweir // Parameter-Strings
578cdf0e10cSrcweir //
579cdf0e10cSrcweir
580cdf0e10cSrcweir // SetExtraStrings( *pMemChart );
581cdf0e10cSrcweir }
582cdf0e10cSrcweir
583cdf0e10cSrcweir return pMemChart;
584cdf0e10cSrcweir }
585cdf0e10cSrcweir
586cdf0e10cSrcweir #ifdef _MSC_VER
587cdf0e10cSrcweir #pragma optimize("",on)
588cdf0e10cSrcweir #endif
589cdf0e10cSrcweir
590cdf0e10cSrcweir
591cdf0e10cSrcweir //
592cdf0e10cSrcweir // Collection
593cdf0e10cSrcweir //
594cdf0e10cSrcweir
Clone() const595cdf0e10cSrcweir ScDataObject* ScChartCollection::Clone() const
596cdf0e10cSrcweir {
597cdf0e10cSrcweir return new ScChartCollection(*this);
598cdf0e10cSrcweir }
599cdf0e10cSrcweir
operator ==(const ScChartCollection & rCmp) const600cdf0e10cSrcweir sal_Bool ScChartCollection::operator==(const ScChartCollection& rCmp) const
601cdf0e10cSrcweir {
602cdf0e10cSrcweir if (nCount != rCmp.nCount)
603cdf0e10cSrcweir return sal_False;
604cdf0e10cSrcweir
605cdf0e10cSrcweir for (sal_uInt16 i=0; i<nCount; i++)
606cdf0e10cSrcweir if (!((*(const ScChartArray*)pItems[i]) == (*(const ScChartArray*)rCmp.pItems[i])))
607cdf0e10cSrcweir return sal_False;
608cdf0e10cSrcweir
609cdf0e10cSrcweir return sal_True;
610cdf0e10cSrcweir }
611cdf0e10cSrcweir
612