?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
re-enabled user-defined numeric fields for dBase export
[LibreOffice.git] / sc / source / core / data / dpobject.cxx
blob3ade4cff5c8f4f37d02d07989f73921653d3e9ea
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include "dpobject.hxx"
21 #include "dptabsrc.hxx"
22 #include "dpsave.hxx"
23 #include "dpdimsave.hxx"
24 #include "dpoutput.hxx"
25 #include "dpshttab.hxx"
26 #include "dpsdbtab.hxx"
27 #include "dpgroup.hxx"
28 #include "document.hxx"
29 #include "rechead.hxx"
30 #include "pivot.hxx" // PIVOT_DATA_FIELD
31 #include "dapiuno.hxx" // ScDataPilotConversion
32 #include "miscuno.hxx"
33 #include "scerrors.hxx"
34 #include "refupdat.hxx"
35 #include "scresid.hxx"
36 #include "sc.hrc"
37 #include "attrib.hxx"
38 #include "scitems.hxx"
39 #include "unonames.hxx"
40 #include "dpglobal.hxx"
41 #include "globstr.hrc"
42 #include "queryentry.hxx"
43 #include "dputil.hxx"
44
45 #include <com/sun/star/beans/XPropertySet.hpp>
46 #include <com/sun/star/sdb/XCompletedExecution.hpp>
47 #include <com/sun/star/sdbc/DataType.hpp>
48 #include <com/sun/star/sdbc/XResultSetMetaData.hpp>
49 #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
50 #include <com/sun/star/sdbc/XRow.hpp>
51 #include <com/sun/star/sdbc/XRowSet.hpp>
52 #include <com/sun/star/sheet/GeneralFunction.hpp>
53 #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
54 #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
55 #include <com/sun/star/sheet/DataPilotFieldReferenceType.hpp>
56 #include <com/sun/star/sheet/DataPilotTableHeaderData.hpp>
57 #include <com/sun/star/sheet/DataPilotTablePositionData.hpp>
58 #include <com/sun/star/sheet/DataPilotTablePositionType.hpp>
59 #include <com/sun/star/sheet/DimensionFlags.hpp>
60 #include <com/sun/star/task/InteractionHandler.hpp>
61 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
62 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
63 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
64 #include <com/sun/star/lang/XInitialization.hpp>
65 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
66 #include <com/sun/star/sheet/XDrillDownDataSupplier.hpp>
67
68 #include <comphelper/processfactory.hxx>
69 #include <comphelper/string.hxx>
70 #include <comphelper/types.hxx>
71 #include <sal/macros.h>
72 #include <tools/debug.hxx>
73 #include <tools/diagnose_ex.h>
74 #include <svl/zforlist.hxx> // IsNumberFormat
75 #include <vcl/msgbox.hxx>
76
77 #include <vector>
78 #include <memory>
79
80 #include <boost/unordered_map.hpp>
81
82 using namespace com::sun::star;
83 using ::std::vector;
84 using ::std::unary_function;
85 using ::boost::shared_ptr;
86 using ::com::sun::star::uno::Sequence;
87 using ::com::sun::star::uno::Reference;
88 using ::com::sun::star::uno::UNO_QUERY;
89 using ::com::sun::star::uno::Any;
90 using ::com::sun::star::uno::Exception;
91 using ::com::sun::star::lang::XComponent;
92 using ::com::sun::star::sheet::DataPilotTableHeaderData;
93 using ::com::sun::star::sheet::DataPilotTablePositionData;
94 using ::com::sun::star::sheet::XDimensionsSupplier;
95 using ::com::sun::star::beans::XPropertySet;
96
97 #define SC_SERVICE_ROWSET "com.sun.star.sdb.RowSet"
98
99 #define SC_DBPROP_DATASOURCENAME "DataSourceName"
100 #define SC_DBPROP_COMMAND "Command"
101 #define SC_DBPROP_COMMANDTYPE "CommandType"
102
103 // -----------------------------------------------------------------------
104
105 #define SCDPSOURCE_SERVICE "com.sun.star.sheet.DataPilotSource"
106
107 namespace {
108
109 /**
110 * Database connection implementation for UNO database API. Note that in
111 * the UNO database API, column index is 1-based, whereas the interface
112 * requires that column index be 0-based.
113 */
114 class DBConnector : public ScDPCache::DBConnector
115 {
116 ScDPCache& mrCache;
117
118 uno::Reference<sdbc::XRowSet> mxRowSet;
119 uno::Reference<sdbc::XRow> mxRow;
120 uno::Reference<sdbc::XResultSetMetaData> mxMetaData;
121 Date maNullDate;
122
123 public:
124 DBConnector(ScDPCache& rCache, const uno::Reference<sdbc::XRowSet>& xRowSet, const Date& rNullDate);
125
126 bool isValid() const;
127
128 virtual void getValue(long nCol, ScDPItemData &rData, short& rNumType) const;
129 virtual OUString getColumnLabel(long nCol) const;
130 virtual long getColumnCount() const;
131 virtual bool first();
132 virtual bool next();
133 virtual void finish();
134 };
135
136 DBConnector::DBConnector(ScDPCache& rCache, const uno::Reference<sdbc::XRowSet>& xRowSet, const Date& rNullDate) :
137 mrCache(rCache), mxRowSet(xRowSet), maNullDate(rNullDate)
138 {
139 Reference<sdbc::XResultSetMetaDataSupplier> xMetaSupp(mxRowSet, UNO_QUERY);
140 if (xMetaSupp.is())
141 mxMetaData = xMetaSupp->getMetaData();
142
143 mxRow.set(mxRowSet, UNO_QUERY);
144 }
145
146 bool DBConnector::isValid() const
147 {
148 return mxRowSet.is() && mxRow.is() && mxMetaData.is();
149 }
150
151 bool DBConnector::first()
152 {
153 return mxRowSet->first();
154 }
155
156 bool DBConnector::next()
157 {
158 return mxRowSet->next();
159 }
160
161 void DBConnector::finish()
162 {
163 mxRowSet->beforeFirst();
164 }
165
166 long DBConnector::getColumnCount() const
167 {
168 return mxMetaData->getColumnCount();
169 }
170
171 OUString DBConnector::getColumnLabel(long nCol) const
172 {
173 return mxMetaData->getColumnLabel(nCol+1);
174 }
175
176 void DBConnector::getValue(long nCol, ScDPItemData &rData, short& rNumType) const
177 {
178 rNumType = NUMBERFORMAT_NUMBER;
179 sal_Int32 nType = mxMetaData->getColumnType(nCol+1);
180
181 try
182 {
183 double fValue = 0.0;
184 switch (nType)
185 {
186 case sdbc::DataType::BIT:
187 case sdbc::DataType::BOOLEAN:
188 {
189 rNumType = NUMBERFORMAT_LOGICAL;
190 fValue = mxRow->getBoolean(nCol+1) ? 1 : 0;
191 rData.SetValue(fValue);
192 break;
193 }
194 case sdbc::DataType::TINYINT:
195 case sdbc::DataType::SMALLINT:
196 case sdbc::DataType::INTEGER:
197 case sdbc::DataType::BIGINT:
198 case sdbc::DataType::FLOAT:
199 case sdbc::DataType::REAL:
200 case sdbc::DataType::DOUBLE:
201 case sdbc::DataType::NUMERIC:
202 case sdbc::DataType::DECIMAL:
203 {
204 //! do the conversion here?
205 fValue = mxRow->getDouble(nCol+1);
206 rData.SetValue(fValue);
207 break;
208 }
209 case sdbc::DataType::DATE:
210 {
211 rNumType = NUMBERFORMAT_DATE;
212
213 util::Date aDate = mxRow->getDate(nCol+1);
214 fValue = Date(aDate.Day, aDate.Month, aDate.Year) - maNullDate;
215 rData.SetValue(fValue);
216 break;
217 }
218 case sdbc::DataType::TIME:
219 {
220 rNumType = NUMBERFORMAT_TIME;
221
222 util::Time aTime = mxRow->getTime(nCol+1);
223 fValue = aTime.Hours / static_cast<double>(::Time::hourPerDay) +
224 aTime.Minutes / static_cast<double>(::Time::minutePerDay) +
225 aTime.Seconds / static_cast<double>(::Time::secondPerDay) +
226 aTime.NanoSeconds / static_cast<double>(::Time::nanoSecPerDay);
227 rData.SetValue(fValue);
228 break;
229 }
230 case sdbc::DataType::TIMESTAMP:
231 {
232 rNumType = NUMBERFORMAT_DATETIME;
233
234 util::DateTime aStamp = mxRow->getTimestamp(nCol+1);
235 fValue = ( Date( aStamp.Day, aStamp.Month, aStamp.Year ) - maNullDate ) +
236 aStamp.Hours / static_cast<double>(::Time::hourPerDay) +
237 aStamp.Minutes / static_cast<double>(::Time::minutePerDay) +
238 aStamp.Seconds / static_cast<double>(::Time::secondPerDay) +
239 aStamp.NanoSeconds / static_cast<double>(::Time::nanoSecPerDay);
240 rData.SetValue(fValue);
241 break;
242 }
243 case sdbc::DataType::CHAR:
244 case sdbc::DataType::VARCHAR:
245 case sdbc::DataType::LONGVARCHAR:
246 case sdbc::DataType::SQLNULL:
247 case sdbc::DataType::BINARY:
248 case sdbc::DataType::VARBINARY:
249 case sdbc::DataType::LONGVARBINARY:
250 default:
251 rData.SetString(mrCache.InternString(mxRow->getString(nCol+1)));
252 }
253 }
254 catch (uno::Exception&)
255 {
256 rData.SetEmpty();
257 }
258 }
259
260 }
261
262 sal_uInt16 lcl_GetDataGetOrientation( const uno::Reference<sheet::XDimensionsSupplier>& xSource )
263 {
264 long nRet = sheet::DataPilotFieldOrientation_HIDDEN;
265 if ( xSource.is() )
266 {
267 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
268 uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
269 long nIntCount = xIntDims->getCount();
270 sal_Bool bFound = false;
271 for (long nIntDim=0; nIntDim<nIntCount && !bFound; nIntDim++)
272 {
273 uno::Reference<uno::XInterface> xIntDim =
274 ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) );
275 uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
276 if ( xDimProp.is() )
277 {
278 bFound = ScUnoHelpFunctions::GetBoolProperty( xDimProp,
279 OUString(SC_UNO_DP_ISDATALAYOUT) );
280 //! error checking -- is "IsDataLayoutDimension" property required??
281 if (bFound)
282 nRet = ScUnoHelpFunctions::GetEnumProperty(
283 xDimProp, OUString(SC_UNO_DP_ORIENTATION),
284 sheet::DataPilotFieldOrientation_HIDDEN );
285 }
286 }
287 }
288 return static_cast< sal_uInt16 >( nRet );
289 }
290
291 ScDPServiceDesc::ScDPServiceDesc(
292 const OUString& rServ, const OUString& rSrc, const OUString& rNam,
293 const OUString& rUser, const OUString& rPass ) :
294 aServiceName( rServ ),
295 aParSource( rSrc ),
296 aParName( rNam ),
297 aParUser( rUser ),
298 aParPass( rPass ) {}
299
300 bool ScDPServiceDesc::operator== ( const ScDPServiceDesc& rOther ) const
301 {
302 return aServiceName == rOther.aServiceName &&
303 aParSource == rOther.aParSource &&
304 aParName == rOther.aParName &&
305 aParUser == rOther.aParUser &&
306 aParPass == rOther.aParPass;
307 }
308
309 ScDPObject::ScDPObject( ScDocument* pD ) :
310 pDoc( pD ),
311 pSaveData( NULL ),
312 pSheetDesc( NULL ),
313 pImpDesc( NULL ),
314 pServDesc( NULL ),
315 mpTableData(static_cast<ScDPTableData*>(NULL)),
316 pOutput( NULL ),
317 mnAutoFormatIndex( 65535 ),
318 nHeaderRows( 0 ),
319 mbHeaderLayout(false),
320 bAllowMove(false),
321 bSettingsChanged(false),
322 mbEnableGetPivotData(true)
323 {
324 }
325
326 ScDPObject::ScDPObject(const ScDPObject& r) :
327 pDoc( r.pDoc ),
328 pSaveData( NULL ),
329 aTableName( r.aTableName ),
330 aTableTag( r.aTableTag ),
331 aOutRange( r.aOutRange ),
332 pSheetDesc( NULL ),
333 pImpDesc( NULL ),
334 pServDesc( NULL ),
335 mpTableData(static_cast<ScDPTableData*>(NULL)),
336 pOutput( NULL ),
337 mnAutoFormatIndex( r.mnAutoFormatIndex ),
338 nHeaderRows( r.nHeaderRows ),
339 mbHeaderLayout( r.mbHeaderLayout ),
340 bAllowMove(false),
341 bSettingsChanged(false),
342 mbEnableGetPivotData(r.mbEnableGetPivotData)
343 {
344 if (r.pSaveData)
345 pSaveData = new ScDPSaveData(*r.pSaveData);
346 if (r.pSheetDesc)
347 pSheetDesc = new ScSheetSourceDesc(*r.pSheetDesc);
348 if (r.pImpDesc)
349 pImpDesc = new ScImportSourceDesc(*r.pImpDesc);
350 if (r.pServDesc)
351 pServDesc = new ScDPServiceDesc(*r.pServDesc);
352 // xSource (and pOutput) is not copied
353 }
354
355 ScDPObject::~ScDPObject()
356 {
357 Clear();
358 }
359
360 ScDPObject& ScDPObject::operator= (const ScDPObject& r)
361 {
362 Clear();
363
364 pDoc = r.pDoc;
365 aTableName = r.aTableName;
366 aTableTag = r.aTableTag;
367 aOutRange = r.aOutRange;
368 mnAutoFormatIndex = r.mnAutoFormatIndex;
369 nHeaderRows = r.nHeaderRows;
370 mbHeaderLayout = r.mbHeaderLayout;
371 bAllowMove = false;
372 bSettingsChanged = false;
373 mbEnableGetPivotData = r.mbEnableGetPivotData;
374
375 if (r.pSaveData)
376 pSaveData = new ScDPSaveData(*r.pSaveData);
377 if (r.pSheetDesc)
378 pSheetDesc = new ScSheetSourceDesc(*r.pSheetDesc);
379 if (r.pImpDesc)
380 pImpDesc = new ScImportSourceDesc(*r.pImpDesc);
381 if (r.pServDesc)
382 pServDesc = new ScDPServiceDesc(*r.pServDesc);
383
384 return *this;
385 }
386
387 void ScDPObject::EnableGetPivotData(bool b)
388 {
389 mbEnableGetPivotData = b;
390 }
391
392 void ScDPObject::SetAllowMove(bool bSet)
393 {
394 bAllowMove = bSet;
395 }
396
397 void ScDPObject::SetSaveData(const ScDPSaveData& rData)
398 {
399 if ( pSaveData != &rData ) // API implementation modifies the original SaveData object
400 {
401 delete pSaveData;
402 pSaveData = new ScDPSaveData( rData );
403 }
404
405 InvalidateData(); // re-init source from SaveData
406 }
407
408 void ScDPObject::SetHeaderLayout (bool bUseGrid)
409 {
410 mbHeaderLayout = bUseGrid;
411 }
412
413 bool ScDPObject::GetHeaderLayout() const
414 {
415 return mbHeaderLayout;
416 }
417
418 void ScDPObject::SetOutRange(const ScRange& rRange)
419 {
420 aOutRange = rRange;
421
422 if ( pOutput )
423 pOutput->SetPosition( rRange.aStart );
424 }
425
426 void ScDPObject::SetSheetDesc(const ScSheetSourceDesc& rDesc, bool /*bFromRefUpdate*/)
427 {
428 if ( pSheetDesc && rDesc == *pSheetDesc )
429 return; // nothing to do
430
431 DELETEZ( pImpDesc );
432 DELETEZ( pServDesc );
433
434 delete pSheetDesc;
435 pSheetDesc = new ScSheetSourceDesc(rDesc);
436
437 // make valid QueryParam
438
439 const ScRange& rSrcRange = pSheetDesc->GetSourceRange();
440 ScQueryParam aParam = pSheetDesc->GetQueryParam();
441 aParam.nCol1 = rSrcRange.aStart.Col();
442 aParam.nRow1 = rSrcRange.aStart.Row();
443 aParam.nCol2 = rSrcRange.aEnd.Col();
444 aParam.nRow2 = rSrcRange.aEnd.Row();
445 aParam.bHasHeader = true;
446 pSheetDesc->SetQueryParam(aParam);
447
448 ClearTableData(); // new source must be created
449 }
450
451 void ScDPObject::SetImportDesc(const ScImportSourceDesc& rDesc)
452 {
453 if ( pImpDesc && rDesc == *pImpDesc )
454 return; // nothing to do
455
456 DELETEZ( pSheetDesc );
457 DELETEZ( pServDesc );
458
459 delete pImpDesc;
460 pImpDesc = new ScImportSourceDesc(rDesc);
461
462 ClearTableData(); // new source must be created
463 }
464
465 void ScDPObject::SetServiceData(const ScDPServiceDesc& rDesc)
466 {
467 if ( pServDesc && rDesc == *pServDesc )
468 return; // nothing to do
469
470 DELETEZ( pSheetDesc );
471 DELETEZ( pImpDesc );
472
473 delete pServDesc;
474 pServDesc = new ScDPServiceDesc(rDesc);
475
476 ClearTableData(); // new source must be created
477 }
478
479 void ScDPObject::WriteSourceDataTo( ScDPObject& rDest ) const
480 {
481 if ( pSheetDesc )
482 rDest.SetSheetDesc( *pSheetDesc );
483 else if ( pImpDesc )
484 rDest.SetImportDesc( *pImpDesc );
485 else if ( pServDesc )
486 rDest.SetServiceData( *pServDesc );
487
488 // name/tag are not source data, but needed along with source data
489
490 rDest.aTableName = aTableName;
491 rDest.aTableTag = aTableTag;
492 }
493
494 void ScDPObject::WriteTempDataTo( ScDPObject& rDest ) const
495 {
496 rDest.nHeaderRows = nHeaderRows;
497 }
498
499 bool ScDPObject::IsSheetData() const
500 {
501 return ( pSheetDesc != NULL );
502 }
503
504 void ScDPObject::SetName(const OUString& rNew)
505 {
506 aTableName = rNew;
507 }
508
509 void ScDPObject::SetTag(const OUString& rNew)
510 {
511 aTableTag = rNew;
512 }
513
514 bool ScDPObject::IsDataDescriptionCell(const ScAddress& rPos)
515 {
516 if (!pSaveData)
517 return false;
518
519 long nDataDimCount = pSaveData->GetDataDimensionCount();
520 if (nDataDimCount != 1)
521 // There has to be exactly one data dimension for the description to
522 // appear at top-left corner.
523 return false;
524
525 CreateOutput();
526 ScRange aTabRange = pOutput->GetOutputRange(sheet::DataPilotOutputRangeType::TABLE);
527 return (rPos == aTabRange.aStart);
528 }
529
530 uno::Reference<sheet::XDimensionsSupplier> ScDPObject::GetSource()
531 {
532 CreateObjects();
533 return xSource;
534 }
535
536 void ScDPObject::CreateOutput()
537 {
538 CreateObjects();
539 if (!pOutput)
540 {
541 sal_Bool bFilterButton = IsSheetData() && pSaveData && pSaveData->GetFilterButton();
542 pOutput = new ScDPOutput( pDoc, xSource, aOutRange.aStart, bFilterButton );
543 pOutput->SetHeaderLayout ( mbHeaderLayout );
544
545 long nOldRows = nHeaderRows;
546 nHeaderRows = pOutput->GetHeaderRows();
547
548 if ( bAllowMove && nHeaderRows != nOldRows )
549 {
550 long nDiff = nOldRows - nHeaderRows;
551 if ( nOldRows == 0 )
552 --nDiff;
553 if ( nHeaderRows == 0 )
554 ++nDiff;
555
556 long nNewRow = aOutRange.aStart.Row() + nDiff;
557 if ( nNewRow < 0 )
558 nNewRow = 0;
559
560 ScAddress aStart( aOutRange.aStart );
561 aStart.SetRow(nNewRow);
562 pOutput->SetPosition( aStart );
563
564 //! modify aOutRange?
565
566 bAllowMove = false; // use only once
567 }
568 }
569 }
570
571 namespace {
572
573 class DisableGetPivotData
574 {
575 ScDPObject& mrDPObj;
576 bool mbOldState;
577 public:
578 DisableGetPivotData(ScDPObject& rObj, bool bOld) : mrDPObj(rObj), mbOldState(bOld)
579 {
580 mrDPObj.EnableGetPivotData(false);
581 }
582
583 ~DisableGetPivotData()
584 {
585 mrDPObj.EnableGetPivotData(mbOldState);
586 }
587 };
588
589 class FindIntersectingTable : std::unary_function<ScDPObject, bool>
590 {
591 ScRange maRange;
592 public:
593 FindIntersectingTable(const ScRange& rRange) : maRange(rRange) {}
594
595 bool operator() (const ScDPObject& rObj) const
596 {
597 return maRange.Intersects(rObj.GetOutRange());
598 }
599 };
600
601 class FindIntersetingTableByColumns : std::unary_function<ScDPObject, bool>
602 {
603 SCCOL mnCol1;
604 SCCOL mnCol2;
605 SCROW mnRow;
606 SCTAB mnTab;
607 public:
608 FindIntersetingTableByColumns(SCCOL nCol1, SCCOL nCol2, SCROW nRow, SCTAB nTab) :
609 mnCol1(nCol1), mnCol2(nCol2), mnRow(nRow), mnTab(nTab) {}
610
611 bool operator() (const ScDPObject& rObj) const
612 {
613 const ScRange& rRange = rObj.GetOutRange();
614 if (mnTab != rRange.aStart.Tab())
615 // Not on this sheet.
616 return false;
617
618 if (rRange.aEnd.Row() < mnRow)
619 // This table is above the row. It's safe.
620 return false;
621
622 if (mnCol1 <= rRange.aStart.Col() && rRange.aEnd.Col() <= mnCol2)
623 // This table is fully enclosed in this column range.
624 return false;
625
626 if (rRange.aEnd.Col() < mnCol1 || mnCol2 < rRange.aStart.Col())
627 // This table is entirely outside this column range.
628 return false;
629
630 // This table must be intersected by this column range.
631 return true;
632 }
633 };
634
635 class FindIntersectingTableByRows : std::unary_function<ScDPObject, bool>
636 {
637 SCCOL mnCol;
638 SCROW mnRow1;
639 SCROW mnRow2;
640 SCTAB mnTab;
641 public:
642 FindIntersectingTableByRows(SCCOL nCol, SCROW nRow1, SCROW nRow2, SCTAB nTab) :
643 mnCol(nCol), mnRow1(nRow1), mnRow2(nRow2), mnTab(nTab) {}
644
645 bool operator() (const ScDPObject& rObj) const
646 {
647 const ScRange& rRange = rObj.GetOutRange();
648 if (mnTab != rRange.aStart.Tab())
649 // Not on this sheet.
650 return false;
651
652 if (rRange.aEnd.Col() < mnCol)
653 // This table is to the left of the column. It's safe.
654 return false;
655
656 if (mnRow1 <= rRange.aStart.Row() && rRange.aEnd.Row() <= mnRow2)
657 // This table is fully enclosed in this row range.
658 return false;
659
660 if (rRange.aEnd.Row() < mnRow1 || mnRow2 < rRange.aStart.Row())
661 // This table is entirely outside this row range.
662 return false;
663
664 // This table must be intersected by this row range.
665 return true;
666 }
667 };
668
669 class AccumulateOutputRanges : std::unary_function<ScDPObject, void>
670 {
671 ScRangeList maRanges;
672 SCTAB mnTab;
673 public:
674 AccumulateOutputRanges(SCTAB nTab) : mnTab(nTab) {}
675 AccumulateOutputRanges(const AccumulateOutputRanges& r) : maRanges(r.maRanges), mnTab(r.mnTab) {}
676
677 void operator() (const ScDPObject& rObj)
678 {
679 const ScRange& rRange = rObj.GetOutRange();
680 if (mnTab != rRange.aStart.Tab())
681 // Not on this sheet.
682 return;
683
684 maRanges.Join(rRange);
685 }
686
687 ScRangeList getRanges() const { return maRanges; }
688 };
689
690 }
691
692 ScDPTableData* ScDPObject::GetTableData()
693 {
694 if (!mpTableData)
695 {
696 shared_ptr<ScDPTableData> pData;
697 const ScDPDimensionSaveData* pDimData = pSaveData ? pSaveData->GetExistingDimensionData() : NULL;
698
699 if ( pImpDesc )
700 {
701 // database data
702 const ScDPCache* pCache = pImpDesc->CreateCache(pDimData);
703 if (pCache)
704 {
705 pCache->AddReference(this);
706 pData.reset(new ScDatabaseDPData(pDoc, *pCache));
707 }
708 }
709 else
710 {
711 // cell data
712 if (!pSheetDesc)
713 {
714 OSL_FAIL("no source descriptor");
715 pSheetDesc = new ScSheetSourceDesc(pDoc); // dummy defaults
716 }
717
718 {
719 // Temporarily disable GETPIVOTDATA to avoid having
720 // GETPIVOTDATA called onto itself from within the source
721 // range.
722 DisableGetPivotData aSwitch(*this, mbEnableGetPivotData);
723 const ScDPCache* pCache = pSheetDesc->CreateCache(pDimData);
724 if (pCache)
725 {
726 pCache->AddReference(this);
727 pData.reset(new ScSheetDPData(pDoc, *pSheetDesc, *pCache));
728 }
729 }
730 }
731
732 // grouping (for cell or database data)
733 if (pData && pDimData)
734 {
735 shared_ptr<ScDPGroupTableData> pGroupData(new ScDPGroupTableData(pData, pDoc));
736 pDimData->WriteToData(*pGroupData);
737 pData = pGroupData;
738 }
739
740 mpTableData = pData; // after SetCacheId
741 }
742
743 return mpTableData.get();
744 }
745
746 void ScDPObject::CreateObjects()
747 {
748 if (!xSource.is())
749 {
750 DELETEZ( pOutput ); // not valid when xSource is changed
751
752 if ( pServDesc )
753 {
754 xSource = CreateSource( *pServDesc );
755 }
756
757 if ( !xSource.is() ) // database or sheet data, or error in CreateSource
758 {
759 OSL_ENSURE( !pServDesc, "DPSource could not be created" );
760 ScDPTableData* pData = GetTableData();
761 if (pData)
762 {
763 if (pSaveData)
764 // Make sure to transfer these flags to the table data
765 // since they may have changed.
766 pData->SetEmptyFlags(pSaveData->GetIgnoreEmptyRows(), pSaveData->GetRepeatIfEmpty());
767
768 pData->ReloadCacheTable();
769 ScDPSource* pSource = new ScDPSource( pData );
770 xSource = pSource;
771 }
772 }
773
774 if (pSaveData)
775 pSaveData->WriteToSource( xSource );
776 }
777 else if (bSettingsChanged)
778 {
779 DELETEZ( pOutput ); // not valid when xSource is changed
780
781 uno::Reference<util::XRefreshable> xRef( xSource, uno::UNO_QUERY );
782 if (xRef.is())
783 {
784 try
785 {
786 xRef->refresh();
787 }
788 catch(uno::Exception&)
789 {
790 OSL_FAIL("exception in refresh");
791 }
792 }
793
794 if (pSaveData)
795 pSaveData->WriteToSource( xSource );
796 }
797 bSettingsChanged = false;
798 }
799
800 void ScDPObject::InvalidateData()
801 {
802 bSettingsChanged = true;
803 }
804
805 void ScDPObject::Clear()
806 {
807 delete pOutput;
808 delete pSaveData;
809 delete pSheetDesc;
810 delete pImpDesc;
811 delete pServDesc;
812 pOutput = NULL;
813 pSaveData = NULL;
814 pSheetDesc = NULL;
815 pImpDesc = NULL;
816 pServDesc = NULL;
817 ClearTableData();
818 }
819
820 void ScDPObject::ClearTableData()
821 {
822 ClearSource();
823
824 if (mpTableData)
825 mpTableData->GetCacheTable().getCache()->RemoveReference(this);
826 mpTableData.reset();
827 }
828
829 void ScDPObject::ReloadGroupTableData()
830 {
831 ClearSource();
832
833 if (!mpTableData)
834 // Table data not built yet. No need to reload the group data.
835 return;
836
837 if (!pSaveData)
838 // How could it not have the save data... but whatever.
839 return;
840
841 const ScDPDimensionSaveData* pDimData = pSaveData->GetExistingDimensionData();
842 if (!pDimData || !pDimData->HasGroupDimensions())
843 {
844 // No group dimensions exist. Check if it currently has group
845 // dimensions, and if so, remove all of them.
846 ScDPGroupTableData* pData = dynamic_cast<ScDPGroupTableData*>(mpTableData.get());
847 if (pData)
848 {
849 // Replace the existing group table data with the source data.
850 shared_ptr<ScDPTableData> pSource = pData->GetSourceTableData();
851 mpTableData = pSource;
852 }
853 return;
854 }
855
856 ScDPGroupTableData* pData = dynamic_cast<ScDPGroupTableData*>(mpTableData.get());
857 if (pData)
858 {
859 // This is already a group table data. Salvage the source data and
860 // re-create a new group data.
861 shared_ptr<ScDPTableData> pSource = pData->GetSourceTableData();
862 shared_ptr<ScDPGroupTableData> pGroupData(new ScDPGroupTableData(pSource, pDoc));
863 pDimData->WriteToData(*pGroupData);
864 mpTableData = pGroupData;
865 }
866 else
867 {
868 // This is a source data. Create a group data based on it.
869 shared_ptr<ScDPGroupTableData> pGroupData(new ScDPGroupTableData(mpTableData, pDoc));
870 pDimData->WriteToData(*pGroupData);
871 mpTableData = pGroupData;
872 }
873
874 bSettingsChanged = true;
875 }
876
877 void ScDPObject::ClearSource()
878 {
879 Reference< XComponent > xObjectComp( xSource, UNO_QUERY );
880 if (xObjectComp.is())
881 {
882 try
883 {
884 xObjectComp->dispose();
885 }
886 catch( const Exception& )
887 {
888 DBG_UNHANDLED_EXCEPTION();
889 }
890 }
891 xSource = NULL;
892 }
893
894 ScRange ScDPObject::GetNewOutputRange( bool& rOverflow )
895 {
896 CreateOutput(); // create xSource and pOutput if not already done
897
898 rOverflow = pOutput->HasError(); // range overflow or exception from source
899 if ( rOverflow )
900 return ScRange( aOutRange.aStart );
901 else
902 {
903 // don't store the result in aOutRange, because nothing has been output yet
904 return pOutput->GetOutputRange();
905 }
906 }
907
908 void ScDPObject::Output( const ScAddress& rPos )
909 {
910 // clear old output area
911 pDoc->DeleteAreaTab( aOutRange.aStart.Col(), aOutRange.aStart.Row(),
912 aOutRange.aEnd.Col(), aOutRange.aEnd.Row(),
913 aOutRange.aStart.Tab(), IDF_ALL );
914 pDoc->RemoveFlagsTab( aOutRange.aStart.Col(), aOutRange.aStart.Row(),
915 aOutRange.aEnd.Col(), aOutRange.aEnd.Row(),
916 aOutRange.aStart.Tab(), SC_MF_AUTO );
917
918 CreateOutput(); // create xSource and pOutput if not already done
919
920 pOutput->SetPosition( rPos );
921
922 pOutput->Output();
923
924 // aOutRange is always the range that was last output to the document
925 aOutRange = pOutput->GetOutputRange();
926 const ScAddress& s = aOutRange.aStart;
927 const ScAddress& e = aOutRange.aEnd;
928 pDoc->ApplyFlagsTab(s.Col(), s.Row(), e.Col(), e.Row(), s.Tab(), SC_MF_DP_TABLE);
929 }
930
931 const ScRange ScDPObject::GetOutputRangeByType( sal_Int32 nType )
932 {
933 CreateOutput();
934
935 if (pOutput->HasError())
936 return ScRange(aOutRange.aStart);
937
938 return pOutput->GetOutputRange(nType);
939 }
940
941 static sal_Bool lcl_HasButton( ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab )
942 {
943 return ((const ScMergeFlagAttr*)pDoc->GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG ))->HasPivotButton();
944 }
945
946 void ScDPObject::RefreshAfterLoad()
947 {
948 // apply drop-down attribute, initialize nHeaderRows, without accessing the source
949 // (button attribute must be present)
950
951 // simple test: block of button cells at the top, followed by an empty cell
952
953 SCCOL nFirstCol = aOutRange.aStart.Col();
954 SCROW nFirstRow = aOutRange.aStart.Row();
955 SCTAB nTab = aOutRange.aStart.Tab();
956
957 SCROW nInitial = 0;
958 SCROW nOutRows = aOutRange.aEnd.Row() + 1 - aOutRange.aStart.Row();
959 while ( nInitial + 1 < nOutRows && lcl_HasButton( pDoc, nFirstCol, nFirstRow + nInitial, nTab ) )
960 ++nInitial;
961
962 if ( nInitial + 1 < nOutRows &&
963 pDoc->IsBlockEmpty( nTab, nFirstCol, nFirstRow + nInitial, nFirstCol, nFirstRow + nInitial ) &&
964 aOutRange.aEnd.Col() > nFirstCol )
965 {
966 nHeaderRows = nInitial;
967 }
968 else
969 nHeaderRows = 0; // nothing found, no drop-down lists
970 }
971
972 void ScDPObject::BuildAllDimensionMembers()
973 {
974 if (!pSaveData)
975 return;
976
977 // #i111857# don't always create empty mpTableData for external service.
978 if (pServDesc)
979 return;
980
981 pSaveData->BuildAllDimensionMembers(GetTableData());
982 }
983
984 bool ScDPObject::SyncAllDimensionMembers()
985 {
986 if (!pSaveData)
987 return false;
988
989 // #i111857# don't always create empty mpTableData for external service.
990 // Ideally, xSource should be used instead of mpTableData.
991 if (pServDesc)
992 return false;
993
994 ScDPTableData* pData = GetTableData();
995 if (!pData)
996 // No table data exists. This can happen when refreshing from an
997 // external source which doesn't exist.
998 return false;
999
1000 // Refresh the cache wrapper since the cache may have changed.
1001 pData->SetEmptyFlags(pSaveData->GetIgnoreEmptyRows(), pSaveData->GetRepeatIfEmpty());
1002 pData->ReloadCacheTable();
1003 pSaveData->SyncAllDimensionMembers(pData);
1004 return true;
1005 }
1006
1007 bool ScDPObject::GetMemberNames( sal_Int32 nDim, Sequence<OUString>& rNames )
1008 {
1009 vector<ScDPLabelData::Member> aMembers;
1010 if (!GetMembers(nDim, GetUsedHierarchy(nDim), aMembers))
1011 return false;
1012
1013 size_t n = aMembers.size();
1014 rNames.realloc(n);
1015 for (size_t i = 0; i < n; ++i)
1016 rNames[i] = aMembers[i].maName;
1017
1018 return true;
1019 }
1020
1021 bool ScDPObject::GetMembers( sal_Int32 nDim, sal_Int32 nHier, vector<ScDPLabelData::Member>& rMembers )
1022 {
1023 Reference< container::XNameAccess > xMembersNA;
1024 if (!GetMembersNA( nDim, nHier, xMembersNA ))
1025 return false;
1026
1027 Reference<container::XIndexAccess> xMembersIA( new ScNameToIndexAccess(xMembersNA) );
1028 sal_Int32 nCount = xMembersIA->getCount();
1029 vector<ScDPLabelData::Member> aMembers;
1030 aMembers.reserve(nCount);
1031
1032 for (sal_Int32 i = 0; i < nCount; ++i)
1033 {
1034 Reference<container::XNamed> xMember(xMembersIA->getByIndex(i), UNO_QUERY);
1035 ScDPLabelData::Member aMem;
1036
1037 if (xMember.is())
1038 aMem.maName = xMember->getName();
1039
1040 Reference<beans::XPropertySet> xMemProp(xMember, UNO_QUERY);
1041 if (xMemProp.is())
1042 {
1043 aMem.mbVisible = ScUnoHelpFunctions::GetBoolProperty(xMemProp, OUString(SC_UNO_DP_ISVISIBLE));
1044 aMem.mbShowDetails = ScUnoHelpFunctions::GetBoolProperty(xMemProp, OUString(SC_UNO_DP_SHOWDETAILS));
1045
1046 aMem.maLayoutName = ScUnoHelpFunctions::GetStringProperty(
1047 xMemProp, OUString(SC_UNO_DP_LAYOUTNAME), OUString());
1048 }
1049
1050 aMembers.push_back(aMem);
1051 }
1052 rMembers.swap(aMembers);
1053 return true;
1054 }
1055
1056 void ScDPObject::UpdateReference( UpdateRefMode eUpdateRefMode,
1057 const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
1058 {
1059 // Output area
1060
1061 SCCOL nCol1 = aOutRange.aStart.Col();
1062 SCROW nRow1 = aOutRange.aStart.Row();
1063 SCTAB nTab1 = aOutRange.aStart.Tab();
1064 SCCOL nCol2 = aOutRange.aEnd.Col();
1065 SCROW nRow2 = aOutRange.aEnd.Row();
1066 SCTAB nTab2 = aOutRange.aEnd.Tab();
1067
1068 ScRefUpdateRes eRes =
1069 ScRefUpdate::Update( pDoc, eUpdateRefMode,
1070 rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(),
1071 rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(), nDx, nDy, nDz,
1072 nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
1073 if ( eRes != UR_NOTHING )
1074 SetOutRange( ScRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ) );
1075
1076 // sheet source data
1077
1078 if ( pSheetDesc )
1079 {
1080 const OUString& rRangeName = pSheetDesc->GetRangeName();
1081 if (!rRangeName.isEmpty())
1082 // Source range is a named range. No need to update.
1083 return;
1084
1085 const ScRange& rSrcRange = pSheetDesc->GetSourceRange();
1086 nCol1 = rSrcRange.aStart.Col();
1087 nRow1 = rSrcRange.aStart.Row();
1088 nTab1 = rSrcRange.aStart.Tab();
1089 nCol2 = rSrcRange.aEnd.Col();
1090 nRow2 = rSrcRange.aEnd.Row();
1091 nTab2 = rSrcRange.aEnd.Tab();
1092
1093 eRes = ScRefUpdate::Update( pDoc, eUpdateRefMode,
1094 rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(),
1095 rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(), nDx, nDy, nDz,
1096 nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
1097 if ( eRes != UR_NOTHING )
1098 {
1099 SCsCOL nDiffX = nCol1 - pSheetDesc->GetSourceRange().aStart.Col();
1100 SCsROW nDiffY = nRow1 - pSheetDesc->GetSourceRange().aStart.Row();
1101
1102 ScQueryParam aParam = pSheetDesc->GetQueryParam();
1103 aParam.nCol1 = sal::static_int_cast<SCCOL>( aParam.nCol1 + nDiffX );
1104 aParam.nCol2 = sal::static_int_cast<SCCOL>( aParam.nCol2 + nDiffX );
1105 aParam.nRow1 += nDiffY; //! used?
1106 aParam.nRow2 += nDiffY; //! used?
1107 SCSIZE nEC = aParam.GetEntryCount();
1108 for (SCSIZE i=0; i<nEC; i++)
1109 if (aParam.GetEntry(i).bDoQuery)
1110 aParam.GetEntry(i).nField += nDiffX;
1111
1112 pSheetDesc->SetQueryParam(aParam);
1113 pSheetDesc->SetSourceRange(ScRange(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2));
1114 }
1115 }
1116 }
1117
1118 bool ScDPObject::RefsEqual( const ScDPObject& r ) const
1119 {
1120 if ( aOutRange != r.aOutRange )
1121 return false;
1122
1123 if ( pSheetDesc && r.pSheetDesc )
1124 {
1125 if ( pSheetDesc->GetSourceRange() != r.pSheetDesc->GetSourceRange() )
1126 return false;
1127 }
1128 else if ( pSheetDesc || r.pSheetDesc )
1129 {
1130 OSL_FAIL("RefsEqual: SheetDesc set at only one object");
1131 return false;
1132 }
1133
1134 return true;
1135 }
1136
1137 void ScDPObject::WriteRefsTo( ScDPObject& r ) const
1138 {
1139 r.SetOutRange( aOutRange );
1140 if ( pSheetDesc )
1141 r.SetSheetDesc( *pSheetDesc, true );
1142 }
1143
1144 void ScDPObject::GetPositionData(const ScAddress& rPos, DataPilotTablePositionData& rPosData)
1145 {
1146 CreateOutput();
1147 pOutput->GetPositionData(rPos, rPosData);
1148 }
1149
1150 bool ScDPObject::GetDataFieldPositionData(
1151 const ScAddress& rPos, Sequence<sheet::DataPilotFieldFilter>& rFilters)
1152 {
1153 CreateOutput();
1154
1155 vector<sheet::DataPilotFieldFilter> aFilters;
1156 if (!pOutput->GetDataResultPositionData(aFilters, rPos))
1157 return false;
1158
1159 sal_Int32 n = static_cast<sal_Int32>(aFilters.size());
1160 rFilters.realloc(n);
1161 for (sal_Int32 i = 0; i < n; ++i)
1162 rFilters[i] = aFilters[i];
1163
1164 return true;
1165 }
1166
1167 void ScDPObject::GetDrillDownData(const ScAddress& rPos, Sequence< Sequence<Any> >& rTableData)
1168 {
1169 CreateOutput();
1170
1171 Reference<sheet::XDrillDownDataSupplier> xDrillDownData(xSource, UNO_QUERY);
1172 if (!xDrillDownData.is())
1173 return;
1174
1175 Sequence<sheet::DataPilotFieldFilter> filters;
1176 if (!GetDataFieldPositionData(rPos, filters))
1177 return;
1178
1179 rTableData = xDrillDownData->getDrillDownData(filters);
1180 }
1181
1182 bool ScDPObject::IsDimNameInUse(const OUString& rName) const
1183 {
1184 if (!xSource.is())
1185 return false;
1186
1187 Reference<container::XNameAccess> xDims = xSource->getDimensions();
1188 Sequence<OUString> aDimNames = xDims->getElementNames();
1189 sal_Int32 n = aDimNames.getLength();
1190 for (sal_Int32 i = 0; i < n; ++i)
1191 {
1192 const OUString& rDimName = aDimNames[i];
1193 if (rDimName.equalsIgnoreAsciiCase(rName))
1194 return true;
1195
1196 Reference<beans::XPropertySet> xPropSet(xDims->getByName(rDimName), UNO_QUERY);
1197 if (!xPropSet.is())
1198 continue;
1199
1200 OUString aLayoutName = ScUnoHelpFunctions::GetStringProperty(
1201 xPropSet, OUString(SC_UNO_DP_LAYOUTNAME), OUString());
1202 if (aLayoutName.equalsIgnoreAsciiCase(rName))
1203 return true;
1204 }
1205 return false;
1206 }
1207
1208 OUString ScDPObject::GetDimName( long nDim, bool& rIsDataLayout, sal_Int32* pFlags )
1209 {
1210 rIsDataLayout = false;
1211 OUString aRet;
1212
1213 if ( xSource.is() )
1214 {
1215 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
1216 uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess( xDimsName );
1217 long nDimCount = xDims->getCount();
1218 if ( nDim < nDimCount )
1219 {
1220 uno::Reference<uno::XInterface> xIntDim =
1221 ScUnoHelpFunctions::AnyToInterface( xDims->getByIndex(nDim) );
1222 uno::Reference<container::XNamed> xDimName( xIntDim, uno::UNO_QUERY );
1223 uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
1224 if ( xDimName.is() && xDimProp.is() )
1225 {
1226 sal_Bool bData = ScUnoHelpFunctions::GetBoolProperty( xDimProp,
1227 OUString(SC_UNO_DP_ISDATALAYOUT) );
1228 //! error checking -- is "IsDataLayoutDimension" property required??
1229
1230 OUString aName;
1231 try
1232 {
1233 aName = xDimName->getName();
1234 }
1235 catch(uno::Exception&)
1236 {
1237 }
1238 if ( bData )
1239 rIsDataLayout = true;
1240 else
1241 aRet = aName;
1242
1243 if (pFlags)
1244 *pFlags = ScUnoHelpFunctions::GetLongProperty( xDimProp,
1245 OUString(SC_UNO_DP_FLAGS), 0 );
1246 }
1247 }
1248 }
1249
1250 return aRet;
1251 }
1252
1253 bool ScDPObject::IsDuplicated( long nDim )
1254 {
1255 bool bDuplicated = false;
1256 if ( xSource.is() )
1257 {
1258 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
1259 uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess( xDimsName );
1260 long nDimCount = xDims->getCount();
1261 if ( nDim < nDimCount )
1262 {
1263 uno::Reference<uno::XInterface> xIntDim =
1264 ScUnoHelpFunctions::AnyToInterface( xDims->getByIndex(nDim) );
1265 uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
1266 if ( xDimProp.is() )
1267 {
1268 try
1269 {
1270 uno::Any aOrigAny = xDimProp->getPropertyValue(
1271 OUString(SC_UNO_DP_ORIGINAL) );
1272 uno::Reference<uno::XInterface> xIntOrig;
1273 if ( (aOrigAny >>= xIntOrig) && xIntOrig.is() )
1274 bDuplicated = true;
1275 }
1276 catch(uno::Exception&)
1277 {
1278 }
1279 }
1280 }
1281 }
1282 return bDuplicated;
1283 }
1284
1285 long ScDPObject::GetDimCount()
1286 {
1287 long nRet = 0;
1288 if ( xSource.is() )
1289 {
1290 try
1291 {
1292 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
1293 if ( xDimsName.is() )
1294 nRet = xDimsName->getElementNames().getLength();
1295 }
1296 catch(uno::Exception&)
1297 {
1298 }
1299 }
1300 return nRet;
1301 }
1302
1303 void ScDPObject::GetHeaderPositionData(const ScAddress& rPos, DataPilotTableHeaderData& rData)
1304 {
1305 using namespace ::com::sun::star::sheet::DataPilotTablePositionType;
1306
1307 CreateOutput(); // create xSource and pOutput if not already done
1308
1309 // Reset member values to invalid state.
1310 rData.Dimension = rData.Hierarchy = rData.Level = -1;
1311 rData.Flags = 0;
1312
1313 DataPilotTablePositionData aPosData;
1314 pOutput->GetPositionData(rPos, aPosData);
1315 const sal_Int32 nPosType = aPosData.PositionType;
1316 if (nPosType == COLUMN_HEADER || nPosType == ROW_HEADER)
1317 aPosData.PositionData >>= rData;
1318 }
1319
1320 namespace {
1321
1322 class FindByName : std::unary_function<const ScDPSaveDimension*, bool>
1323 {
1324 OUString maName; // must be all uppercase.
1325 public:
1326 FindByName(const OUString& rName) : maName(rName) {}
1327 bool operator() (const ScDPSaveDimension* pDim) const
1328 {
1329 // Layout name takes precedence.
1330 const OUString* pLayoutName = pDim->GetLayoutName();
1331 if (pLayoutName && ScGlobal::pCharClass->uppercase(*pLayoutName) == maName)
1332 return true;
1333
1334 sheet::GeneralFunction eGenFunc = static_cast<sheet::GeneralFunction>(pDim->GetFunction());
1335 ScSubTotalFunc eFunc = ScDPUtil::toSubTotalFunc(eGenFunc);
1336 OUString aSrcName = ScDPUtil::getSourceDimensionName(pDim->GetName());
1337 OUString aFuncName = ScDPUtil::getDisplayedMeasureName(aSrcName, eFunc);
1338 if (maName == ScGlobal::pCharClass->uppercase(aFuncName))
1339 return true;
1340
1341 return maName == ScGlobal::pCharClass->uppercase(aSrcName);
1342 }
1343 };
1344
1345 class LessByDimOrder : std::binary_function<sheet::DataPilotFieldFilter, sheet::DataPilotFieldFilter, bool>
1346 {
1347 const ScDPSaveData::DimOrderType& mrDimOrder;
1348
1349 public:
1350 LessByDimOrder(const ScDPSaveData::DimOrderType& rDimOrder) : mrDimOrder(rDimOrder) {}
1351
1352 bool operator() (const sheet::DataPilotFieldFilter& r1, const sheet::DataPilotFieldFilter& r2) const
1353 {
1354 size_t nRank1 = mrDimOrder.size();
1355 size_t nRank2 = mrDimOrder.size();
1356 ScDPSaveData::DimOrderType::const_iterator it1 = mrDimOrder.find(r1.FieldName);
1357 if (it1 != mrDimOrder.end())
1358 nRank1 = it1->second;
1359
1360 ScDPSaveData::DimOrderType::const_iterator it2 = mrDimOrder.find(r2.FieldName);
1361 if (it2 != mrDimOrder.end())
1362 nRank2 = it2->second;
1363
1364 return nRank1 < nRank2;
1365 }
1366 };
1367
1368 }
1369
1370 double ScDPObject::GetPivotData(const OUString& rDataFieldName, std::vector<sheet::DataPilotFieldFilter>& rFilters)
1371 {
1372 double fRet;
1373 rtl::math::setNan(&fRet);
1374 if (!mbEnableGetPivotData)
1375 return fRet;
1376
1377 CreateObjects();
1378
1379 std::vector<const ScDPSaveDimension*> aDataDims;
1380 pSaveData->GetAllDimensionsByOrientation(sheet::DataPilotFieldOrientation_DATA, aDataDims);
1381 if (aDataDims.empty())
1382 return fRet;
1383
1384 std::vector<const ScDPSaveDimension*>::iterator it = std::find_if(
1385 aDataDims.begin(), aDataDims.end(),
1386 FindByName(ScGlobal::pCharClass->uppercase(rDataFieldName)));
1387
1388 if (it == aDataDims.end())
1389 return fRet;
1390
1391 size_t nDataIndex = std::distance(aDataDims.begin(), it);
1392
1393 uno::Reference<sheet::XDataPilotResults> xDPResults(xSource, uno::UNO_QUERY);
1394 if (!xDPResults.is())
1395 return fRet;
1396
1397 // Dimensions must be sorted in order of appearance, and row dimensions
1398 // must come before column dimensions.
1399 std::sort(rFilters.begin(), rFilters.end(), LessByDimOrder(pSaveData->GetDimensionSortOrder()));
1400
1401 size_t n = rFilters.size();
1402 uno::Sequence<sheet::DataPilotFieldFilter> aFilters(n);
1403 for (size_t i = 0; i < n; ++i)
1404 aFilters[i] = rFilters[i];
1405
1406 uno::Sequence<double> aRes = xDPResults->getFilteredResults(aFilters);
1407 if (static_cast<sal_Int32>(nDataIndex) >= aRes.getLength())
1408 return fRet;
1409
1410 return aRes[nDataIndex];
1411 }
1412
1413 bool ScDPObject::IsFilterButton( const ScAddress& rPos )
1414 {
1415 CreateOutput(); // create xSource and pOutput if not already done
1416
1417 return pOutput->IsFilterButton( rPos );
1418 }
1419
1420 long ScDPObject::GetHeaderDim( const ScAddress& rPos, sal_uInt16& rOrient )
1421 {
1422 CreateOutput(); // create xSource and pOutput if not already done
1423
1424 return pOutput->GetHeaderDim( rPos, rOrient );
1425 }
1426
1427 bool ScDPObject::GetHeaderDrag( const ScAddress& rPos, bool bMouseLeft, bool bMouseTop, long nDragDim,
1428 Rectangle& rPosRect, sal_uInt16& rOrient, long& rDimPos )
1429 {
1430 CreateOutput(); // create xSource and pOutput if not already done
1431
1432 return pOutput->GetHeaderDrag( rPos, bMouseLeft, bMouseTop, nDragDim, rPosRect, rOrient, rDimPos );
1433 }
1434
1435 void ScDPObject::GetMemberResultNames(ScDPUniqueStringSet& rNames, long nDimension)
1436 {
1437 CreateOutput(); // create xSource and pOutput if not already done
1438
1439 pOutput->GetMemberResultNames(rNames, nDimension); // used only with table data -> level not needed
1440 }
1441
1442 namespace {
1443
1444 bool dequote( const OUString& rSource, sal_Int32 nStartPos, sal_Int32& rEndPos, OUString& rResult )
1445 {
1446 // nStartPos has to point to opening quote
1447
1448 bool bRet = false;
1449 const sal_Unicode cQuote = '\'';
1450
1451 if (rSource[nStartPos] == cQuote)
1452 {
1453 OUStringBuffer aBuffer;
1454 sal_Int32 nPos = nStartPos + 1;
1455 const sal_Int32 nLen = rSource.getLength();
1456
1457 while ( nPos < nLen )
1458 {
1459 const sal_Unicode cNext = rSource[nPos];
1460 if ( cNext == cQuote )
1461 {
1462 if (nPos+1 < nLen && rSource[nPos+1] == cQuote)
1463 {
1464 // double quote is used for an embedded quote
1465 aBuffer.append( cNext ); // append one quote
1466 ++nPos; // skip the next one
1467 }
1468 else
1469 {
1470 // end of quoted string
1471 rResult = aBuffer.makeStringAndClear();
1472 rEndPos = nPos + 1; // behind closing quote
1473 return true;
1474 }
1475 }
1476 else
1477 aBuffer.append( cNext );
1478
1479 ++nPos;
1480 }
1481 // no closing quote before the end of the string -> error (bRet still false)
1482 }
1483
1484 return bRet;
1485 }
1486
1487 struct ScGetPivotDataFunctionEntry
1488 {
1489 const sal_Char* pName;
1490 sheet::GeneralFunction eFunc;
1491 };
1492
1493 bool parseFunction( const OUString& rList, sal_Int32 nStartPos, sal_Int32& rEndPos, sheet::GeneralFunction& rFunc )
1494 {
1495 static const ScGetPivotDataFunctionEntry aFunctions[] =
1496 {
1497 // our names
1498 { "Sum", sheet::GeneralFunction_SUM },
1499 { "Count", sheet::GeneralFunction_COUNT },
1500 { "Average", sheet::GeneralFunction_AVERAGE },
1501 { "Max", sheet::GeneralFunction_MAX },
1502 { "Min", sheet::GeneralFunction_MIN },
1503 { "Product", sheet::GeneralFunction_PRODUCT },
1504 { "CountNums", sheet::GeneralFunction_COUNTNUMS },
1505 { "StDev", sheet::GeneralFunction_STDEV },
1506 { "StDevp", sheet::GeneralFunction_STDEVP },
1507 { "Var", sheet::GeneralFunction_VAR },
1508 { "VarP", sheet::GeneralFunction_VARP },
1509 // compatibility names
1510 { "Count Nums", sheet::GeneralFunction_COUNTNUMS },
1511 { "StdDev", sheet::GeneralFunction_STDEV },
1512 { "StdDevp", sheet::GeneralFunction_STDEVP }
1513 };
1514
1515 const sal_Int32 nListLen = rList.getLength();
1516 while (nStartPos < nListLen && rList[nStartPos] == ' ')
1517 ++nStartPos;
1518
1519 bool bParsed = false;
1520 bool bFound = false;
1521 OUString aFuncStr;
1522 sal_Int32 nFuncEnd = 0;
1523 if (nStartPos < nListLen && rList[nStartPos] == '\'')
1524 bParsed = dequote( rList, nStartPos, nFuncEnd, aFuncStr );
1525 else
1526 {
1527 nFuncEnd = rList.indexOf(']', nStartPos);
1528 if (nFuncEnd >= 0)
1529 {
1530 aFuncStr = rList.copy(nStartPos, nFuncEnd - nStartPos);
1531 bParsed = true;
1532 }
1533 }
1534
1535 if ( bParsed )
1536 {
1537 aFuncStr = comphelper::string::strip(aFuncStr, ' ');
1538
1539 const sal_Int32 nFuncCount = sizeof(aFunctions) / sizeof(aFunctions[0]);
1540 for ( sal_Int32 nFunc=0; nFunc<nFuncCount && !bFound; nFunc++ )
1541 {
1542 if (aFuncStr.equalsIgnoreAsciiCaseAscii(aFunctions[nFunc].pName))
1543 {
1544 rFunc = aFunctions[nFunc].eFunc;
1545 bFound = true;
1546
1547 while (nFuncEnd < nListLen && rList[nFuncEnd] == ' ')
1548 ++nFuncEnd;
1549 rEndPos = nFuncEnd;
1550 }
1551 }
1552 }
1553
1554 return bFound;
1555 }
1556
1557 bool isAtStart(
1558 const OUString& rList, const OUString& rSearch, sal_Int32& rMatched,
1559 bool bAllowBracket, sheet::GeneralFunction* pFunc )
1560 {
1561 sal_Int32 nMatchList = 0;
1562 sal_Int32 nMatchSearch = 0;
1563 sal_Unicode cFirst = rList[0];
1564 if ( cFirst == '\'' || cFirst == '[' )
1565 {
1566 // quoted string or string in brackets must match completely
1567
1568 OUString aDequoted;
1569 sal_Int32 nQuoteEnd = 0;
1570 bool bParsed = false;
1571
1572 if ( cFirst == '\'' )
1573 bParsed = dequote( rList, 0, nQuoteEnd, aDequoted );
1574 else if ( cFirst == '[' )
1575 {
1576 // skip spaces after the opening bracket
1577
1578 sal_Int32 nStartPos = 1;
1579 const sal_Int32 nListLen = rList.getLength();
1580 while (nStartPos < nListLen && rList[nStartPos] == ' ')
1581 ++nStartPos;
1582
1583 if (nStartPos < nListLen && rList[nStartPos] == '\'') // quoted within the brackets?
1584 {
1585 if ( dequote( rList, nStartPos, nQuoteEnd, aDequoted ) )
1586 {
1587 // after the quoted string, there must be the closing bracket, optionally preceded by spaces,
1588 // and/or a function name
1589 while (nQuoteEnd < nListLen && rList[nQuoteEnd] == ' ')
1590 ++nQuoteEnd;
1591
1592 // semicolon separates function name
1593 if (nQuoteEnd < nListLen && rList[nQuoteEnd] == ';' && pFunc)
1594 {
1595 sal_Int32 nFuncEnd = 0;
1596 if ( parseFunction( rList, nQuoteEnd + 1, nFuncEnd, *pFunc ) )
1597 nQuoteEnd = nFuncEnd;
1598 }
1599 if (nQuoteEnd < nListLen && rList[nQuoteEnd] == ']')
1600 {
1601 ++nQuoteEnd; // include the closing bracket for the matched length
1602 bParsed = true;
1603 }
1604 }
1605 }
1606 else
1607 {
1608 // implicit quoting to the closing bracket
1609
1610 sal_Int32 nClosePos = rList.indexOf(']', nStartPos);
1611 if (nClosePos >= 0)
1612 {
1613 sal_Int32 nNameEnd = nClosePos;
1614 sal_Int32 nSemiPos = rList.indexOf(';', nStartPos);
1615 if (nSemiPos >= 0 && nSemiPos < nClosePos && pFunc)
1616 {
1617 sal_Int32 nFuncEnd = 0;
1618 if (parseFunction(rList, nSemiPos+1, nFuncEnd, *pFunc))
1619 nNameEnd = nSemiPos;
1620 }
1621
1622 aDequoted = rList.copy(nStartPos, nNameEnd - nStartPos);
1623 // spaces before the closing bracket or semicolon
1624 aDequoted = comphelper::string::stripEnd(aDequoted, ' ');
1625 nQuoteEnd = nClosePos + 1;
1626 bParsed = true;
1627 }
1628 }
1629 }
1630
1631 if ( bParsed && ScGlobal::GetpTransliteration()->isEqual( aDequoted, rSearch ) )
1632 {
1633 nMatchList = nQuoteEnd; // match count in the list string, including quotes
1634 nMatchSearch = rSearch.getLength();
1635 }
1636 }
1637 else
1638 {
1639 // otherwise look for search string at the start of rList
1640 ScGlobal::GetpTransliteration()->equals(
1641 rList, 0, rList.getLength(), nMatchList, rSearch, 0, rSearch.getLength(), nMatchSearch);
1642 }
1643
1644 if (nMatchSearch == rSearch.getLength())
1645 {
1646 // search string is at start of rList - look for following space or end of string
1647
1648 bool bValid = false;
1649 if ( sal::static_int_cast<sal_Int32>(nMatchList) >= rList.getLength() )
1650 bValid = true;
1651 else
1652 {
1653 sal_Unicode cNext = rList[nMatchList];
1654 if ( cNext == ' ' || ( bAllowBracket && cNext == '[' ) )
1655 bValid = true;
1656 }
1657
1658 if ( bValid )
1659 {
1660 rMatched = nMatchList;
1661 return true;
1662 }
1663 }
1664
1665 return false;
1666 }
1667
1668 } // anonymous namespace
1669
1670 bool ScDPObject::ParseFilters(
1671 OUString& rDataFieldName,
1672 std::vector<sheet::DataPilotFieldFilter>& rFilters,
1673 std::vector<sheet::GeneralFunction>& rFilterFuncs, const OUString& rFilterList )
1674 {
1675 // parse the string rFilterList into parameters for GetPivotData
1676
1677 CreateObjects(); // create xSource if not already done
1678
1679 std::vector<OUString> aDataNames; // data fields (source name)
1680 std::vector<OUString> aGivenNames; // data fields (compound name)
1681 std::vector<OUString> aFieldNames; // column/row/data fields
1682 std::vector< uno::Sequence<OUString> > aFieldValues;
1683
1684 //
1685 // get all the field and item names
1686 //
1687
1688 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
1689 uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
1690 sal_Int32 nDimCount = xIntDims->getCount();
1691 for ( sal_Int32 nDim = 0; nDim<nDimCount; nDim++ )
1692 {
1693 uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nDim) );
1694 uno::Reference<container::XNamed> xDim( xIntDim, uno::UNO_QUERY );
1695 uno::Reference<beans::XPropertySet> xDimProp( xDim, uno::UNO_QUERY );
1696 uno::Reference<sheet::XHierarchiesSupplier> xDimSupp( xDim, uno::UNO_QUERY );
1697 sal_Bool bDataLayout = ScUnoHelpFunctions::GetBoolProperty( xDimProp,
1698 OUString(SC_UNO_DP_ISDATALAYOUT) );
1699 sal_Int32 nOrient = ScUnoHelpFunctions::GetEnumProperty(
1700 xDimProp, OUString(SC_UNO_DP_ORIENTATION),
1701 sheet::DataPilotFieldOrientation_HIDDEN );
1702 if ( !bDataLayout )
1703 {
1704 if ( nOrient == sheet::DataPilotFieldOrientation_DATA )
1705 {
1706 OUString aSourceName;
1707 OUString aGivenName;
1708 ScDPOutput::GetDataDimensionNames( aSourceName, aGivenName, xIntDim );
1709 aDataNames.push_back( aSourceName );
1710 aGivenNames.push_back( aGivenName );
1711 }
1712 else if ( nOrient != sheet::DataPilotFieldOrientation_HIDDEN )
1713 {
1714 // get level names, as in ScDPOutput
1715
1716 uno::Reference<container::XIndexAccess> xHiers = new ScNameToIndexAccess( xDimSupp->getHierarchies() );
1717 sal_Int32 nHierarchy = ScUnoHelpFunctions::GetLongProperty( xDimProp,
1718 OUString(SC_UNO_DP_USEDHIERARCHY) );
1719 if ( nHierarchy >= xHiers->getCount() )
1720 nHierarchy = 0;
1721
1722 uno::Reference<uno::XInterface> xHier = ScUnoHelpFunctions::AnyToInterface(
1723 xHiers->getByIndex(nHierarchy) );
1724 uno::Reference<sheet::XLevelsSupplier> xHierSupp( xHier, uno::UNO_QUERY );
1725 if ( xHierSupp.is() )
1726 {
1727 uno::Reference<container::XIndexAccess> xLevels = new ScNameToIndexAccess( xHierSupp->getLevels() );
1728 sal_Int32 nLevCount = xLevels->getCount();
1729 for (sal_Int32 nLev=0; nLev<nLevCount; nLev++)
1730 {
1731 uno::Reference<uno::XInterface> xLevel = ScUnoHelpFunctions::AnyToInterface(
1732 xLevels->getByIndex(nLev) );
1733 uno::Reference<container::XNamed> xLevNam( xLevel, uno::UNO_QUERY );
1734 uno::Reference<sheet::XMembersSupplier> xLevSupp( xLevel, uno::UNO_QUERY );
1735 if ( xLevNam.is() && xLevSupp.is() )
1736 {
1737 uno::Reference<container::XNameAccess> xMembers = xLevSupp->getMembers();
1738
1739 OUString aFieldName( xLevNam->getName() );
1740 uno::Sequence<OUString> aMemberNames( xMembers->getElementNames() );
1741
1742 aFieldNames.push_back( aFieldName );
1743 aFieldValues.push_back( aMemberNames );
1744 }
1745 }
1746 }
1747 }
1748 }
1749 }
1750
1751 //
1752 // compare and build filters
1753 //
1754
1755 SCSIZE nDataFields = aDataNames.size();
1756 SCSIZE nFieldCount = aFieldNames.size();
1757 OSL_ENSURE( aGivenNames.size() == nDataFields && aFieldValues.size() == nFieldCount, "wrong count" );
1758
1759 bool bError = false;
1760 bool bHasData = false;
1761 OUString aRemaining(comphelper::string::strip(rFilterList, ' '));
1762 while (!aRemaining.isEmpty() && !bError)
1763 {
1764 bool bUsed = false;
1765
1766 // look for data field name
1767
1768 for ( SCSIZE nDataPos=0; nDataPos<nDataFields && !bUsed; nDataPos++ )
1769 {
1770 OUString aFound;
1771 sal_Int32 nMatched = 0;
1772 if (isAtStart(aRemaining, aDataNames[nDataPos], nMatched, false, NULL))
1773 aFound = aDataNames[nDataPos];
1774 else if (isAtStart(aRemaining, aGivenNames[nDataPos], nMatched, false, NULL))
1775 aFound = aGivenNames[nDataPos];
1776
1777 if (!aFound.isEmpty())
1778 {
1779 rDataFieldName = aFound;
1780 aRemaining = aRemaining.copy(nMatched);
1781 bHasData = true;
1782 bUsed = true;
1783 }
1784 }
1785
1786 // look for field name
1787
1788 OUString aSpecField;
1789 bool bHasFieldName = false;
1790 if ( !bUsed )
1791 {
1792 sal_Int32 nMatched = 0;
1793 for ( SCSIZE nField=0; nField<nFieldCount && !bHasFieldName; nField++ )
1794 {
1795 if (isAtStart(aRemaining, aFieldNames[nField], nMatched, true, NULL))
1796 {
1797 aSpecField = aFieldNames[nField];
1798 aRemaining = aRemaining.copy(nMatched);
1799 aRemaining = comphelper::string::stripStart(aRemaining, ' ');
1800
1801 // field name has to be followed by item name in brackets
1802 if (!aRemaining.isEmpty() && aRemaining[0] == '[')
1803 {
1804 bHasFieldName = true;
1805 // bUsed remains false - still need the item
1806 }
1807 else
1808 {
1809 bUsed = true;
1810 bError = true;
1811 }
1812 }
1813 }
1814 }
1815
1816 // look for field item
1817
1818 if ( !bUsed )
1819 {
1820 bool bItemFound = false;
1821 sal_Int32 nMatched = 0;
1822 OUString aFoundName;
1823 OUString aFoundValue;
1824 sheet::GeneralFunction eFunc = sheet::GeneralFunction_NONE;
1825 sheet::GeneralFunction eFoundFunc = sheet::GeneralFunction_NONE;
1826
1827 for ( SCSIZE nField=0; nField<nFieldCount; nField++ )
1828 {
1829 // If a field name is given, look in that field only, otherwise in all fields.
1830 // aSpecField is initialized from aFieldNames array, so exact comparison can be used.
1831 if ( !bHasFieldName || aFieldNames[nField] == aSpecField )
1832 {
1833 const uno::Sequence<OUString>& rItems = aFieldValues[nField];
1834 sal_Int32 nItemCount = rItems.getLength();
1835 const OUString* pItemArr = rItems.getConstArray();
1836 for ( sal_Int32 nItem=0; nItem<nItemCount; nItem++ )
1837 {
1838 if ( isAtStart( aRemaining, pItemArr[nItem], nMatched, false, &eFunc ) )
1839 {
1840 if ( bItemFound )
1841 bError = true; // duplicate (also across fields)
1842 else
1843 {
1844 aFoundName = aFieldNames[nField];
1845 aFoundValue = pItemArr[nItem];
1846 eFoundFunc = eFunc;
1847 bItemFound = true;
1848 bUsed = true;
1849 }
1850 }
1851 }
1852 }
1853 }
1854
1855 if ( bItemFound && !bError )
1856 {
1857 sheet::DataPilotFieldFilter aField;
1858 aField.FieldName = aFoundName;
1859 aField.MatchValue = aFoundValue;
1860 rFilters.push_back(aField);
1861 rFilterFuncs.push_back(eFoundFunc);
1862 aRemaining = aRemaining.copy(nMatched);
1863 }
1864 }
1865
1866 if ( !bUsed )
1867 bError = true;
1868
1869 // remove any number of spaces between entries
1870 aRemaining = comphelper::string::stripStart(aRemaining, ' ');
1871 }
1872
1873 if ( !bError && !bHasData && aDataNames.size() == 1 )
1874 {
1875 // if there's only one data field, its name need not be specified
1876 rDataFieldName = aDataNames[0];
1877 bHasData = true;
1878 }
1879
1880 return bHasData && !bError;
1881 }
1882
1883 void ScDPObject::ToggleDetails(const DataPilotTableHeaderData& rElemDesc, ScDPObject* pDestObj)
1884 {
1885 CreateObjects(); // create xSource if not already done
1886
1887 // find dimension name
1888
1889 uno::Reference<container::XNamed> xDim;
1890 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
1891 uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
1892 long nIntCount = xIntDims->getCount();
1893 if ( rElemDesc.Dimension < nIntCount )
1894 {
1895 uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface(
1896 xIntDims->getByIndex(rElemDesc.Dimension) );
1897 xDim = uno::Reference<container::XNamed>( xIntDim, uno::UNO_QUERY );
1898 }
1899 OSL_ENSURE( xDim.is(), "dimension not found" );
1900 if ( !xDim.is() ) return;
1901 String aDimName = xDim->getName();
1902
1903 uno::Reference<beans::XPropertySet> xDimProp( xDim, uno::UNO_QUERY );
1904 sal_Bool bDataLayout = ScUnoHelpFunctions::GetBoolProperty( xDimProp,
1905 OUString(SC_UNO_DP_ISDATALAYOUT) );
1906 if (bDataLayout)
1907 {
1908 // the elements of the data layout dimension can't be found by their names
1909 // -> don't change anything
1910 return;
1911 }
1912
1913 // query old state
1914
1915 long nHierCount = 0;
1916 uno::Reference<container::XIndexAccess> xHiers;
1917 uno::Reference<sheet::XHierarchiesSupplier> xHierSupp( xDim, uno::UNO_QUERY );
1918 if ( xHierSupp.is() )
1919 {
1920 uno::Reference<container::XNameAccess> xHiersName = xHierSupp->getHierarchies();
1921 xHiers = new ScNameToIndexAccess( xHiersName );
1922 nHierCount = xHiers->getCount();
1923 }
1924 uno::Reference<uno::XInterface> xHier;
1925 if ( rElemDesc.Hierarchy < nHierCount )
1926 xHier = ScUnoHelpFunctions::AnyToInterface( xHiers->getByIndex(rElemDesc.Hierarchy) );
1927 OSL_ENSURE( xHier.is(), "hierarchy not found" );
1928 if ( !xHier.is() ) return;
1929
1930 long nLevCount = 0;
1931 uno::Reference<container::XIndexAccess> xLevels;
1932 uno::Reference<sheet::XLevelsSupplier> xLevSupp( xHier, uno::UNO_QUERY );
1933 if ( xLevSupp.is() )
1934 {
1935 uno::Reference<container::XNameAccess> xLevsName = xLevSupp->getLevels();
1936 xLevels = new ScNameToIndexAccess( xLevsName );
1937 nLevCount = xLevels->getCount();
1938 }
1939 uno::Reference<uno::XInterface> xLevel;
1940 if ( rElemDesc.Level < nLevCount )
1941 xLevel = ScUnoHelpFunctions::AnyToInterface( xLevels->getByIndex(rElemDesc.Level) );
1942 OSL_ENSURE( xLevel.is(), "level not found" );
1943 if ( !xLevel.is() ) return;
1944
1945 uno::Reference<container::XNameAccess> xMembers;
1946 uno::Reference<sheet::XMembersSupplier> xMbrSupp( xLevel, uno::UNO_QUERY );
1947 if ( xMbrSupp.is() )
1948 xMembers = xMbrSupp->getMembers();
1949
1950 sal_Bool bFound = false;
1951 sal_Bool bShowDetails = sal_True;
1952
1953 if ( xMembers.is() )
1954 {
1955 if ( xMembers->hasByName(rElemDesc.MemberName) )
1956 {
1957 uno::Reference<uno::XInterface> xMemberInt = ScUnoHelpFunctions::AnyToInterface(
1958 xMembers->getByName(rElemDesc.MemberName) );
1959 uno::Reference<beans::XPropertySet> xMbrProp( xMemberInt, uno::UNO_QUERY );
1960 if ( xMbrProp.is() )
1961 {
1962 bShowDetails = ScUnoHelpFunctions::GetBoolProperty( xMbrProp,
1963 OUString(SC_UNO_DP_SHOWDETAILS) );
1964 //! don't set bFound if property is unknown?
1965 bFound = sal_True;
1966 }
1967 }
1968 }
1969
1970 OSL_ENSURE( bFound, "member not found" );
1971 (void)bFound;
1972
1973 //! use Hierarchy and Level in SaveData !!!!
1974
1975 // modify pDestObj if set, this object otherwise
1976 ScDPSaveData* pModifyData = pDestObj ? ( pDestObj->pSaveData ) : pSaveData;
1977 OSL_ENSURE( pModifyData, "no data?" );
1978 if ( pModifyData )
1979 {
1980 const String aName = rElemDesc.MemberName;
1981 pModifyData->GetDimensionByName(aDimName)->
1982 GetMemberByName(aName)->SetShowDetails( !bShowDetails ); // toggle
1983
1984 if ( pDestObj )
1985 pDestObj->InvalidateData(); // re-init source from SaveData
1986 else
1987 InvalidateData(); // re-init source from SaveData
1988 }
1989 }
1990
1991 static sal_uInt16 lcl_FirstSubTotal( const uno::Reference<beans::XPropertySet>& xDimProp ) // PIVOT_FUNC mask
1992 {
1993 uno::Reference<sheet::XHierarchiesSupplier> xDimSupp( xDimProp, uno::UNO_QUERY );
1994 if ( xDimProp.is() && xDimSupp.is() )
1995 {
1996 uno::Reference<container::XIndexAccess> xHiers = new ScNameToIndexAccess( xDimSupp->getHierarchies() );
1997 long nHierarchy = ScUnoHelpFunctions::GetLongProperty( xDimProp,
1998 OUString(SC_UNO_DP_USEDHIERARCHY) );
1999 if ( nHierarchy >= xHiers->getCount() )
2000 nHierarchy = 0;
2001
2002 uno::Reference<uno::XInterface> xHier = ScUnoHelpFunctions::AnyToInterface(
2003 xHiers->getByIndex(nHierarchy) );
2004 uno::Reference<sheet::XLevelsSupplier> xHierSupp( xHier, uno::UNO_QUERY );
2005 if ( xHierSupp.is() )
2006 {
2007 uno::Reference<container::XIndexAccess> xLevels = new ScNameToIndexAccess( xHierSupp->getLevels() );
2008 uno::Reference<uno::XInterface> xLevel =
2009 ScUnoHelpFunctions::AnyToInterface( xLevels->getByIndex( 0 ) );
2010 uno::Reference<beans::XPropertySet> xLevProp( xLevel, uno::UNO_QUERY );
2011 if ( xLevProp.is() )
2012 {
2013 uno::Any aSubAny;
2014 try
2015 {
2016 aSubAny = xLevProp->getPropertyValue(
2017 OUString(SC_UNO_DP_SUBTOTAL) );
2018 }
2019 catch(uno::Exception&)
2020 {
2021 }
2022 uno::Sequence<sheet::GeneralFunction> aSeq;
2023 if ( aSubAny >>= aSeq )
2024 {
2025 sal_uInt16 nMask = 0;
2026 const sheet::GeneralFunction* pArray = aSeq.getConstArray();
2027 long nCount = aSeq.getLength();
2028 for (long i=0; i<nCount; i++)
2029 nMask |= ScDataPilotConversion::FunctionBit(pArray[i]);
2030 return nMask;
2031 }
2032 }
2033 }
2034 }
2035
2036 OSL_FAIL("FirstSubTotal: NULL");
2037 return 0;
2038 }
2039
2040 namespace {
2041
2042 class FindByColumn : public std::unary_function<ScPivotField, bool>
2043 {
2044 SCsCOL mnCol;
2045 sal_uInt16 mnMask;
2046 public:
2047 FindByColumn(SCsCOL nCol, sal_uInt16 nMask) : mnCol(nCol), mnMask(nMask) {}
2048 bool operator() (const ScPivotField& r) const
2049 {
2050 return r.nCol == mnCol && r.nFuncMask == mnMask;
2051 }
2052 };
2053
2054 }
2055
2056 void lcl_FillOldFields( ScPivotFieldVector& rFields,
2057 const uno::Reference<sheet::XDimensionsSupplier>& xSource,
2058 sal_uInt16 nOrient, bool bAddData )
2059 {
2060 ScPivotFieldVector aFields;
2061
2062 bool bDataFound = false;
2063
2064 //! merge multiple occurrences (data field with different functions)
2065 //! force data field in one dimension
2066
2067 vector<long> aPos;
2068
2069 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
2070 uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess( xDimsName );
2071 long nDimCount = xDims->getCount();
2072 for (long nDim = 0; nDim < nDimCount; ++nDim)
2073 {
2074 // Get dimension object.
2075 uno::Reference<uno::XInterface> xIntDim =
2076 ScUnoHelpFunctions::AnyToInterface( xDims->getByIndex(nDim) );
2077
2078 // dimension properties
2079 uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
2080
2081 // dimension orientation, hidden by default.
2082 long nDimOrient = ScUnoHelpFunctions::GetEnumProperty(
2083 xDimProp, OUString(SC_UNO_DP_ORIENTATION),
2084 sheet::DataPilotFieldOrientation_HIDDEN );
2085
2086 if ( xDimProp.is() && nDimOrient == nOrient )
2087 {
2088 // Let's take this dimension.
2089
2090 // function mask.
2091 sal_uInt16 nMask = 0;
2092 if ( nOrient == sheet::DataPilotFieldOrientation_DATA )
2093 {
2094 sheet::GeneralFunction eFunc = (sheet::GeneralFunction)ScUnoHelpFunctions::GetEnumProperty(
2095 xDimProp, OUString(SC_UNO_DP_FUNCTION),
2096 sheet::GeneralFunction_NONE );
2097 if ( eFunc == sheet::GeneralFunction_AUTO )
2098 {
2099 //! test for numeric data
2100 eFunc = sheet::GeneralFunction_SUM;
2101 }
2102 nMask = ScDataPilotConversion::FunctionBit(eFunc);
2103 }
2104 else
2105 nMask = lcl_FirstSubTotal( xDimProp ); // from first hierarchy
2106
2107 // is this data layout dimension?
2108 bool bDataLayout = ScUnoHelpFunctions::GetBoolProperty(
2109 xDimProp, OUString(SC_UNO_DP_ISDATALAYOUT));
2110
2111 // is this dimension cloned?
2112 long nDupSource = -1;
2113 try
2114 {
2115 uno::Any aOrigAny = xDimProp->getPropertyValue(
2116 OUString(SC_UNO_DP_ORIGINAL_POS));
2117 sal_Int32 nTmp = 0;
2118 if (aOrigAny >>= nTmp)
2119 nDupSource = static_cast<sal_Int32>(nTmp);
2120 }
2121 catch(uno::Exception&)
2122 {
2123 }
2124
2125 sal_uInt8 nDupCount = 0;
2126 if (nDupSource >= 0)
2127 {
2128 // this dimension is cloned.
2129
2130 SCsCOL nCompCol; // ID of the original dimension.
2131 if ( bDataLayout )
2132 nCompCol = PIVOT_DATA_FIELD;
2133 else
2134 nCompCol = static_cast<SCsCOL>(nDupSource); //! seek source column from name
2135
2136 ScPivotFieldVector::iterator it = std::find_if(aFields.begin(), aFields.end(), FindByColumn(nCompCol, nMask));
2137 if (it != aFields.end())
2138 nDupCount = it->mnDupCount + 1;
2139 }
2140
2141 aFields.push_back(ScPivotField());
2142 ScPivotField& rField = aFields.back();
2143 if (bDataLayout)
2144 {
2145 rField.nCol = PIVOT_DATA_FIELD;
2146 bDataFound = true;
2147 }
2148 else
2149 {
2150 rField.mnOriginalDim = nDupSource;
2151 rField.nCol = static_cast<SCCOL>(nDim); //! seek source column from name
2152 }
2153
2154 rField.nFuncMask = nMask;
2155 rField.mnDupCount = nDupCount;
2156 long nPos = ScUnoHelpFunctions::GetLongProperty(
2157 xDimProp, OUString(SC_UNO_DP_POSITION));
2158 aPos.push_back(nPos);
2159
2160 try
2161 {
2162 if (nOrient == sheet::DataPilotFieldOrientation_DATA)
2163 xDimProp->getPropertyValue(OUString(SC_UNO_DP_REFVALUE))
2164 >>= rField.maFieldRef;
2165 }
2166 catch (uno::Exception&)
2167 {
2168 }
2169 }
2170 }
2171
2172 // sort by getPosition() value
2173
2174 size_t nOutCount = aFields.size();
2175 if (nOutCount >= 1)
2176 {
2177 for (size_t i = 0; i < nOutCount - 1; ++i)
2178 {
2179 for (size_t j = 0; j + i < nOutCount - 1; ++j)
2180 {
2181 if ( aPos[j+1] < aPos[j] )
2182 {
2183 std::swap( aPos[j], aPos[j+1] );
2184 std::swap( aFields[j], aFields[j+1] );
2185 }
2186 }
2187 }
2188 }
2189
2190 if (bAddData && !bDataFound)
2191 aFields.push_back(ScPivotField(PIVOT_DATA_FIELD, 0));
2192
2193 rFields.swap(aFields);
2194 }
2195
2196 bool ScDPObject::FillOldParam(ScPivotParam& rParam) const
2197 {
2198 ((ScDPObject*)this)->CreateObjects(); // xSource is needed for field numbers
2199
2200 if (!xSource.is())
2201 return false;
2202
2203 rParam.nCol = aOutRange.aStart.Col();
2204 rParam.nRow = aOutRange.aStart.Row();
2205 rParam.nTab = aOutRange.aStart.Tab();
2206 // ppLabelArr / nLabels is not changed
2207
2208 bool bAddData = ( lcl_GetDataGetOrientation( xSource ) == sheet::DataPilotFieldOrientation_HIDDEN );
2209 lcl_FillOldFields(
2210 rParam.maPageFields, xSource, sheet::DataPilotFieldOrientation_PAGE, false);
2211 lcl_FillOldFields(
2212 rParam.maColFields, xSource, sheet::DataPilotFieldOrientation_COLUMN, bAddData);
2213 lcl_FillOldFields(
2214 rParam.maRowFields, xSource, sheet::DataPilotFieldOrientation_ROW, false);
2215 lcl_FillOldFields(
2216 rParam.maDataFields, xSource, sheet::DataPilotFieldOrientation_DATA, false);
2217
2218 uno::Reference<beans::XPropertySet> xProp( xSource, uno::UNO_QUERY );
2219 if (xProp.is())
2220 {
2221 try
2222 {
2223 rParam.bMakeTotalCol = ScUnoHelpFunctions::GetBoolProperty( xProp,
2224 OUString(SC_UNO_DP_COLGRAND), true );
2225 rParam.bMakeTotalRow = ScUnoHelpFunctions::GetBoolProperty( xProp,
2226 OUString(SC_UNO_DP_ROWGRAND), true );
2227
2228 // following properties may be missing for external sources
2229 rParam.bIgnoreEmptyRows = ScUnoHelpFunctions::GetBoolProperty( xProp,
2230 OUString(SC_UNO_DP_IGNOREEMPTY) );
2231 rParam.bDetectCategories = ScUnoHelpFunctions::GetBoolProperty( xProp,
2232 OUString(SC_UNO_DP_REPEATEMPTY) );
2233 }
2234 catch(uno::Exception&)
2235 {
2236 // no error
2237 }
2238 }
2239 return true;
2240 }
2241
2242 static void lcl_FillLabelData( ScDPLabelData& rData, const uno::Reference< beans::XPropertySet >& xDimProp )
2243 {
2244 uno::Reference<sheet::XHierarchiesSupplier> xDimSupp( xDimProp, uno::UNO_QUERY );
2245 if (!xDimProp.is() || !xDimSupp.is())
2246 return;
2247
2248 uno::Reference<container::XIndexAccess> xHiers = new ScNameToIndexAccess( xDimSupp->getHierarchies() );
2249 long nHierarchy = ScUnoHelpFunctions::GetLongProperty(
2250 xDimProp, OUString(SC_UNO_DP_USEDHIERARCHY));
2251 if ( nHierarchy >= xHiers->getCount() )
2252 nHierarchy = 0;
2253 rData.mnUsedHier = nHierarchy;
2254
2255 uno::Reference<uno::XInterface> xHier =
2256 ScUnoHelpFunctions::AnyToInterface(xHiers->getByIndex(nHierarchy));
2257
2258 uno::Reference<sheet::XLevelsSupplier> xHierSupp( xHier, uno::UNO_QUERY );
2259 if (!xHierSupp.is())
2260 return;
2261
2262 uno::Reference<container::XIndexAccess> xLevels =
2263 new ScNameToIndexAccess( xHierSupp->getLevels() );
2264
2265 uno::Reference<uno::XInterface> xLevel =
2266 ScUnoHelpFunctions::AnyToInterface( xLevels->getByIndex(0) );
2267 uno::Reference<beans::XPropertySet> xLevProp( xLevel, uno::UNO_QUERY );
2268 if (!xLevProp.is())
2269 return;
2270
2271 rData.mbShowAll = ScUnoHelpFunctions::GetBoolProperty(
2272 xLevProp, OUString(SC_UNO_DP_SHOWEMPTY));
2273
2274 try
2275 {
2276 xLevProp->getPropertyValue( OUString( SC_UNO_DP_SORTING ) )
2277 >>= rData.maSortInfo;
2278 xLevProp->getPropertyValue( OUString( SC_UNO_DP_LAYOUT ) )
2279 >>= rData.maLayoutInfo;
2280 xLevProp->getPropertyValue( OUString( SC_UNO_DP_AUTOSHOW ) )
2281 >>= rData.maShowInfo;
2282 }
2283 catch(uno::Exception&)
2284 {
2285 }
2286 }
2287
2288 bool ScDPObject::FillLabelDataForDimension(
2289 const uno::Reference<container::XIndexAccess>& xDims, sal_Int32 nDim, ScDPLabelData& rLabelData)
2290 {
2291 uno::Reference<uno::XInterface> xIntDim =
2292 ScUnoHelpFunctions::AnyToInterface( xDims->getByIndex(nDim) );
2293 uno::Reference<container::XNamed> xDimName( xIntDim, uno::UNO_QUERY );
2294 uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
2295
2296 if (!xDimName.is() || !xDimProp.is())
2297 return false;
2298
2299 bool bData = ScUnoHelpFunctions::GetBoolProperty(
2300 xDimProp, OUString(SC_UNO_DP_ISDATALAYOUT));
2301 //! error checking -- is "IsDataLayoutDimension" property required??
2302
2303 sal_Int32 nOrigPos = -1;
2304 OUString aFieldName;
2305 try
2306 {
2307 aFieldName = xDimName->getName();
2308 uno::Any aOrigAny = xDimProp->getPropertyValue(
2309 OUString(SC_UNO_DP_ORIGINAL_POS));
2310 aOrigAny >>= nOrigPos;
2311 }
2312 catch(uno::Exception&)
2313 {
2314 }
2315
2316 OUString aLayoutName = ScUnoHelpFunctions::GetStringProperty(
2317 xDimProp, OUString(SC_UNO_DP_LAYOUTNAME), OUString());
2318
2319 OUString aSubtotalName = ScUnoHelpFunctions::GetStringProperty(
2320 xDimProp, OUString(SC_UNO_DP_FIELD_SUBTOTALNAME), OUString());
2321
2322 bool bIsValue = true; //! check
2323
2324 // Name from the UNO dimension object may have trailing '*'s in which
2325 // case it's a duplicate dimension. Convert that to a duplicate index.
2326
2327 sal_uInt8 nDupCount = ScDPUtil::getDuplicateIndex(aFieldName);
2328 aFieldName = ScDPUtil::getSourceDimensionName(aFieldName);
2329
2330 rLabelData.maName = aFieldName;
2331 rLabelData.mnCol = static_cast<SCCOL>(nDim);
2332 rLabelData.mnDupCount = nDupCount;
2333 rLabelData.mbDataLayout = bData;
2334 rLabelData.mbIsValue = bIsValue;
2335
2336 if (!bData)
2337 {
2338 rLabelData.mnOriginalDim = static_cast<long>(nOrigPos);
2339 rLabelData.maLayoutName = aLayoutName;
2340 rLabelData.maSubtotalName = aSubtotalName;
2341 if (nOrigPos >= 0)
2342 // This is a duplicated dimension. Use the original dimension index.
2343 nDim = nOrigPos;
2344 GetHierarchies(nDim, rLabelData.maHiers);
2345 GetMembers(nDim, GetUsedHierarchy(nDim), rLabelData.maMembers);
2346 lcl_FillLabelData(rLabelData, xDimProp);
2347 rLabelData.mnFlags = ScUnoHelpFunctions::GetLongProperty(
2348 xDimProp, OUString(SC_UNO_DP_FLAGS), 0);
2349 }
2350 return true;
2351 }
2352
2353 bool ScDPObject::FillLabelData(sal_Int32 nDim, ScDPLabelData& rLabels)
2354 {
2355 CreateObjects();
2356 if (!xSource.is())
2357 return false;
2358
2359 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
2360 uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess( xDimsName );
2361 sal_Int32 nDimCount = xDims->getCount();
2362 if (nDimCount <= 0 || nDim >= nDimCount)
2363 return false;
2364
2365 return FillLabelDataForDimension(xDims, nDim, rLabels);
2366 }
2367
2368 bool ScDPObject::FillLabelData(ScPivotParam& rParam)
2369 {
2370 rParam.maLabelArray.clear();
2371
2372 CreateObjects();
2373 if (!xSource.is())
2374 return false;
2375
2376 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
2377 uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess( xDimsName );
2378 sal_Int32 nDimCount = xDims->getCount();
2379 if (nDimCount <= 0)
2380 return false;
2381
2382 for (sal_Int32 nDim = 0; nDim < nDimCount; ++nDim)
2383 {
2384 std::auto_ptr<ScDPLabelData> pNewLabel(new ScDPLabelData);
2385 FillLabelDataForDimension(xDims, nDim, *pNewLabel);
2386 rParam.maLabelArray.push_back(pNewLabel);
2387 }
2388
2389 return true;
2390 }
2391
2392 bool ScDPObject::GetHierarchiesNA( sal_Int32 nDim, uno::Reference< container::XNameAccess >& xHiers )
2393 {
2394 bool bRet = false;
2395 uno::Reference<container::XNameAccess> xDimsName( GetSource()->getDimensions() );
2396 uno::Reference<container::XIndexAccess> xIntDims(new ScNameToIndexAccess( xDimsName ));
2397 if( xIntDims.is() )
2398 {
2399 uno::Reference<sheet::XHierarchiesSupplier> xHierSup(xIntDims->getByIndex( nDim ), uno::UNO_QUERY);
2400 if (xHierSup.is())
2401 {
2402 xHiers.set( xHierSup->getHierarchies() );
2403 bRet = xHiers.is();
2404 }
2405 }
2406 return bRet;
2407 }
2408
2409 bool ScDPObject::GetHierarchies( sal_Int32 nDim, uno::Sequence< OUString >& rHiers )
2410 {
2411 bool bRet = false;
2412 uno::Reference< container::XNameAccess > xHiersNA;
2413 if( GetHierarchiesNA( nDim, xHiersNA ) )
2414 {
2415 rHiers = xHiersNA->getElementNames();
2416 bRet = true;
2417 }
2418 return bRet;
2419 }
2420
2421 sal_Int32 ScDPObject::GetUsedHierarchy( sal_Int32 nDim )
2422 {
2423 sal_Int32 nHier = 0;
2424 uno::Reference<container::XNameAccess> xDimsName( GetSource()->getDimensions() );
2425 uno::Reference<container::XIndexAccess> xIntDims(new ScNameToIndexAccess( xDimsName ));
2426 uno::Reference<beans::XPropertySet> xDim(xIntDims->getByIndex( nDim ), uno::UNO_QUERY);
2427 if (xDim.is())
2428 nHier = ScUnoHelpFunctions::GetLongProperty( xDim, OUString( SC_UNO_DP_USEDHIERARCHY ) );
2429 return nHier;
2430 }
2431
2432 bool ScDPObject::GetMembersNA( sal_Int32 nDim, uno::Reference< container::XNameAccess >& xMembers )
2433 {
2434 return GetMembersNA( nDim, GetUsedHierarchy( nDim ), xMembers );
2435 }
2436
2437 bool ScDPObject::GetMembersNA( sal_Int32 nDim, sal_Int32 nHier, uno::Reference< container::XNameAccess >& xMembers )
2438 {
2439 bool bRet = false;
2440 uno::Reference<container::XNameAccess> xDimsName( GetSource()->getDimensions() );
2441 uno::Reference<container::XIndexAccess> xIntDims(new ScNameToIndexAccess( xDimsName ));
2442 uno::Reference<beans::XPropertySet> xDim(xIntDims->getByIndex( nDim ), uno::UNO_QUERY);
2443 if (xDim.is())
2444 {
2445 uno::Reference<sheet::XHierarchiesSupplier> xHierSup(xDim, uno::UNO_QUERY);
2446 if (xHierSup.is())
2447 {
2448 uno::Reference<container::XIndexAccess> xHiers(new ScNameToIndexAccess(xHierSup->getHierarchies()));
2449 uno::Reference<sheet::XLevelsSupplier> xLevSupp( xHiers->getByIndex(nHier), uno::UNO_QUERY );
2450 if ( xLevSupp.is() )
2451 {
2452 uno::Reference<container::XIndexAccess> xLevels(new ScNameToIndexAccess( xLevSupp->getLevels()));
2453 if (xLevels.is())
2454 {
2455 sal_Int32 nLevCount = xLevels->getCount();
2456 if (nLevCount > 0)
2457 {
2458 uno::Reference<sheet::XMembersSupplier> xMembSupp( xLevels->getByIndex(0), uno::UNO_QUERY );
2459 if ( xMembSupp.is() )
2460 {
2461 xMembers.set(xMembSupp->getMembers());
2462 bRet = true;
2463 }
2464 }
2465 }
2466 }
2467 }
2468 }
2469 return bRet;
2470 }
2471
2472 //------------------------------------------------------------------------
2473 // convert old pivot tables into new datapilot tables
2474
2475 namespace {
2476
2477 OUString lcl_GetDimName( const uno::Reference<sheet::XDimensionsSupplier>& xSource, long nDim )
2478 {
2479 OUString aName;
2480 if ( xSource.is() )
2481 {
2482 uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
2483 uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess( xDimsName );
2484 long nDimCount = xDims->getCount();
2485 if ( nDim < nDimCount )
2486 {
2487 uno::Reference<uno::XInterface> xIntDim =
2488 ScUnoHelpFunctions::AnyToInterface( xDims->getByIndex(nDim) );
2489 uno::Reference<container::XNamed> xDimName( xIntDim, uno::UNO_QUERY );
2490 if (xDimName.is())
2491 {
2492 try
2493 {
2494 aName = xDimName->getName();
2495 }
2496 catch(uno::Exception&)
2497 {
2498 }
2499 }
2500 }
2501 }
2502 return aName;
2503 }
2504
2505 bool hasFieldColumn(const vector<ScPivotField>* pRefFields, SCCOL nCol)
2506 {
2507 if (!pRefFields)
2508 return false;
2509
2510 vector<ScPivotField>::const_iterator itr = pRefFields->begin(), itrEnd = pRefFields->end();
2511 for (; itr != itrEnd; ++itr)
2512 {
2513 if (itr->nCol == nCol)
2514 // This array of fields contains the specified column.
2515 return true;
2516 }
2517 return false;
2518 }
2519
2520 class FindByOriginalDim : public std::unary_function<ScPivotField, bool>
2521 {
2522 long mnDim;
2523 public:
2524 FindByOriginalDim(long nDim) : mnDim(nDim) {}
2525 bool operator() (const ScPivotField& r) const
2526 {
2527 return mnDim == r.getOriginalDim();
2528 }
2529 };
2530
2531 }
2532
2533 void ScDPObject::ConvertOrientation(
2534 ScDPSaveData& rSaveData, const ScPivotFieldVector& rFields, sal_uInt16 nOrient,
2535 const Reference<XDimensionsSupplier>& xSource,
2536 const ScDPLabelDataVector& rLabels,
2537 const ScPivotFieldVector* pRefColFields,
2538 const ScPivotFieldVector* pRefRowFields,
2539 const ScPivotFieldVector* pRefPageFields )
2540 {
2541 ScPivotFieldVector::const_iterator itr, itrBeg = rFields.begin(), itrEnd = rFields.end();
2542 for (itr = itrBeg; itr != itrEnd; ++itr)
2543 {
2544 const ScPivotField& rField = *itr;
2545
2546 long nCol = rField.getOriginalDim();
2547 sal_uInt16 nFuncs = rField.nFuncMask;
2548 const sheet::DataPilotFieldReference& rFieldRef = rField.maFieldRef;
2549
2550 ScDPSaveDimension* pDim = NULL;
2551 if ( nCol == PIVOT_DATA_FIELD )
2552 pDim = rSaveData.GetDataLayoutDimension();
2553 else
2554 {
2555 OUString aDocStr = lcl_GetDimName( xSource, nCol ); // cols must start at 0
2556 if (!aDocStr.isEmpty())
2557 pDim = rSaveData.GetDimensionByName(aDocStr);
2558 else
2559 pDim = NULL;
2560 }
2561
2562 if (!pDim)
2563 continue;
2564
2565 if ( nOrient == sheet::DataPilotFieldOrientation_DATA ) // set summary function
2566 {
2567 // generate an individual entry for each function
2568 bool bFirst = true;
2569
2570 // if a dimension is used for column/row/page and data,
2571 // use duplicated dimensions for all data occurrences
2572 if (hasFieldColumn(pRefColFields, nCol))
2573 bFirst = false;
2574
2575 if (bFirst && hasFieldColumn(pRefRowFields, nCol))
2576 bFirst = false;
2577
2578 if (bFirst && hasFieldColumn(pRefPageFields, nCol))
2579 bFirst = false;
2580
2581 if (bFirst)
2582 {
2583 // if set via api, a data column may occur several times
2584 // (if the function hasn't been changed yet) -> also look for duplicate data column
2585 bFirst = std::find_if(itrBeg, itr, FindByOriginalDim(nCol)) == itr;
2586 }
2587
2588 sheet::GeneralFunction eFunc = ScDataPilotConversion::FirstFunc(rField.nFuncMask);
2589 if (!bFirst)
2590 pDim = rSaveData.DuplicateDimension(pDim->GetName());
2591 pDim->SetOrientation(nOrient);
2592 pDim->SetFunction(sal::static_int_cast<sal_uInt16>(eFunc));
2593
2594 if( rFieldRef.ReferenceType == sheet::DataPilotFieldReferenceType::NONE )
2595 pDim->SetReferenceValue(0);
2596 else
2597 pDim->SetReferenceValue(&rFieldRef);
2598 }
2599 else // set SubTotals
2600 {
2601 pDim->SetOrientation( nOrient );
2602
2603 sal_uInt16 nFuncArray[16];
2604 sal_uInt16 nFuncCount = 0;
2605 sal_uInt16 nMask = 1;
2606 for (sal_uInt16 nBit=0; nBit<16; nBit++)
2607 {
2608 if ( nFuncs & nMask )
2609 nFuncArray[nFuncCount++] = sal::static_int_cast<sal_uInt16>(ScDataPilotConversion::FirstFunc( nMask ));
2610 nMask *= 2;
2611 }
2612 pDim->SetSubTotals( nFuncCount, nFuncArray );
2613
2614 // ShowEmpty was implicit in old tables,
2615 // must be set for data layout dimension (not accessible in dialog)
2616 if ( nCol == PIVOT_DATA_FIELD )
2617 pDim->SetShowEmpty( true );
2618 }
2619
2620 size_t nDimIndex = rField.nCol;
2621 pDim->RemoveLayoutName();
2622 pDim->RemoveSubtotalName();
2623 if (nDimIndex < rLabels.size())
2624 {
2625 const ScDPLabelData& rLabel = rLabels[nDimIndex];
2626 if (!rLabel.maLayoutName.isEmpty())
2627 pDim->SetLayoutName(rLabel.maLayoutName);
2628 if (!rLabel.maSubtotalName.isEmpty())
2629 pDim->SetSubtotalName(rLabel.maSubtotalName);
2630 }
2631 }
2632 }
2633
2634 bool ScDPObject::IsOrientationAllowed( sal_uInt16 nOrient, sal_Int32 nDimFlags )
2635 {
2636 bool bAllowed = true;
2637 switch (nOrient)
2638 {
2639 case sheet::DataPilotFieldOrientation_PAGE:
2640 bAllowed = ( nDimFlags & sheet::DimensionFlags::NO_PAGE_ORIENTATION ) == 0;
2641 break;
2642 case sheet::DataPilotFieldOrientation_COLUMN:
2643 bAllowed = ( nDimFlags & sheet::DimensionFlags::NO_COLUMN_ORIENTATION ) == 0;
2644 break;
2645 case sheet::DataPilotFieldOrientation_ROW:
2646 bAllowed = ( nDimFlags & sheet::DimensionFlags::NO_ROW_ORIENTATION ) == 0;
2647 break;
2648 case sheet::DataPilotFieldOrientation_DATA:
2649 bAllowed = ( nDimFlags & sheet::DimensionFlags::NO_DATA_ORIENTATION ) == 0;
2650 break;
2651 default:
2652 {
2653 // allowed to remove from previous orientation
2654 }
2655 }
2656 return bAllowed;
2657 }
2658
2659 // -----------------------------------------------------------------------
2660
2661 bool ScDPObject::HasRegisteredSources()
2662 {
2663 bool bFound = false;
2664
2665 uno::Reference<lang::XMultiServiceFactory> xManager = comphelper::getProcessServiceFactory();
2666 uno::Reference<container::XContentEnumerationAccess> xEnAc( xManager, uno::UNO_QUERY );
2667 if ( xEnAc.is() )
2668 {
2669 uno::Reference<container::XEnumeration> xEnum = xEnAc->createContentEnumeration(
2670 OUString( SCDPSOURCE_SERVICE ) );
2671 if ( xEnum.is() && xEnum->hasMoreElements() )
2672 bFound = true;
2673 }
2674
2675 return bFound;
2676 }
2677
2678 uno::Sequence<OUString> ScDPObject::GetRegisteredSources()
2679 {
2680 uno::Sequence<OUString> aSeq(0);
2681
2682 // use implementation names...
2683
2684 uno::Reference<lang::XMultiServiceFactory> xManager = comphelper::getProcessServiceFactory();
2685 uno::Reference<container::XContentEnumerationAccess> xEnAc( xManager, uno::UNO_QUERY );
2686 if ( xEnAc.is() )
2687 {
2688 uno::Reference<container::XEnumeration> xEnum = xEnAc->createContentEnumeration(
2689 OUString( SCDPSOURCE_SERVICE ) );
2690 if ( xEnum.is() )
2691 {
2692 long nCount = 0;
2693 while ( xEnum->hasMoreElements() )
2694 {
2695 uno::Any aAddInAny = xEnum->nextElement();
2696 // if ( aAddInAny.getReflection()->getTypeClass() == TypeClass_INTERFACE )
2697 {
2698 uno::Reference<uno::XInterface> xIntFac;
2699 aAddInAny >>= xIntFac;
2700 if ( xIntFac.is() )
2701 {
2702 uno::Reference<lang::XServiceInfo> xInfo( xIntFac, uno::UNO_QUERY );
2703 if ( xInfo.is() )
2704 {
2705 OUString sName = xInfo->getImplementationName();
2706
2707 aSeq.realloc( nCount+1 );
2708 aSeq.getArray()[nCount] = sName;
2709 ++nCount;
2710 }
2711 }
2712 }
2713 }
2714 }
2715 }
2716
2717 return aSeq;
2718 }
2719
2720 uno::Reference<sheet::XDimensionsSupplier> ScDPObject::CreateSource( const ScDPServiceDesc& rDesc )
2721 {
2722 OUString aImplName = rDesc.aServiceName;
2723 uno::Reference<sheet::XDimensionsSupplier> xRet = NULL;
2724
2725 uno::Reference<lang::XMultiServiceFactory> xManager = comphelper::getProcessServiceFactory();
2726 uno::Reference<container::XContentEnumerationAccess> xEnAc(xManager, uno::UNO_QUERY);
2727 if (!xEnAc.is())
2728 return xRet;
2729
2730 uno::Reference<container::XEnumeration> xEnum =
2731 xEnAc->createContentEnumeration(OUString(SCDPSOURCE_SERVICE));
2732 if (!xEnum.is())
2733 return xRet;
2734
2735 while (xEnum->hasMoreElements() && !xRet.is())
2736 {
2737 uno::Any aAddInAny = xEnum->nextElement();
2738 uno::Reference<uno::XInterface> xIntFac;
2739 aAddInAny >>= xIntFac;
2740 if (!xIntFac.is())
2741 continue;
2742
2743 uno::Reference<lang::XServiceInfo> xInfo(xIntFac, uno::UNO_QUERY);
2744 if (!xInfo.is() || xInfo->getImplementationName() != aImplName)
2745 continue;
2746
2747 try
2748 {
2749 // #i113160# try XSingleComponentFactory in addition to (old) XSingleServiceFactory,
2750 // passing the context to the component (see ScUnoAddInCollection::Initialize)
2751
2752 uno::Reference<uno::XInterface> xInterface;
2753 uno::Reference<uno::XComponentContext> xCtx(
2754 comphelper::getComponentContext(xManager));
2755 uno::Reference<lang::XSingleComponentFactory> xCFac( xIntFac, uno::UNO_QUERY );
2756 if (xCFac.is())
2757 xInterface = xCFac->createInstanceWithContext(xCtx);
2758
2759 if (!xInterface.is())
2760 {
2761 uno::Reference<lang::XSingleServiceFactory> xFac( xIntFac, uno::UNO_QUERY );
2762 if ( xFac.is() )
2763 xInterface = xFac->createInstance();
2764 }
2765
2766 uno::Reference<lang::XInitialization> xInit( xInterface, uno::UNO_QUERY );
2767 if (xInit.is())
2768 {
2769 // initialize
2770 uno::Sequence<uno::Any> aSeq(4);
2771 uno::Any* pArray = aSeq.getArray();
2772 pArray[0] <<= OUString( rDesc.aParSource );
2773 pArray[1] <<= OUString( rDesc.aParName );
2774 pArray[2] <<= OUString( rDesc.aParUser );
2775 pArray[3] <<= OUString( rDesc.aParPass );
2776 xInit->initialize( aSeq );
2777 }
2778 xRet = uno::Reference<sheet::XDimensionsSupplier>( xInterface, uno::UNO_QUERY );
2779 }
2780 catch(uno::Exception&)
2781 {
2782 }
2783 }
2784
2785 return xRet;
2786 }
2787
2788 #if DEBUG_PIVOT_TABLE
2789 void ScDPObject::DumpCache() const
2790 {
2791 if (!mpTableData)
2792 return;
2793
2794 const ScDPCache* pCache = mpTableData->GetCacheTable().getCache();
2795 if (!pCache)
2796 return;
2797
2798 pCache->Dump();
2799 }
2800 #endif
2801
2802 ScDPCollection::SheetCaches::SheetCaches(ScDocument* pDoc) : mpDoc(pDoc) {}
2803
2804 namespace {
2805
2806 struct FindInvalidRange : public std::unary_function<ScRange, bool>
2807 {
2808 bool operator() (const ScRange& r) const
2809 {
2810 return !r.IsValid();
2811 }
2812 };
2813
2814 void setGroupItemsToCache( ScDPCache& rCache, const std::set<ScDPObject*>& rRefs )
2815 {
2816 // Go through all referencing pivot tables, and re-fill the group dimension info.
2817 std::set<ScDPObject*>::const_iterator itRef = rRefs.begin(), itRefEnd = rRefs.end();
2818 for (; itRef != itRefEnd; ++itRef)
2819 {
2820 const ScDPObject* pObj = *itRef;
2821 const ScDPSaveData* pSave = pObj->GetSaveData();
2822 if (!pSave)
2823 continue;
2824
2825 const ScDPDimensionSaveData* pGroupDims = pSave->GetExistingDimensionData();
2826 if (!pGroupDims)
2827 continue;
2828
2829 pGroupDims->WriteToCache(rCache);
2830 }
2831 }
2832
2833 }
2834
2835 bool ScDPCollection::SheetCaches::hasCache(const ScRange& rRange) const
2836 {
2837 RangeIndexType::const_iterator it = std::find(maRanges.begin(), maRanges.end(), rRange);
2838 if (it == maRanges.end())
2839 return false;
2840
2841 // Already cached.
2842 size_t nIndex = std::distance(maRanges.begin(), it);
2843 CachesType::const_iterator itCache = maCaches.find(nIndex);
2844 return itCache != maCaches.end();
2845 }
2846
2847 const ScDPCache* ScDPCollection::SheetCaches::getCache(const ScRange& rRange, const ScDPDimensionSaveData* pDimData)
2848 {
2849 RangeIndexType::iterator it = std::find(maRanges.begin(), maRanges.end(), rRange);
2850 if (it != maRanges.end())
2851 {
2852 // Already cached.
2853 size_t nIndex = std::distance(maRanges.begin(), it);
2854 CachesType::iterator itCache = maCaches.find(nIndex);
2855 if (itCache == maCaches.end())
2856 {
2857 OSL_FAIL("Cache pool and index pool out-of-sync !!!");
2858 return NULL;
2859 }
2860
2861 if (pDimData)
2862 pDimData->WriteToCache(*itCache->second);
2863
2864 return itCache->second;
2865 }
2866
2867 // Not cached. Create a new cache.
2868 SAL_WNODEPRECATED_DECLARATIONS_PUSH
2869 ::std::auto_ptr<ScDPCache> pCache(new ScDPCache(mpDoc));
2870 SAL_WNODEPRECATED_DECLARATIONS_POP
2871 pCache->InitFromDoc(mpDoc, rRange);
2872 if (pDimData)
2873 pDimData->WriteToCache(*pCache);
2874
2875 // Get the smallest available range index.
2876 it = std::find_if(maRanges.begin(), maRanges.end(), FindInvalidRange());
2877
2878 size_t nIndex = maRanges.size();
2879 if (it == maRanges.end())
2880 {
2881 // All range indices are valid. Append a new index.
2882 maRanges.push_back(rRange);
2883 }
2884 else
2885 {
2886 // Slot with invalid range. Re-use this slot.
2887 *it = rRange;
2888 nIndex = std::distance(maRanges.begin(), it);
2889 }
2890
2891 const ScDPCache* p = pCache.get();
2892 maCaches.insert(nIndex, pCache);
2893 return p;
2894 }
2895
2896 ScDPCache* ScDPCollection::SheetCaches::getExistingCache(const ScRange& rRange)
2897 {
2898 RangeIndexType::iterator it = std::find(maRanges.begin(), maRanges.end(), rRange);
2899 if (it == maRanges.end())
2900 // Not cached.
2901 return NULL;
2902
2903 // Already cached.
2904 size_t nIndex = std::distance(maRanges.begin(), it);
2905 CachesType::iterator itCache = maCaches.find(nIndex);
2906 if (itCache == maCaches.end())
2907 {
2908 OSL_FAIL("Cache pool and index pool out-of-sync !!!");
2909 return NULL;
2910 }
2911
2912 return itCache->second;
2913 }
2914
2915 size_t ScDPCollection::SheetCaches::size() const
2916 {
2917 return maCaches.size();
2918 }
2919
2920 void ScDPCollection::SheetCaches::updateReference(
2921 UpdateRefMode eMode, const ScRange& r, SCsCOL nDx, SCsROW nDy, SCsTAB nDz)
2922 {
2923 if (maRanges.empty())
2924 // No caches.
2925 return;
2926
2927 RangeIndexType::iterator it = maRanges.begin(), itEnd = maRanges.end();
2928 for (; it != itEnd; ++it)
2929 {
2930 const ScRange& rKeyRange = *it;
2931 SCCOL nCol1 = rKeyRange.aStart.Col();
2932 SCROW nRow1 = rKeyRange.aStart.Row();
2933 SCTAB nTab1 = rKeyRange.aStart.Tab();
2934 SCCOL nCol2 = rKeyRange.aEnd.Col();
2935 SCROW nRow2 = rKeyRange.aEnd.Row();
2936 SCTAB nTab2 = rKeyRange.aEnd.Tab();
2937
2938 ScRefUpdateRes eRes = ScRefUpdate::Update(
2939 mpDoc, eMode,
2940 r.aStart.Col(), r.aStart.Row(), r.aStart.Tab(),
2941 r.aEnd.Col(), r.aEnd.Row(), r.aEnd.Tab(), nDx, nDy, nDz,
2942 nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2943
2944 if (eRes != UR_NOTHING)
2945 {
2946 // range updated.
2947 ScRange aNew(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2948 *it = aNew;
2949 }
2950 }
2951 }
2952
2953 void ScDPCollection::SheetCaches::updateCache(const ScRange& rRange, std::set<ScDPObject*>& rRefs)
2954 {
2955 RangeIndexType::iterator it = std::find(maRanges.begin(), maRanges.end(), rRange);
2956 if (it == maRanges.end())
2957 {
2958 // Not cached. Nothing to do.
2959 rRefs.clear();
2960 return;
2961 }
2962
2963 size_t nIndex = std::distance(maRanges.begin(), it);
2964 CachesType::iterator itCache = maCaches.find(nIndex);
2965 if (itCache == maCaches.end())
2966 {
2967 OSL_FAIL("Cache pool and index pool out-of-sync !!!");
2968 rRefs.clear();
2969 return;
2970 }
2971
2972 ScDPCache& rCache = *itCache->second;
2973
2974 // Update the cache with new cell values. This will clear all group dimension info.
2975 rCache.InitFromDoc(mpDoc, rRange);
2976
2977 std::set<ScDPObject*> aRefs(rCache.GetAllReferences());
2978 rRefs.swap(aRefs);
2979
2980 // Make sure to re-populate the group dimension info.
2981 setGroupItemsToCache(rCache, rRefs);
2982 }
2983
2984 bool ScDPCollection::SheetCaches::remove(const ScDPCache* p)
2985 {
2986 CachesType::iterator it = maCaches.begin(), itEnd = maCaches.end();
2987 for (; it != itEnd; ++it)
2988 {
2989 if (it->second == p)
2990 {
2991 size_t idx = it->first;
2992 maCaches.erase(it);
2993 maRanges[idx].SetInvalid();
2994 return true;
2995 }
2996 }
2997 return false;
2998 }
2999
3000 ScDPCollection::NameCaches::NameCaches(ScDocument* pDoc) : mpDoc(pDoc) {}
3001
3002 bool ScDPCollection::NameCaches::hasCache(const OUString& rName) const
3003 {
3004 return maCaches.count(rName) != 0;
3005 }
3006
3007 const ScDPCache* ScDPCollection::NameCaches::getCache(
3008 const OUString& rName, const ScRange& rRange, const ScDPDimensionSaveData* pDimData)
3009 {
3010 CachesType::const_iterator itr = maCaches.find(rName);
3011 if (itr != maCaches.end())
3012 // already cached.
3013 return itr->second;
3014
3015 SAL_WNODEPRECATED_DECLARATIONS_PUSH
3016 ::std::auto_ptr<ScDPCache> pCache(new ScDPCache(mpDoc));
3017 SAL_WNODEPRECATED_DECLARATIONS_POP
3018 pCache->InitFromDoc(mpDoc, rRange);
3019 if (pDimData)
3020 pDimData->WriteToCache(*pCache);
3021
3022 const ScDPCache* p = pCache.get();
3023 maCaches.insert(rName, pCache);
3024 return p;
3025 }
3026
3027 ScDPCache* ScDPCollection::NameCaches::getExistingCache(const OUString& rName)
3028 {
3029 CachesType::iterator itr = maCaches.find(rName);
3030 return itr != maCaches.end() ? itr->second : NULL;
3031 }
3032
3033 size_t ScDPCollection::NameCaches::size() const
3034 {
3035 return maCaches.size();
3036 }
3037
3038 void ScDPCollection::NameCaches::updateCache(
3039 const OUString& rName, const ScRange& rRange, std::set<ScDPObject*>& rRefs)
3040 {
3041 CachesType::iterator itr = maCaches.find(rName);
3042 if (itr == maCaches.end())
3043 {
3044 rRefs.clear();
3045 return;
3046 }
3047
3048 ScDPCache& rCache = *itr->second;
3049 // Update the cache with new cell values. This will clear all group dimension info.
3050 rCache.InitFromDoc(mpDoc, rRange);
3051
3052 std::set<ScDPObject*> aRefs(rCache.GetAllReferences());
3053 rRefs.swap(aRefs);
3054
3055 // Make sure to re-populate the group dimension info.
3056 setGroupItemsToCache(rCache, rRefs);
3057 }
3058
3059 bool ScDPCollection::NameCaches::remove(const ScDPCache* p)
3060 {
3061 CachesType::iterator it = maCaches.begin(), itEnd = maCaches.end();
3062 for (; it != itEnd; ++it)
3063 {
3064 if (it->second == p)
3065 {
3066 maCaches.erase(it);
3067 return true;
3068 }
3069 }
3070 return false;
3071 }
3072
3073 ScDPCollection::DBType::DBType(sal_Int32 nSdbType, const OUString& rDBName, const OUString& rCommand) :
3074 mnSdbType(nSdbType), maDBName(rDBName), maCommand(rCommand) {}
3075
3076 bool ScDPCollection::DBType::less::operator() (const DBType& left, const DBType& right) const
3077 {
3078 return left < right;
3079 }
3080
3081 ScDPCollection::DBCaches::DBCaches(ScDocument* pDoc) : mpDoc(pDoc) {}
3082
3083 bool ScDPCollection::DBCaches::hasCache(sal_Int32 nSdbType, const OUString& rDBName, const OUString& rCommand) const
3084 {
3085 DBType aType(nSdbType, rDBName, rCommand);
3086 CachesType::const_iterator itr = maCaches.find(aType);
3087 return itr != maCaches.end();
3088 }
3089
3090 const ScDPCache* ScDPCollection::DBCaches::getCache(
3091 sal_Int32 nSdbType, const OUString& rDBName, const OUString& rCommand,
3092 const ScDPDimensionSaveData* pDimData)
3093 {
3094 DBType aType(nSdbType, rDBName, rCommand);
3095 CachesType::const_iterator itr = maCaches.find(aType);
3096 if (itr != maCaches.end())
3097 // already cached.
3098 return itr->second;
3099
3100 uno::Reference<sdbc::XRowSet> xRowSet = createRowSet(nSdbType, rDBName, rCommand);
3101 if (!xRowSet.is())
3102 return NULL;
3103
3104 SAL_WNODEPRECATED_DECLARATIONS_PUSH
3105 ::std::auto_ptr<ScDPCache> pCache(new ScDPCache(mpDoc));
3106 SAL_WNODEPRECATED_DECLARATIONS_POP
3107 SvNumberFormatter aFormat( comphelper::getComponentContext(mpDoc->GetServiceManager()), ScGlobal::eLnge);
3108 DBConnector aDB(*pCache, xRowSet, *aFormat.GetNullDate());
3109 if (!aDB.isValid())
3110 return NULL;
3111
3112 if (!pCache->InitFromDataBase(aDB))
3113 {
3114 // initialization failed.
3115 comphelper::disposeComponent(xRowSet);
3116 return NULL;
3117 }
3118
3119 if (pDimData)
3120 pDimData->WriteToCache(*pCache);
3121
3122 ::comphelper::disposeComponent(xRowSet);
3123 const ScDPCache* p = pCache.get();
3124 maCaches.insert(aType, pCache);
3125 return p;
3126 }
3127
3128 ScDPCache* ScDPCollection::DBCaches::getExistingCache(
3129 sal_Int32 nSdbType, const OUString& rDBName, const OUString& rCommand)
3130 {
3131 DBType aType(nSdbType, rDBName, rCommand);
3132 CachesType::iterator itr = maCaches.find(aType);
3133 return itr != maCaches.end() ? itr->second : NULL;
3134 }
3135
3136 uno::Reference<sdbc::XRowSet> ScDPCollection::DBCaches::createRowSet(
3137 sal_Int32 nSdbType, const OUString& rDBName, const OUString& rCommand)
3138 {
3139 uno::Reference<sdbc::XRowSet> xRowSet;
3140 try
3141 {
3142 xRowSet = uno::Reference<sdbc::XRowSet>(
3143 comphelper::getProcessServiceFactory()->createInstance(
3144 OUString(SC_SERVICE_ROWSET)),
3145 UNO_QUERY);
3146
3147 uno::Reference<beans::XPropertySet> xRowProp(xRowSet, UNO_QUERY);
3148 OSL_ENSURE( xRowProp.is(), "can't get RowSet" );
3149 if (!xRowProp.is())
3150 {
3151 xRowSet.set(NULL);
3152 return xRowSet;
3153 }
3154
3155 //
3156 // set source parameters
3157 //
3158 uno::Any aAny;
3159 aAny <<= rDBName;
3160 xRowProp->setPropertyValue(
3161 OUString(SC_DBPROP_DATASOURCENAME), aAny );
3162
3163 aAny <<= rCommand;
3164 xRowProp->setPropertyValue(
3165 OUString(SC_DBPROP_COMMAND), aAny );
3166
3167 aAny <<= nSdbType;
3168 xRowProp->setPropertyValue(
3169 OUString(SC_DBPROP_COMMANDTYPE), aAny );
3170
3171 uno::Reference<sdb::XCompletedExecution> xExecute( xRowSet, uno::UNO_QUERY );
3172 if ( xExecute.is() )
3173 {
3174 uno::Reference<task::XInteractionHandler> xHandler(
3175 task::InteractionHandler::createWithParent(comphelper::getProcessComponentContext(), 0),
3176 uno::UNO_QUERY_THROW);
3177 xExecute->executeWithCompletion( xHandler );
3178 }
3179 else
3180 xRowSet->execute();
3181
3182 return xRowSet;
3183 }
3184 catch ( const sdbc::SQLException& rError )
3185 {
3186 //! store error message
3187 InfoBox aInfoBox( 0, String(rError.Message) );
3188 aInfoBox.Execute();
3189 }
3190 catch ( uno::Exception& )
3191 {
3192 OSL_FAIL("Unexpected exception in database");
3193 }
3194
3195 xRowSet.set(NULL);
3196 return xRowSet;
3197 }
3198
3199 void ScDPCollection::DBCaches::updateCache(
3200 sal_Int32 nSdbType, const OUString& rDBName, const OUString& rCommand,
3201 std::set<ScDPObject*>& rRefs)
3202 {
3203 DBType aType(nSdbType, rDBName, rCommand);
3204 CachesType::iterator it = maCaches.find(aType);
3205 if (it == maCaches.end())
3206 {
3207 // not cached.
3208 rRefs.clear();
3209 return;
3210 }
3211
3212 ScDPCache& rCache = *it->second;
3213
3214 uno::Reference<sdbc::XRowSet> xRowSet = createRowSet(nSdbType, rDBName, rCommand);
3215 if (!xRowSet.is())
3216 {
3217 rRefs.clear();
3218 return;
3219 }
3220
3221 SvNumberFormatter aFormat( comphelper::getComponentContext(mpDoc->GetServiceManager()), ScGlobal::eLnge);
3222 DBConnector aDB(rCache, xRowSet, *aFormat.GetNullDate());
3223 if (!aDB.isValid())
3224 return;
3225
3226 if (!rCache.InitFromDataBase(aDB))
3227 {
3228 // initialization failed.
3229 rRefs.clear();
3230 comphelper::disposeComponent(xRowSet);
3231 return;
3232 }
3233
3234 comphelper::disposeComponent(xRowSet);
3235 std::set<ScDPObject*> aRefs(rCache.GetAllReferences());
3236 aRefs.swap(rRefs);
3237
3238 // Make sure to re-populate the group dimension info.
3239 setGroupItemsToCache(rCache, rRefs);
3240 }
3241
3242 bool ScDPCollection::DBCaches::remove(const ScDPCache* p)
3243 {
3244 CachesType::iterator it = maCaches.begin(), itEnd = maCaches.end();
3245 for (; it != itEnd; ++it)
3246 {
3247 if (it->second == p)
3248 {
3249 maCaches.erase(it);
3250 return true;
3251 }
3252 }
3253 return false;
3254 }
3255
3256 ScDPCollection::ScDPCollection(ScDocument* pDocument) :
3257 mpDoc( pDocument ),
3258 maSheetCaches(pDocument),
3259 maNameCaches(pDocument),
3260 maDBCaches(pDocument)
3261 {
3262 }
3263
3264 ScDPCollection::ScDPCollection(const ScDPCollection& r) :
3265 mpDoc(r.mpDoc),
3266 maSheetCaches(r.mpDoc),
3267 maNameCaches(r.mpDoc),
3268 maDBCaches(r.mpDoc)
3269 {
3270 }
3271
3272 ScDPCollection::~ScDPCollection()
3273 {
3274 maTables.clear();
3275 }
3276
3277 namespace {
3278
3279 /**
3280 * Unary predicate to match DP objects by the table ID.
3281 */
3282 class MatchByTable : public unary_function<ScDPObject, bool>
3283 {
3284 SCTAB mnTab;
3285 public:
3286 MatchByTable(SCTAB nTab) : mnTab(nTab) {}
3287
3288 bool operator() (const ScDPObject& rObj) const
3289 {
3290 return rObj.GetOutRange().aStart.Tab() == mnTab;
3291 }
3292 };
3293
3294 }
3295
3296 sal_uLong ScDPCollection::ReloadCache(ScDPObject* pDPObj, std::set<ScDPObject*>& rRefs)
3297 {
3298 if (!pDPObj)
3299 return STR_ERR_DATAPILOTSOURCE;
3300
3301 if (pDPObj->IsSheetData())
3302 {
3303 // data source is internal sheet.
3304 const ScSheetSourceDesc* pDesc = pDPObj->GetSheetDesc();
3305 if (!pDesc)
3306 return STR_ERR_DATAPILOTSOURCE;
3307
3308 sal_uLong nErrId = pDesc->CheckSourceRange();
3309 if (nErrId)
3310 return nErrId;
3311
3312 if (pDesc->HasRangeName())
3313 {
3314 // cache by named range
3315 ScDPCollection::NameCaches& rCaches = GetNameCaches();
3316 if (rCaches.hasCache(pDesc->GetRangeName()))
3317 rCaches.updateCache(pDesc->GetRangeName(), pDesc->GetSourceRange(), rRefs);
3318 else
3319 {
3320 // Not cached yet. Collect all tables that use this named
3321 // range as data source.
3322 GetAllTables(pDesc->GetRangeName(), rRefs);
3323 }
3324 }
3325 else
3326 {
3327 // cache by cell range
3328 ScDPCollection::SheetCaches& rCaches = GetSheetCaches();
3329 if (rCaches.hasCache(pDesc->GetSourceRange()))
3330 rCaches.updateCache(pDesc->GetSourceRange(), rRefs);
3331 else
3332 {
3333 // Not cached yet. Collect all tables that use this range as
3334 // data source.
3335 GetAllTables(pDesc->GetSourceRange(), rRefs);
3336 }
3337 }
3338 }
3339 else if (pDPObj->IsImportData())
3340 {
3341 // data source is external database.
3342 const ScImportSourceDesc* pDesc = pDPObj->GetImportSourceDesc();
3343 if (!pDesc)
3344 return STR_ERR_DATAPILOTSOURCE;
3345
3346 ScDPCollection::DBCaches& rCaches = GetDBCaches();
3347 if (rCaches.hasCache(pDesc->GetCommandType(), pDesc->aDBName, pDesc->aObject))
3348 rCaches.updateCache(
3349 pDesc->GetCommandType(), pDesc->aDBName, pDesc->aObject, rRefs);
3350 else
3351 {
3352 // Not cached yet. Collect all tables that use this range as
3353 // data source.
3354 GetAllTables(pDesc->GetCommandType(), pDesc->aDBName, pDesc->aObject, rRefs);
3355 }
3356 }
3357 return 0;
3358 }
3359
3360 bool ScDPCollection::ReloadGroupsInCache(ScDPObject* pDPObj, std::set<ScDPObject*>& rRefs)
3361 {
3362 if (!pDPObj)
3363 return false;
3364
3365 const ScDPSaveData* pSaveData = pDPObj->GetSaveData();
3366 if (!pSaveData)
3367 return false;
3368
3369 // Note: Unlike reloading cache, when modifying the group dimensions the
3370 // cache may not have all its references when this method is called.
3371 // Therefore, we need to always call GetAllTables to get its correct
3372 // references even when the cache exists. This may become a non-issue
3373 // if/when we implement loading and saving of pivot caches.
3374
3375 ScDPCache* pCache = NULL;
3376
3377 if (pDPObj->IsSheetData())
3378 {
3379 // data source is internal sheet.
3380 const ScSheetSourceDesc* pDesc = pDPObj->GetSheetDesc();
3381 if (!pDesc)
3382 return false;
3383
3384 if (pDesc->HasRangeName())
3385 {
3386 // cache by named range
3387 ScDPCollection::NameCaches& rCaches = GetNameCaches();
3388 if (rCaches.hasCache(pDesc->GetRangeName()))
3389 pCache = rCaches.getExistingCache(pDesc->GetRangeName());
3390 else
3391 {
3392 // Not cached yet. Cache the source dimensions. Groups will
3393 // be added below.
3394 pCache = const_cast<ScDPCache*>(
3395 rCaches.getCache(pDesc->GetRangeName(), pDesc->GetSourceRange(), NULL));
3396 }
3397 GetAllTables(pDesc->GetRangeName(), rRefs);
3398 }
3399 else
3400 {
3401 // cache by cell range
3402 ScDPCollection::SheetCaches& rCaches = GetSheetCaches();
3403 if (rCaches.hasCache(pDesc->GetSourceRange()))
3404 pCache = rCaches.getExistingCache(pDesc->GetSourceRange());
3405 else
3406 {
3407 // Not cached yet. Cache the source dimensions. Groups will
3408 // be added below.
3409 pCache = const_cast<ScDPCache*>(
3410 rCaches.getCache(pDesc->GetSourceRange(), NULL));
3411 }
3412 GetAllTables(pDesc->GetSourceRange(), rRefs);
3413 }
3414 }
3415 else if (pDPObj->IsImportData())
3416 {
3417 // data source is external database.
3418 const ScImportSourceDesc* pDesc = pDPObj->GetImportSourceDesc();
3419 if (!pDesc)
3420 return false;
3421
3422 ScDPCollection::DBCaches& rCaches = GetDBCaches();
3423 if (rCaches.hasCache(pDesc->GetCommandType(), pDesc->aDBName, pDesc->aObject))
3424 pCache = rCaches.getExistingCache(
3425 pDesc->GetCommandType(), pDesc->aDBName, pDesc->aObject);
3426 else
3427 {
3428 // Not cached yet. Cache the source dimensions. Groups will
3429 // be added below.
3430 pCache = const_cast<ScDPCache*>(
3431 rCaches.getCache(pDesc->GetCommandType(), pDesc->aDBName, pDesc->aObject, NULL));
3432 }
3433 GetAllTables(pDesc->GetCommandType(), pDesc->aDBName, pDesc->aObject, rRefs);
3434 }
3435
3436 if (!pCache)
3437 return false;
3438
3439 // Clear the existing group data from the cache, and rebuild it from the
3440 // dimension data.
3441 pCache->ClearGroupFields();
3442 const ScDPDimensionSaveData* pDimData = pSaveData->GetExistingDimensionData();
3443 if (pDimData)
3444 pDimData->WriteToCache(*pCache);
3445 return true;
3446 }
3447
3448 void ScDPCollection::DeleteOnTab( SCTAB nTab )
3449 {
3450 maTables.erase_if(MatchByTable(nTab));
3451 }
3452
3453 void ScDPCollection::UpdateReference( UpdateRefMode eUpdateRefMode,
3454 const ScRange& r, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
3455 {
3456 TablesType::iterator itr = maTables.begin(), itrEnd = maTables.end();
3457 for (; itr != itrEnd; ++itr)
3458 itr->UpdateReference(eUpdateRefMode, r, nDx, nDy, nDz);
3459
3460 // Update the source ranges of the caches.
3461 maSheetCaches.updateReference(eUpdateRefMode, r, nDx, nDy, nDz);
3462 }
3463
3464 void ScDPCollection::CopyToTab( SCTAB nOld, SCTAB nNew )
3465 {
3466 TablesType aAdded;
3467 TablesType::const_iterator it = maTables.begin(), itEnd = maTables.end();
3468 for (; it != itEnd; ++it)
3469 {
3470 const ScDPObject& rObj = *it;
3471 ScRange aOutRange = rObj.GetOutRange();
3472 if (aOutRange.aStart.Tab() != nOld)
3473 continue;
3474
3475 ScAddress& s = aOutRange.aStart;
3476 ScAddress& e = aOutRange.aEnd;
3477 s.SetTab(nNew);
3478 e.SetTab(nNew);
3479 std::auto_ptr<ScDPObject> pNew(new ScDPObject(rObj));
3480 pNew->SetOutRange(aOutRange);
3481 mpDoc->ApplyFlagsTab(s.Col(), s.Row(), e.Col(), e.Row(), s.Tab(), SC_MF_DP_TABLE);
3482 aAdded.push_back(pNew);
3483 }
3484
3485 maTables.transfer(maTables.end(), aAdded.begin(), aAdded.end(), aAdded);
3486 }
3487
3488 bool ScDPCollection::RefsEqual( const ScDPCollection& r ) const
3489 {
3490 if (maTables.size() != r.maTables.size())
3491 return false;
3492
3493 TablesType::const_iterator itr = maTables.begin(), itr2 = r.maTables.begin(), itrEnd = maTables.end();
3494 for (; itr != itrEnd; ++itr, ++itr2)
3495 if (!itr->RefsEqual(*itr2))
3496 return false;
3497
3498 return true;
3499 }
3500
3501 void ScDPCollection::WriteRefsTo( ScDPCollection& r ) const
3502 {
3503 if ( maTables.size() == r.maTables.size() )
3504 {
3505 //! assert equal names?
3506 TablesType::const_iterator itr = maTables.begin(), itrEnd = maTables.end();
3507 TablesType::iterator itr2 = r.maTables.begin();
3508 for (; itr != itrEnd; ++itr, ++itr2)
3509 itr->WriteRefsTo(*itr2);
3510 }
3511 else
3512 {
3513 // #i8180# If data pilot tables were deleted with their sheet,
3514 // this collection contains extra entries that must be restored.
3515 // Matching objects are found by their names.
3516 size_t nSrcSize = maTables.size();
3517 size_t nDestSize = r.maTables.size();
3518 OSL_ENSURE( nSrcSize >= nDestSize, "WriteRefsTo: missing entries in document" );
3519 for (size_t nSrcPos = 0; nSrcPos < nSrcSize; ++nSrcPos)
3520 {
3521 const ScDPObject& rSrcObj = maTables[nSrcPos];
3522 const OUString& aName = rSrcObj.GetName();
3523 bool bFound = false;
3524 for (size_t nDestPos = 0; nDestPos < nDestSize && !bFound; ++nDestPos)
3525 {
3526 ScDPObject& rDestObj = r.maTables[nDestPos];
3527 if (rDestObj.GetName() == aName)
3528 {
3529 rSrcObj.WriteRefsTo(rDestObj); // found object, copy refs
3530 bFound = true;
3531 }
3532 }
3533
3534 if (!bFound)
3535 {
3536 // none found, re-insert deleted object (see ScUndoDataPilot::Undo)
3537
3538 ScDPObject* pDestObj = new ScDPObject(rSrcObj);
3539 r.InsertNewTable(pDestObj);
3540 }
3541 }
3542 OSL_ENSURE( maTables.size() == r.maTables.size(), "WriteRefsTo: couldn't restore all entries" );
3543 }
3544 }
3545
3546 size_t ScDPCollection::GetCount() const
3547 {
3548 return maTables.size();
3549 }
3550
3551 ScDPObject* ScDPCollection::operator [](size_t nIndex)
3552 {
3553 return &maTables[nIndex];
3554 }
3555
3556 const ScDPObject* ScDPCollection::operator [](size_t nIndex) const
3557 {
3558 return &maTables[nIndex];
3559 }
3560
3561 const ScDPObject* ScDPCollection::GetByName(const OUString& rName) const
3562 {
3563 TablesType::const_iterator itr = maTables.begin(), itrEnd = maTables.end();
3564 for (; itr != itrEnd; ++itr)
3565 if (itr->GetName() == rName)
3566 return &(*itr);
3567
3568 return NULL;
3569 }
3570
3571 OUString ScDPCollection::CreateNewName( sal_uInt16 nMin ) const
3572 {
3573 OUString aBase("DataPilot");
3574
3575 size_t n = maTables.size();
3576 for (size_t nAdd = 0; nAdd <= n; ++nAdd) // nCount+1 tries
3577 {
3578 OUStringBuffer aBuf;
3579 aBuf.append(aBase);
3580 aBuf.append(static_cast<sal_Int32>(nMin + nAdd));
3581 OUString aNewName = aBuf.makeStringAndClear();
3582 bool bFound = false;
3583 TablesType::const_iterator itr = maTables.begin(), itrEnd = maTables.end();
3584 for (; itr != itrEnd; ++itr)
3585 {
3586 if (itr->GetName() == aNewName)
3587 {
3588 bFound = true;
3589 break;
3590 }
3591 }
3592 if (!bFound)
3593 return aNewName; // found unused Name
3594 }
3595 return OUString(); // should not happen
3596 }
3597
3598 void ScDPCollection::FreeTable(ScDPObject* pDPObj)
3599 {
3600 const ScRange& rOutRange = pDPObj->GetOutRange();
3601 const ScAddress& s = rOutRange.aStart;
3602 const ScAddress& e = rOutRange.aEnd;
3603 mpDoc->RemoveFlagsTab(s.Col(), s.Row(), e.Col(), e.Row(), s.Tab(), SC_MF_DP_TABLE);
3604 TablesType::iterator itr = maTables.begin(), itrEnd = maTables.end();
3605 for (; itr != itrEnd; ++itr)
3606 {
3607 ScDPObject* p = &(*itr);
3608 if (p == pDPObj)
3609 {
3610 maTables.erase(itr);
3611 break;
3612 }
3613 }
3614 }
3615
3616 bool ScDPCollection::InsertNewTable(ScDPObject* pDPObj)
3617 {
3618 const ScRange& rOutRange = pDPObj->GetOutRange();
3619 const ScAddress& s = rOutRange.aStart;
3620 const ScAddress& e = rOutRange.aEnd;
3621 mpDoc->ApplyFlagsTab(s.Col(), s.Row(), e.Col(), e.Row(), s.Tab(), SC_MF_DP_TABLE);
3622
3623 maTables.push_back(pDPObj);
3624 return true;
3625 }
3626
3627 ScDPCollection::SheetCaches& ScDPCollection::GetSheetCaches()
3628 {
3629 return maSheetCaches;
3630 }
3631
3632 ScDPCollection::NameCaches& ScDPCollection::GetNameCaches()
3633 {
3634 return maNameCaches;
3635 }
3636
3637 ScDPCollection::DBCaches& ScDPCollection::GetDBCaches()
3638 {
3639 return maDBCaches;
3640 }
3641
3642 ScRangeList ScDPCollection::GetAllTableRanges( SCTAB nTab ) const
3643 {
3644 return std::for_each(maTables.begin(), maTables.end(), AccumulateOutputRanges(nTab)).getRanges();
3645 }
3646
3647 bool ScDPCollection::IntersectsTableByColumns( SCCOL nCol1, SCCOL nCol2, SCROW nRow, SCTAB nTab ) const
3648 {
3649 return std::find_if(
3650 maTables.begin(), maTables.end(), FindIntersetingTableByColumns(nCol1, nCol2, nRow, nTab)) != maTables.end();
3651 }
3652
3653 bool ScDPCollection::IntersectsTableByRows( SCCOL nCol, SCROW nRow1, SCROW nRow2, SCTAB nTab ) const
3654 {
3655 return std::find_if(
3656 maTables.begin(), maTables.end(), FindIntersectingTableByRows(nCol, nRow1, nRow2, nTab)) != maTables.end();
3657 }
3658
3659 bool ScDPCollection::HasTable( const ScRange& rRange ) const
3660 {
3661 return std::find_if(
3662 maTables.begin(), maTables.end(), FindIntersectingTable(rRange)) != maTables.end();
3663 }
3664
3665 void ScDPCollection::RemoveCache(const ScDPCache* pCache)
3666 {
3667 if (maSheetCaches.remove(pCache))
3668 // sheet cache removed.
3669 return;
3670
3671 if (maNameCaches.remove(pCache))
3672 // named range cache removed.
3673 return;
3674
3675 if (maDBCaches.remove(pCache))
3676 // database cache removed.
3677 return;
3678 }
3679
3680 void ScDPCollection::GetAllTables(const ScRange& rSrcRange, std::set<ScDPObject*>& rRefs) const
3681 {
3682 std::set<ScDPObject*> aRefs;
3683 TablesType::const_iterator it = maTables.begin(), itEnd = maTables.end();
3684 for (; it != itEnd; ++it)
3685 {
3686 const ScDPObject& rObj = *it;
3687 if (!rObj.IsSheetData())
3688 // Source is not a sheet range.
3689 continue;
3690
3691 const ScSheetSourceDesc* pDesc = rObj.GetSheetDesc();
3692 if (!pDesc)
3693 continue;
3694
3695 if (pDesc->HasRangeName())
3696 // This table has a range name as its source.
3697 continue;
3698
3699 if (pDesc->GetSourceRange() != rSrcRange)
3700 // Different source range.
3701 continue;
3702
3703 aRefs.insert(const_cast<ScDPObject*>(&rObj));
3704 }
3705
3706 rRefs.swap(aRefs);
3707 }
3708
3709 void ScDPCollection::GetAllTables(const OUString& rSrcName, std::set<ScDPObject*>& rRefs) const
3710 {
3711 std::set<ScDPObject*> aRefs;
3712 TablesType::const_iterator it = maTables.begin(), itEnd = maTables.end();
3713 for (; it != itEnd; ++it)
3714 {
3715 const ScDPObject& rObj = *it;
3716 if (!rObj.IsSheetData())
3717 // Source is not a sheet range.
3718 continue;
3719
3720 const ScSheetSourceDesc* pDesc = rObj.GetSheetDesc();
3721 if (!pDesc)
3722 continue;
3723
3724 if (!pDesc->HasRangeName())
3725 // This table probably has a sheet range as its source.
3726 continue;
3727
3728 if (pDesc->GetRangeName() != rSrcName)
3729 // Different source name.
3730 continue;
3731
3732 aRefs.insert(const_cast<ScDPObject*>(&rObj));
3733 }
3734
3735 rRefs.swap(aRefs);
3736 }
3737
3738 void ScDPCollection::GetAllTables(
3739 sal_Int32 nSdbType, const OUString& rDBName, const OUString& rCommand,
3740 std::set<ScDPObject*>& rRefs) const
3741 {
3742 std::set<ScDPObject*> aRefs;
3743 TablesType::const_iterator it = maTables.begin(), itEnd = maTables.end();
3744 for (; it != itEnd; ++it)
3745 {
3746 const ScDPObject& rObj = *it;
3747 if (!rObj.IsImportData())
3748 // Source data is not a database.
3749 continue;
3750
3751 const ScImportSourceDesc* pDesc = rObj.GetImportSourceDesc();
3752 if (!pDesc)
3753 continue;
3754
3755 if (!pDesc->aDBName.equals(rDBName) || !pDesc->aObject.equals(rCommand) || pDesc->GetCommandType() != nSdbType)
3756 // Different database source.
3757 continue;
3758
3759 aRefs.insert(const_cast<ScDPObject*>(&rObj));
3760 }
3761
3762 rRefs.swap(aRefs);
3763 }
3764
3765 bool operator<(const ScDPCollection::DBType& left, const ScDPCollection::DBType& right)
3766 {
3767 if (left.mnSdbType != right.mnSdbType)
3768 return left.mnSdbType < right.mnSdbType;
3769
3770 if (!left.maDBName.equals(right.maDBName))
3771 return left.maDBName < right.maDBName;
3772
3773 return left.maCommand < right.maCommand;
3774 }
3775
3776 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE