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 :
21 : #include "chart2uno.hxx"
22 : #include "miscuno.hxx"
23 : #include "document.hxx"
24 : #include "formulacell.hxx"
25 : #include "chartpos.hxx"
26 : #include "unonames.hxx"
27 : #include "globstr.hrc"
28 : #include "convuno.hxx"
29 : #include "rangeutl.hxx"
30 : #include "hints.hxx"
31 : #include "unoreflist.hxx"
32 : #include "compiler.hxx"
33 : #include "reftokenhelper.hxx"
34 : #include "chartlis.hxx"
35 : #include "stlalgorithm.hxx"
36 : #include "tokenuno.hxx"
37 : #include "docsh.hxx"
38 : #include "cellvalue.hxx"
39 : #include "tokenarray.hxx"
40 : #include "scmatrix.hxx"
41 :
42 : #include "formula/opcode.hxx"
43 : #include "svl/sharedstring.hxx"
44 :
45 : #include <sfx2/objsh.hxx>
46 : #include <vcl/svapp.hxx>
47 :
48 : #include <com/sun/star/beans/UnknownPropertyException.hpp>
49 : #include <com/sun/star/chart2/data/LabeledDataSequence.hpp>
50 : #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
51 : #include <com/sun/star/table/XCellRange.hpp>
52 : #include <com/sun/star/table/CellAddress.hpp>
53 : #include <com/sun/star/text/XText.hpp>
54 : #include <comphelper/extract.hxx>
55 : #include <comphelper/processfactory.hxx>
56 :
57 : #include <rtl/math.hxx>
58 :
59 0 : SC_SIMPLE_SERVICE_INFO( ScChart2DataProvider, "ScChart2DataProvider",
60 : "com.sun.star.chart2.data.DataProvider")
61 0 : SC_SIMPLE_SERVICE_INFO( ScChart2DataSource, "ScChart2DataSource",
62 : "com.sun.star.chart2.data.DataSource")
63 0 : SC_SIMPLE_SERVICE_INFO( ScChart2DataSequence, "ScChart2DataSequence",
64 : "com.sun.star.chart2.data.DataSequence")
65 :
66 : using namespace ::com::sun::star;
67 : using namespace ::formula;
68 : using ::com::sun::star::uno::Sequence;
69 : using ::com::sun::star::uno::Reference;
70 : using ::std::auto_ptr;
71 : using ::std::vector;
72 : using ::std::list;
73 : using ::std::distance;
74 : using ::std::unary_function;
75 : using ::boost::shared_ptr;
76 :
77 : namespace
78 : {
79 0 : const SfxItemPropertyMapEntry* lcl_GetDataProviderPropertyMap()
80 : {
81 : static const SfxItemPropertyMapEntry aDataProviderPropertyMap_Impl[] =
82 : {
83 0 : { OUString(SC_UNONAME_INCLUDEHIDDENCELLS), 0, getBooleanCppuType(), 0, 0 },
84 0 : { OUString(SC_UNONAME_USE_INTERNAL_DATA_PROVIDER), 0, getBooleanCppuType(), 0, 0 },
85 : { OUString(), 0, css::uno::Type(), 0, 0 }
86 0 : };
87 0 : return aDataProviderPropertyMap_Impl;
88 : }
89 :
90 0 : const SfxItemPropertyMapEntry* lcl_GetDataSequencePropertyMap()
91 : {
92 : static const SfxItemPropertyMapEntry aDataSequencePropertyMap_Impl[] =
93 : {
94 0 : {OUString(SC_UNONAME_HIDDENVALUES), 0, getCppuType((uno::Sequence<sal_Int32>*)0 ), 0, 0 },
95 0 : {OUString(SC_UNONAME_ROLE), 0, getCppuType((::com::sun::star::chart2::data::DataSequenceRole*)0), 0, 0 },
96 0 : {OUString(SC_UNONAME_INCLUDEHIDDENCELLS), 0, getBooleanCppuType(), 0, 0 },
97 : { OUString(), 0, css::uno::Type(), 0, 0 }
98 0 : };
99 0 : return aDataSequencePropertyMap_Impl;
100 : }
101 :
102 : template< typename T >
103 0 : ::com::sun::star::uno::Sequence< T > lcl_VectorToSequence(
104 : const ::std::vector< T > & rCont )
105 : {
106 0 : ::com::sun::star::uno::Sequence< T > aResult( rCont.size());
107 0 : ::std::copy( rCont.begin(), rCont.end(), aResult.getArray());
108 0 : return aResult;
109 : }
110 :
111 : struct lcl_appendTableNumber : public ::std::unary_function< SCTAB, void >
112 : {
113 0 : lcl_appendTableNumber( OUStringBuffer & rBuffer ) :
114 0 : m_rBuffer( rBuffer )
115 0 : {}
116 0 : void operator() ( SCTAB nTab )
117 : {
118 : // there is no append with SCTAB or sal_Int16
119 0 : m_rBuffer.append( static_cast< sal_Int32 >( nTab ));
120 0 : m_rBuffer.append( ' ' );
121 0 : }
122 : private:
123 : OUStringBuffer & m_rBuffer;
124 : };
125 :
126 0 : OUString lcl_createTableNumberList( const ::std::list< SCTAB > & rTableList )
127 : {
128 0 : OUStringBuffer aBuffer;
129 0 : ::std::for_each( rTableList.begin(), rTableList.end(), lcl_appendTableNumber( aBuffer ));
130 : // remove last trailing ' '
131 0 : if( !aBuffer.isEmpty() )
132 0 : aBuffer.setLength( aBuffer.getLength() - 1 );
133 0 : return aBuffer.makeStringAndClear();
134 : }
135 :
136 0 : uno::Reference< frame::XModel > lcl_GetXModel( ScDocument * pDoc )
137 : {
138 0 : uno::Reference< frame::XModel > xModel;
139 0 : SfxObjectShell * pObjSh( pDoc ? pDoc->GetDocumentShell() : 0 );
140 0 : if( pObjSh )
141 0 : xModel.set( pObjSh->GetModel());
142 0 : return xModel;
143 : }
144 :
145 0 : struct TokenTable : boost::noncopyable
146 : {
147 : SCROW mnRowCount;
148 : SCCOL mnColCount;
149 : vector<FormulaToken*> maTokens;
150 :
151 0 : void init( SCCOL nColCount, SCROW nRowCount )
152 : {
153 0 : mnColCount = nColCount;
154 0 : mnRowCount = nRowCount;
155 0 : maTokens.reserve(mnColCount*mnRowCount);
156 0 : }
157 0 : void clear()
158 : {
159 0 : ::std::for_each(maTokens.begin(), maTokens.end(), ScDeleteObjectByPtr<FormulaToken>());
160 0 : }
161 :
162 0 : void push_back( FormulaToken* pToken )
163 : {
164 0 : maTokens.push_back( pToken );
165 : OSL_ENSURE( maTokens.size()<= static_cast<sal_uInt32>( mnColCount*mnRowCount ), "too much tokens" );
166 0 : }
167 :
168 0 : sal_uInt32 getIndex(SCCOL nCol, SCROW nRow) const
169 : {
170 : OSL_ENSURE( nCol<mnColCount, "wrong column index" );
171 : OSL_ENSURE( nRow<mnRowCount, "wrong row index" );
172 0 : sal_uInt32 nRet = static_cast<sal_uInt32>(nCol*mnRowCount + nRow);
173 : OSL_ENSURE( maTokens.size()>= static_cast<sal_uInt32>( mnColCount*mnRowCount ), "too few tokens" );
174 0 : return nRet;
175 : }
176 :
177 : vector<ScTokenRef>* getColRanges(SCCOL nCol) const;
178 : vector<ScTokenRef>* getRowRanges(SCROW nRow) const;
179 : vector<ScTokenRef>* getAllRanges() const;
180 : };
181 :
182 0 : vector<ScTokenRef>* TokenTable::getColRanges(SCCOL nCol) const
183 : {
184 0 : if (nCol >= mnColCount)
185 0 : return NULL;
186 0 : if( mnRowCount<=0 )
187 0 : return NULL;
188 :
189 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
190 0 : auto_ptr< vector<ScTokenRef> > pTokens(new vector<ScTokenRef>);
191 : SAL_WNODEPRECATED_DECLARATIONS_POP
192 0 : sal_uInt32 nLast = getIndex(nCol, mnRowCount-1);
193 0 : for (sal_uInt32 i = getIndex(nCol, 0); i <= nLast; ++i)
194 : {
195 0 : FormulaToken* p = maTokens[i];
196 0 : if (!p)
197 0 : continue;
198 :
199 0 : ScTokenRef pCopy(static_cast<ScToken*>(p->Clone()));
200 0 : ScRefTokenHelper::join(*pTokens, pCopy, ScAddress());
201 0 : }
202 0 : return pTokens.release();
203 : }
204 :
205 0 : vector<ScTokenRef>* TokenTable::getRowRanges(SCROW nRow) const
206 : {
207 0 : if (nRow >= mnRowCount)
208 0 : return NULL;
209 0 : if( mnColCount<=0 )
210 0 : return NULL;
211 :
212 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
213 0 : auto_ptr< vector<ScTokenRef> > pTokens(new vector<ScTokenRef>);
214 : SAL_WNODEPRECATED_DECLARATIONS_POP
215 0 : sal_uInt32 nLast = getIndex(mnColCount-1, nRow);
216 0 : for (sal_uInt32 i = getIndex(0, nRow); i <= nLast; i += mnRowCount)
217 : {
218 0 : FormulaToken* p = maTokens[i];
219 0 : if (!p)
220 0 : continue;
221 :
222 0 : ScTokenRef p2(static_cast<ScToken*>(p->Clone()));
223 0 : ScRefTokenHelper::join(*pTokens, p2, ScAddress());
224 0 : }
225 0 : return pTokens.release();
226 : }
227 :
228 0 : vector<ScTokenRef>* TokenTable::getAllRanges() const
229 : {
230 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
231 0 : auto_ptr< vector<ScTokenRef> > pTokens(new vector<ScTokenRef>);
232 : SAL_WNODEPRECATED_DECLARATIONS_POP
233 0 : sal_uInt32 nStop = mnColCount*mnRowCount;
234 0 : for (sal_uInt32 i = 0; i < nStop; i++)
235 : {
236 0 : FormulaToken* p = maTokens[i];
237 0 : if (!p)
238 0 : continue;
239 :
240 0 : ScTokenRef p2(static_cast<ScToken*>(p->Clone()));
241 0 : ScRefTokenHelper::join(*pTokens, p2, ScAddress());
242 0 : }
243 0 : return pTokens.release();
244 : }
245 :
246 : typedef std::map<sal_uInt32, FormulaToken*> FormulaTokenMap;
247 : typedef std::map<sal_uInt32, FormulaTokenMap*> FormulaTokenMapMap;
248 :
249 : class Chart2PositionMap
250 : {
251 : public:
252 : Chart2PositionMap(SCCOL nColCount, SCROW nRowCount,
253 : bool bFillRowHeader, bool bFillColumnHeader, FormulaTokenMapMap& rCols,
254 : ScDocument* pDoc );
255 : ~Chart2PositionMap();
256 :
257 0 : SCCOL getDataColCount() const { return mnDataColCount; }
258 0 : SCROW getDataRowCount() const { return mnDataRowCount; }
259 :
260 : vector<ScTokenRef>* getLeftUpperCornerRanges() const;
261 : vector<ScTokenRef>* getAllColHeaderRanges() const;
262 : vector<ScTokenRef>* getAllRowHeaderRanges() const;
263 :
264 : vector<ScTokenRef>* getColHeaderRanges(SCCOL nChartCol) const;
265 : vector<ScTokenRef>* getRowHeaderRanges(SCROW nChartRow) const;
266 :
267 : vector<ScTokenRef>* getDataColRanges(SCCOL nCol) const;
268 : vector<ScTokenRef>* getDataRowRanges(SCROW nRow) const;
269 :
270 : private:
271 : SCCOL mnDataColCount;
272 : SCROW mnDataRowCount;
273 :
274 : TokenTable maLeftUpperCorner; //nHeaderColCount*nHeaderRowCount
275 : TokenTable maColHeaders; //mnDataColCount*nHeaderRowCount
276 : TokenTable maRowHeaders; //nHeaderColCount*mnDataRowCount
277 : TokenTable maData;//mnDataColCount*mnDataRowCount
278 : };
279 :
280 0 : Chart2PositionMap::Chart2PositionMap(SCCOL nAllColCount, SCROW nAllRowCount,
281 0 : bool bFillRowHeader, bool bFillColumnHeader, FormulaTokenMapMap& rCols, ScDocument* pDoc)
282 : {
283 : // if bFillRowHeader is true, at least the first column serves as a row header.
284 : // If more than one column is pure text all the first pure text columns are used as header.
285 : // Likewise, if bFillColumnHeader is true, at least the first row serves as a column header.
286 : // If more than one row is pure text all the first pure text rows are used as header.
287 :
288 0 : SCROW nHeaderRowCount = (bFillColumnHeader && nAllColCount && nAllRowCount) ? 1 : 0;
289 0 : SCCOL nHeaderColCount = (bFillRowHeader && nAllColCount && nAllRowCount) ? 1 : 0;
290 :
291 0 : if( nHeaderColCount || nHeaderRowCount )
292 : {
293 0 : const SCCOL nInitialHeaderColCount = nHeaderColCount;
294 : //check whether there is more than one text column or row that should be added to the headers
295 0 : SCROW nSmallestValueRowIndex = nAllRowCount;
296 0 : bool bFoundValues = false;
297 0 : bool bFoundAnything = false;
298 0 : FormulaTokenMapMap::const_iterator it1 = rCols.begin();
299 0 : for (SCCOL nCol = 0; nCol < nAllColCount; ++nCol)
300 : {
301 0 : if (it1 != rCols.end() && nCol>=nHeaderColCount)
302 : {
303 0 : bool bFoundValuesInRow = false;
304 0 : FormulaTokenMap* pCol = it1->second;
305 0 : FormulaTokenMap::const_iterator it2 = pCol->begin();
306 0 : for (SCROW nRow = 0; !bFoundValuesInRow && nRow < nSmallestValueRowIndex && it2 != pCol->end(); ++nRow)
307 : {
308 0 : FormulaToken* pToken = it2->second;
309 0 : if (pToken && nRow>=nHeaderRowCount)
310 : {
311 0 : ScRange aRange;
312 0 : bool bExternal = false;
313 0 : StackVar eType = pToken->GetType();
314 0 : if( eType==svExternal || eType==svExternalSingleRef || eType==svExternalDoubleRef || eType==svExternalName )
315 0 : bExternal = true;//lllll todo correct?
316 0 : ScTokenRef pSharedToken(static_cast<ScToken*>(pToken->Clone()));
317 0 : ScRefTokenHelper::getRangeFromToken(aRange, pSharedToken, ScAddress(), bExternal);
318 0 : SCCOL nCol1=0, nCol2=0;
319 0 : SCROW nRow1=0, nRow2=0;
320 0 : SCTAB nTab1=0, nTab2=0;
321 0 : aRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
322 0 : if (pDoc && pDoc->HasValueData( nCol1, nRow1, nTab1 ))
323 : {
324 0 : bFoundValuesInRow = bFoundValues = bFoundAnything = true;
325 0 : nSmallestValueRowIndex = std::min( nSmallestValueRowIndex, nRow );
326 : }
327 0 : if( !bFoundAnything )
328 : {
329 0 : if (pDoc && pDoc->HasData( nCol1, nRow1, nTab1 ) )
330 0 : bFoundAnything = true;
331 0 : }
332 : }
333 0 : ++it2;
334 : }
335 0 : if(!bFoundValues && nHeaderColCount>0)
336 0 : nHeaderColCount++;
337 : }
338 0 : ++it1;
339 : }
340 0 : if( bFoundAnything )
341 : {
342 0 : if(nHeaderRowCount>0)
343 : {
344 0 : if( bFoundValues )
345 0 : nHeaderRowCount = nSmallestValueRowIndex;
346 0 : else if( nAllRowCount>1 )
347 0 : nHeaderRowCount = nAllRowCount-1;
348 : }
349 : }
350 : else //if the cells are completely empty, just use single header rows and columns
351 0 : nHeaderColCount = nInitialHeaderColCount;
352 : }
353 :
354 0 : mnDataColCount = nAllColCount - nHeaderColCount;
355 0 : mnDataRowCount = nAllRowCount - nHeaderRowCount;
356 :
357 0 : maLeftUpperCorner.init(nHeaderColCount,nHeaderRowCount);
358 0 : maColHeaders.init(mnDataColCount,nHeaderRowCount);
359 0 : maRowHeaders.init(nHeaderColCount,mnDataRowCount);
360 0 : maData.init(mnDataColCount,mnDataRowCount);
361 :
362 0 : FormulaTokenMapMap::const_iterator it1 = rCols.begin();
363 0 : for (SCCOL nCol = 0; nCol < nAllColCount; ++nCol)
364 : {
365 0 : if (it1 != rCols.end())
366 : {
367 0 : FormulaTokenMap* pCol = it1->second;
368 0 : FormulaTokenMap::const_iterator it2 = pCol->begin();
369 0 : for (SCROW nRow = 0; nRow < nAllRowCount; ++nRow)
370 : {
371 0 : FormulaToken* pToken = NULL;
372 0 : if (it2 != pCol->end())
373 : {
374 0 : pToken = it2->second;
375 0 : ++it2;
376 : }
377 :
378 0 : if( nCol < nHeaderColCount )
379 : {
380 0 : if( nRow < nHeaderRowCount )
381 0 : maLeftUpperCorner.push_back(pToken);
382 : else
383 0 : maRowHeaders.push_back(pToken);
384 : }
385 0 : else if( nRow < nHeaderRowCount )
386 0 : maColHeaders.push_back(pToken);
387 : else
388 0 : maData.push_back(pToken);
389 : }
390 0 : ++it1;
391 : }
392 : }
393 0 : }
394 :
395 0 : Chart2PositionMap::~Chart2PositionMap()
396 : {
397 0 : maLeftUpperCorner.clear();
398 0 : maColHeaders.clear();
399 0 : maRowHeaders.clear();
400 0 : maData.clear();
401 0 : }
402 :
403 0 : vector<ScTokenRef>* Chart2PositionMap::getLeftUpperCornerRanges() const
404 : {
405 0 : return maLeftUpperCorner.getAllRanges();
406 : }
407 0 : vector<ScTokenRef>* Chart2PositionMap::getAllColHeaderRanges() const
408 : {
409 0 : return maColHeaders.getAllRanges();
410 : }
411 0 : vector<ScTokenRef>* Chart2PositionMap::getAllRowHeaderRanges() const
412 : {
413 0 : return maRowHeaders.getAllRanges();
414 : }
415 0 : vector<ScTokenRef>* Chart2PositionMap::getColHeaderRanges(SCCOL nCol) const
416 : {
417 0 : return maColHeaders.getColRanges( nCol);
418 : }
419 0 : vector<ScTokenRef>* Chart2PositionMap::getRowHeaderRanges(SCROW nRow) const
420 : {
421 0 : return maRowHeaders.getRowRanges( nRow);
422 : }
423 :
424 0 : vector<ScTokenRef>* Chart2PositionMap::getDataColRanges(SCCOL nCol) const
425 : {
426 0 : return maData.getColRanges( nCol);
427 : }
428 :
429 0 : vector<ScTokenRef>* Chart2PositionMap::getDataRowRanges(SCROW nRow) const
430 : {
431 0 : return maData.getRowRanges( nRow);
432 : }
433 :
434 : /**
435 : * Designed to be a drop-in replacement for ScChartPositioner, in order to
436 : * handle external references.
437 : */
438 : class Chart2Positioner : boost::noncopyable
439 : {
440 : enum GlueType
441 : {
442 : GLUETYPE_NA,
443 : GLUETYPE_NONE,
444 : GLUETYPE_COLS,
445 : GLUETYPE_ROWS,
446 : GLUETYPE_BOTH
447 : };
448 :
449 : public:
450 0 : Chart2Positioner(ScDocument* pDoc, const vector<ScTokenRef>& rRefTokens) :
451 : mrRefTokens(rRefTokens),
452 : mpPositionMap(NULL),
453 : meGlue(GLUETYPE_NA),
454 : mnStartCol(0),
455 : mnStartRow(0),
456 : mpDoc(pDoc),
457 : mbColHeaders(false),
458 : mbRowHeaders(false),
459 0 : mbDummyUpperLeft(false)
460 : {
461 0 : }
462 :
463 0 : ~Chart2Positioner()
464 0 : {
465 0 : }
466 :
467 0 : void setHeaders(bool bColHeaders, bool bRowHeaders)
468 : {
469 0 : mbColHeaders = bColHeaders;
470 0 : mbRowHeaders = bRowHeaders;
471 0 : }
472 :
473 0 : Chart2PositionMap* getPositionMap()
474 : {
475 0 : createPositionMap();
476 0 : return mpPositionMap.get();
477 : }
478 :
479 : private:
480 : void invalidateGlue();
481 : void glueState();
482 : void calcGlueState(SCCOL nCols, SCROW nRows);
483 : void createPositionMap();
484 :
485 : private:
486 : const vector<ScTokenRef>& mrRefTokens;
487 : boost::scoped_ptr<Chart2PositionMap> mpPositionMap;
488 : GlueType meGlue;
489 : SCCOL mnStartCol;
490 : SCROW mnStartRow;
491 : ScDocument* mpDoc;
492 : bool mbColHeaders:1;
493 : bool mbRowHeaders:1;
494 : bool mbDummyUpperLeft:1;
495 : };
496 :
497 0 : void Chart2Positioner::invalidateGlue()
498 : {
499 0 : meGlue = GLUETYPE_NA;
500 0 : mpPositionMap.reset();
501 0 : }
502 :
503 0 : void Chart2Positioner::glueState()
504 : {
505 0 : if (meGlue != GLUETYPE_NA)
506 0 : return;
507 :
508 0 : mbDummyUpperLeft = false;
509 0 : if (mrRefTokens.size() <= 1)
510 : {
511 : // Source data consists of only one data range.
512 0 : const ScTokenRef& p = mrRefTokens.front();
513 : ScComplexRefData aData;
514 0 : if (ScRefTokenHelper::getDoubleRefDataFromToken(aData, p))
515 : {
516 0 : if (aData.Ref1.Tab() == aData.Ref2.Tab())
517 0 : meGlue = GLUETYPE_NONE;
518 : else
519 0 : meGlue = GLUETYPE_COLS;
520 0 : mnStartCol = aData.Ref1.Col();
521 0 : mnStartRow = aData.Ref1.Row();
522 : }
523 : else
524 : {
525 0 : invalidateGlue();
526 0 : mnStartCol = 0;
527 0 : mnStartRow = 0;
528 : }
529 0 : return;
530 : }
531 :
532 : ScComplexRefData aData;
533 0 : ScRefTokenHelper::getDoubleRefDataFromToken(aData, mrRefTokens.front());
534 0 : mnStartCol = aData.Ref1.Col();
535 0 : mnStartRow = aData.Ref1.Row();
536 :
537 0 : SCCOL nEndCol = 0;
538 0 : SCROW nEndRow = 0;
539 0 : for (vector<ScTokenRef>::const_iterator itr = mrRefTokens.begin(), itrEnd = mrRefTokens.end()
540 : ; itr != itrEnd; ++itr)
541 : {
542 0 : ScRefTokenHelper::getDoubleRefDataFromToken(aData, *itr);
543 0 : SCCOLROW n1 = aData.Ref1.Col();
544 0 : SCCOLROW n2 = aData.Ref2.Col();
545 0 : if (n1 > MAXCOL)
546 0 : n1 = MAXCOL;
547 0 : if (n2 > MAXCOL)
548 0 : n2 = MAXCOL;
549 0 : if (n1 < mnStartCol)
550 0 : mnStartCol = static_cast<SCCOL>(n1);
551 0 : if (n2 > nEndCol)
552 0 : nEndCol = static_cast<SCCOL>(n2);
553 :
554 0 : n1 = aData.Ref1.Row();
555 0 : n2 = aData.Ref2.Row();
556 0 : if (n1 > MAXROW)
557 0 : n1 = MAXROW;
558 0 : if (n2 > MAXROW)
559 0 : n2 = MAXROW;
560 :
561 0 : if (n1 < mnStartRow)
562 0 : mnStartRow = static_cast<SCROW>(n1);
563 0 : if (n2 > nEndRow)
564 0 : nEndRow = static_cast<SCROW>(n2);
565 : }
566 :
567 0 : if (mnStartCol == nEndCol)
568 : {
569 : // All source data is in a single column.
570 0 : meGlue = GLUETYPE_ROWS;
571 0 : return;
572 : }
573 :
574 0 : if (mnStartRow == nEndRow)
575 : {
576 : // All source data is in a single row.
577 0 : meGlue = GLUETYPE_COLS;
578 0 : return;
579 : }
580 :
581 : // total column size
582 0 : SCCOL nC = nEndCol - mnStartCol + 1;
583 :
584 : // total row size
585 0 : SCROW nR = nEndRow - mnStartRow + 1;
586 :
587 : // #i103540# prevent invalid vector size
588 0 : if ((nC <= 0) || (nR <= 0))
589 : {
590 0 : invalidateGlue();
591 0 : mnStartCol = 0;
592 0 : mnStartRow = 0;
593 0 : return;
594 : }
595 :
596 0 : calcGlueState(nC, nR);
597 : }
598 :
599 : enum State { Hole = 0, Occupied = 1, Free = 2, Glue = 3 };
600 :
601 0 : void Chart2Positioner::calcGlueState(SCCOL nColSize, SCROW nRowSize)
602 : {
603 : // TODO: This code can use some space optimization. Using an array to
604 : // store individual cell's states is terribly inefficient esp for large
605 : // data ranges; let's use flat_segment_tree to reduce memory usage here.
606 :
607 0 : sal_uInt32 nCR = static_cast<sal_uInt32>(nColSize*nRowSize);
608 :
609 0 : vector<State> aCellStates(nCR, Hole);
610 :
611 : // Mark all referenced cells "occupied".
612 0 : for (vector<ScTokenRef>::const_iterator itr = mrRefTokens.begin(), itrEnd = mrRefTokens.end();
613 : itr != itrEnd; ++itr)
614 : {
615 : ScComplexRefData aData;
616 0 : ScRefTokenHelper::getDoubleRefDataFromToken(aData, *itr);
617 0 : SCCOL nCol1 = aData.Ref1.Col() - mnStartCol;
618 0 : SCCOL nCol2 = aData.Ref2.Col() - mnStartCol;
619 0 : SCROW nRow1 = aData.Ref1.Row() - mnStartRow;
620 0 : SCROW nRow2 = aData.Ref2.Row() - mnStartRow;
621 0 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
622 0 : for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
623 : {
624 0 : size_t i = nCol*nRowSize + nRow;
625 0 : aCellStates[i] = Occupied;
626 : }
627 : }
628 :
629 : // If at least one cell in either the first column or first row is empty,
630 : // we don't glue at all unless the whole column or row is empty; we expect
631 : // all cells in the first column / row to be fully populated. If we have
632 : // empty column or row, then we do glue by the column or row,
633 : // respectively.
634 :
635 0 : bool bGlue = true;
636 0 : bool bGlueCols = false;
637 0 : for (SCCOL nCol = 0; bGlue && nCol < nColSize; ++nCol)
638 : {
639 0 : for (SCROW nRow = 0; bGlue && nRow < nRowSize; ++nRow)
640 : {
641 0 : size_t i = nCol*nRowSize + nRow;
642 0 : if (aCellStates[i] == Occupied)
643 : {
644 0 : if (nCol == 0 || nRow == 0)
645 : break;
646 :
647 0 : bGlue = false;
648 : }
649 : else
650 0 : aCellStates[i] = Free;
651 : }
652 0 : size_t nLast = (nCol+1)*nRowSize - 1; // index for the last cell in the column.
653 0 : if (bGlue && aCellStates[nLast] == Free)
654 : {
655 : // Whole column is empty.
656 0 : aCellStates[nLast] = Glue;
657 0 : bGlueCols = true;
658 : }
659 : }
660 :
661 0 : bool bGlueRows = false;
662 0 : for (SCROW nRow = 0; bGlue && nRow < nRowSize; ++nRow)
663 : {
664 0 : size_t i = nRow;
665 0 : for (SCCOL nCol = 0; bGlue && nCol < nColSize; ++nCol, i += nRowSize)
666 : {
667 0 : if (aCellStates[i] == Occupied)
668 : {
669 0 : if (nCol == 0 || nRow == 0)
670 : break;
671 :
672 0 : bGlue = false;
673 : }
674 : else
675 0 : aCellStates[i] = Free;
676 : }
677 0 : i = (nColSize-1)*nRowSize + nRow; // index for the row position in the last column.
678 0 : if (bGlue && aCellStates[i] == Free)
679 : {
680 : // Whole row is empty.
681 0 : aCellStates[i] = Glue;
682 0 : bGlueRows = true;
683 : }
684 : }
685 :
686 0 : size_t i = 1;
687 0 : for (sal_uInt32 n = 1; bGlue && n < nCR; ++n, ++i)
688 0 : if (aCellStates[i] == Hole)
689 0 : bGlue = false;
690 :
691 0 : if (bGlue)
692 : {
693 0 : if (bGlueCols && bGlueRows)
694 0 : meGlue = GLUETYPE_BOTH;
695 0 : else if (bGlueRows)
696 0 : meGlue = GLUETYPE_ROWS;
697 : else
698 0 : meGlue = GLUETYPE_COLS;
699 0 : if (aCellStates.front() != Occupied)
700 0 : mbDummyUpperLeft = true;
701 : }
702 : else
703 0 : meGlue = GLUETYPE_NONE;
704 0 : }
705 :
706 0 : void Chart2Positioner::createPositionMap()
707 : {
708 0 : if (meGlue == GLUETYPE_NA && mpPositionMap.get())
709 0 : mpPositionMap.reset();
710 :
711 0 : if (mpPositionMap.get())
712 0 : return;
713 :
714 0 : glueState();
715 :
716 0 : bool bNoGlue = (meGlue == GLUETYPE_NONE);
717 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
718 0 : auto_ptr<FormulaTokenMapMap> pCols(new FormulaTokenMapMap);
719 : SAL_WNODEPRECATED_DECLARATIONS_POP
720 0 : FormulaTokenMap* pCol = NULL;
721 0 : SCROW nNoGlueRow = 0;
722 0 : for (vector<ScTokenRef>::const_iterator itr = mrRefTokens.begin(), itrEnd = mrRefTokens.end();
723 : itr != itrEnd; ++itr)
724 : {
725 0 : const ScTokenRef& pToken = *itr;
726 :
727 0 : bool bExternal = ScRefTokenHelper::isExternalRef(pToken);
728 0 : sal_uInt16 nFileId = bExternal ? pToken->GetIndex() : 0;
729 0 : svl::SharedString aTabName = svl::SharedString::getEmptyString();
730 0 : if (bExternal)
731 0 : aTabName = pToken->GetString();
732 :
733 : ScComplexRefData aData;
734 0 : if( !ScRefTokenHelper::getDoubleRefDataFromToken(aData, *itr) )
735 0 : break;
736 0 : const ScSingleRefData& s = aData.Ref1;
737 0 : const ScSingleRefData& e = aData.Ref2;
738 0 : SCCOL nCol1 = s.Col(), nCol2 = e.Col();
739 0 : SCROW nRow1 = s.Row(), nRow2 = e.Row();
740 0 : SCTAB nTab1 = s.Tab(), nTab2 = e.Tab();
741 :
742 0 : for (SCTAB nTab = nTab1; nTab <= nTab2; ++nTab)
743 : {
744 : // columns on secondary sheets are appended; we treat them as if
745 : // all columns are on the same sheet. TODO: We can't assume that
746 : // the column range is 16-bit; remove that restriction.
747 0 : sal_uInt32 nInsCol = (static_cast<sal_uInt32>(nTab) << 16) |
748 0 : (bNoGlue ? 0 : static_cast<sal_uInt32>(nCol1));
749 :
750 0 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol, ++nInsCol)
751 : {
752 0 : FormulaTokenMapMap::const_iterator it = pCols->find(nInsCol);
753 0 : if (it == pCols->end())
754 : {
755 0 : pCol = new FormulaTokenMap;
756 0 : (*pCols)[ nInsCol ] = pCol;
757 : }
758 : else
759 0 : pCol = it->second;
760 :
761 0 : sal_uInt32 nInsRow = static_cast<sal_uInt32>(bNoGlue ? nNoGlueRow : nRow1);
762 0 : for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow, ++nInsRow)
763 : {
764 : ScSingleRefData aCellData;
765 0 : aCellData.InitFlags();
766 0 : aCellData.SetFlag3D(true);
767 0 : aCellData.SetColRel(false);
768 0 : aCellData.SetRowRel(false);
769 0 : aCellData.SetTabRel(false);
770 0 : aCellData.SetAbsCol(nCol);
771 0 : aCellData.SetAbsRow(nRow);
772 0 : aCellData.SetAbsTab(nTab);
773 :
774 0 : if (pCol->find(nInsRow) == pCol->end())
775 : {
776 0 : if (bExternal)
777 0 : (*pCol)[ nInsRow ] = new ScExternalSingleRefToken(nFileId, aTabName, aCellData);
778 : else
779 0 : (*pCol)[ nInsRow ] = new ScSingleRefToken(aCellData);
780 : }
781 : }
782 : }
783 : }
784 0 : nNoGlueRow += nRow2 - nRow1 + 1;
785 0 : }
786 :
787 0 : bool bFillRowHeader = mbRowHeaders;
788 0 : bool bFillColumnHeader = mbColHeaders;
789 :
790 0 : SCSIZE nAllColCount = static_cast<SCSIZE>(pCols->size());
791 0 : SCSIZE nAllRowCount = 0;
792 0 : if (!pCols->empty())
793 : {
794 0 : pCol = pCols->begin()->second;
795 0 : if (mbDummyUpperLeft)
796 0 : if (pCol->find(0) == pCol->end())
797 0 : (*pCol)[ 0 ] = NULL; // Dummy fuer Beschriftung
798 0 : nAllRowCount = static_cast<SCSIZE>(pCol->size());
799 : }
800 :
801 0 : if( nAllColCount!=0 && nAllRowCount!=0 )
802 : {
803 0 : if (bNoGlue)
804 : {
805 0 : FormulaTokenMap* pFirstCol = pCols->begin()->second;
806 0 : for (FormulaTokenMap::const_iterator it1 = pFirstCol->begin(); it1 != pFirstCol->end(); ++it1)
807 : {
808 0 : sal_uInt32 nKey = it1->first;
809 0 : for (FormulaTokenMapMap::const_iterator it2 = pCols->begin(); it2 != pCols->end(); ++it2)
810 : {
811 0 : pCol = it2->second;
812 0 : if (pCol->find(nKey) == pCol->end())
813 0 : (*pCol)[ nKey ] = NULL;
814 : }
815 : }
816 : }
817 : }
818 : mpPositionMap.reset(
819 : new Chart2PositionMap(
820 : static_cast<SCCOL>(nAllColCount), static_cast<SCROW>(nAllRowCount),
821 0 : bFillRowHeader, bFillColumnHeader, *pCols, mpDoc));
822 :
823 : // Destroy all column instances.
824 0 : for (FormulaTokenMapMap::const_iterator it = pCols->begin(); it != pCols->end(); ++it)
825 : {
826 0 : pCol = it->second;
827 0 : delete pCol;
828 0 : }
829 : }
830 :
831 : /**
832 : * Function object to create a range string from a token list.
833 : */
834 0 : class Tokens2RangeString : public unary_function<ScTokenRef, void>
835 : {
836 : public:
837 0 : Tokens2RangeString(ScDocument* pDoc, FormulaGrammar::Grammar eGram, sal_Unicode cRangeSep) :
838 0 : mpRangeStr(new OUStringBuffer),
839 : mpDoc(pDoc),
840 : meGrammar(eGram),
841 : mcRangeSep(cRangeSep),
842 0 : mbFirst(true)
843 : {
844 0 : }
845 :
846 0 : Tokens2RangeString(const Tokens2RangeString& r) :
847 : mpRangeStr(r.mpRangeStr),
848 : mpDoc(r.mpDoc),
849 : meGrammar(r.meGrammar),
850 : mcRangeSep(r.mcRangeSep),
851 0 : mbFirst(r.mbFirst)
852 : {
853 0 : }
854 :
855 0 : void operator() (const ScTokenRef& rToken)
856 : {
857 0 : ScCompiler aCompiler(mpDoc, ScAddress(0,0,0));
858 0 : aCompiler.SetGrammar(meGrammar);
859 0 : OUString aStr;
860 0 : aCompiler.CreateStringFromToken(aStr, rToken.get());
861 0 : if (mbFirst)
862 0 : mbFirst = false;
863 : else
864 0 : mpRangeStr->append(mcRangeSep);
865 0 : mpRangeStr->append(aStr);
866 0 : }
867 :
868 0 : void getString(OUString& rStr)
869 : {
870 0 : rStr = mpRangeStr->makeStringAndClear();
871 0 : }
872 :
873 : private:
874 : shared_ptr<OUStringBuffer> mpRangeStr;
875 : ScDocument* mpDoc;
876 : FormulaGrammar::Grammar meGrammar;
877 : sal_Unicode mcRangeSep;
878 : bool mbFirst;
879 : };
880 :
881 : /**
882 : * Function object to convert a list of tokens into a string form suitable
883 : * for ODF export. In ODF, a range is expressed as
884 : *
885 : * (start cell address):(end cell address)
886 : *
887 : * and each address doesn't include any '$' symbols.
888 : */
889 0 : class Tokens2RangeStringXML : public unary_function<ScTokenRef, void>
890 : {
891 : public:
892 0 : Tokens2RangeStringXML(ScDocument* pDoc) :
893 0 : mpRangeStr(new OUStringBuffer),
894 : mpDoc(pDoc),
895 : mcRangeSep(' '),
896 : mcAddrSep(':'),
897 0 : mbFirst(true)
898 : {
899 0 : }
900 :
901 0 : Tokens2RangeStringXML(const Tokens2RangeStringXML& r) :
902 : mpRangeStr(r.mpRangeStr),
903 : mpDoc(r.mpDoc),
904 : mcRangeSep(r.mcRangeSep),
905 : mcAddrSep(r.mcAddrSep),
906 0 : mbFirst(r.mbFirst)
907 : {
908 0 : }
909 :
910 0 : void operator() (const ScTokenRef& rToken)
911 : {
912 0 : if (mbFirst)
913 0 : mbFirst = false;
914 : else
915 0 : mpRangeStr->append(mcRangeSep);
916 :
917 0 : ScTokenRef aStart, aEnd;
918 0 : bool bValidToken = splitRangeToken(rToken, aStart, aEnd);
919 : OSL_ENSURE(bValidToken, "invalid token");
920 0 : if (!bValidToken)
921 0 : return;
922 0 : ScCompiler aCompiler(mpDoc, ScAddress(0,0,0));
923 0 : aCompiler.SetGrammar(FormulaGrammar::GRAM_ENGLISH);
924 : {
925 0 : OUString aStr;
926 0 : aCompiler.CreateStringFromToken(aStr, aStart.get());
927 0 : mpRangeStr->append(aStr);
928 : }
929 0 : mpRangeStr->append(mcAddrSep);
930 : {
931 0 : OUString aStr;
932 0 : aCompiler.CreateStringFromToken(aStr, aEnd.get());
933 0 : mpRangeStr->append(aStr);
934 0 : }
935 : }
936 :
937 0 : void getString(OUString& rStr)
938 : {
939 0 : rStr = mpRangeStr->makeStringAndClear();
940 0 : }
941 :
942 : private:
943 0 : bool splitRangeToken(const ScTokenRef& pToken, ScTokenRef& rStart, ScTokenRef& rEnd) const
944 : {
945 : ScComplexRefData aData;
946 0 : bool bIsRefToken = ScRefTokenHelper::getDoubleRefDataFromToken(aData, pToken);
947 : OSL_ENSURE(bIsRefToken, "invalid token");
948 0 : if (!bIsRefToken)
949 0 : return false;
950 0 : bool bExternal = ScRefTokenHelper::isExternalRef(pToken);
951 0 : sal_uInt16 nFileId = bExternal ? pToken->GetIndex() : 0;
952 0 : svl::SharedString aTabName = svl::SharedString::getEmptyString();
953 0 : if (bExternal)
954 0 : aTabName = pToken->GetString();
955 :
956 : // In saving to XML, we don't prepend address with '$'.
957 0 : setRelative(aData.Ref1);
958 0 : setRelative(aData.Ref2);
959 :
960 : // In XML, the range must explicitly specify sheet name.
961 0 : aData.Ref1.SetFlag3D(true);
962 0 : aData.Ref2.SetFlag3D(true);
963 :
964 0 : if (bExternal)
965 0 : rStart.reset(new ScExternalSingleRefToken(nFileId, aTabName, aData.Ref1));
966 : else
967 0 : rStart.reset(new ScSingleRefToken(aData.Ref1));
968 :
969 0 : if (bExternal)
970 0 : rEnd.reset(new ScExternalSingleRefToken(nFileId, aTabName, aData.Ref2));
971 : else
972 0 : rEnd.reset(new ScSingleRefToken(aData.Ref2));
973 0 : return true;
974 : }
975 :
976 0 : void setRelative(ScSingleRefData& rData) const
977 : {
978 0 : rData.SetColRel(true);
979 0 : rData.SetRowRel(true);
980 0 : rData.SetTabRel(true);
981 0 : }
982 :
983 : private:
984 : shared_ptr<OUStringBuffer> mpRangeStr;
985 : ScDocument* mpDoc;
986 : sal_Unicode mcRangeSep;
987 : sal_Unicode mcAddrSep;
988 : bool mbFirst;
989 : };
990 :
991 0 : void lcl_convertTokensToString(OUString& rStr, const vector<ScTokenRef>& rTokens, ScDocument* pDoc)
992 : {
993 0 : const sal_Unicode cRangeSep = ScCompiler::GetNativeSymbolChar(ocSep);
994 0 : FormulaGrammar::Grammar eGrammar = pDoc->GetGrammar();
995 0 : Tokens2RangeString func(pDoc, eGrammar, cRangeSep);
996 0 : func = ::std::for_each(rTokens.begin(), rTokens.end(), func);
997 0 : func.getString(rStr);
998 0 : }
999 :
1000 : } // anonymous namespace
1001 :
1002 : // DataProvider ==============================================================
1003 :
1004 0 : ScChart2DataProvider::ScChart2DataProvider( ScDocument* pDoc )
1005 : : m_pDocument( pDoc)
1006 : , m_aPropSet(lcl_GetDataProviderPropertyMap())
1007 0 : , m_bIncludeHiddenCells( true)
1008 : {
1009 0 : if ( m_pDocument )
1010 0 : m_pDocument->AddUnoObject( *this);
1011 0 : }
1012 :
1013 0 : ScChart2DataProvider::~ScChart2DataProvider()
1014 : {
1015 0 : if ( m_pDocument )
1016 0 : m_pDocument->RemoveUnoObject( *this);
1017 0 : }
1018 :
1019 :
1020 0 : void ScChart2DataProvider::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
1021 : {
1022 0 : if ( rHint.ISA( SfxSimpleHint ) &&
1023 0 : ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
1024 : {
1025 0 : m_pDocument = NULL;
1026 : }
1027 0 : }
1028 :
1029 0 : sal_Bool SAL_CALL ScChart2DataProvider::createDataSourcePossible( const uno::Sequence< beans::PropertyValue >& aArguments )
1030 : throw (uno::RuntimeException, std::exception)
1031 : {
1032 0 : SolarMutexGuard aGuard;
1033 0 : if( ! m_pDocument )
1034 0 : return false;
1035 :
1036 0 : OUString aRangeRepresentation;
1037 0 : for(sal_Int32 i = 0; i < aArguments.getLength(); ++i)
1038 : {
1039 0 : if ( aArguments[i].Name == "CellRangeRepresentation" )
1040 : {
1041 0 : aArguments[i].Value >>= aRangeRepresentation;
1042 : }
1043 : }
1044 :
1045 0 : vector<ScTokenRef> aTokens;
1046 0 : const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
1047 : ScRefTokenHelper::compileRangeRepresentation(
1048 0 : aTokens, aRangeRepresentation, m_pDocument, cSep, m_pDocument->GetGrammar(), true);
1049 0 : return !aTokens.empty();
1050 : }
1051 :
1052 : namespace
1053 : {
1054 :
1055 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1056 0 : Reference< chart2::data::XLabeledDataSequence > lcl_createLabeledDataSequenceFromTokens(
1057 : auto_ptr< vector< ScTokenRef > > pValueTokens, auto_ptr< vector< ScTokenRef > > pLabelTokens,
1058 : ScDocument* pDoc, const Reference< chart2::data::XDataProvider >& xDP, bool bIncludeHiddenCells )
1059 : {
1060 0 : Reference< chart2::data::XLabeledDataSequence > xResult;
1061 0 : bool bHasValues = pValueTokens.get() && !pValueTokens->empty();
1062 0 : bool bHasLabel = pLabelTokens.get() && !pLabelTokens->empty();
1063 0 : if( bHasValues || bHasLabel )
1064 : {
1065 : try
1066 : {
1067 0 : Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
1068 0 : if ( xContext.is() )
1069 : {
1070 0 : xResult.set( chart2::data::LabeledDataSequence::create(xContext), uno::UNO_QUERY_THROW );
1071 : }
1072 0 : if ( bHasValues )
1073 : {
1074 0 : Reference< chart2::data::XDataSequence > xSeq( new ScChart2DataSequence( pDoc, xDP, pValueTokens.release(), bIncludeHiddenCells ) );
1075 0 : xResult->setValues( xSeq );
1076 : }
1077 0 : if ( bHasLabel )
1078 : {
1079 0 : Reference< chart2::data::XDataSequence > xLabelSeq( new ScChart2DataSequence( pDoc, xDP, pLabelTokens.release(), bIncludeHiddenCells ) );
1080 0 : xResult->setLabel( xLabelSeq );
1081 0 : }
1082 : }
1083 0 : catch( const uno::Exception& )
1084 : {
1085 : }
1086 : }
1087 0 : return xResult;
1088 : }
1089 : SAL_WNODEPRECATED_DECLARATIONS_POP
1090 :
1091 :
1092 : /**
1093 : * Check the current list of reference tokens, and add the upper left
1094 : * corner of the minimum range that encloses all ranges if certain
1095 : * conditions are met.
1096 : *
1097 : * @param rRefTokens list of reference tokens
1098 : *
1099 : * @return true if the corner was added, false otherwise.
1100 : */
1101 0 : bool lcl_addUpperLeftCornerIfMissing(vector<ScTokenRef>& rRefTokens,
1102 : SCROW nCornerRowCount=1, SCCOL nCornerColumnCount=1)
1103 : {
1104 : using ::std::max;
1105 : using ::std::min;
1106 :
1107 0 : if (rRefTokens.empty())
1108 0 : return false;
1109 :
1110 0 : SCCOL nMinCol = MAXCOLCOUNT;
1111 0 : SCROW nMinRow = MAXROWCOUNT;
1112 0 : SCCOL nMaxCol = 0;
1113 0 : SCROW nMaxRow = 0;
1114 0 : SCTAB nTab = 0;
1115 :
1116 0 : sal_uInt16 nFileId = 0;
1117 0 : svl::SharedString aExtTabName;
1118 0 : bool bExternal = false;
1119 :
1120 0 : vector<ScTokenRef>::const_iterator itr = rRefTokens.begin(), itrEnd = rRefTokens.end();
1121 :
1122 : // Get the first ref token.
1123 0 : ScTokenRef pToken = *itr;
1124 0 : switch (pToken->GetType())
1125 : {
1126 : case svSingleRef:
1127 : {
1128 0 : const ScSingleRefData& rData = pToken->GetSingleRef();
1129 0 : nMinCol = rData.Col();
1130 0 : nMinRow = rData.Row();
1131 0 : nMaxCol = rData.Col();
1132 0 : nMaxRow = rData.Row();
1133 0 : nTab = rData.Tab();
1134 : }
1135 0 : break;
1136 : case svDoubleRef:
1137 : {
1138 0 : const ScComplexRefData& rData = pToken->GetDoubleRef();
1139 0 : nMinCol = min(rData.Ref1.Col(), rData.Ref2.Col());
1140 0 : nMinRow = min(rData.Ref1.Row(), rData.Ref2.Row());
1141 0 : nMaxCol = max(rData.Ref1.Col(), rData.Ref2.Col());
1142 0 : nMaxRow = max(rData.Ref1.Row(), rData.Ref2.Row());
1143 0 : nTab = rData.Ref1.Tab();
1144 : }
1145 0 : break;
1146 : case svExternalSingleRef:
1147 : {
1148 0 : const ScSingleRefData& rData = pToken->GetSingleRef();
1149 0 : nMinCol = rData.Col();
1150 0 : nMinRow = rData.Row();
1151 0 : nMaxCol = rData.Col();
1152 0 : nMaxRow = rData.Row();
1153 0 : nTab = rData.Tab();
1154 0 : nFileId = pToken->GetIndex();
1155 0 : aExtTabName = pToken->GetString();
1156 0 : bExternal = true;
1157 : }
1158 0 : break;
1159 : case svExternalDoubleRef:
1160 : {
1161 0 : const ScComplexRefData& rData = pToken->GetDoubleRef();
1162 0 : nMinCol = min(rData.Ref1.Col(), rData.Ref2.Col());
1163 0 : nMinRow = min(rData.Ref1.Row(), rData.Ref2.Row());
1164 0 : nMaxCol = max(rData.Ref1.Col(), rData.Ref2.Col());
1165 0 : nMaxRow = max(rData.Ref1.Row(), rData.Ref2.Row());
1166 0 : nTab = rData.Ref1.Tab();
1167 0 : nFileId = pToken->GetIndex();
1168 0 : aExtTabName = pToken->GetString();
1169 0 : bExternal = true;
1170 : }
1171 0 : break;
1172 : default:
1173 : ;
1174 : }
1175 :
1176 : // Determine the minimum range enclosing all data ranges. Also make sure
1177 : // that they are all on the same table.
1178 :
1179 0 : for (++itr; itr != itrEnd; ++itr)
1180 : {
1181 0 : pToken = *itr;
1182 0 : switch (pToken->GetType())
1183 : {
1184 : case svSingleRef:
1185 : {
1186 0 : const ScSingleRefData& rData = pToken->GetSingleRef();
1187 :
1188 0 : nMinCol = min(nMinCol, rData.Col());
1189 0 : nMinRow = min(nMinRow, rData.Row());
1190 0 : nMaxCol = max(nMaxCol, rData.Col());
1191 0 : nMaxRow = max(nMaxRow, rData.Row());
1192 0 : if (nTab != rData.Tab() || bExternal)
1193 0 : return false;
1194 : }
1195 0 : break;
1196 : case svDoubleRef:
1197 : {
1198 0 : const ScComplexRefData& rData = pToken->GetDoubleRef();
1199 :
1200 0 : nMinCol = min(nMinCol, rData.Ref1.Col());
1201 0 : nMinCol = min(nMinCol, rData.Ref2.Col());
1202 0 : nMinRow = min(nMinRow, rData.Ref1.Row());
1203 0 : nMinRow = min(nMinRow, rData.Ref2.Row());
1204 :
1205 0 : nMaxCol = max(nMaxCol, rData.Ref1.Col());
1206 0 : nMaxCol = max(nMaxCol, rData.Ref2.Col());
1207 0 : nMaxRow = max(nMaxRow, rData.Ref1.Row());
1208 0 : nMaxRow = max(nMaxRow, rData.Ref2.Row());
1209 :
1210 0 : if (nTab != rData.Ref1.Tab() || bExternal)
1211 0 : return false;
1212 : }
1213 0 : break;
1214 : case svExternalSingleRef:
1215 : {
1216 0 : if (!bExternal)
1217 0 : return false;
1218 :
1219 0 : if (nFileId != pToken->GetIndex() || aExtTabName != pToken->GetString())
1220 0 : return false;
1221 :
1222 0 : const ScSingleRefData& rData = pToken->GetSingleRef();
1223 :
1224 0 : nMinCol = min(nMinCol, rData.Col());
1225 0 : nMinRow = min(nMinRow, rData.Row());
1226 0 : nMaxCol = max(nMaxCol, rData.Col());
1227 0 : nMaxRow = max(nMaxRow, rData.Row());
1228 : }
1229 0 : break;
1230 : case svExternalDoubleRef:
1231 : {
1232 0 : if (!bExternal)
1233 0 : return false;
1234 :
1235 0 : if (nFileId != pToken->GetIndex() || aExtTabName != pToken->GetString())
1236 0 : return false;
1237 :
1238 0 : const ScComplexRefData& rData = pToken->GetDoubleRef();
1239 :
1240 0 : nMinCol = min(nMinCol, rData.Ref1.Col());
1241 0 : nMinCol = min(nMinCol, rData.Ref2.Col());
1242 0 : nMinRow = min(nMinRow, rData.Ref1.Row());
1243 0 : nMinRow = min(nMinRow, rData.Ref2.Row());
1244 :
1245 0 : nMaxCol = max(nMaxCol, rData.Ref1.Col());
1246 0 : nMaxCol = max(nMaxCol, rData.Ref2.Col());
1247 0 : nMaxRow = max(nMaxRow, rData.Ref1.Row());
1248 0 : nMaxRow = max(nMaxRow, rData.Ref2.Row());
1249 : }
1250 0 : break;
1251 : default:
1252 : ;
1253 : }
1254 : }
1255 :
1256 0 : if (nMinRow >= nMaxRow || nMinCol >= nMaxCol ||
1257 0 : nMinRow >= MAXROWCOUNT || nMinCol >= MAXCOLCOUNT ||
1258 0 : nMaxRow >= MAXROWCOUNT || nMaxCol >= MAXCOLCOUNT)
1259 : {
1260 : // Invalid range. Bail out.
1261 0 : return false;
1262 : }
1263 :
1264 : // Check if the following conditions are met:
1265 :
1266 : // 1) The upper-left corner cell is not included.
1267 : // 2) The three adjacent cells of that corner cell are included.
1268 :
1269 0 : bool bRight = false, bBottom = false, bDiagonal = false;
1270 0 : for (itr = rRefTokens.begin(); itr != itrEnd; ++itr)
1271 : {
1272 0 : pToken = *itr;
1273 0 : switch (pToken->GetType())
1274 : {
1275 : case svSingleRef:
1276 : case svExternalSingleRef:
1277 : {
1278 0 : const ScSingleRefData& rData = pToken->GetSingleRef();
1279 0 : if (rData.Col() == nMinCol && rData.Row() == nMinRow)
1280 : // The corner cell is contained.
1281 0 : return false;
1282 :
1283 0 : if (rData.Col() == nMinCol+nCornerColumnCount && rData.Row() == nMinRow)
1284 0 : bRight = true;
1285 :
1286 0 : if (rData.Col() == nMinCol && rData.Row() == nMinRow+nCornerRowCount)
1287 0 : bBottom = true;
1288 :
1289 0 : if (rData.Col() == nMinCol+nCornerColumnCount && rData.Row() == nMinRow+nCornerRowCount)
1290 0 : bDiagonal = true;
1291 : }
1292 0 : break;
1293 : case svDoubleRef:
1294 : case svExternalDoubleRef:
1295 : {
1296 0 : const ScComplexRefData& rData = pToken->GetDoubleRef();
1297 0 : const ScSingleRefData& r1 = rData.Ref1;
1298 0 : const ScSingleRefData& r2 = rData.Ref2;
1299 0 : if (r1.Col() <= nMinCol && nMinCol <= r2.Col() &&
1300 0 : r1.Row() <= nMinRow && nMinRow <= r2.Row())
1301 : // The corner cell is contained.
1302 0 : return false;
1303 :
1304 0 : if (r1.Col() <= nMinCol+nCornerColumnCount && nMinCol+nCornerColumnCount <= r2.Col() &&
1305 0 : r1.Row() <= nMinRow && nMinRow <= r2.Row())
1306 0 : bRight = true;
1307 :
1308 0 : if (r1.Col() <= nMinCol && nMinCol <= r2.Col() &&
1309 0 : r1.Row() <= nMinRow+nCornerRowCount && nMinRow+nCornerRowCount <= r2.Row())
1310 0 : bBottom = true;
1311 :
1312 0 : if (r1.Col() <= nMinCol+nCornerColumnCount && nMinCol+nCornerColumnCount <= r2.Col() &&
1313 0 : r1.Row() <= nMinRow+nCornerRowCount && nMinRow+nCornerRowCount <= r2.Row())
1314 0 : bDiagonal = true;
1315 : }
1316 0 : break;
1317 : default:
1318 : ;
1319 : }
1320 : }
1321 :
1322 0 : if (!bRight || !bBottom || !bDiagonal)
1323 : // Not all the adjacent cells are included. Bail out.
1324 0 : return false;
1325 :
1326 : ScSingleRefData aData;
1327 0 : aData.InitFlags();
1328 0 : aData.SetFlag3D(true);
1329 0 : aData.SetAbsCol(nMinCol);
1330 0 : aData.SetAbsRow(nMinRow);
1331 0 : aData.SetAbsTab(nTab);
1332 :
1333 0 : if( nCornerRowCount==1 && nCornerColumnCount==1 )
1334 : {
1335 0 : if (bExternal)
1336 : {
1337 : ScTokenRef pCorner(
1338 0 : new ScExternalSingleRefToken(nFileId, aExtTabName, aData));
1339 0 : ScRefTokenHelper::join(rRefTokens, pCorner, ScAddress());
1340 : }
1341 : else
1342 : {
1343 0 : ScTokenRef pCorner(new ScSingleRefToken(aData));
1344 0 : ScRefTokenHelper::join(rRefTokens, pCorner, ScAddress());
1345 0 : }
1346 : }
1347 : else
1348 : {
1349 0 : ScSingleRefData aDataEnd(aData);
1350 0 : aDataEnd.IncCol(nCornerColumnCount-1);
1351 0 : aDataEnd.IncRow(nCornerRowCount-1);
1352 : ScComplexRefData r;
1353 0 : r.Ref1=aData;
1354 0 : r.Ref2=aDataEnd;
1355 0 : if (bExternal)
1356 : {
1357 : ScTokenRef pCorner(
1358 0 : new ScExternalDoubleRefToken(nFileId, aExtTabName, r));
1359 0 : ScRefTokenHelper::join(rRefTokens, pCorner, ScAddress());
1360 : }
1361 : else
1362 : {
1363 0 : ScTokenRef pCorner(new ScDoubleRefToken(r));
1364 0 : ScRefTokenHelper::join(rRefTokens, pCorner, ScAddress());
1365 : }
1366 : }
1367 :
1368 0 : return true;
1369 : }
1370 :
1371 : class ShrinkRefTokenToDataRange : std::unary_function<ScTokenRef, void>
1372 : {
1373 : ScDocument* mpDoc;
1374 : public:
1375 0 : ShrinkRefTokenToDataRange(ScDocument* pDoc) : mpDoc(pDoc) {}
1376 0 : void operator() (ScTokenRef& rRef)
1377 : {
1378 0 : if (ScRefTokenHelper::isExternalRef(rRef))
1379 0 : return;
1380 :
1381 : // Don't assume an ScDoubleRefToken if it isn't. It can be at least an
1382 : // ScSingleRefToken, then there isn't anything to shrink.
1383 0 : if (rRef->GetType() != svDoubleRef)
1384 0 : return;
1385 :
1386 0 : ScComplexRefData& rData = rRef->GetDoubleRef();
1387 0 : ScSingleRefData& s = rData.Ref1;
1388 0 : ScSingleRefData& e = rData.Ref2;
1389 :
1390 0 : SCCOL nMinCol = MAXCOL, nMaxCol = 0;
1391 0 : SCROW nMinRow = MAXROW, nMaxRow = 0;
1392 :
1393 : // Determine the smallest range that encompasses the data ranges of all sheets.
1394 0 : SCTAB nTab1 = s.Tab(), nTab2 = e.Tab();
1395 0 : for (SCTAB nTab = nTab1; nTab <= nTab2; ++nTab)
1396 : {
1397 0 : SCCOL nCol1 = 0, nCol2 = MAXCOL;
1398 0 : SCROW nRow1 = 0, nRow2 = MAXROW;
1399 0 : mpDoc->ShrinkToDataArea(nTab, nCol1, nRow1, nCol2, nRow2);
1400 0 : nMinCol = std::min(nMinCol, nCol1);
1401 0 : nMinRow = std::min(nMinRow, nRow1);
1402 0 : nMaxCol = std::max(nMaxCol, nCol2);
1403 0 : nMaxRow = std::max(nMaxRow, nRow2);
1404 : }
1405 :
1406 : // Shrink range to the data range if applicable.
1407 0 : if (s.Col() < nMinCol)
1408 0 : s.SetAbsCol(nMinCol);
1409 0 : if (s.Row() < nMinRow)
1410 0 : s.SetAbsRow(nMinRow);
1411 0 : if (e.Col() > nMaxCol)
1412 0 : e.SetAbsCol(nMaxCol);
1413 0 : if (e.Row() > nMaxRow)
1414 0 : e.SetAbsRow(nMaxRow);
1415 : }
1416 : };
1417 :
1418 0 : void shrinkToDataRange(ScDocument* pDoc, vector<ScTokenRef>& rRefTokens)
1419 : {
1420 0 : std::for_each(rRefTokens.begin(), rRefTokens.end(), ShrinkRefTokenToDataRange(pDoc));
1421 0 : }
1422 :
1423 : }
1424 :
1425 : uno::Reference< chart2::data::XDataSource> SAL_CALL
1426 0 : ScChart2DataProvider::createDataSource(
1427 : const uno::Sequence< beans::PropertyValue >& aArguments )
1428 : throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception)
1429 : {
1430 0 : SolarMutexGuard aGuard;
1431 0 : if ( ! m_pDocument )
1432 0 : throw uno::RuntimeException();
1433 :
1434 0 : uno::Reference< chart2::data::XDataSource> xResult;
1435 0 : bool bLabel = true;
1436 0 : bool bCategories = false;
1437 0 : bool bOrientCol = true;
1438 0 : OUString aRangeRepresentation;
1439 0 : uno::Sequence< sal_Int32 > aSequenceMapping;
1440 0 : sal_Bool bTimeBased = false;
1441 0 : for(sal_Int32 i = 0; i < aArguments.getLength(); ++i)
1442 : {
1443 0 : if ( aArguments[i].Name == "DataRowSource" )
1444 : {
1445 0 : chart::ChartDataRowSource eSource = chart::ChartDataRowSource_COLUMNS;
1446 0 : if( ! (aArguments[i].Value >>= eSource))
1447 : {
1448 0 : sal_Int32 nSource(0);
1449 0 : if( aArguments[i].Value >>= nSource )
1450 0 : eSource = (static_cast< chart::ChartDataRowSource >( nSource ));
1451 : }
1452 0 : bOrientCol = (eSource == chart::ChartDataRowSource_COLUMNS);
1453 : }
1454 0 : else if ( aArguments[i].Name == "FirstCellAsLabel" )
1455 : {
1456 0 : bLabel = ::cppu::any2bool(aArguments[i].Value);
1457 : }
1458 0 : else if ( aArguments[i].Name == "HasCategories" )
1459 : {
1460 0 : bCategories = ::cppu::any2bool(aArguments[i].Value);
1461 : }
1462 0 : else if ( aArguments[i].Name == "CellRangeRepresentation" )
1463 : {
1464 0 : aArguments[i].Value >>= aRangeRepresentation;
1465 : }
1466 0 : else if ( aArguments[i].Name == "SequenceMapping" )
1467 : {
1468 0 : aArguments[i].Value >>= aSequenceMapping;
1469 : }
1470 0 : else if ( aArguments[i].Name == "TimeBased" )
1471 : {
1472 0 : aArguments[i].Value >>= bTimeBased;
1473 : }
1474 : }
1475 :
1476 0 : vector<ScTokenRef> aRefTokens;
1477 0 : const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
1478 : ScRefTokenHelper::compileRangeRepresentation(
1479 0 : aRefTokens, aRangeRepresentation, m_pDocument, cSep, m_pDocument->GetGrammar(), true);
1480 0 : if (aRefTokens.empty())
1481 : // Invalid range representation. Bail out.
1482 0 : throw lang::IllegalArgumentException();
1483 :
1484 0 : SCTAB nTimeBasedStart = MAXTAB;
1485 0 : SCTAB nTimeBasedEnd = 0;
1486 0 : if(bTimeBased)
1487 : {
1488 : // limit to first sheet
1489 0 : for(vector<ScTokenRef>::iterator itr = aRefTokens.begin(),
1490 0 : itrEnd = aRefTokens.end(); itr != itrEnd; ++itr)
1491 : {
1492 0 : if ((*itr)->GetType() != svDoubleRef)
1493 0 : continue;
1494 :
1495 0 : ScComplexRefData& rData = (*itr)->GetDoubleRef();
1496 0 : ScSingleRefData& s = rData.Ref1;
1497 0 : ScSingleRefData& e = rData.Ref2;
1498 :
1499 0 : nTimeBasedStart = std::min(nTimeBasedStart, s.Tab());
1500 0 : nTimeBasedEnd = std::min(nTimeBasedEnd, e.Tab());
1501 :
1502 0 : if(s.Tab() != e.Tab())
1503 0 : e.SetAbsTab(s.Tab());
1504 : }
1505 : }
1506 :
1507 0 : if(!bTimeBased)
1508 0 : shrinkToDataRange(m_pDocument, aRefTokens);
1509 :
1510 0 : if (bLabel)
1511 0 : lcl_addUpperLeftCornerIfMissing(aRefTokens); //#i90669#
1512 :
1513 0 : bool bColHeaders = (bOrientCol ? bLabel : bCategories );
1514 0 : bool bRowHeaders = (bOrientCol ? bCategories : bLabel );
1515 :
1516 0 : Chart2Positioner aChPositioner(m_pDocument, aRefTokens);
1517 0 : aChPositioner.setHeaders(bColHeaders, bRowHeaders);
1518 :
1519 0 : const Chart2PositionMap* pChartMap = aChPositioner.getPositionMap();
1520 0 : if (!pChartMap)
1521 : // No chart position map instance. Bail out.
1522 0 : return xResult;
1523 :
1524 0 : ScChart2DataSource* pDS = NULL;
1525 0 : ::std::list< Reference< chart2::data::XLabeledDataSequence > > aSeqs;
1526 :
1527 : // Fill Categories
1528 0 : if( bCategories )
1529 : {
1530 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1531 0 : auto_ptr< vector<ScTokenRef> > pValueTokens(NULL);
1532 : SAL_WNODEPRECATED_DECLARATIONS_POP
1533 0 : if (bOrientCol)
1534 0 : pValueTokens.reset(pChartMap->getAllRowHeaderRanges());
1535 : else
1536 0 : pValueTokens.reset(pChartMap->getAllColHeaderRanges());
1537 :
1538 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1539 : auto_ptr< vector<ScTokenRef> > pLabelTokens(
1540 0 : pChartMap->getLeftUpperCornerRanges());
1541 : SAL_WNODEPRECATED_DECLARATIONS_POP
1542 :
1543 : Reference< chart2::data::XLabeledDataSequence > xCategories = lcl_createLabeledDataSequenceFromTokens(
1544 0 : pValueTokens, pLabelTokens, m_pDocument, this, m_bIncludeHiddenCells ); //ownership of pointers is transferred!
1545 0 : if ( xCategories.is() )
1546 : {
1547 0 : aSeqs.push_back( xCategories );
1548 0 : }
1549 : }
1550 :
1551 : // Fill Serieses (values and label)
1552 0 : sal_Int32 nCount = bOrientCol ? pChartMap->getDataColCount() : pChartMap->getDataRowCount();
1553 0 : for (sal_Int32 i = 0; i < nCount; ++i)
1554 : {
1555 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1556 0 : auto_ptr< vector<ScTokenRef> > pValueTokens(NULL);
1557 0 : auto_ptr< vector<ScTokenRef> > pLabelTokens(NULL);
1558 : SAL_WNODEPRECATED_DECLARATIONS_POP
1559 0 : if (bOrientCol)
1560 : {
1561 0 : pValueTokens.reset(pChartMap->getDataColRanges(static_cast<SCCOL>(i)));
1562 0 : pLabelTokens.reset(pChartMap->getColHeaderRanges(static_cast<SCCOL>(i)));
1563 : }
1564 : else
1565 : {
1566 0 : pValueTokens.reset(pChartMap->getDataRowRanges(static_cast<SCROW>(i)));
1567 0 : pLabelTokens.reset(pChartMap->getRowHeaderRanges(static_cast<SCROW>(i)));
1568 : }
1569 : Reference< chart2::data::XLabeledDataSequence > xChartSeries = lcl_createLabeledDataSequenceFromTokens(
1570 0 : pValueTokens, pLabelTokens, m_pDocument, this, m_bIncludeHiddenCells ); //ownership of pointers is transferred!
1571 0 : if ( xChartSeries.is() && xChartSeries->getValues().is() && xChartSeries->getValues()->getData().getLength() )
1572 : {
1573 0 : aSeqs.push_back( xChartSeries );
1574 : }
1575 0 : }
1576 :
1577 0 : pDS = new ScChart2DataSource(m_pDocument);
1578 0 : ::std::list< Reference< chart2::data::XLabeledDataSequence > >::iterator aItr( aSeqs.begin() );
1579 0 : ::std::list< Reference< chart2::data::XLabeledDataSequence > >::iterator aEndItr( aSeqs.end() );
1580 :
1581 : //reorder labeled sequences according to aSequenceMapping
1582 0 : ::std::vector< Reference< chart2::data::XLabeledDataSequence > > aSeqVector;
1583 0 : while(aItr != aEndItr)
1584 : {
1585 0 : aSeqVector.push_back(*aItr);
1586 0 : ++aItr;
1587 : }
1588 :
1589 0 : ::std::map< sal_Int32, Reference< chart2::data::XLabeledDataSequence > > aSequenceMap;
1590 0 : for( sal_Int32 nNewIndex = 0; nNewIndex < aSequenceMapping.getLength(); nNewIndex++ )
1591 : {
1592 : // note: assuming that the values in the sequence mapping are always non-negative
1593 0 : ::std::vector< Reference< chart2::data::XLabeledDataSequence > >::size_type nOldIndex( static_cast< sal_uInt32 >( aSequenceMapping[nNewIndex] ) );
1594 0 : if( nOldIndex < aSeqVector.size() )
1595 : {
1596 0 : pDS->AddLabeledSequence( aSeqVector[nOldIndex] );
1597 0 : aSeqVector[nOldIndex] = 0;
1598 : }
1599 : }
1600 :
1601 0 : ::std::vector< Reference< chart2::data::XLabeledDataSequence > >::iterator aVectorItr( aSeqVector.begin() );
1602 0 : ::std::vector< Reference< chart2::data::XLabeledDataSequence > >::iterator aVectorEndItr( aSeqVector.end() );
1603 0 : while(aVectorItr != aVectorEndItr)
1604 : {
1605 0 : Reference< chart2::data::XLabeledDataSequence > xSeq( *aVectorItr );
1606 0 : if ( xSeq.is() )
1607 : {
1608 0 : pDS->AddLabeledSequence( xSeq );
1609 : }
1610 0 : ++aVectorItr;
1611 0 : }
1612 :
1613 0 : xResult.set( pDS );
1614 0 : return xResult;
1615 : }
1616 :
1617 : namespace
1618 : {
1619 :
1620 : /**
1621 : * Function object to create a list of table numbers from a token list.
1622 : */
1623 0 : class InsertTabNumber : public unary_function<ScTokenRef, void>
1624 : {
1625 : public:
1626 0 : InsertTabNumber() :
1627 0 : mpTabNumList(new list<SCTAB>())
1628 : {
1629 0 : }
1630 :
1631 0 : InsertTabNumber(const InsertTabNumber& r) :
1632 0 : mpTabNumList(r.mpTabNumList)
1633 : {
1634 0 : }
1635 :
1636 0 : void operator() (const ScTokenRef& pToken) const
1637 : {
1638 0 : if (!ScRefTokenHelper::isRef(pToken))
1639 0 : return;
1640 :
1641 0 : const ScSingleRefData& r = pToken->GetSingleRef();
1642 0 : mpTabNumList->push_back(r.Tab());
1643 : }
1644 :
1645 0 : void getList(list<SCTAB>& rList)
1646 : {
1647 0 : mpTabNumList->swap(rList);
1648 0 : }
1649 : private:
1650 : shared_ptr< list<SCTAB> > mpTabNumList;
1651 : };
1652 :
1653 : class RangeAnalyzer
1654 : {
1655 : public:
1656 : RangeAnalyzer();
1657 : void initRangeAnalyzer( const vector<ScTokenRef>& rTokens );
1658 : void analyzeRange( sal_Int32& rnDataInRows, sal_Int32& rnDataInCols,
1659 : bool& rbRowSourceAmbiguous ) const;
1660 : bool inSameSingleRow( RangeAnalyzer& rOther );
1661 : bool inSameSingleColumn( RangeAnalyzer& rOther );
1662 0 : SCROW getRowCount() { return mnRowCount; }
1663 0 : SCCOL getColumnCount() { return mnColumnCount; }
1664 :
1665 : private:
1666 : bool mbEmpty;
1667 : bool mbAmbiguous;
1668 : SCROW mnRowCount;
1669 : SCCOL mnColumnCount;
1670 :
1671 : SCCOL mnStartColumn;
1672 : SCROW mnStartRow;
1673 : };
1674 :
1675 0 : RangeAnalyzer::RangeAnalyzer()
1676 : : mbEmpty(true)
1677 : , mbAmbiguous(false)
1678 : , mnRowCount(0)
1679 : , mnColumnCount(0)
1680 : , mnStartColumn(-1)
1681 0 : , mnStartRow(-1)
1682 : {
1683 0 : }
1684 :
1685 0 : void RangeAnalyzer::initRangeAnalyzer( const vector<ScTokenRef>& rTokens )
1686 : {
1687 0 : mnRowCount=0;
1688 0 : mnColumnCount=0;
1689 0 : mnStartColumn = -1;
1690 0 : mnStartRow = -1;
1691 0 : mbAmbiguous=false;
1692 0 : if( rTokens.empty() )
1693 : {
1694 0 : mbEmpty=true;
1695 0 : return;
1696 : }
1697 0 : mbEmpty=false;
1698 :
1699 0 : vector<ScTokenRef>::const_iterator itr = rTokens.begin(), itrEnd = rTokens.end();
1700 0 : for (; itr != itrEnd ; ++itr)
1701 : {
1702 0 : ScTokenRef aRefToken = *itr;
1703 0 : StackVar eVar = aRefToken->GetType();
1704 0 : if (eVar == svDoubleRef || eVar == svExternalDoubleRef)
1705 : {
1706 0 : const ScComplexRefData& r = aRefToken->GetDoubleRef();
1707 0 : if (r.Ref1.Tab() == r.Ref2.Tab())
1708 : {
1709 0 : mnColumnCount = std::max<SCCOL>(mnColumnCount, static_cast<SCCOL>(abs(r.Ref2.Col() - r.Ref1.Col())+1));
1710 0 : mnRowCount = std::max<SCROW>(mnRowCount, static_cast<SCROW>(abs(r.Ref2.Row() - r.Ref1.Row())+1));
1711 0 : if( mnStartColumn == -1 )
1712 : {
1713 0 : mnStartColumn = r.Ref1.Col();
1714 0 : mnStartRow = r.Ref1.Row();
1715 : }
1716 : else
1717 : {
1718 0 : if (mnStartColumn != r.Ref1.Col() && mnStartRow != r.Ref1.Row())
1719 0 : mbAmbiguous=true;
1720 : }
1721 : }
1722 : else
1723 0 : mbAmbiguous=true;
1724 : }
1725 0 : else if (eVar == svSingleRef || eVar == svExternalSingleRef)
1726 : {
1727 0 : const ScSingleRefData& r = aRefToken->GetSingleRef();
1728 0 : mnColumnCount = std::max<SCCOL>( mnColumnCount, 1);
1729 0 : mnRowCount = std::max<SCROW>( mnRowCount, 1);
1730 0 : if( mnStartColumn == -1 )
1731 : {
1732 0 : mnStartColumn = r.Col();
1733 0 : mnStartRow = r.Row();
1734 : }
1735 : else
1736 : {
1737 0 : if (mnStartColumn != r.Col() && mnStartRow != r.Row())
1738 0 : mbAmbiguous=true;
1739 0 : }
1740 : }
1741 : else
1742 0 : mbAmbiguous=true;
1743 0 : }
1744 : }
1745 :
1746 0 : void RangeAnalyzer::analyzeRange( sal_Int32& rnDataInRows,
1747 : sal_Int32& rnDataInCols,
1748 : bool& rbRowSourceAmbiguous ) const
1749 : {
1750 0 : if(!mbEmpty && !mbAmbiguous)
1751 : {
1752 0 : if( mnRowCount==1 && mnColumnCount>1 )
1753 0 : ++rnDataInRows;
1754 0 : else if( mnColumnCount==1 && mnRowCount>1 )
1755 0 : ++rnDataInCols;
1756 0 : else if( mnRowCount>1 && mnColumnCount>1 )
1757 0 : rbRowSourceAmbiguous = true;
1758 : }
1759 0 : else if( !mbEmpty )
1760 0 : rbRowSourceAmbiguous = true;
1761 0 : }
1762 :
1763 0 : bool RangeAnalyzer::inSameSingleRow( RangeAnalyzer& rOther )
1764 : {
1765 0 : if( mnStartRow==rOther.mnStartRow &&
1766 0 : mnRowCount==1 && rOther.mnRowCount==1 )
1767 0 : return true;
1768 0 : return false;
1769 : }
1770 :
1771 0 : bool RangeAnalyzer::inSameSingleColumn( RangeAnalyzer& rOther )
1772 : {
1773 0 : if( mnStartColumn==rOther.mnStartColumn &&
1774 0 : mnColumnCount==1 && rOther.mnColumnCount==1 )
1775 0 : return true;
1776 0 : return false;
1777 : }
1778 :
1779 : } //end anonymous namespace
1780 :
1781 0 : uno::Sequence< beans::PropertyValue > SAL_CALL ScChart2DataProvider::detectArguments(
1782 : const uno::Reference< chart2::data::XDataSource >& xDataSource )
1783 : throw (uno::RuntimeException, std::exception)
1784 : {
1785 0 : ::std::vector< beans::PropertyValue > aResult;
1786 0 : bool bRowSourceDetected = false;
1787 0 : bool bFirstCellAsLabel = false;
1788 0 : bool bHasCategories = false;
1789 0 : OUString sRangeRep;
1790 :
1791 0 : bool bHasCategoriesLabels = false;
1792 0 : vector<ScTokenRef> aAllCategoriesValuesTokens;
1793 0 : vector<ScTokenRef> aAllSeriesLabelTokens;
1794 :
1795 0 : chart::ChartDataRowSource eRowSource = chart::ChartDataRowSource_COLUMNS;
1796 :
1797 0 : vector<ScTokenRef> aAllTokens;
1798 :
1799 : // parse given data source and collect infos
1800 : {
1801 0 : SolarMutexGuard aGuard;
1802 : OSL_ENSURE( m_pDocument, "No Document -> no detectArguments" );
1803 0 : if(!m_pDocument ||!xDataSource.is())
1804 0 : return lcl_VectorToSequence( aResult );
1805 :
1806 0 : sal_Int32 nDataInRows = 0;
1807 0 : sal_Int32 nDataInCols = 0;
1808 0 : bool bRowSourceAmbiguous = false;
1809 :
1810 0 : Sequence< Reference< chart2::data::XLabeledDataSequence > > aSequences( xDataSource->getDataSequences());
1811 0 : const sal_Int32 nCount( aSequences.getLength());
1812 0 : RangeAnalyzer aPrevLabel,aPrevValues;
1813 0 : for( sal_Int32 nIdx=0; nIdx<nCount; ++nIdx )
1814 : {
1815 0 : Reference< chart2::data::XLabeledDataSequence > xLS(aSequences[nIdx]);
1816 0 : if( xLS.is() )
1817 : {
1818 0 : bool bThisIsCategories = false;
1819 0 : if(!bHasCategories)
1820 : {
1821 0 : Reference< beans::XPropertySet > xSeqProp( xLS->getValues(), uno::UNO_QUERY );
1822 0 : OUString aRole;
1823 0 : if( xSeqProp.is() && (xSeqProp->getPropertyValue("Role") >>= aRole) &&
1824 0 : aRole == "categories" )
1825 0 : bThisIsCategories = bHasCategories = true;
1826 : }
1827 :
1828 0 : RangeAnalyzer aLabel,aValues;
1829 : // label
1830 0 : Reference< chart2::data::XDataSequence > xLabel( xLS->getLabel());
1831 0 : if( xLabel.is())
1832 : {
1833 0 : bFirstCellAsLabel = true;
1834 0 : vector<ScTokenRef> aTokens;
1835 0 : const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
1836 : ScRefTokenHelper::compileRangeRepresentation(
1837 0 : aTokens, xLabel->getSourceRangeRepresentation(), m_pDocument, cSep, m_pDocument->GetGrammar(), true);
1838 0 : aLabel.initRangeAnalyzer(aTokens);
1839 0 : vector<ScTokenRef>::const_iterator itr = aTokens.begin(), itrEnd = aTokens.end();
1840 0 : for (; itr != itrEnd; ++itr)
1841 : {
1842 0 : ScRefTokenHelper::join(aAllTokens, *itr, ScAddress());
1843 0 : if(!bThisIsCategories)
1844 0 : ScRefTokenHelper::join(aAllSeriesLabelTokens, *itr, ScAddress());
1845 : }
1846 0 : if(bThisIsCategories)
1847 0 : bHasCategoriesLabels=true;
1848 : }
1849 : // values
1850 0 : Reference< chart2::data::XDataSequence > xValues( xLS->getValues());
1851 0 : if( xValues.is())
1852 : {
1853 0 : vector<ScTokenRef> aTokens;
1854 0 : const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
1855 : ScRefTokenHelper::compileRangeRepresentation(
1856 0 : aTokens, xValues->getSourceRangeRepresentation(), m_pDocument, cSep, m_pDocument->GetGrammar(), true);
1857 0 : aValues.initRangeAnalyzer(aTokens);
1858 0 : vector<ScTokenRef>::const_iterator itr = aTokens.begin(), itrEnd = aTokens.end();
1859 0 : for (; itr != itrEnd; ++itr)
1860 : {
1861 0 : ScRefTokenHelper::join(aAllTokens, *itr, ScAddress());
1862 0 : if(bThisIsCategories)
1863 0 : ScRefTokenHelper::join(aAllCategoriesValuesTokens, *itr, ScAddress());
1864 0 : }
1865 : }
1866 : //detect row source
1867 0 : if(!bThisIsCategories || nCount==1) //categories might span multiple rows *and* columns, so they should be used for detection only if nothing else is available
1868 : {
1869 0 : if (!bRowSourceAmbiguous)
1870 : {
1871 0 : aValues.analyzeRange(nDataInRows,nDataInCols,bRowSourceAmbiguous);
1872 0 : aLabel.analyzeRange(nDataInRows,nDataInCols,bRowSourceAmbiguous);
1873 0 : if (nDataInRows > 1 && nDataInCols > 1)
1874 0 : bRowSourceAmbiguous = true;
1875 0 : else if( !bRowSourceAmbiguous && !nDataInRows && !nDataInCols )
1876 : {
1877 0 : if( aValues.inSameSingleColumn( aLabel ) )
1878 0 : nDataInCols++;
1879 0 : else if( aValues.inSameSingleRow( aLabel ) )
1880 0 : nDataInRows++;
1881 : else
1882 : {
1883 : //#i86188# also detect a single column split into rows correctly
1884 0 : if( aValues.inSameSingleColumn( aPrevValues ) )
1885 0 : nDataInRows++;
1886 0 : else if( aValues.inSameSingleRow( aPrevValues ) )
1887 0 : nDataInCols++;
1888 0 : else if( aLabel.inSameSingleColumn( aPrevLabel ) )
1889 0 : nDataInRows++;
1890 0 : else if( aLabel.inSameSingleRow( aPrevLabel ) )
1891 0 : nDataInCols++;
1892 : }
1893 : }
1894 : }
1895 : }
1896 0 : aPrevValues=aValues;
1897 0 : aPrevLabel=aLabel;
1898 : }
1899 0 : }
1900 :
1901 0 : if (!bRowSourceAmbiguous)
1902 : {
1903 0 : bRowSourceDetected = true;
1904 : eRowSource = ( nDataInRows > 0
1905 : ? chart::ChartDataRowSource_ROWS
1906 0 : : chart::ChartDataRowSource_COLUMNS );
1907 : }
1908 : else
1909 : {
1910 : // set DataRowSource to the better of the two ambiguities
1911 : eRowSource = ( nDataInRows > nDataInCols
1912 : ? chart::ChartDataRowSource_ROWS
1913 0 : : chart::ChartDataRowSource_COLUMNS );
1914 0 : }
1915 :
1916 : }
1917 :
1918 : // TableNumberList
1919 : {
1920 0 : list<SCTAB> aTableNumList;
1921 0 : InsertTabNumber func;
1922 0 : func = ::std::for_each(aAllTokens.begin(), aAllTokens.end(), func);
1923 0 : func.getList(aTableNumList);
1924 : aResult.push_back(
1925 : beans::PropertyValue( OUString("TableNumberList"), -1,
1926 : uno::makeAny( lcl_createTableNumberList( aTableNumList ) ),
1927 0 : beans::PropertyState_DIRECT_VALUE ));
1928 : }
1929 :
1930 : // DataRowSource (calculated before)
1931 0 : if( bRowSourceDetected )
1932 : {
1933 : aResult.push_back(
1934 : beans::PropertyValue( OUString("DataRowSource"), -1,
1935 0 : uno::makeAny( eRowSource ), beans::PropertyState_DIRECT_VALUE ));
1936 : }
1937 :
1938 : // HasCategories
1939 0 : if( bRowSourceDetected )
1940 : {
1941 : aResult.push_back(
1942 : beans::PropertyValue( OUString("HasCategories"), -1,
1943 0 : uno::makeAny( bHasCategories ), beans::PropertyState_DIRECT_VALUE ));
1944 : }
1945 :
1946 : // FirstCellAsLabel
1947 0 : if( bRowSourceDetected )
1948 : {
1949 : aResult.push_back(
1950 : beans::PropertyValue( OUString("FirstCellAsLabel"), -1,
1951 0 : uno::makeAny( bFirstCellAsLabel ), beans::PropertyState_DIRECT_VALUE ));
1952 : }
1953 :
1954 : // Add the left upper corner to the range if it is missing.
1955 0 : if (bRowSourceDetected && bFirstCellAsLabel && bHasCategories && !bHasCategoriesLabels )
1956 : {
1957 0 : RangeAnalyzer aTop,aLeft;
1958 0 : if( eRowSource==chart::ChartDataRowSource_COLUMNS )
1959 : {
1960 0 : aTop.initRangeAnalyzer(aAllSeriesLabelTokens);
1961 0 : aLeft.initRangeAnalyzer(aAllCategoriesValuesTokens);
1962 : }
1963 : else
1964 : {
1965 0 : aTop.initRangeAnalyzer(aAllCategoriesValuesTokens);
1966 0 : aLeft.initRangeAnalyzer(aAllSeriesLabelTokens);
1967 : }
1968 0 : lcl_addUpperLeftCornerIfMissing(aAllTokens, aTop.getRowCount(), aLeft.getColumnCount());//e.g. #i91212#
1969 : }
1970 :
1971 : // Get range string.
1972 0 : lcl_convertTokensToString(sRangeRep, aAllTokens, m_pDocument);
1973 :
1974 : // add cell range property
1975 : aResult.push_back(
1976 : beans::PropertyValue( OUString("CellRangeRepresentation"), -1,
1977 0 : uno::makeAny( sRangeRep ), beans::PropertyState_DIRECT_VALUE ));
1978 :
1979 : //Sequence Mapping
1980 0 : bool bSequencesReordered = true;//todo detect this above or detect this sequence mapping cheaper ...
1981 0 : if( bSequencesReordered && bRowSourceDetected )
1982 : {
1983 0 : bool bDifferentIndexes = false;
1984 :
1985 0 : std::vector< sal_Int32 > aSequenceMappingVector;
1986 :
1987 0 : uno::Reference< chart2::data::XDataSource > xCompareDataSource;
1988 : try
1989 : {
1990 0 : xCompareDataSource.set( this->createDataSource( lcl_VectorToSequence( aResult ) ) );
1991 : }
1992 0 : catch( const lang::IllegalArgumentException & )
1993 : {
1994 : // creation of data source to compare didn't work, so we cannot
1995 : // create a sequence mapping
1996 : }
1997 :
1998 0 : if( xDataSource.is() && xCompareDataSource.is() )
1999 : {
2000 : uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence> > aOldSequences(
2001 0 : xCompareDataSource->getDataSequences() );
2002 : uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aNewSequences(
2003 0 : xDataSource->getDataSequences());
2004 :
2005 0 : OUString aOldLabel;
2006 0 : OUString aNewLabel;
2007 0 : OUString aOldValues;
2008 0 : OUString aNewValues;
2009 0 : OUString aEmpty;
2010 :
2011 0 : for( sal_Int32 nNewIndex = 0; nNewIndex < aNewSequences.getLength(); nNewIndex++ )
2012 : {
2013 0 : uno::Reference< chart2::data::XLabeledDataSequence> xNew( aNewSequences[nNewIndex] );
2014 0 : for( sal_Int32 nOldIndex = 0; nOldIndex < aOldSequences.getLength(); nOldIndex++ )
2015 : {
2016 0 : uno::Reference< chart2::data::XLabeledDataSequence> xOld( aOldSequences[nOldIndex] );
2017 :
2018 0 : if( xOld.is() && xNew.is() )
2019 : {
2020 0 : aOldLabel = aNewLabel = aOldValues = aNewValues = aEmpty;
2021 0 : if( xOld.is() && xOld->getLabel().is() )
2022 0 : aOldLabel = xOld->getLabel()->getSourceRangeRepresentation();
2023 0 : if( xNew.is() && xNew->getLabel().is() )
2024 0 : aNewLabel = xNew->getLabel()->getSourceRangeRepresentation();
2025 0 : if( xOld.is() && xOld->getValues().is() )
2026 0 : aOldValues = xOld->getValues()->getSourceRangeRepresentation();
2027 0 : if( xNew.is() && xNew->getValues().is() )
2028 0 : aNewValues = xNew->getValues()->getSourceRangeRepresentation();
2029 :
2030 0 : if( aOldLabel.equals(aNewLabel)
2031 0 : && ( aOldValues.equals(aNewValues) ) )
2032 : {
2033 0 : if( nOldIndex!=nNewIndex )
2034 0 : bDifferentIndexes = true;
2035 0 : aSequenceMappingVector.push_back(nOldIndex);
2036 0 : break;
2037 : }
2038 : }
2039 0 : }
2040 0 : }
2041 : }
2042 :
2043 0 : if( bDifferentIndexes && !aSequenceMappingVector.empty() )
2044 : {
2045 : aResult.push_back(
2046 : beans::PropertyValue( OUString("SequenceMapping"), -1,
2047 : uno::makeAny( lcl_VectorToSequence(aSequenceMappingVector) )
2048 0 : , beans::PropertyState_DIRECT_VALUE ));
2049 0 : }
2050 : }
2051 :
2052 0 : return lcl_VectorToSequence( aResult );
2053 : }
2054 :
2055 0 : sal_Bool SAL_CALL ScChart2DataProvider::createDataSequenceByRangeRepresentationPossible( const OUString& aRangeRepresentation )
2056 : throw (uno::RuntimeException, std::exception)
2057 : {
2058 0 : SolarMutexGuard aGuard;
2059 0 : if( ! m_pDocument )
2060 0 : return false;
2061 :
2062 0 : vector<ScTokenRef> aTokens;
2063 0 : const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
2064 : ScRefTokenHelper::compileRangeRepresentation(
2065 0 : aTokens, aRangeRepresentation, m_pDocument, cSep, m_pDocument->GetGrammar(), true);
2066 0 : return !aTokens.empty();
2067 : }
2068 :
2069 : uno::Reference< chart2::data::XDataSequence > SAL_CALL
2070 0 : ScChart2DataProvider::createDataSequenceByRangeRepresentation(
2071 : const OUString& aRangeRepresentation )
2072 : throw (lang::IllegalArgumentException,
2073 : uno::RuntimeException, std::exception)
2074 : {
2075 0 : SolarMutexGuard aGuard;
2076 0 : uno::Reference< chart2::data::XDataSequence > xResult;
2077 :
2078 : OSL_ENSURE( m_pDocument, "No Document -> no createDataSequenceByRangeRepresentation" );
2079 0 : if(!m_pDocument || aRangeRepresentation.isEmpty())
2080 0 : return xResult;
2081 :
2082 0 : vector<ScTokenRef> aRefTokens;
2083 0 : const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
2084 : ScRefTokenHelper::compileRangeRepresentation(
2085 0 : aRefTokens, aRangeRepresentation, m_pDocument, cSep, m_pDocument->GetGrammar(), true);
2086 0 : if (aRefTokens.empty())
2087 0 : return xResult;
2088 :
2089 0 : shrinkToDataRange(m_pDocument, aRefTokens);
2090 :
2091 : // ScChart2DataSequence manages the life cycle of pRefTokens.
2092 0 : vector<ScTokenRef>* pRefTokens = new vector<ScTokenRef>();
2093 0 : pRefTokens->swap(aRefTokens);
2094 0 : xResult.set(new ScChart2DataSequence(m_pDocument, this, pRefTokens, m_bIncludeHiddenCells));
2095 :
2096 0 : return xResult;
2097 : }
2098 :
2099 0 : uno::Reference< sheet::XRangeSelection > SAL_CALL ScChart2DataProvider::getRangeSelection()
2100 : throw (uno::RuntimeException, std::exception)
2101 : {
2102 0 : uno::Reference< sheet::XRangeSelection > xResult;
2103 :
2104 0 : uno::Reference< frame::XModel > xModel( lcl_GetXModel( m_pDocument ));
2105 0 : if( xModel.is())
2106 0 : xResult.set( xModel->getCurrentController(), uno::UNO_QUERY );
2107 :
2108 0 : return xResult;
2109 : }
2110 :
2111 0 : sal_Bool SAL_CALL ScChart2DataProvider::createDataSequenceByFormulaTokensPossible(
2112 : const Sequence<sheet::FormulaToken>& aTokens )
2113 : throw (uno::RuntimeException, std::exception)
2114 : {
2115 0 : if (aTokens.getLength() <= 0)
2116 0 : return false;
2117 :
2118 0 : ScTokenArray aCode;
2119 0 : if (!ScTokenConversion::ConvertToTokenArray(*m_pDocument, aCode, aTokens))
2120 0 : return false;
2121 :
2122 0 : sal_uInt16 n = aCode.GetLen();
2123 0 : if (!n)
2124 0 : return false;
2125 :
2126 0 : const formula::FormulaToken* pFirst = aCode.First();
2127 0 : const formula::FormulaToken* pLast = aCode.GetArray()[n-1];
2128 0 : for (const formula::FormulaToken* p = aCode.First(); p; p = aCode.Next())
2129 : {
2130 0 : switch (p->GetType())
2131 : {
2132 : case svSep:
2133 : {
2134 0 : switch (p->GetOpCode())
2135 : {
2136 : case ocSep:
2137 : // separators are allowed.
2138 0 : break;
2139 : case ocOpen:
2140 0 : if (p != pFirst)
2141 : // open paran is allowed only as the first token.
2142 0 : return false;
2143 0 : break;
2144 : case ocClose:
2145 0 : if (p != pLast)
2146 : // close paren is allowed only as the last token.
2147 0 : return false;
2148 0 : break;
2149 : default:
2150 0 : return false;
2151 : }
2152 : }
2153 0 : break;
2154 : case svSingleRef:
2155 : case svDoubleRef:
2156 : case svExternalSingleRef:
2157 : case svExternalDoubleRef:
2158 0 : break;
2159 : default:
2160 0 : return false;
2161 : }
2162 : }
2163 :
2164 0 : return true;
2165 : }
2166 :
2167 : Reference<chart2::data::XDataSequence> SAL_CALL
2168 0 : ScChart2DataProvider::createDataSequenceByFormulaTokens(
2169 : const Sequence<sheet::FormulaToken>& aTokens )
2170 : throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
2171 : {
2172 0 : Reference<chart2::data::XDataSequence> xResult;
2173 0 : if (aTokens.getLength() <= 0)
2174 0 : return xResult;
2175 :
2176 0 : ScTokenArray aCode;
2177 0 : if (!ScTokenConversion::ConvertToTokenArray(*m_pDocument, aCode, aTokens))
2178 0 : return xResult;
2179 :
2180 0 : sal_uInt16 n = aCode.GetLen();
2181 0 : if (!n)
2182 0 : return xResult;
2183 :
2184 0 : vector<ScTokenRef> aRefTokens;
2185 0 : const formula::FormulaToken* pFirst = aCode.First();
2186 0 : const formula::FormulaToken* pLast = aCode.GetArray()[n-1];
2187 0 : for (const formula::FormulaToken* p = aCode.First(); p; p = aCode.Next())
2188 : {
2189 0 : switch (p->GetType())
2190 : {
2191 : case svSep:
2192 : {
2193 0 : switch (p->GetOpCode())
2194 : {
2195 : case ocSep:
2196 : // separators are allowed.
2197 0 : break;
2198 : case ocOpen:
2199 0 : if (p != pFirst)
2200 : // open paran is allowed only as the first token.
2201 0 : throw lang::IllegalArgumentException();
2202 0 : break;
2203 : case ocClose:
2204 0 : if (p != pLast)
2205 : // close paren is allowed only as the last token.
2206 0 : throw lang::IllegalArgumentException();
2207 0 : break;
2208 : default:
2209 0 : throw lang::IllegalArgumentException();
2210 : }
2211 : }
2212 0 : break;
2213 : case svString:
2214 : case svSingleRef:
2215 : case svDoubleRef:
2216 : case svExternalSingleRef:
2217 : case svExternalDoubleRef:
2218 : {
2219 0 : ScTokenRef pNew(static_cast<ScToken*>(p->Clone()));
2220 0 : aRefTokens.push_back(pNew);
2221 : }
2222 0 : break;
2223 : default:
2224 0 : throw lang::IllegalArgumentException();
2225 : }
2226 : }
2227 :
2228 0 : if (aRefTokens.empty())
2229 0 : return xResult;
2230 :
2231 0 : shrinkToDataRange(m_pDocument, aRefTokens);
2232 :
2233 : // ScChart2DataSequence manages the life cycle of pRefTokens.
2234 0 : vector<ScTokenRef>* pRefTokens = new vector<ScTokenRef>();
2235 0 : pRefTokens->swap(aRefTokens);
2236 0 : xResult.set(new ScChart2DataSequence(m_pDocument, this, pRefTokens, m_bIncludeHiddenCells));
2237 0 : return xResult;
2238 : }
2239 :
2240 : // XRangeXMLConversion ---------------------------------------------------
2241 :
2242 0 : OUString SAL_CALL ScChart2DataProvider::convertRangeToXML( const OUString& sRangeRepresentation )
2243 : throw ( uno::RuntimeException, lang::IllegalArgumentException, std::exception )
2244 : {
2245 0 : OUString aRet;
2246 0 : if (!m_pDocument)
2247 0 : return aRet;
2248 :
2249 0 : if (sRangeRepresentation.isEmpty())
2250 : // Empty data range is allowed.
2251 0 : return aRet;
2252 :
2253 0 : vector<ScTokenRef> aRefTokens;
2254 0 : const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
2255 : ScRefTokenHelper::compileRangeRepresentation(
2256 0 : aRefTokens, sRangeRepresentation, m_pDocument, cSep, m_pDocument->GetGrammar(), true);
2257 0 : if (aRefTokens.empty())
2258 0 : throw lang::IllegalArgumentException();
2259 :
2260 0 : Tokens2RangeStringXML converter(m_pDocument);
2261 0 : converter = ::std::for_each(aRefTokens.begin(), aRefTokens.end(), converter);
2262 0 : converter.getString(aRet);
2263 :
2264 0 : return aRet;
2265 : }
2266 :
2267 0 : OUString SAL_CALL ScChart2DataProvider::convertRangeFromXML( const OUString& sXMLRange )
2268 : throw ( uno::RuntimeException, lang::IllegalArgumentException, std::exception )
2269 : {
2270 0 : const sal_Unicode cSep = ' ';
2271 0 : const sal_Unicode cQuote = '\'';
2272 :
2273 0 : if (!m_pDocument)
2274 : {
2275 : // #i74062# When loading flat XML, this is called before the referenced sheets are in the document,
2276 : // so the conversion has to take place directly with the strings, without looking up the sheets.
2277 :
2278 0 : OUStringBuffer sRet;
2279 0 : sal_Int32 nOffset = 0;
2280 0 : while( nOffset >= 0 )
2281 : {
2282 0 : OUString sToken;
2283 0 : ScRangeStringConverter::GetTokenByOffset( sToken, sXMLRange, nOffset, cSep, cQuote );
2284 0 : if( nOffset >= 0 )
2285 : {
2286 : // convert one address (remove dots)
2287 :
2288 0 : OUString aUIString(sToken);
2289 :
2290 0 : sal_Int32 nIndex = ScRangeStringConverter::IndexOf( sToken, ':', 0, cQuote );
2291 0 : if ( nIndex >= 0 && nIndex < aUIString.getLength() - 1 &&
2292 0 : aUIString[nIndex + 1] == '.' )
2293 0 : aUIString = aUIString.replaceAt( nIndex + 1, 1, "" );
2294 :
2295 0 : if ( aUIString[0] == '.' )
2296 0 : aUIString = aUIString.copy( 1 );
2297 :
2298 0 : if( !sRet.isEmpty() )
2299 0 : sRet.append( ';' );
2300 0 : sRet.append( aUIString );
2301 : }
2302 0 : }
2303 :
2304 0 : return sRet.makeStringAndClear();
2305 : }
2306 :
2307 0 : OUString aRet;
2308 0 : ScRangeStringConverter::GetStringFromXMLRangeString(aRet, sXMLRange, m_pDocument);
2309 0 : return aRet;
2310 : }
2311 :
2312 : // DataProvider XPropertySet -------------------------------------------------
2313 :
2314 : uno::Reference< beans::XPropertySetInfo> SAL_CALL
2315 0 : ScChart2DataProvider::getPropertySetInfo() throw( uno::RuntimeException, std::exception)
2316 : {
2317 0 : SolarMutexGuard aGuard;
2318 : static uno::Reference<beans::XPropertySetInfo> aRef =
2319 0 : new SfxItemPropertySetInfo( m_aPropSet.getPropertyMap() );
2320 0 : return aRef;
2321 : }
2322 :
2323 :
2324 0 : void SAL_CALL ScChart2DataProvider::setPropertyValue(
2325 : const OUString& rPropertyName, const uno::Any& rValue)
2326 : throw( beans::UnknownPropertyException,
2327 : beans::PropertyVetoException,
2328 : lang::IllegalArgumentException,
2329 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2330 : {
2331 0 : if ( rPropertyName == SC_UNONAME_INCLUDEHIDDENCELLS )
2332 : {
2333 0 : if ( !(rValue >>= m_bIncludeHiddenCells))
2334 0 : throw lang::IllegalArgumentException();
2335 : }
2336 : else
2337 0 : throw beans::UnknownPropertyException();
2338 0 : }
2339 :
2340 :
2341 0 : uno::Any SAL_CALL ScChart2DataProvider::getPropertyValue(
2342 : const OUString& rPropertyName)
2343 : throw( beans::UnknownPropertyException,
2344 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2345 : {
2346 0 : uno::Any aRet;
2347 0 : if ( rPropertyName == SC_UNONAME_INCLUDEHIDDENCELLS )
2348 0 : aRet <<= m_bIncludeHiddenCells;
2349 0 : else if (rPropertyName == SC_UNONAME_USE_INTERNAL_DATA_PROVIDER)
2350 : {
2351 : // This is a read-only property.
2352 0 : aRet <<= static_cast<sal_Bool>(m_pDocument->PastingDrawFromOtherDoc());
2353 : }
2354 : else
2355 0 : throw beans::UnknownPropertyException();
2356 0 : return aRet;
2357 : }
2358 :
2359 :
2360 0 : void SAL_CALL ScChart2DataProvider::addPropertyChangeListener(
2361 : const OUString& /*rPropertyName*/,
2362 : const uno::Reference< beans::XPropertyChangeListener>& /*xListener*/)
2363 : throw( beans::UnknownPropertyException,
2364 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2365 : {
2366 : OSL_FAIL( "Not yet implemented" );
2367 0 : }
2368 :
2369 :
2370 0 : void SAL_CALL ScChart2DataProvider::removePropertyChangeListener(
2371 : const OUString& /*rPropertyName*/,
2372 : const uno::Reference< beans::XPropertyChangeListener>& /*rListener*/)
2373 : throw( beans::UnknownPropertyException,
2374 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2375 : {
2376 : OSL_FAIL( "Not yet implemented" );
2377 0 : }
2378 :
2379 :
2380 0 : void SAL_CALL ScChart2DataProvider::addVetoableChangeListener(
2381 : const OUString& /*rPropertyName*/,
2382 : const uno::Reference< beans::XVetoableChangeListener>& /*rListener*/)
2383 : throw( beans::UnknownPropertyException,
2384 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2385 : {
2386 : OSL_FAIL( "Not yet implemented" );
2387 0 : }
2388 :
2389 :
2390 0 : void SAL_CALL ScChart2DataProvider::removeVetoableChangeListener(
2391 : const OUString& /*rPropertyName*/,
2392 : const uno::Reference< beans::XVetoableChangeListener>& /*rListener*/ )
2393 : throw( beans::UnknownPropertyException,
2394 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2395 : {
2396 : OSL_FAIL( "Not yet implemented" );
2397 0 : }
2398 :
2399 : // DataSource ================================================================
2400 :
2401 0 : ScChart2DataSource::ScChart2DataSource( ScDocument* pDoc)
2402 0 : : m_pDocument( pDoc)
2403 : {
2404 0 : if ( m_pDocument )
2405 0 : m_pDocument->AddUnoObject( *this);
2406 0 : }
2407 :
2408 :
2409 0 : ScChart2DataSource::~ScChart2DataSource()
2410 : {
2411 0 : if ( m_pDocument )
2412 0 : m_pDocument->RemoveUnoObject( *this);
2413 0 : }
2414 :
2415 :
2416 0 : void ScChart2DataSource::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
2417 : {
2418 0 : if ( rHint.ISA( SfxSimpleHint ) &&
2419 0 : ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
2420 : {
2421 0 : m_pDocument = NULL;
2422 : }
2423 0 : }
2424 :
2425 :
2426 : uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence> > SAL_CALL
2427 0 : ScChart2DataSource::getDataSequences() throw ( uno::RuntimeException, std::exception)
2428 : {
2429 0 : SolarMutexGuard aGuard;
2430 :
2431 0 : LabeledList::const_iterator aItr(m_aLabeledSequences.begin());
2432 0 : LabeledList::const_iterator aEndItr(m_aLabeledSequences.end());
2433 :
2434 0 : uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aRet(m_aLabeledSequences.size());
2435 :
2436 0 : sal_Int32 i = 0;
2437 0 : while (aItr != aEndItr)
2438 : {
2439 0 : aRet[i] = *aItr;
2440 0 : ++i;
2441 0 : ++aItr;
2442 : }
2443 :
2444 0 : return aRet;
2445 : }
2446 :
2447 0 : void ScChart2DataSource::AddLabeledSequence(const uno::Reference < chart2::data::XLabeledDataSequence >& xNew)
2448 : {
2449 0 : m_aLabeledSequences.push_back(xNew);
2450 0 : }
2451 :
2452 : // DataSequence ==============================================================
2453 :
2454 0 : ScChart2DataSequence::Item::Item() :
2455 0 : mfValue(0.0), mbIsValue(false)
2456 : {
2457 0 : ::rtl::math::setNan(&mfValue);
2458 0 : }
2459 :
2460 0 : ScChart2DataSequence::HiddenRangeListener::HiddenRangeListener(ScChart2DataSequence& rParent) :
2461 0 : mrParent(rParent)
2462 : {
2463 0 : }
2464 :
2465 0 : ScChart2DataSequence::HiddenRangeListener::~HiddenRangeListener()
2466 : {
2467 0 : }
2468 :
2469 0 : void ScChart2DataSequence::HiddenRangeListener::notify()
2470 : {
2471 0 : mrParent.setDataChangedHint(true);
2472 0 : }
2473 :
2474 0 : ScChart2DataSequence::ScChart2DataSequence( ScDocument* pDoc,
2475 : const uno::Reference < chart2::data::XDataProvider >& xDP,
2476 : vector<ScTokenRef>* pTokens,
2477 : bool bIncludeHiddenCells )
2478 : : m_bIncludeHiddenCells( bIncludeHiddenCells)
2479 : , m_nObjectId( 0 )
2480 : , m_pDocument( pDoc)
2481 : , m_pTokens(pTokens)
2482 : , m_pRangeIndices(NULL)
2483 : , m_pExtRefListener(NULL)
2484 : , m_xDataProvider( xDP)
2485 : , m_aPropSet(lcl_GetDataSequencePropertyMap())
2486 : , m_pHiddenListener(NULL)
2487 : , m_pValueListener( NULL )
2488 : , m_bGotDataChangedHint(false)
2489 : , m_bExtDataRebuildQueued(false)
2490 : , mbTimeBased(false)
2491 : , mnTimeBasedStart(0)
2492 : , mnTimeBasedEnd(0)
2493 0 : , mnCurrentTab(0)
2494 : {
2495 : OSL_ENSURE(pTokens, "reference token list is null");
2496 :
2497 0 : if ( m_pDocument )
2498 : {
2499 0 : m_pDocument->AddUnoObject( *this);
2500 0 : m_nObjectId = m_pDocument->GetNewUnoId();
2501 : }
2502 : // FIXME: real implementation of identifier and it's mapping to ranges.
2503 : // Reuse ScChartListener?
2504 :
2505 : // BM: don't use names of named ranges but the UI range strings
2506 : // String aStr;
2507 : // rRangeList->Format( aStr, SCR_ABS_3D, m_pDocument );
2508 : // m_aIdentifier = aStr;
2509 :
2510 : // m_aIdentifier = "ID_";
2511 : // static sal_Int32 nID = 0;
2512 : // m_aIdentifier += OUString::valueOf( ++nID);
2513 0 : }
2514 :
2515 0 : ScChart2DataSequence::~ScChart2DataSequence()
2516 : {
2517 0 : if ( m_pDocument )
2518 : {
2519 0 : m_pDocument->RemoveUnoObject( *this);
2520 0 : if (m_pHiddenListener.get())
2521 : {
2522 0 : ScChartListenerCollection* pCLC = m_pDocument->GetChartListenerCollection();
2523 0 : if (pCLC)
2524 0 : pCLC->EndListeningHiddenRange(m_pHiddenListener.get());
2525 : }
2526 0 : StopListeningToAllExternalRefs();
2527 : }
2528 :
2529 0 : delete m_pValueListener;
2530 0 : }
2531 :
2532 0 : void ScChart2DataSequence::RefChanged()
2533 : {
2534 0 : if( m_pValueListener && !m_aValueListeners.empty() )
2535 : {
2536 0 : m_pValueListener->EndListeningAll();
2537 :
2538 0 : if( m_pDocument )
2539 : {
2540 0 : ScChartListenerCollection* pCLC = NULL;
2541 0 : if (m_pHiddenListener.get())
2542 : {
2543 0 : pCLC = m_pDocument->GetChartListenerCollection();
2544 0 : if (pCLC)
2545 0 : pCLC->EndListeningHiddenRange(m_pHiddenListener.get());
2546 : }
2547 :
2548 0 : vector<ScTokenRef>::const_iterator itr = m_pTokens->begin(), itrEnd = m_pTokens->end();
2549 0 : for (; itr != itrEnd; ++itr)
2550 : {
2551 0 : ScRange aRange;
2552 0 : if (!ScRefTokenHelper::getRangeFromToken(aRange, *itr, ScAddress()))
2553 0 : continue;
2554 :
2555 0 : m_pDocument->StartListeningArea(aRange, m_pValueListener);
2556 0 : if (pCLC)
2557 0 : pCLC->StartListeningHiddenRange(aRange, m_pHiddenListener.get());
2558 : }
2559 : }
2560 : }
2561 0 : }
2562 :
2563 0 : void ScChart2DataSequence::BuildDataCache()
2564 : {
2565 0 : m_bExtDataRebuildQueued = false;
2566 :
2567 0 : if (!m_aDataArray.empty())
2568 0 : return;
2569 :
2570 0 : if (!m_pTokens.get())
2571 : {
2572 : OSL_FAIL("m_pTokens == NULL! Something is wrong.");
2573 0 : return;
2574 : }
2575 :
2576 0 : StopListeningToAllExternalRefs();
2577 :
2578 0 : ::std::list<sal_Int32> aHiddenValues;
2579 0 : sal_Int32 nDataCount = 0;
2580 0 : sal_Int32 nHiddenValueCount = 0;
2581 :
2582 0 : for (vector<ScTokenRef>::const_iterator itr = m_pTokens->begin(), itrEnd = m_pTokens->end();
2583 : itr != itrEnd; ++itr)
2584 : {
2585 0 : if (ScRefTokenHelper::isExternalRef(*itr))
2586 : {
2587 0 : nDataCount += FillCacheFromExternalRef(*itr);
2588 : }
2589 : else
2590 : {
2591 0 : ScRange aRange;
2592 0 : if (!ScRefTokenHelper::getRangeFromToken(aRange, *itr, ScAddress()))
2593 0 : continue;
2594 :
2595 0 : SCCOL nLastCol = -1;
2596 0 : SCROW nLastRow = -1;
2597 0 : for (SCTAB nTab = aRange.aStart.Tab(); nTab <= aRange.aEnd.Tab(); ++nTab)
2598 : {
2599 0 : for (SCCOL nCol = aRange.aStart.Col(); nCol <= aRange.aEnd.Col(); ++nCol)
2600 : {
2601 0 : for (SCROW nRow = aRange.aStart.Row(); nRow <= aRange.aEnd.Row(); ++nRow)
2602 : {
2603 0 : bool bColHidden = m_pDocument->ColHidden(nCol, nTab, NULL, &nLastCol);
2604 0 : bool bRowHidden = m_pDocument->RowHidden(nRow, nTab, NULL, &nLastRow);
2605 :
2606 0 : if (bColHidden || bRowHidden)
2607 : {
2608 : // hidden cell
2609 0 : ++nHiddenValueCount;
2610 0 : aHiddenValues.push_back(nDataCount-1);
2611 :
2612 0 : if( !m_bIncludeHiddenCells )
2613 0 : continue;
2614 : }
2615 :
2616 0 : m_aDataArray.push_back(Item());
2617 0 : Item& rItem = m_aDataArray.back();
2618 0 : ++nDataCount;
2619 :
2620 0 : ScAddress aAdr(nCol, nRow, nTab);
2621 0 : rItem.maString = m_pDocument->GetString(aAdr);
2622 :
2623 0 : switch (m_pDocument->GetCellType(aAdr))
2624 : {
2625 : case CELLTYPE_VALUE:
2626 0 : rItem.mfValue = m_pDocument->GetValue(aAdr);
2627 0 : rItem.mbIsValue = true;
2628 0 : break;
2629 : case CELLTYPE_FORMULA:
2630 : {
2631 0 : ScFormulaCell* pFCell = m_pDocument->GetFormulaCell(aAdr);
2632 0 : if (!pFCell)
2633 0 : break;
2634 0 : sal_uInt16 nErr = pFCell->GetErrCode();
2635 0 : if (nErr)
2636 0 : break;
2637 :
2638 0 : if (pFCell->IsValue())
2639 : {
2640 0 : rItem.mfValue = pFCell->GetValue();
2641 0 : rItem.mbIsValue = true;
2642 : }
2643 : }
2644 0 : break;
2645 : case CELLTYPE_EDIT:
2646 : case CELLTYPE_NONE:
2647 : case CELLTYPE_STRING:
2648 : default:
2649 : ; // do nothing
2650 : }
2651 : }
2652 : }
2653 : }
2654 : }
2655 : }
2656 :
2657 : // convert the hidden cell list to sequence.
2658 0 : m_aHiddenValues.realloc(nHiddenValueCount);
2659 0 : sal_Int32* pArr = m_aHiddenValues.getArray();
2660 0 : ::std::list<sal_Int32>::const_iterator itr = aHiddenValues.begin(), itrEnd = aHiddenValues.end();
2661 0 : for (;itr != itrEnd; ++itr, ++pArr)
2662 0 : *pArr = *itr;
2663 :
2664 : // Clear the data series cache when the array is re-built.
2665 0 : m_aMixedDataCache.realloc(0);
2666 : }
2667 :
2668 0 : void ScChart2DataSequence::RebuildDataCache()
2669 : {
2670 0 : if (!m_bExtDataRebuildQueued)
2671 : {
2672 0 : m_aDataArray.clear();
2673 0 : m_pDocument->BroadcastUno(ScHint(SC_HINT_DATACHANGED, ScAddress()));
2674 0 : m_bExtDataRebuildQueued = true;
2675 0 : m_bGotDataChangedHint = true;
2676 : }
2677 0 : }
2678 :
2679 0 : sal_Int32 ScChart2DataSequence::FillCacheFromExternalRef(const ScTokenRef& pToken)
2680 : {
2681 0 : ScExternalRefManager* pRefMgr = m_pDocument->GetExternalRefManager();
2682 0 : ScRange aRange;
2683 0 : if (!ScRefTokenHelper::getRangeFromToken(aRange, pToken, ScAddress(), true))
2684 0 : return 0;
2685 :
2686 0 : sal_uInt16 nFileId = pToken->GetIndex();
2687 0 : OUString aTabName = pToken->GetString().getString();
2688 0 : ScExternalRefCache::TokenArrayRef pArray = pRefMgr->getDoubleRefTokens(nFileId, aTabName, aRange, NULL);
2689 0 : if (!pArray)
2690 : // no external data exists for this range.
2691 0 : return 0;
2692 :
2693 : // Start listening for this external document.
2694 0 : ExternalRefListener* pExtRefListener = GetExtRefListener();
2695 0 : pRefMgr->addLinkListener(nFileId, pExtRefListener);
2696 0 : pExtRefListener->addFileId(nFileId);
2697 :
2698 0 : ScExternalRefCache::TableTypeRef pTable = pRefMgr->getCacheTable(nFileId, aTabName, false, NULL);
2699 0 : sal_Int32 nDataCount = 0;
2700 0 : for (FormulaToken* p = pArray->First(); p; p = pArray->Next())
2701 : {
2702 : // Cached external range is always represented as a single
2703 : // matrix token, although that might change in the future when
2704 : // we introduce a new token type to store multi-table range
2705 : // data.
2706 :
2707 0 : if (p->GetType() != svMatrix)
2708 : {
2709 : OSL_FAIL("Cached array is not a matrix token.");
2710 0 : continue;
2711 : }
2712 :
2713 0 : const ScMatrix* pMat = static_cast<ScToken*>(p)->GetMatrix();
2714 : SCSIZE nCSize, nRSize;
2715 0 : pMat->GetDimensions(nCSize, nRSize);
2716 0 : for (SCSIZE nC = 0; nC < nCSize; ++nC)
2717 : {
2718 0 : for (SCSIZE nR = 0; nR < nRSize; ++nR)
2719 : {
2720 0 : if (pMat->IsValue(nC, nR) || pMat->IsBoolean(nC, nR))
2721 : {
2722 0 : m_aDataArray.push_back(Item());
2723 0 : Item& rItem = m_aDataArray.back();
2724 0 : ++nDataCount;
2725 :
2726 0 : rItem.mbIsValue = true;
2727 0 : rItem.mfValue = pMat->GetDouble(nC, nR);
2728 :
2729 0 : SvNumberFormatter* pFormatter = m_pDocument->GetFormatTable();
2730 0 : if (pFormatter)
2731 : {
2732 0 : const double fVal = rItem.mfValue;
2733 0 : Color* pColor = NULL;
2734 0 : sal_uInt32 nFmt = 0;
2735 0 : if (pTable)
2736 : {
2737 : // Get the correct format index from the cache.
2738 0 : SCCOL nCol = aRange.aStart.Col() + static_cast<SCCOL>(nC);
2739 0 : SCROW nRow = aRange.aStart.Row() + static_cast<SCROW>(nR);
2740 0 : pTable->getCell(nCol, nRow, &nFmt);
2741 : }
2742 0 : pFormatter->GetOutputString(fVal, nFmt, rItem.maString, &pColor);
2743 : }
2744 : }
2745 0 : else if (pMat->IsString(nC, nR))
2746 : {
2747 0 : m_aDataArray.push_back(Item());
2748 0 : Item& rItem = m_aDataArray.back();
2749 0 : ++nDataCount;
2750 :
2751 0 : rItem.mbIsValue = false;
2752 0 : rItem.maString = pMat->GetString(nC, nR).getString();
2753 : }
2754 : }
2755 : }
2756 : }
2757 0 : return nDataCount;
2758 : }
2759 :
2760 0 : void ScChart2DataSequence::UpdateTokensFromRanges(const ScRangeList& rRanges)
2761 : {
2762 0 : if (!m_pRangeIndices.get())
2763 0 : return;
2764 :
2765 0 : for ( size_t i = 0, nCount = rRanges.size(); i < nCount; ++i )
2766 : {
2767 0 : ScTokenRef pToken;
2768 0 : const ScRange* pRange = rRanges[i];
2769 : OSL_ENSURE(pRange, "range object is NULL.");
2770 :
2771 0 : ScRefTokenHelper::getTokenFromRange(pToken, *pRange);
2772 0 : sal_uInt32 nOrigPos = (*m_pRangeIndices)[i];
2773 0 : (*m_pTokens)[nOrigPos] = pToken;
2774 0 : }
2775 :
2776 0 : RefChanged();
2777 :
2778 : // any change of the range address is broadcast to value (modify) listeners
2779 0 : if ( !m_aValueListeners.empty() )
2780 0 : m_bGotDataChangedHint = true;
2781 : }
2782 :
2783 0 : ScChart2DataSequence::ExternalRefListener* ScChart2DataSequence::GetExtRefListener()
2784 : {
2785 0 : if (!m_pExtRefListener.get())
2786 0 : m_pExtRefListener.reset(new ExternalRefListener(*this, m_pDocument));
2787 :
2788 0 : return m_pExtRefListener.get();
2789 : }
2790 :
2791 0 : void ScChart2DataSequence::StopListeningToAllExternalRefs()
2792 : {
2793 0 : if (!m_pExtRefListener.get())
2794 0 : return;
2795 :
2796 0 : const boost::unordered_set<sal_uInt16>& rFileIds = m_pExtRefListener->getAllFileIds();
2797 0 : boost::unordered_set<sal_uInt16>::const_iterator itr = rFileIds.begin(), itrEnd = rFileIds.end();
2798 0 : ScExternalRefManager* pRefMgr = m_pDocument->GetExternalRefManager();
2799 0 : for (; itr != itrEnd; ++itr)
2800 0 : pRefMgr->removeLinkListener(*itr, m_pExtRefListener.get());
2801 :
2802 0 : m_pExtRefListener.reset();
2803 : }
2804 :
2805 0 : void ScChart2DataSequence::CopyData(const ScChart2DataSequence& r)
2806 : {
2807 0 : if (!m_pDocument)
2808 : {
2809 : OSL_FAIL("document instance is NULL!?");
2810 0 : return;
2811 : }
2812 :
2813 0 : list<Item> aDataArray(r.m_aDataArray);
2814 0 : m_aDataArray.swap(aDataArray);
2815 :
2816 0 : m_aHiddenValues = r.m_aHiddenValues;
2817 0 : m_aRole = r.m_aRole;
2818 :
2819 0 : if (r.m_pRangeIndices.get())
2820 0 : m_pRangeIndices.reset(new vector<sal_uInt32>(*r.m_pRangeIndices));
2821 :
2822 0 : if (r.m_pExtRefListener.get())
2823 : {
2824 : // Re-register all external files that the old instance was
2825 : // listening to.
2826 :
2827 0 : ScExternalRefManager* pRefMgr = m_pDocument->GetExternalRefManager();
2828 0 : m_pExtRefListener.reset(new ExternalRefListener(*this, m_pDocument));
2829 0 : const boost::unordered_set<sal_uInt16>& rFileIds = r.m_pExtRefListener->getAllFileIds();
2830 0 : boost::unordered_set<sal_uInt16>::const_iterator itr = rFileIds.begin(), itrEnd = rFileIds.end();
2831 0 : for (; itr != itrEnd; ++itr)
2832 : {
2833 0 : pRefMgr->addLinkListener(*itr, m_pExtRefListener.get());
2834 0 : m_pExtRefListener->addFileId(*itr);
2835 : }
2836 0 : }
2837 : }
2838 :
2839 0 : void ScChart2DataSequence::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
2840 : {
2841 0 : if ( rHint.ISA( SfxSimpleHint ) )
2842 : {
2843 0 : sal_uLong nId = static_cast<const SfxSimpleHint&>(rHint).GetId();
2844 0 : if ( nId ==SFX_HINT_DYING )
2845 : {
2846 0 : m_pDocument = NULL;
2847 : }
2848 0 : else if ( nId == SFX_HINT_DATACHANGED )
2849 : {
2850 : // delayed broadcast as in ScCellRangesBase
2851 :
2852 0 : if ( m_bGotDataChangedHint && m_pDocument )
2853 : {
2854 0 : m_aDataArray.clear();
2855 0 : lang::EventObject aEvent;
2856 0 : aEvent.Source.set((cppu::OWeakObject*)this);
2857 :
2858 0 : if( m_pDocument )
2859 : {
2860 0 : for ( sal_uInt16 n=0; n<m_aValueListeners.size(); n++ )
2861 0 : m_pDocument->AddUnoListenerCall( m_aValueListeners[n], aEvent );
2862 : }
2863 :
2864 0 : m_bGotDataChangedHint = false;
2865 : }
2866 : }
2867 0 : else if ( nId == SC_HINT_CALCALL )
2868 : {
2869 : // broadcast from DoHardRecalc - set m_bGotDataChangedHint
2870 : // (SFX_HINT_DATACHANGED follows separately)
2871 :
2872 0 : if ( !m_aValueListeners.empty() )
2873 0 : m_bGotDataChangedHint = true;
2874 : }
2875 : }
2876 0 : else if ( rHint.ISA( ScUpdateRefHint ) )
2877 : {
2878 : // Create a range list from the token list, have the range list
2879 : // updated, and bring the change back to the token list.
2880 :
2881 0 : ScRangeList aRanges;
2882 0 : m_pRangeIndices.reset(new vector<sal_uInt32>());
2883 0 : vector<ScTokenRef>::const_iterator itrBeg = m_pTokens->begin(), itrEnd = m_pTokens->end();
2884 0 : for (vector<ScTokenRef>::const_iterator itr = itrBeg ;itr != itrEnd; ++itr)
2885 : {
2886 0 : if (!ScRefTokenHelper::isExternalRef(*itr))
2887 : {
2888 0 : ScRange aRange;
2889 0 : ScRefTokenHelper::getRangeFromToken(aRange, *itr, ScAddress());
2890 0 : aRanges.Append(aRange);
2891 0 : sal_uInt32 nPos = distance(itrBeg, itr);
2892 0 : m_pRangeIndices->push_back(nPos);
2893 : }
2894 : }
2895 :
2896 : OSL_ENSURE(m_pRangeIndices->size() == static_cast<size_t>(aRanges.size()),
2897 : "range list and range index list have different sizes.");
2898 :
2899 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2900 0 : auto_ptr<ScRangeList> pUndoRanges;
2901 : SAL_WNODEPRECATED_DECLARATIONS_POP
2902 0 : if ( m_pDocument->HasUnoRefUndo() )
2903 0 : pUndoRanges.reset(new ScRangeList(aRanges));
2904 :
2905 0 : const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint;
2906 : bool bChanged = aRanges.UpdateReference(
2907 0 : rRef.GetMode(), m_pDocument, rRef.GetRange(), rRef.GetDx(), rRef.GetDy(), rRef.GetDz());
2908 :
2909 0 : if (bChanged)
2910 : {
2911 : OSL_ENSURE(m_pRangeIndices->size() == aRanges.size(),
2912 : "range list and range index list have different sizes after the reference update.");
2913 :
2914 : // Bring the change back from the range list to the token list.
2915 0 : UpdateTokensFromRanges(aRanges);
2916 :
2917 0 : if (pUndoRanges.get())
2918 0 : m_pDocument->AddUnoRefChange(m_nObjectId, *pUndoRanges);
2919 0 : }
2920 : }
2921 0 : else if ( rHint.ISA( ScUnoRefUndoHint ) )
2922 : {
2923 0 : const ScUnoRefUndoHint& rUndoHint = static_cast<const ScUnoRefUndoHint&>(rHint);
2924 :
2925 : do
2926 : {
2927 0 : if (rUndoHint.GetObjectId() != m_nObjectId)
2928 0 : break;
2929 :
2930 : // The hint object provides the old ranges. Restore the old state
2931 : // from these ranges.
2932 :
2933 0 : if (!m_pRangeIndices.get() || m_pRangeIndices->empty())
2934 : {
2935 : OSL_FAIL(" faulty range indices");
2936 0 : break;
2937 : }
2938 :
2939 0 : const ScRangeList& rRanges = rUndoHint.GetRanges();
2940 :
2941 0 : size_t nCount = rRanges.size();
2942 0 : if (nCount != m_pRangeIndices->size())
2943 : {
2944 : OSL_FAIL("range count and range index count differ.");
2945 0 : break;
2946 : }
2947 :
2948 0 : UpdateTokensFromRanges(rRanges);
2949 : }
2950 : while (false);
2951 : }
2952 0 : }
2953 :
2954 :
2955 0 : IMPL_LINK( ScChart2DataSequence, ValueListenerHdl, SfxHint*, pHint )
2956 : {
2957 0 : if ( m_pDocument && pHint && pHint->ISA( SfxSimpleHint ) &&
2958 0 : ((const SfxSimpleHint*)pHint)->GetId() & SC_HINT_DATACHANGED)
2959 : {
2960 : // This may be called several times for a single change, if several formulas
2961 : // in the range are notified. So only a flag is set that is checked when
2962 : // SFX_HINT_DATACHANGED is received.
2963 :
2964 0 : setDataChangedHint(true);
2965 : }
2966 0 : return 0;
2967 : }
2968 :
2969 0 : ScChart2DataSequence::ExternalRefListener::ExternalRefListener(
2970 : ScChart2DataSequence& rParent, ScDocument* pDoc) :
2971 : ScExternalRefManager::LinkListener(),
2972 : mrParent(rParent),
2973 0 : mpDoc(pDoc)
2974 : {
2975 0 : }
2976 :
2977 0 : ScChart2DataSequence::ExternalRefListener::~ExternalRefListener()
2978 : {
2979 0 : if (!mpDoc || mpDoc->IsInDtorClear())
2980 : // The document is being destroyed. Do nothing.
2981 0 : return;
2982 :
2983 : // Make sure to remove all pointers to this object.
2984 0 : mpDoc->GetExternalRefManager()->removeLinkListener(this);
2985 0 : }
2986 :
2987 0 : void ScChart2DataSequence::ExternalRefListener::notify(sal_uInt16 nFileId, ScExternalRefManager::LinkUpdateType eType)
2988 : {
2989 0 : switch (eType)
2990 : {
2991 : case ScExternalRefManager::LINK_MODIFIED:
2992 : {
2993 0 : if (maFileIds.count(nFileId))
2994 : // We are listening to this external document.
2995 0 : mrParent.RebuildDataCache();
2996 : }
2997 0 : break;
2998 : case ScExternalRefManager::LINK_BROKEN:
2999 0 : removeFileId(nFileId);
3000 0 : break;
3001 : }
3002 0 : }
3003 :
3004 0 : void ScChart2DataSequence::ExternalRefListener::addFileId(sal_uInt16 nFileId)
3005 : {
3006 0 : maFileIds.insert(nFileId);
3007 0 : }
3008 :
3009 0 : void ScChart2DataSequence::ExternalRefListener::removeFileId(sal_uInt16 nFileId)
3010 : {
3011 0 : maFileIds.erase(nFileId);
3012 0 : }
3013 :
3014 0 : const boost::unordered_set<sal_uInt16>& ScChart2DataSequence::ExternalRefListener::getAllFileIds()
3015 : {
3016 0 : return maFileIds;
3017 : }
3018 :
3019 0 : uno::Sequence< uno::Any> SAL_CALL ScChart2DataSequence::getData()
3020 : throw (uno::RuntimeException, std::exception)
3021 : {
3022 0 : SolarMutexGuard aGuard;
3023 0 : if ( !m_pDocument)
3024 0 : throw uno::RuntimeException();
3025 :
3026 0 : BuildDataCache();
3027 :
3028 0 : if (!m_aMixedDataCache.getLength())
3029 : {
3030 : // Build a cache for the 1st time...
3031 :
3032 0 : sal_Int32 nCount = m_aDataArray.size();
3033 0 : m_aMixedDataCache.realloc(nCount);
3034 0 : uno::Any* pArr = m_aMixedDataCache.getArray();
3035 0 : ::std::list<Item>::const_iterator itr = m_aDataArray.begin(), itrEnd = m_aDataArray.end();
3036 0 : for (; itr != itrEnd; ++itr, ++pArr)
3037 : {
3038 0 : if (itr->mbIsValue)
3039 0 : *pArr <<= itr->mfValue;
3040 : else
3041 0 : *pArr <<= itr->maString;
3042 : }
3043 : }
3044 0 : return m_aMixedDataCache;
3045 : }
3046 :
3047 : // XNumericalDataSequence --------------------------------------------------
3048 :
3049 0 : uno::Sequence< double > SAL_CALL ScChart2DataSequence::getNumericalData()
3050 : throw (uno::RuntimeException, std::exception)
3051 : {
3052 0 : SolarMutexGuard aGuard;
3053 0 : if ( !m_pDocument)
3054 0 : throw uno::RuntimeException();
3055 :
3056 0 : BuildDataCache();
3057 :
3058 : double fNAN;
3059 0 : ::rtl::math::setNan(&fNAN);
3060 :
3061 0 : sal_Int32 nCount = m_aDataArray.size();
3062 0 : uno::Sequence<double> aSeq(nCount);
3063 0 : double* pArr = aSeq.getArray();
3064 0 : ::std::list<Item>::const_iterator itr = m_aDataArray.begin(), itrEnd = m_aDataArray.end();
3065 0 : for (; itr != itrEnd; ++itr, ++pArr)
3066 0 : *pArr = itr->mbIsValue ? itr->mfValue : fNAN;
3067 :
3068 0 : return aSeq;
3069 : }
3070 :
3071 : // XTextualDataSequence --------------------------------------------------
3072 :
3073 0 : uno::Sequence< OUString > SAL_CALL ScChart2DataSequence::getTextualData()
3074 : throw (uno::RuntimeException, std::exception)
3075 : {
3076 0 : SolarMutexGuard aGuard;
3077 0 : uno::Sequence<OUString> aSeq;
3078 0 : if ( !m_pDocument )
3079 0 : throw uno::RuntimeException();
3080 :
3081 0 : BuildDataCache();
3082 :
3083 0 : sal_Int32 nCount = m_aDataArray.size();
3084 0 : if ( nCount > 0 )
3085 : {
3086 0 : aSeq = uno::Sequence<OUString>(nCount);
3087 0 : OUString* pArr = aSeq.getArray();
3088 0 : ::std::list<Item>::const_iterator itr = m_aDataArray.begin(), itrEnd = m_aDataArray.end();
3089 0 : for(; itr != itrEnd; ++itr, ++pArr)
3090 0 : *pArr = itr->maString;
3091 : }
3092 0 : else if ( m_pTokens.get() && m_pTokens->front() )
3093 : {
3094 0 : if( m_pTokens->front()->GetType() == svString )
3095 : {
3096 0 : aSeq = uno::Sequence<OUString>(1);
3097 0 : aSeq[0] = m_pTokens->front()->GetString().getString();
3098 : }
3099 : }
3100 :
3101 0 : return aSeq;
3102 : }
3103 :
3104 0 : OUString SAL_CALL ScChart2DataSequence::getSourceRangeRepresentation()
3105 : throw ( uno::RuntimeException, std::exception)
3106 : {
3107 0 : SolarMutexGuard aGuard;
3108 0 : OUString aStr;
3109 : OSL_ENSURE( m_pDocument, "No Document -> no SourceRangeRepresentation" );
3110 0 : if (m_pDocument && m_pTokens.get())
3111 0 : lcl_convertTokensToString(aStr, *m_pTokens, m_pDocument);
3112 :
3113 0 : return aStr;
3114 : }
3115 :
3116 : namespace {
3117 :
3118 : /**
3119 : * This function object is used to accumulatively count the numbers of
3120 : * columns and rows in all reference tokens.
3121 : */
3122 : class AccumulateRangeSize : public unary_function<ScTokenRef, void>
3123 : {
3124 : public:
3125 0 : AccumulateRangeSize() :
3126 0 : mnCols(0), mnRows(0) {}
3127 :
3128 0 : AccumulateRangeSize(const AccumulateRangeSize& r) :
3129 0 : mnCols(r.mnCols), mnRows(r.mnRows) {}
3130 :
3131 0 : void operator() (const ScTokenRef& pToken)
3132 : {
3133 0 : ScRange r;
3134 0 : bool bExternal = ScRefTokenHelper::isExternalRef(pToken);
3135 0 : ScRefTokenHelper::getRangeFromToken(r, pToken, ScAddress(), bExternal);
3136 0 : r.Justify();
3137 0 : mnCols += r.aEnd.Col() - r.aStart.Col() + 1;
3138 0 : mnRows += r.aEnd.Row() - r.aStart.Row() + 1;
3139 0 : }
3140 :
3141 0 : SCCOL getCols() const { return mnCols; }
3142 0 : SCROW getRows() const { return mnRows; }
3143 : private:
3144 : SCCOL mnCols;
3145 : SCROW mnRows;
3146 : };
3147 :
3148 : /**
3149 : * This function object is used to generate label strings from a list of
3150 : * reference tokens.
3151 : */
3152 0 : class GenerateLabelStrings : public unary_function<ScTokenRef, void>
3153 : {
3154 : public:
3155 0 : GenerateLabelStrings(sal_Int32 nSize, chart2::data::LabelOrigin eOrigin, bool bColumn) :
3156 0 : mpLabels(new Sequence<OUString>(nSize)),
3157 : meOrigin(eOrigin),
3158 : mnCount(0),
3159 0 : mbColumn(bColumn) {}
3160 :
3161 0 : GenerateLabelStrings(const GenerateLabelStrings& r) :
3162 : mpLabels(r.mpLabels),
3163 : meOrigin(r.meOrigin),
3164 : mnCount(r.mnCount),
3165 0 : mbColumn(r.mbColumn) {}
3166 :
3167 0 : void operator() (const ScTokenRef& pToken)
3168 : {
3169 0 : bool bExternal = ScRefTokenHelper::isExternalRef(pToken);
3170 0 : ScRange aRange;
3171 0 : ScRefTokenHelper::getRangeFromToken(aRange, pToken, ScAddress(), bExternal);
3172 0 : OUString* pArr = mpLabels->getArray();
3173 0 : if (mbColumn)
3174 : {
3175 0 : for (SCCOL nCol = aRange.aStart.Col(); nCol <= aRange.aEnd.Col(); ++nCol)
3176 : {
3177 0 : if ( meOrigin != chart2::data::LabelOrigin_LONG_SIDE)
3178 : {
3179 0 : OUString aString = ScGlobal::GetRscString(STR_COLUMN);
3180 0 : aString += " ";
3181 0 : ScAddress aPos( nCol, 0, 0 );
3182 0 : OUString aColStr(aPos.Format(SCA_VALID_COL, NULL));
3183 0 : aString += aColStr;
3184 0 : pArr[mnCount] = aString;
3185 : }
3186 : else //only indices for categories
3187 0 : pArr[mnCount] = OUString::number( mnCount+1 );
3188 0 : ++mnCount;
3189 : }
3190 : }
3191 : else
3192 : {
3193 0 : for (sal_Int32 nRow = aRange.aStart.Row(); nRow <= aRange.aEnd.Row(); ++nRow)
3194 : {
3195 0 : if (meOrigin != chart2::data::LabelOrigin_LONG_SIDE)
3196 : {
3197 0 : OUString aString = ScGlobal::GetRscString(STR_ROW) +
3198 0 : " " + OUString::number( nRow+1 );
3199 0 : pArr[mnCount] = aString;
3200 : }
3201 : else //only indices for categories
3202 0 : pArr[mnCount] = OUString::number( mnCount+1 );
3203 0 : ++mnCount;
3204 : }
3205 : }
3206 0 : }
3207 :
3208 0 : Sequence<OUString> getLabels() const { return *mpLabels; }
3209 :
3210 : private:
3211 : shared_ptr< Sequence<OUString> > mpLabels;
3212 : chart2::data::LabelOrigin meOrigin;
3213 : sal_Int32 mnCount;
3214 : bool mbColumn;
3215 : };
3216 :
3217 : }
3218 :
3219 0 : uno::Sequence< OUString > SAL_CALL ScChart2DataSequence::generateLabel(chart2::data::LabelOrigin eOrigin)
3220 : throw (uno::RuntimeException, std::exception)
3221 : {
3222 0 : SolarMutexGuard aGuard;
3223 0 : if ( !m_pDocument)
3224 0 : throw uno::RuntimeException();
3225 :
3226 0 : if (!m_pTokens.get())
3227 0 : return Sequence<OUString>();
3228 :
3229 : // Determine the total size of all ranges.
3230 0 : AccumulateRangeSize func;
3231 0 : func = ::std::for_each(m_pTokens->begin(), m_pTokens->end(), func);
3232 0 : SCCOL nCols = func.getCols();
3233 0 : SCROW nRows = func.getRows();
3234 :
3235 : // Detemine whether this is column-major or row-major.
3236 0 : bool bColumn = true;
3237 0 : if ((eOrigin == chart2::data::LabelOrigin_SHORT_SIDE) ||
3238 : (eOrigin == chart2::data::LabelOrigin_LONG_SIDE))
3239 : {
3240 0 : if (nRows > nCols)
3241 : {
3242 0 : if (eOrigin == chart2::data::LabelOrigin_SHORT_SIDE)
3243 0 : bColumn = true;
3244 : else
3245 0 : bColumn = false;
3246 : }
3247 0 : else if (nCols > nRows)
3248 : {
3249 0 : if (eOrigin == chart2::data::LabelOrigin_SHORT_SIDE)
3250 0 : bColumn = false;
3251 : else
3252 0 : bColumn = true;
3253 : }
3254 : else
3255 0 : return Sequence<OUString>();
3256 : }
3257 :
3258 : // Generate label strings based on the info so far.
3259 0 : sal_Int32 nCount = bColumn ? nCols : nRows;
3260 0 : GenerateLabelStrings genLabels(nCount, eOrigin, bColumn);
3261 0 : genLabels = ::std::for_each(m_pTokens->begin(), m_pTokens->end(), genLabels);
3262 0 : Sequence<OUString> aSeq = genLabels.getLabels();
3263 :
3264 0 : return aSeq;
3265 : }
3266 :
3267 : namespace {
3268 :
3269 0 : sal_uLong getDisplayNumberFormat(ScDocument* pDoc, const ScAddress& rPos)
3270 : {
3271 0 : sal_uLong nFormat = pDoc->GetNumberFormat(rPos); // original format from cell.
3272 0 : return nFormat;
3273 : }
3274 :
3275 : }
3276 :
3277 0 : ::sal_Int32 SAL_CALL ScChart2DataSequence::getNumberFormatKeyByIndex( ::sal_Int32 nIndex )
3278 : throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
3279 : {
3280 : // index -1 means a heuristic value for the entire sequence
3281 0 : bool bGetSeriesFormat = (nIndex == -1);
3282 :
3283 0 : SolarMutexGuard aGuard;
3284 0 : if ( !m_pDocument || !m_pTokens.get())
3285 0 : return 0;
3286 :
3287 : // TODO: Handle external references too.
3288 :
3289 0 : sal_Int32 nCount = 0;
3290 :
3291 0 : ScRangeList aRanges;
3292 0 : ScRefTokenHelper::getRangeListFromTokens(aRanges, *m_pTokens, ScAddress());
3293 0 : for (size_t i = 0, n = aRanges.size(); i < n; ++i)
3294 : {
3295 0 : ScRange* p = aRanges[i];
3296 0 : for (SCTAB nTab = p->aStart.Tab(); nTab <= p->aEnd.Tab(); ++nTab)
3297 : {
3298 0 : for (SCCOL nCol = p->aStart.Col(); nCol <= p->aEnd.Col(); ++nCol)
3299 : {
3300 0 : if (!m_bIncludeHiddenCells)
3301 : {
3302 : // Skip hidden columns.
3303 0 : SCCOL nLastCol = -1;
3304 0 : bool bColHidden = m_pDocument->ColHidden(nCol, nTab, NULL, &nLastCol);
3305 0 : if (bColHidden)
3306 : {
3307 0 : nCol = nLastCol;
3308 0 : continue;
3309 : }
3310 : }
3311 :
3312 0 : for (SCROW nRow = p->aStart.Row(); nRow <= p->aEnd.Row(); ++nRow)
3313 : {
3314 0 : if (!m_bIncludeHiddenCells)
3315 : {
3316 : // Skip hidden rows.
3317 0 : SCROW nLastRow = -1;
3318 0 : bool bRowHidden = m_pDocument->RowHidden(nRow, nTab, NULL, &nLastRow);
3319 0 : if (bRowHidden)
3320 : {
3321 0 : nRow = nLastRow;
3322 0 : continue;
3323 : }
3324 : }
3325 :
3326 0 : ScAddress aPos(nCol, nRow, nTab);
3327 :
3328 0 : if( bGetSeriesFormat )
3329 : {
3330 : // TODO: use nicer heuristic
3331 : // return format of first non-empty cell
3332 0 : ScRefCellValue aCell;
3333 0 : aCell.assign(*m_pDocument, aPos);
3334 0 : if (!aCell.isEmpty())
3335 0 : return static_cast<sal_Int32>(getDisplayNumberFormat(m_pDocument, aPos));
3336 : }
3337 0 : else if( nCount == nIndex )
3338 : {
3339 0 : return static_cast<sal_Int32>(getDisplayNumberFormat(m_pDocument, aPos));
3340 : }
3341 0 : ++nCount;
3342 : }
3343 : }
3344 : }
3345 : }
3346 0 : return 0;
3347 : }
3348 :
3349 : // XCloneable ================================================================
3350 :
3351 0 : uno::Reference< util::XCloneable > SAL_CALL ScChart2DataSequence::createClone()
3352 : throw (uno::RuntimeException, std::exception)
3353 : {
3354 0 : SolarMutexGuard aGuard;
3355 :
3356 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
3357 0 : auto_ptr< vector<ScTokenRef> > pTokensNew;
3358 : SAL_WNODEPRECATED_DECLARATIONS_POP
3359 0 : if (m_pTokens.get())
3360 : {
3361 : // Clone tokens.
3362 0 : pTokensNew.reset(new vector<ScTokenRef>);
3363 0 : pTokensNew->reserve(m_pTokens->size());
3364 0 : vector<ScTokenRef>::const_iterator itr = m_pTokens->begin(), itrEnd = m_pTokens->end();
3365 0 : for (; itr != itrEnd; ++itr)
3366 : {
3367 0 : ScTokenRef p(static_cast<ScToken*>((*itr)->Clone()));
3368 0 : pTokensNew->push_back(p);
3369 0 : }
3370 : }
3371 :
3372 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
3373 0 : auto_ptr<ScChart2DataSequence> p(new ScChart2DataSequence(m_pDocument, m_xDataProvider, pTokensNew.release(), m_bIncludeHiddenCells));
3374 : SAL_WNODEPRECATED_DECLARATIONS_POP
3375 0 : p->CopyData(*this);
3376 0 : Reference< util::XCloneable > xClone(p.release());
3377 :
3378 0 : return xClone;
3379 : }
3380 :
3381 : // XModifyBroadcaster ========================================================
3382 :
3383 0 : void SAL_CALL ScChart2DataSequence::addModifyListener( const uno::Reference< util::XModifyListener >& aListener )
3384 : throw (uno::RuntimeException, std::exception)
3385 : {
3386 : // like ScCellRangesBase::addModifyListener
3387 0 : SolarMutexGuard aGuard;
3388 0 : if (!m_pTokens.get() || m_pTokens->empty())
3389 0 : return;
3390 :
3391 0 : ScRangeList aRanges;
3392 0 : ScRefTokenHelper::getRangeListFromTokens(aRanges, *m_pTokens, ScAddress());
3393 : uno::Reference<util::XModifyListener> *pObj =
3394 0 : new uno::Reference<util::XModifyListener>( aListener );
3395 0 : m_aValueListeners.push_back( pObj );
3396 :
3397 0 : if ( m_aValueListeners.size() == 1 )
3398 : {
3399 0 : if (!m_pValueListener)
3400 0 : m_pValueListener = new ScLinkListener( LINK( this, ScChart2DataSequence, ValueListenerHdl ) );
3401 :
3402 0 : if (!m_pHiddenListener.get())
3403 0 : m_pHiddenListener.reset(new HiddenRangeListener(*this));
3404 :
3405 0 : if( m_pDocument )
3406 : {
3407 0 : ScChartListenerCollection* pCLC = m_pDocument->GetChartListenerCollection();
3408 0 : vector<ScTokenRef>::const_iterator itr = m_pTokens->begin(), itrEnd = m_pTokens->end();
3409 0 : for (; itr != itrEnd; ++itr)
3410 : {
3411 0 : ScRange aRange;
3412 0 : if (!ScRefTokenHelper::getRangeFromToken(aRange, *itr, ScAddress()))
3413 0 : continue;
3414 :
3415 0 : m_pDocument->StartListeningArea( aRange, m_pValueListener );
3416 0 : if (pCLC)
3417 0 : pCLC->StartListeningHiddenRange(aRange, m_pHiddenListener.get());
3418 : }
3419 : }
3420 :
3421 0 : acquire(); // don't lose this object (one ref for all listeners)
3422 0 : }
3423 : }
3424 :
3425 0 : void SAL_CALL ScChart2DataSequence::removeModifyListener( const uno::Reference< util::XModifyListener >& aListener )
3426 : throw (uno::RuntimeException, std::exception)
3427 : {
3428 : // like ScCellRangesBase::removeModifyListener
3429 :
3430 0 : SolarMutexGuard aGuard;
3431 0 : if (!m_pTokens.get() || m_pTokens->empty())
3432 0 : return;
3433 :
3434 0 : acquire(); // in case the listeners have the last ref - released below
3435 :
3436 0 : sal_uInt16 nCount = m_aValueListeners.size();
3437 0 : for ( sal_uInt16 n=nCount; n--; )
3438 : {
3439 0 : uno::Reference<util::XModifyListener>& rObj = m_aValueListeners[n];
3440 0 : if ( rObj == aListener )
3441 : {
3442 0 : m_aValueListeners.erase( m_aValueListeners.begin() + n );
3443 :
3444 0 : if ( m_aValueListeners.empty() )
3445 : {
3446 0 : if (m_pValueListener)
3447 0 : m_pValueListener->EndListeningAll();
3448 :
3449 0 : if (m_pHiddenListener.get() && m_pDocument)
3450 : {
3451 0 : ScChartListenerCollection* pCLC = m_pDocument->GetChartListenerCollection();
3452 0 : if (pCLC)
3453 0 : pCLC->EndListeningHiddenRange(m_pHiddenListener.get());
3454 : }
3455 :
3456 0 : release(); // release the ref for the listeners
3457 : }
3458 :
3459 0 : break;
3460 : }
3461 : }
3462 :
3463 0 : release(); // might delete this object
3464 : }
3465 :
3466 : // DataSequence XPropertySet -------------------------------------------------
3467 :
3468 : uno::Reference< beans::XPropertySetInfo> SAL_CALL
3469 0 : ScChart2DataSequence::getPropertySetInfo() throw( uno::RuntimeException, std::exception)
3470 : {
3471 0 : SolarMutexGuard aGuard;
3472 : static uno::Reference<beans::XPropertySetInfo> aRef =
3473 0 : new SfxItemPropertySetInfo( m_aPropSet.getPropertyMap() );
3474 0 : return aRef;
3475 : }
3476 :
3477 :
3478 0 : void SAL_CALL ScChart2DataSequence::setPropertyValue(
3479 : const OUString& rPropertyName, const uno::Any& rValue)
3480 : throw( beans::UnknownPropertyException,
3481 : beans::PropertyVetoException,
3482 : lang::IllegalArgumentException,
3483 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3484 : {
3485 0 : if ( rPropertyName == SC_UNONAME_ROLE )
3486 : {
3487 0 : if ( !(rValue >>= m_aRole))
3488 0 : throw lang::IllegalArgumentException();
3489 : }
3490 0 : else if ( rPropertyName == SC_UNONAME_INCLUDEHIDDENCELLS )
3491 : {
3492 0 : bool bOldValue = m_bIncludeHiddenCells;
3493 0 : if ( !(rValue >>= m_bIncludeHiddenCells))
3494 0 : throw lang::IllegalArgumentException();
3495 0 : if( bOldValue != m_bIncludeHiddenCells )
3496 0 : m_aDataArray.clear();//data array is dirty now
3497 : }
3498 0 : else if( rPropertyName == "TimeBased" )
3499 : {
3500 0 : sal_Bool bTimeBased = mbTimeBased;
3501 0 : rValue>>= bTimeBased;
3502 0 : mbTimeBased = bTimeBased;
3503 : }
3504 : else
3505 0 : throw beans::UnknownPropertyException();
3506 : // TODO: support optional properties
3507 0 : }
3508 :
3509 :
3510 0 : uno::Any SAL_CALL ScChart2DataSequence::getPropertyValue(const OUString& rPropertyName)
3511 : throw(beans::UnknownPropertyException,
3512 : lang::WrappedTargetException,
3513 : uno::RuntimeException,
3514 : std::exception)
3515 : {
3516 0 : uno::Any aRet;
3517 0 : if ( rPropertyName == SC_UNONAME_ROLE )
3518 0 : aRet <<= m_aRole;
3519 0 : else if ( rPropertyName == SC_UNONAME_INCLUDEHIDDENCELLS )
3520 0 : aRet <<= m_bIncludeHiddenCells;
3521 0 : else if ( rPropertyName == SC_UNONAME_HIDDENVALUES )
3522 : {
3523 : // This property is read-only thus cannot be set externally via
3524 : // setPropertyValue(...).
3525 0 : BuildDataCache();
3526 0 : aRet <<= m_aHiddenValues;
3527 : }
3528 0 : else if (rPropertyName == "TimeBased")
3529 : {
3530 0 : aRet <<= mbTimeBased;
3531 : }
3532 : else
3533 0 : throw beans::UnknownPropertyException();
3534 : // TODO: support optional properties
3535 0 : return aRet;
3536 : }
3537 :
3538 :
3539 0 : void SAL_CALL ScChart2DataSequence::addPropertyChangeListener(
3540 : const OUString& /*rPropertyName*/,
3541 : const uno::Reference< beans::XPropertyChangeListener>& /*xListener*/)
3542 : throw( beans::UnknownPropertyException,
3543 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3544 : {
3545 : // FIXME: real implementation
3546 : OSL_FAIL( "Not yet implemented" );
3547 0 : }
3548 :
3549 :
3550 0 : void SAL_CALL ScChart2DataSequence::removePropertyChangeListener(
3551 : const OUString& /*rPropertyName*/,
3552 : const uno::Reference< beans::XPropertyChangeListener>& /*rListener*/)
3553 : throw( beans::UnknownPropertyException,
3554 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3555 : {
3556 : // FIXME: real implementation
3557 : OSL_FAIL( "Not yet implemented" );
3558 0 : }
3559 :
3560 :
3561 0 : void SAL_CALL ScChart2DataSequence::addVetoableChangeListener(
3562 : const OUString& /*rPropertyName*/,
3563 : const uno::Reference< beans::XVetoableChangeListener>& /*rListener*/)
3564 : throw( beans::UnknownPropertyException,
3565 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3566 : {
3567 : // FIXME: real implementation
3568 : OSL_FAIL( "Not yet implemented" );
3569 0 : }
3570 :
3571 :
3572 0 : void SAL_CALL ScChart2DataSequence::removeVetoableChangeListener(
3573 : const OUString& /*rPropertyName*/,
3574 : const uno::Reference< beans::XVetoableChangeListener>& /*rListener*/)
3575 : throw( beans::UnknownPropertyException,
3576 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3577 : {
3578 : // FIXME: real implementation
3579 : OSL_FAIL( "Not yet implemented" );
3580 0 : }
3581 :
3582 0 : void ScChart2DataSequence::setDataChangedHint(bool b)
3583 : {
3584 0 : m_bGotDataChangedHint = b;
3585 0 : }
3586 :
3587 0 : sal_Bool ScChart2DataSequence::switchToNext(sal_Bool bWrap)
3588 : throw (uno::RuntimeException, std::exception)
3589 : {
3590 0 : if(!m_pTokens || !mbTimeBased)
3591 0 : return sal_True;
3592 :
3593 0 : if(mnCurrentTab >= mnTimeBasedEnd)
3594 : {
3595 0 : if(bWrap)
3596 0 : setToPointInTime(0);
3597 0 : return false;
3598 : }
3599 :
3600 0 : for(vector<ScTokenRef>::iterator itr = m_pTokens->begin(),
3601 0 : itrEnd = m_pTokens->end(); itr != itrEnd; ++itr)
3602 : {
3603 0 : if ((*itr)->GetType() != svDoubleRef)
3604 0 : continue;
3605 :
3606 0 : ScComplexRefData& rData = (*itr)->GetDoubleRef();
3607 0 : ScSingleRefData& s = rData.Ref1;
3608 0 : ScSingleRefData& e = rData.Ref2;
3609 :
3610 0 : s.IncTab(1);
3611 0 : e.IncTab(1);
3612 : }
3613 :
3614 0 : ++mnCurrentTab;
3615 :
3616 0 : RebuildDataCache();
3617 :
3618 0 : return sal_True;
3619 : }
3620 :
3621 0 : void ScChart2DataSequence::setRange(sal_Int32 nStart, sal_Int32 nEnd)
3622 : throw (uno::RuntimeException, std::exception)
3623 : {
3624 0 : mnTimeBasedStart = nStart;
3625 0 : mnTimeBasedEnd = nEnd;
3626 0 : mnCurrentTab = mnTimeBasedStart;
3627 0 : }
3628 :
3629 0 : sal_Bool ScChart2DataSequence::setToPointInTime(sal_Int32 nPoint)
3630 : throw (uno::RuntimeException, std::exception)
3631 : {
3632 0 : if(!m_pTokens)
3633 0 : return sal_True;
3634 :
3635 0 : if(nPoint > mnTimeBasedEnd - mnTimeBasedStart)
3636 0 : return false;
3637 :
3638 0 : SCTAB nTab = mnTimeBasedStart + nPoint;
3639 0 : for(vector<ScTokenRef>::iterator itr = m_pTokens->begin(),
3640 0 : itrEnd = m_pTokens->end(); itr != itrEnd; ++itr)
3641 : {
3642 0 : if ((*itr)->GetType() != svDoubleRef)
3643 0 : continue;
3644 :
3645 0 : ScComplexRefData& rData = (*itr)->GetDoubleRef();
3646 0 : ScSingleRefData& s = rData.Ref1;
3647 0 : ScSingleRefData& e = rData.Ref2;
3648 :
3649 0 : s.SetAbsTab(nTab);
3650 0 : e.SetAbsTab(nTab);
3651 : }
3652 :
3653 0 : mnCurrentTab = nTab;
3654 :
3655 0 : RebuildDataCache();
3656 :
3657 0 : return sal_True;
3658 : }
3659 :
3660 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
