?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Stop leaking all ScPostIt instances.
[LibreOffice.git] / sc / source / ui / unoobj / dapiuno.cxx
blob180c06129c36082032d0f29f67dfe7c20e40ea2f
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <algorithm>
22 #include <svl/smplhint.hxx>
23 #include <vcl/svapp.hxx>
24
25 #include "dapiuno.hxx"
26 #include "datauno.hxx"
27 #include "miscuno.hxx"
28 #include "convuno.hxx"
29 #include "docsh.hxx"
30 #include "tabvwsh.hxx"
31 #include "pivot.hxx"
32 #include "rangeutl.hxx"
33 #include "dpobject.hxx"
34 #include "dpshttab.hxx"
35 #include "dpsdbtab.hxx"
36 #include "dpsave.hxx"
37 #include "dbdocfun.hxx"
38 #include "unonames.hxx"
39 #include "dpgroup.hxx"
40 #include "dpdimsave.hxx"
41 #include "hints.hxx"
42
43 #include <com/sun/star/sheet/XHierarchiesSupplier.hpp>
44 #include <com/sun/star/sheet/XLevelsSupplier.hpp>
45 #include <com/sun/star/sheet/XMembersSupplier.hpp>
46 #include <com/sun/star/beans/PropertyAttribute.hpp>
47 #include <com/sun/star/sheet/DataImportMode.hpp>
48 #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
49 #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
50 #include <com/sun/star/sheet/DataPilotOutputRangeType.hpp>
51 #include <com/sun/star/sheet/DataPilotTablePositionData.hpp>
52
53 #include <comphelper/extract.hxx>
54 #include <comphelper/sequence.hxx>
55 #include <comphelper/servicehelper.hxx>
56
57 using namespace com::sun::star;
58 using namespace com::sun::star::sheet;
59
60
61 using ::com::sun::star::uno::Any;
62 using ::com::sun::star::uno::Exception;
63 using ::com::sun::star::uno::Reference;
64 using ::com::sun::star::uno::RuntimeException;
65 using ::com::sun::star::uno::Sequence;
66 using ::com::sun::star::uno::UNO_QUERY;
67 using ::com::sun::star::uno::UNO_QUERY_THROW;
68
69 using ::com::sun::star::container::ElementExistException;
70 using ::com::sun::star::container::NoSuchElementException;
71 using ::com::sun::star::container::XEnumeration;
72 using ::com::sun::star::container::XIndexAccess;
73 using ::com::sun::star::container::XNameAccess;
74 using ::com::sun::star::container::XNamed;
75
76 using ::com::sun::star::beans::PropertyVetoException;
77 using ::com::sun::star::beans::UnknownPropertyException;
78 using ::com::sun::star::beans::XPropertyChangeListener;
79 using ::com::sun::star::beans::XPropertySet;
80 using ::com::sun::star::beans::XPropertySetInfo;
81 using ::com::sun::star::beans::XVetoableChangeListener;
82
83 using ::com::sun::star::lang::IllegalArgumentException;
84 using ::com::sun::star::lang::IndexOutOfBoundsException;
85 using ::com::sun::star::lang::WrappedTargetException;
86
87 using ::com::sun::star::table::CellAddress;
88 using ::com::sun::star::table::CellRangeAddress;
89
90 // ============================================================================
91
92 namespace {
93
94 const SfxItemPropertyMapEntry* lcl_GetDataPilotDescriptorBaseMap()
95 {
96 static const SfxItemPropertyMapEntry aDataPilotDescriptorBaseMap_Impl[] =
97 {
98 {MAP_CHAR_LEN(SC_UNO_DP_COLGRAND), 0, &getBooleanCppuType(), 0, 0 },
99 {MAP_CHAR_LEN(SC_UNO_DP_DRILLDOWN), 0, &getBooleanCppuType(), 0, 0 },
100 {MAP_CHAR_LEN(SC_UNO_DP_GRANDTOTAL_NAME),0,&getCppuType((OUString*)0), beans::PropertyAttribute::MAYBEVOID, 0 },
101 {MAP_CHAR_LEN(SC_UNO_DP_IGNORE_EMPTYROWS), 0, &getBooleanCppuType(), 0, 0 },
102 {MAP_CHAR_LEN(SC_UNO_DP_IMPORTDESC), 0, &getCppuType((uno::Sequence<beans::PropertyValue>*)0), 0, 0 },
103 {MAP_CHAR_LEN(SC_UNO_DP_REPEATEMPTY), 0, &getBooleanCppuType(), 0, 0 },
104 {MAP_CHAR_LEN(SC_UNO_DP_ROWGRAND), 0, &getBooleanCppuType(), 0, 0 },
105 {MAP_CHAR_LEN(SC_UNO_DP_SERVICEARG), 0, &getCppuType((uno::Sequence<beans::PropertyValue>*)0), 0, 0 },
106 {MAP_CHAR_LEN(SC_UNO_DP_SHOWFILTER), 0, &getBooleanCppuType(), 0, 0 },
107 {MAP_CHAR_LEN(SC_UNO_DP_SOURCESERVICE), 0, &getCppuType((OUString*)0), 0, 0 },
108 {0,0,0,0,0,0}
109 };
110 return aDataPilotDescriptorBaseMap_Impl;
111 }
112
113 // ----------------------------------------------------------------------------
114
115 const SfxItemPropertyMapEntry* lcl_GetDataPilotFieldMap()
116 {
117 using namespace ::com::sun::star::beans::PropertyAttribute;
118 static const SfxItemPropertyMapEntry aDataPilotFieldMap_Impl[] =
119 {
120 {MAP_CHAR_LEN(SC_UNONAME_AUTOSHOW), 0, &getCppuType((DataPilotFieldAutoShowInfo*)0), MAYBEVOID, 0 },
121 {MAP_CHAR_LEN(SC_UNONAME_FUNCTION), 0, &getCppuType((GeneralFunction*)0), 0, 0 },
122 {MAP_CHAR_LEN(SC_UNONAME_GROUPINFO), 0, &getCppuType((DataPilotFieldGroupInfo*)0), MAYBEVOID, 0 },
123 {MAP_CHAR_LEN(SC_UNONAME_HASAUTOSHOW), 0, &getBooleanCppuType(), 0, 0 },
124 {MAP_CHAR_LEN(SC_UNONAME_HASLAYOUTINFO),0, &getBooleanCppuType(), 0, 0 },
125 {MAP_CHAR_LEN(SC_UNONAME_HASREFERENCE), 0, &getBooleanCppuType(), 0, 0 },
126 {MAP_CHAR_LEN(SC_UNONAME_HASSORTINFO), 0, &getBooleanCppuType(), 0, 0 },
127 {MAP_CHAR_LEN(SC_UNONAME_ISGROUP), 0, &getBooleanCppuType(), 0, 0 },
128 {MAP_CHAR_LEN(SC_UNONAME_LAYOUTINFO), 0, &getCppuType((DataPilotFieldLayoutInfo*)0), MAYBEVOID, 0 },
129 {MAP_CHAR_LEN(SC_UNONAME_ORIENT), 0, &getCppuType((DataPilotFieldOrientation*)0), MAYBEVOID, 0 },
130 {MAP_CHAR_LEN(SC_UNONAME_REFERENCE), 0, &getCppuType((DataPilotFieldReference*)0), MAYBEVOID, 0 },
131 {MAP_CHAR_LEN(SC_UNONAME_SELPAGE), 0, &getCppuType((OUString*)0), 0, 0 },
132 {MAP_CHAR_LEN(SC_UNONAME_SHOWEMPTY), 0, &getBooleanCppuType(), 0, 0 },
133 {MAP_CHAR_LEN(SC_UNONAME_SORTINFO), 0, &getCppuType((DataPilotFieldSortInfo*)0), MAYBEVOID, 0 },
134 {MAP_CHAR_LEN(SC_UNONAME_SUBTOTALS), 0, &getCppuType((Sequence<GeneralFunction>*)0), 0, 0 },
135 {MAP_CHAR_LEN(SC_UNONAME_USESELPAGE), 0, &getBooleanCppuType(), 0, 0 },
136 {0,0,0,0,0,0}
137 };
138 return aDataPilotFieldMap_Impl;
139 }
140
141 // ----------------------------------------------------------------------------
142
143 const SfxItemPropertyMapEntry* lcl_GetDataPilotItemMap()
144 {
145 static const SfxItemPropertyMapEntry aDataPilotItemMap_Impl[] =
146 {
147 {MAP_CHAR_LEN(SC_UNONAME_ISHIDDEN), 0, &getBooleanCppuType(), 0, 0 },
148 {MAP_CHAR_LEN(SC_UNONAME_POS), 0, &getCppuType((sal_Int32*)0), 0, 0 },
149 {MAP_CHAR_LEN(SC_UNONAME_SHOWDETAIL), 0, &getBooleanCppuType(), 0, 0 },
150 {0,0,0,0,0,0}
151 };
152 return aDataPilotItemMap_Impl;
153 }
154
155 // ----------------------------------------------------------------------------
156
157 inline bool lclCheckValidDouble( double fValue, sal_Bool bAuto )
158 {
159 return bAuto || ::rtl::math::isFinite( fValue );
160 }
161
162 bool lclCheckMinMaxStep( const DataPilotFieldGroupInfo& rInfo )
163 {
164 return
165 lclCheckValidDouble( rInfo.Start, rInfo.HasAutoStart ) &&
166 lclCheckValidDouble( rInfo.End, rInfo.HasAutoEnd ) &&
167 (rInfo.HasAutoStart || rInfo.HasAutoEnd || (rInfo.Start <= rInfo.End)) &&
168 lclCheckValidDouble( rInfo.Step, false ) &&
169 (0.0 <= rInfo.Step);
170 }
171
172 } // namespace
173
174 // ============================================================================
175
176 SC_SIMPLE_SERVICE_INFO( ScDataPilotDescriptor, "ScDataPilotDescriptor", "stardiv::one::sheet::DataPilotDescriptor" )
177 SC_SIMPLE_SERVICE_INFO( ScDataPilotFieldObj, "ScDataPilotFieldObj", "com.sun.star.sheet.DataPilotField" )
178 SC_SIMPLE_SERVICE_INFO( ScDataPilotFieldsObj, "ScDataPilotFieldsObj", "com.sun.star.sheet.DataPilotFields" )
179 SC_SIMPLE_SERVICE_INFO( ScDataPilotTableObj, "ScDataPilotTableObj", "com.sun.star.sheet.DataPilotTable" )
180 SC_SIMPLE_SERVICE_INFO( ScDataPilotTablesObj, "ScDataPilotTablesObj", "com.sun.star.sheet.DataPilotTables" )
181 SC_SIMPLE_SERVICE_INFO( ScDataPilotItemsObj, "ScDataPilotItemsObj", "com.sun.star.sheet.DataPilotItems" )
182 SC_SIMPLE_SERVICE_INFO( ScDataPilotItemObj, "ScDataPilotItemObj", "com.sun.star.sheet.DataPilotItem" )
183
184 SC_SIMPLE_SERVICE_INFO( ScDataPilotFieldGroupsObj, "ScDataPilotFieldGroupsObj", "com.sun.star.sheet.DataPilotFieldGroups" )
185 SC_SIMPLE_SERVICE_INFO( ScDataPilotFieldGroupObj, "ScDataPilotFieldGroupObj", "com.sun.star.sheet.DataPilotFieldGroup" )
186 SC_SIMPLE_SERVICE_INFO( ScDataPilotFieldGroupItemObj, "ScDataPilotFieldGroupItemObj", "com.sun.star.sheet.DataPilotFieldGroupItem" )
187
188 //------------------------------------------------------------------------
189
190 // name that is used in the API for the data layout field
191 #define SC_DATALAYOUT_NAME "Data"
192
193 //------------------------------------------------------------------------
194
195 GeneralFunction ScDataPilotConversion::FirstFunc( sal_uInt16 nBits )
196 {
197 if ( nBits & PIVOT_FUNC_SUM ) return GeneralFunction_SUM;
198 if ( nBits & PIVOT_FUNC_COUNT ) return GeneralFunction_COUNT;
199 if ( nBits & PIVOT_FUNC_AVERAGE ) return GeneralFunction_AVERAGE;
200 if ( nBits & PIVOT_FUNC_MAX ) return GeneralFunction_MAX;
201 if ( nBits & PIVOT_FUNC_MIN ) return GeneralFunction_MIN;
202 if ( nBits & PIVOT_FUNC_PRODUCT ) return GeneralFunction_PRODUCT;
203 if ( nBits & PIVOT_FUNC_COUNT_NUM ) return GeneralFunction_COUNTNUMS;
204 if ( nBits & PIVOT_FUNC_STD_DEV ) return GeneralFunction_STDEV;
205 if ( nBits & PIVOT_FUNC_STD_DEVP ) return GeneralFunction_STDEVP;
206 if ( nBits & PIVOT_FUNC_STD_VAR ) return GeneralFunction_VAR;
207 if ( nBits & PIVOT_FUNC_STD_VARP ) return GeneralFunction_VARP;
208 if ( nBits & PIVOT_FUNC_AUTO ) return GeneralFunction_AUTO;
209 return GeneralFunction_NONE;
210 }
211
212 sal_uInt16 ScDataPilotConversion::FunctionBit( GeneralFunction eFunc )
213 {
214 sal_uInt16 nRet = PIVOT_FUNC_NONE; // 0
215 switch (eFunc)
216 {
217 case GeneralFunction_SUM: nRet = PIVOT_FUNC_SUM; break;
218 case GeneralFunction_COUNT: nRet = PIVOT_FUNC_COUNT; break;
219 case GeneralFunction_AVERAGE: nRet = PIVOT_FUNC_AVERAGE; break;
220 case GeneralFunction_MAX: nRet = PIVOT_FUNC_MAX; break;
221 case GeneralFunction_MIN: nRet = PIVOT_FUNC_MIN; break;
222 case GeneralFunction_PRODUCT: nRet = PIVOT_FUNC_PRODUCT; break;
223 case GeneralFunction_COUNTNUMS: nRet = PIVOT_FUNC_COUNT_NUM; break;
224 case GeneralFunction_STDEV: nRet = PIVOT_FUNC_STD_DEV; break;
225 case GeneralFunction_STDEVP: nRet = PIVOT_FUNC_STD_DEVP; break;
226 case GeneralFunction_VAR: nRet = PIVOT_FUNC_STD_VAR; break;
227 case GeneralFunction_VARP: nRet = PIVOT_FUNC_STD_VARP; break;
228 case GeneralFunction_AUTO: nRet = PIVOT_FUNC_AUTO; break;
229 default:
230 {
231 // added to avoid warnings
232 }
233 }
234 return nRet;
235 }
236
237 void ScDataPilotConversion::FillGroupInfo( DataPilotFieldGroupInfo& rInfo, const ScDPNumGroupInfo& rGroupInfo )
238 {
239 rInfo.HasDateValues = rGroupInfo.mbDateValues;
240 rInfo.HasAutoStart = rGroupInfo.mbAutoStart;
241 rInfo.Start = rGroupInfo.mfStart;
242 rInfo.HasAutoEnd = rGroupInfo.mbAutoEnd;
243 rInfo.End = rGroupInfo.mfEnd;
244 rInfo.Step = rGroupInfo.mfStep;
245 }
246
247 //------------------------------------------------------------------------
248
249 static ScDPObject* lcl_GetDPObject( ScDocShell* pDocShell, SCTAB nTab, const OUString& rName )
250 {
251 if (pDocShell)
252 {
253 ScDocument* pDoc = pDocShell->GetDocument();
254 ScDPCollection* pColl = pDoc->GetDPCollection();
255 if ( pColl )
256 {
257 size_t nCount = pColl->GetCount();
258 for (size_t i=0; i<nCount; ++i)
259 {
260 ScDPObject* pDPObj = (*pColl)[i];
261 if ( pDPObj->GetOutRange().aStart.Tab() == nTab &&
262 pDPObj->GetName() == rName )
263 return pDPObj;
264 }
265 }
266 }
267 return NULL; // nicht gefunden
268 }
269
270 static OUString lcl_CreatePivotName( ScDocShell* pDocShell )
271 {
272 if (pDocShell)
273 {
274 ScDocument* pDoc = pDocShell->GetDocument();
275 ScDPCollection* pColl = pDoc->GetDPCollection();
276 if ( pColl )
277 return pColl->CreateNewName();
278 }
279 return OUString(); // sollte nicht vorkommen
280 }
281
282 static sal_Int32 lcl_GetObjectIndex( ScDPObject* pDPObj, const ScFieldIdentifier& rFieldId )
283 {
284 // used for items - nRepeat in identifier can be ignored
285 if ( pDPObj )
286 {
287 sal_Int32 nCount = pDPObj->GetDimCount();
288 for ( sal_Int32 nDim = 0; nDim < nCount; ++nDim )
289 {
290 bool bIsDataLayout = false;
291 OUString aDimName( pDPObj->GetDimName( nDim, bIsDataLayout ) );
292 if ( rFieldId.mbDataLayout ? bIsDataLayout : (aDimName == rFieldId.maFieldName) )
293 return nDim;
294 }
295 }
296 return -1; // none
297 }
298
299 //------------------------------------------------------------------------
300
301 ScDataPilotTablesObj::ScDataPilotTablesObj(ScDocShell* pDocSh, SCTAB nT) :
302 pDocShell( pDocSh ),
303 nTab( nT )
304 {
305 pDocShell->GetDocument()->AddUnoObject(*this);
306 }
307
308 ScDataPilotTablesObj::~ScDataPilotTablesObj()
309 {
310 if (pDocShell)
311 pDocShell->GetDocument()->RemoveUnoObject(*this);
312 }
313
314 void ScDataPilotTablesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
315 {
316 //! Referenz-Update
317
318 if ( rHint.ISA( SfxSimpleHint ) &&
319 ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
320 {
321 pDocShell = NULL; // ungueltig geworden
322 }
323 }
324
325 // XDataPilotTables
326
327 ScDataPilotTableObj* ScDataPilotTablesObj::GetObjectByIndex_Impl( sal_Int32 nIndex )
328 {
329 if (pDocShell)
330 {
331 ScDocument* pDoc = pDocShell->GetDocument();
332 ScDPCollection* pColl = pDoc->GetDPCollection();
333 if ( pColl )
334 {
335 // count tables on this sheet
336 sal_Int32 nFound = 0;
337 size_t nCount = pColl->GetCount();
338 for (size_t i=0; i<nCount; ++i)
339 {
340 ScDPObject* pDPObj = (*pColl)[i];
341 if ( pDPObj->GetOutRange().aStart.Tab() == nTab )
342 {
343 if ( nFound == nIndex )
344 {
345 OUString aName = pDPObj->GetName();
346 return new ScDataPilotTableObj( pDocShell, nTab, aName );
347 }
348 ++nFound;
349 }
350 }
351 }
352 }
353 return NULL;
354 }
355
356 ScDataPilotTableObj* ScDataPilotTablesObj::GetObjectByName_Impl(const OUString& rName)
357 {
358 if (hasByName(rName))
359 return new ScDataPilotTableObj( pDocShell, nTab, rName );
360 return 0;
361 }
362
363 Reference<XDataPilotDescriptor> SAL_CALL ScDataPilotTablesObj::createDataPilotDescriptor()
364 throw(RuntimeException)
365 {
366 SolarMutexGuard aGuard;
367 if (pDocShell)
368 return new ScDataPilotDescriptor(pDocShell);
369 return NULL;
370 }
371
372 static bool lcl_IsDuplicated( const Reference<XPropertySet> xDimProps )
373 {
374 try
375 {
376 Any aAny = xDimProps->getPropertyValue( OUString( SC_UNO_DP_ORIGINAL ) );
377 Reference< XNamed > xOriginal( aAny, UNO_QUERY );
378 return xOriginal.is();
379 }
380 catch( Exception& )
381 {
382 }
383 return false;
384 }
385
386 static OUString lcl_GetOriginalName( const Reference< XNamed > xDim )
387 {
388 Reference< XNamed > xOriginal;
389
390 Reference< XPropertySet > xDimProps( xDim, UNO_QUERY );
391 if ( xDimProps.is() )
392 {
393 try
394 {
395 Any aAny = xDimProps->getPropertyValue(OUString(SC_UNO_DP_ORIGINAL));
396 aAny >>= xOriginal;
397 }
398 catch( Exception& )
399 {
400 }
401 }
402
403 if ( !xOriginal.is() )
404 xOriginal = xDim;
405
406 return xOriginal->getName();
407 }
408
409 void SAL_CALL ScDataPilotTablesObj::insertNewByName( const OUString& aNewName,
410 const CellAddress& aOutputAddress,
411 const Reference<XDataPilotDescriptor>& xDescriptor )
412 throw(RuntimeException)
413 {
414 SolarMutexGuard aGuard;
415 if (!xDescriptor.is()) return;
416
417 // inserting with already existing name?
418 if ( !aNewName.isEmpty() && hasByName( aNewName ) )
419 throw RuntimeException(); // no other exceptions specified
420
421 sal_Bool bDone = false;
422 ScDataPilotDescriptorBase* pImp = ScDataPilotDescriptorBase::getImplementation( xDescriptor );
423 if ( pDocShell && pImp )
424 {
425 ScDPObject* pNewObj = pImp->GetDPObject();
426
427 if (pNewObj)
428 {
429 ScRange aOutputRange((SCCOL)aOutputAddress.Column, (SCROW)aOutputAddress.Row, (SCTAB)aOutputAddress.Sheet,
430 (SCCOL)aOutputAddress.Column, (SCROW)aOutputAddress.Row, (SCTAB)aOutputAddress.Sheet);
431 pNewObj->SetOutRange(aOutputRange);
432 OUString aName = aNewName;
433 if (aName.isEmpty())
434 aName = lcl_CreatePivotName( pDocShell );
435 pNewObj->SetName(aName);
436 OUString aTag = xDescriptor->getTag();
437 pNewObj->SetTag(aTag);
438
439 // todo: handle double fields (for more information see ScDPObject
440
441 ScDBDocFunc aFunc(*pDocShell);
442 bDone = aFunc.CreatePivotTable(*pNewObj, true, true);
443 }
444 }
445
446 if (!bDone)
447 throw RuntimeException(); // no other exceptions specified
448 }
449
450 void SAL_CALL ScDataPilotTablesObj::removeByName( const OUString& aName )
451 throw(RuntimeException)
452 {
453 SolarMutexGuard aGuard;
454 OUString aNameStr(aName);
455 ScDPObject* pDPObj = lcl_GetDPObject( pDocShell, nTab, aNameStr );
456 if (pDPObj && pDocShell)
457 {
458 ScDBDocFunc aFunc(*pDocShell);
459 aFunc.RemovePivotTable(*pDPObj, true, true); // remove - incl. undo etc.
460 }
461 else
462 throw RuntimeException(); // no other exceptions specified
463 }
464
465 // XEnumerationAccess
466
467 Reference< XEnumeration > SAL_CALL ScDataPilotTablesObj::createEnumeration() throw(RuntimeException)
468 {
469 SolarMutexGuard aGuard;
470 return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.DataPilotTablesEnumeration"));
471 }
472
473 // XIndexAccess
474
475 sal_Int32 SAL_CALL ScDataPilotTablesObj::getCount() throw(RuntimeException)
476 {
477 SolarMutexGuard aGuard;
478 if ( pDocShell )
479 {
480 ScDocument* pDoc = pDocShell->GetDocument();
481 ScDPCollection* pColl = pDoc->GetDPCollection();
482 if ( pColl )
483 {
484 // count tables on this sheet
485
486 sal_uInt16 nFound = 0;
487 size_t nCount = pColl->GetCount();
488 for (size_t i=0; i<nCount; ++i)
489 {
490 ScDPObject* pDPObj = (*pColl)[i];
491 if ( pDPObj->GetOutRange().aStart.Tab() == nTab )
492 ++nFound;
493 }
494 return nFound;
495 }
496 }
497
498 return 0;
499 }
500
501 Any SAL_CALL ScDataPilotTablesObj::getByIndex( sal_Int32 nIndex )
502 throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
503 {
504 SolarMutexGuard aGuard;
505 Reference<XDataPilotTable2> xTable(GetObjectByIndex_Impl(nIndex));
506 if (!xTable.is())
507 throw IndexOutOfBoundsException();
508 return Any( xTable );
509 }
510
511 uno::Type SAL_CALL ScDataPilotTablesObj::getElementType() throw(RuntimeException)
512 {
513 SolarMutexGuard aGuard;
514 return getCppuType((Reference<XDataPilotTable2>*)0);
515 }
516
517 sal_Bool SAL_CALL ScDataPilotTablesObj::hasElements() throw(RuntimeException)
518 {
519 SolarMutexGuard aGuard;
520 return ( getCount() != 0 );
521 }
522
523 // XNameAccess
524
525 Any SAL_CALL ScDataPilotTablesObj::getByName( const OUString& aName )
526 throw(NoSuchElementException, WrappedTargetException, RuntimeException)
527 {
528 SolarMutexGuard aGuard;
529 Reference<XDataPilotTable2> xTable(GetObjectByName_Impl(aName));
530 if (!xTable.is())
531 throw NoSuchElementException();
532 return Any( xTable );
533 }
534
535 Sequence<OUString> SAL_CALL ScDataPilotTablesObj::getElementNames()
536 throw(RuntimeException)
537 {
538 SolarMutexGuard aGuard;
539 if (pDocShell)
540 {
541 ScDocument* pDoc = pDocShell->GetDocument();
542 ScDPCollection* pColl = pDoc->GetDPCollection();
543 if ( pColl )
544 {
545 // count tables on this sheet
546
547 sal_uInt16 nFound = 0;
548 size_t nCount = pColl->GetCount();
549 size_t i;
550 for (i=0; i<nCount; ++i)
551 {
552 ScDPObject* pDPObj = (*pColl)[i];
553 if ( pDPObj->GetOutRange().aStart.Tab() == nTab )
554 ++nFound;
555 }
556
557 sal_uInt16 nPos = 0;
558 Sequence<OUString> aSeq(nFound);
559 OUString* pAry = aSeq.getArray();
560 for (i=0; i<nCount; ++i)
561 {
562 ScDPObject* pDPObj = (*pColl)[i];
563 if ( pDPObj->GetOutRange().aStart.Tab() == nTab )
564 pAry[nPos++] = pDPObj->GetName();
565 }
566
567 return aSeq;
568 }
569 }
570 return Sequence<OUString>(0);
571 }
572
573 sal_Bool SAL_CALL ScDataPilotTablesObj::hasByName( const OUString& aName )
574 throw(RuntimeException)
575 {
576 SolarMutexGuard aGuard;
577 if (pDocShell)
578 {
579 ScDocument* pDoc = pDocShell->GetDocument();
580 ScDPCollection* pColl = pDoc->GetDPCollection();
581 if ( pColl )
582 {
583 size_t nCount = pColl->GetCount();
584 for (size_t i=0; i<nCount; ++i)
585 {
586 ScDPObject* pDPObj = (*pColl)[i];
587 if ( pDPObj->GetOutRange().aStart.Tab() == nTab &&
588 pDPObj->GetName() == aName )
589 return true;
590 }
591 }
592 }
593 return false;
594 }
595
596 //------------------------------------------------------------------------
597
598 ScDataPilotDescriptorBase::ScDataPilotDescriptorBase(ScDocShell* pDocSh) :
599 maPropSet( lcl_GetDataPilotDescriptorBaseMap() ),
600 pDocShell( pDocSh )
601 {
602 pDocShell->GetDocument()->AddUnoObject(*this);
603 }
604
605 ScDataPilotDescriptorBase::~ScDataPilotDescriptorBase()
606 {
607 if (pDocShell)
608 pDocShell->GetDocument()->RemoveUnoObject(*this);
609 }
610
611 Any SAL_CALL ScDataPilotDescriptorBase::queryInterface( const uno::Type& rType )
612 throw(RuntimeException)
613 {
614 SC_QUERYINTERFACE( XDataPilotDescriptor )
615 SC_QUERYINTERFACE( XPropertySet )
616 SC_QUERYINTERFACE( XDataPilotDataLayoutFieldSupplier )
617 SC_QUERYINTERFACE( XNamed ) // base of XDataPilotDescriptor
618 SC_QUERYINTERFACE( lang::XUnoTunnel )
619 SC_QUERYINTERFACE( lang::XTypeProvider )
620 SC_QUERYINTERFACE( lang::XServiceInfo )
621
622 return OWeakObject::queryInterface( rType );
623 }
624
625 void SAL_CALL ScDataPilotDescriptorBase::acquire() throw()
626 {
627 OWeakObject::acquire();
628 }
629
630 void SAL_CALL ScDataPilotDescriptorBase::release() throw()
631 {
632 OWeakObject::release();
633 }
634
635 Sequence< uno::Type > SAL_CALL ScDataPilotDescriptorBase::getTypes()
636 throw(RuntimeException)
637 {
638 static Sequence< uno::Type > aTypes;
639 if ( aTypes.getLength() == 0 )
640 {
641 aTypes.realloc( 6 );
642 uno::Type* pPtr = aTypes.getArray();
643 pPtr[ 0 ] = getCppuType( (const Reference< XDataPilotDescriptor >*)0 );
644 pPtr[ 1 ] = getCppuType( (const Reference< XPropertySet >*)0 );
645 pPtr[ 2 ] = getCppuType( (const Reference< XDataPilotDataLayoutFieldSupplier >*)0 );
646 pPtr[ 3 ] = getCppuType( (const Reference< lang::XUnoTunnel >*)0 );
647 pPtr[ 4 ] = getCppuType( (const Reference< lang::XTypeProvider >*)0 );
648 pPtr[ 5 ] = getCppuType( (const Reference< lang::XServiceInfo >*)0 );
649 }
650 return aTypes;
651 }
652
653 namespace
654 {
655 class theScDataPilotDescriptorBaseImplementationId : public rtl::Static< UnoTunnelIdInit, theScDataPilotDescriptorBaseImplementationId > {};
656 }
657
658 Sequence<sal_Int8> SAL_CALL ScDataPilotDescriptorBase::getImplementationId()
659 throw(RuntimeException)
660 {
661 return theScDataPilotDescriptorBaseImplementationId::get().getSeq();
662 }
663
664 void ScDataPilotDescriptorBase::Notify( SfxBroadcaster&, const SfxHint& rHint )
665 {
666 //! Referenz-Update?
667
668 if ( rHint.ISA( SfxSimpleHint ) &&
669 ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
670 {
671 pDocShell = NULL; // ungueltig geworden
672 }
673 }
674
675 // XDataPilotDescriptor
676
677 CellRangeAddress SAL_CALL ScDataPilotDescriptorBase::getSourceRange()
678 throw(RuntimeException)
679 {
680 SolarMutexGuard aGuard;
681
682 ScDPObject* pDPObject(GetDPObject());
683 if (!pDPObject)
684 throw RuntimeException();
685
686 CellRangeAddress aRet;
687 if (pDPObject->IsSheetData())
688 ScUnoConversion::FillApiRange( aRet, pDPObject->GetSheetDesc()->GetSourceRange() );
689 return aRet;
690 }
691
692 void SAL_CALL ScDataPilotDescriptorBase::setSourceRange( const CellRangeAddress& aSourceRange ) throw(RuntimeException)
693 {
694 SolarMutexGuard aGuard;
695
696 ScDPObject* pDPObject = GetDPObject();
697 if (!pDPObject)
698 throw RuntimeException();
699
700 ScSheetSourceDesc aSheetDesc(pDocShell->GetDocument());
701 if (pDPObject->IsSheetData())
702 aSheetDesc = *pDPObject->GetSheetDesc();
703
704 ScRange aRange;
705 ScUnoConversion::FillScRange(aRange, aSourceRange);
706 aSheetDesc.SetSourceRange(aRange);
707 pDPObject->SetSheetDesc( aSheetDesc );
708 SetDPObject( pDPObject );
709 }
710
711 Reference<XSheetFilterDescriptor> SAL_CALL ScDataPilotDescriptorBase::getFilterDescriptor()
712 throw(RuntimeException)
713 {
714 SolarMutexGuard aGuard;
715 return new ScDataPilotFilterDescriptor( pDocShell, this );
716 }
717
718 Reference<XIndexAccess> SAL_CALL ScDataPilotDescriptorBase::getDataPilotFields()
719 throw(RuntimeException)
720 {
721 SolarMutexGuard aGuard;
722 return new ScDataPilotFieldsObj( *this );
723 }
724
725 Reference<XIndexAccess> SAL_CALL ScDataPilotDescriptorBase::getColumnFields()
726 throw(RuntimeException)
727 {
728 SolarMutexGuard aGuard;
729 return new ScDataPilotFieldsObj( *this, DataPilotFieldOrientation_COLUMN );
730 }
731
732 Reference<XIndexAccess> SAL_CALL ScDataPilotDescriptorBase::getRowFields()
733 throw(RuntimeException)
734 {
735 SolarMutexGuard aGuard;
736 return new ScDataPilotFieldsObj( *this, DataPilotFieldOrientation_ROW );
737 }
738
739 Reference<XIndexAccess> SAL_CALL ScDataPilotDescriptorBase::getPageFields()
740 throw(RuntimeException)
741 {
742 SolarMutexGuard aGuard;
743 return new ScDataPilotFieldsObj( *this, DataPilotFieldOrientation_PAGE );
744 }
745
746 Reference<XIndexAccess> SAL_CALL ScDataPilotDescriptorBase::getDataFields()
747 throw(RuntimeException)
748 {
749 SolarMutexGuard aGuard;
750 return new ScDataPilotFieldsObj( *this, DataPilotFieldOrientation_DATA );
751 }
752
753 Reference<XIndexAccess> SAL_CALL ScDataPilotDescriptorBase::getHiddenFields()
754 throw(RuntimeException)
755 {
756 SolarMutexGuard aGuard;
757 return new ScDataPilotFieldsObj( *this, DataPilotFieldOrientation_HIDDEN );
758 }
759
760 // XPropertySet
761 Reference< XPropertySetInfo > SAL_CALL ScDataPilotDescriptorBase::getPropertySetInfo( )
762 throw(RuntimeException)
763 {
764 SolarMutexGuard aGuard;
765 static Reference<XPropertySetInfo> aRef =
766 new SfxItemPropertySetInfo( maPropSet.getPropertyMap() );
767 return aRef;
768 }
769
770 void SAL_CALL ScDataPilotDescriptorBase::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
771 throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException,
772 WrappedTargetException, RuntimeException)
773 {
774 SolarMutexGuard aGuard;
775 ScDPObject* pDPObject = GetDPObject();
776 if (pDPObject)
777 {
778 ScDPSaveData* pOldData = pDPObject->GetSaveData();
779 OSL_ENSURE(pOldData, "Here should be a SaveData");
780 if ( pOldData )
781 {
782 ScDPSaveData aNewData( *pOldData );
783
784 OUString aNameString = aPropertyName;
785 if ( aNameString.equalsAscii( SC_UNO_DP_COLGRAND ) )
786 {
787 aNewData.SetColumnGrand(::cppu::any2bool( aValue ));
788 }
789 else if ( aNameString.equalsAscii( SC_UNO_DP_IGNORE_EMPTYROWS ) )
790 {
791 aNewData.SetIgnoreEmptyRows(::cppu::any2bool( aValue ));
792 }
793 else if ( aNameString.equalsAscii( SC_UNO_DP_REPEATEMPTY ) )
794 {
795 aNewData.SetRepeatIfEmpty(::cppu::any2bool( aValue ));
796 }
797 else if ( aNameString.equalsAscii( SC_UNO_DP_ROWGRAND ) )
798 {
799 aNewData.SetRowGrand(::cppu::any2bool( aValue ));
800 }
801 else if ( aNameString.equalsAscii( SC_UNO_DP_SHOWFILTER ) )
802 {
803 aNewData.SetFilterButton(::cppu::any2bool( aValue ));
804 }
805 else if ( aNameString.equalsAscii( SC_UNO_DP_DRILLDOWN ) )
806 {
807 aNewData.SetDrillDown(::cppu::any2bool( aValue ));
808 }
809 else if ( aNameString.equalsAscii( SC_UNO_DP_GRANDTOTAL_NAME ) )
810 {
811 OUString aStrVal;
812 if ( aValue >>= aStrVal )
813 aNewData.SetGrandTotalName(aStrVal);
814 }
815 else if ( aNameString.equalsAscii( SC_UNO_DP_IMPORTDESC ) )
816 {
817 uno::Sequence<beans::PropertyValue> aArgSeq;
818 if ( aValue >>= aArgSeq )
819 {
820 ScImportSourceDesc aImportDesc(pDocShell->GetDocument());
821
822 const ScImportSourceDesc* pOldDesc = pDPObject->GetImportSourceDesc();
823 if (pOldDesc)
824 aImportDesc = *pOldDesc;
825
826 ScImportParam aParam;
827 ScImportDescriptor::FillImportParam( aParam, aArgSeq );
828
829 sal_uInt16 nNewType = sheet::DataImportMode_NONE;
830 if ( aParam.bImport )
831 {
832 if ( aParam.bSql )
833 nNewType = sheet::DataImportMode_SQL;
834 else if ( aParam.nType == ScDbQuery )
835 nNewType = sheet::DataImportMode_QUERY;
836 else
837 nNewType = sheet::DataImportMode_TABLE;
838 }
839 aImportDesc.nType = nNewType;
840 aImportDesc.aDBName = aParam.aDBName;
841 aImportDesc.aObject = aParam.aStatement;
842 aImportDesc.bNative = aParam.bNative;
843
844 pDPObject->SetImportDesc( aImportDesc );
845 }
846 }
847 else if ( aNameString.equalsAscii( SC_UNO_DP_SOURCESERVICE ) )
848 {
849 OUString aStrVal;
850 if ( aValue >>= aStrVal )
851 {
852 OUString aEmpty;
853 ScDPServiceDesc aServiceDesc(aEmpty, aEmpty, aEmpty, aEmpty, aEmpty);
854
855 const ScDPServiceDesc* pOldDesc = pDPObject->GetDPServiceDesc();
856 if (pOldDesc)
857 aServiceDesc = *pOldDesc;
858
859 aServiceDesc.aServiceName = aStrVal;
860
861 pDPObject->SetServiceData( aServiceDesc );
862 }
863 }
864 else if ( aNameString.equalsAscii( SC_UNO_DP_SERVICEARG ) )
865 {
866 uno::Sequence<beans::PropertyValue> aArgSeq;
867 if ( aValue >>= aArgSeq )
868 {
869 OUString aEmpty;
870 ScDPServiceDesc aServiceDesc(aEmpty, aEmpty, aEmpty, aEmpty, aEmpty);
871
872 const ScDPServiceDesc* pOldDesc = pDPObject->GetDPServiceDesc();
873 if (pOldDesc)
874 aServiceDesc = *pOldDesc;
875
876 OUString aStrVal;
877 sal_Int32 nArgs = aArgSeq.getLength();
878 for (sal_Int32 nArgPos=0; nArgPos<nArgs; ++nArgPos)
879 {
880 const beans::PropertyValue& rProp = aArgSeq[nArgPos];
881 OUString aPropName(rProp.Name);
882
883 if (aPropName.equalsAscii( SC_UNO_DP_SOURCENAME ))
884 {
885 if ( rProp.Value >>= aStrVal )
886 aServiceDesc.aParSource = aStrVal;
887 }
888 else if (aPropName.equalsAscii( SC_UNO_DP_OBJECTNAME ))
889 {
890 if ( rProp.Value >>= aStrVal )
891 aServiceDesc.aParName = aStrVal;
892 }
893 else if (aPropName.equalsAscii( SC_UNO_DP_USERNAME ))
894 {
895 if ( rProp.Value >>= aStrVal )
896 aServiceDesc.aParUser = aStrVal;
897 }
898 else if (aPropName.equalsAscii( SC_UNO_DP_PASSWORD ))
899 {
900 if ( rProp.Value >>= aStrVal )
901 aServiceDesc.aParPass = aStrVal;
902 }
903 }
904
905 pDPObject->SetServiceData( aServiceDesc );
906 }
907 }
908 else
909 throw UnknownPropertyException();
910
911 pDPObject->SetSaveData( aNewData );
912 }
913
914 SetDPObject(pDPObject);
915 }
916 }
917
918 Any SAL_CALL ScDataPilotDescriptorBase::getPropertyValue( const OUString& aPropertyName )
919 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
920 {
921 SolarMutexGuard aGuard;
922 Any aRet;
923
924 ScDPObject* pDPObject(GetDPObject());
925 if (pDPObject)
926 {
927 ScDPSaveData* pOldData = pDPObject->GetSaveData();
928 OSL_ENSURE(pOldData, "Here should be a SaveData");
929 if ( pOldData )
930 {
931 ScDPSaveData aNewData( *pOldData );
932
933 OUString aNameString = aPropertyName;
934 if ( aNameString.equalsAscii( SC_UNO_DP_COLGRAND ) )
935 {
936 aRet = ::cppu::bool2any( aNewData.GetColumnGrand() );
937 }
938 else if ( aNameString.equalsAscii( SC_UNO_DP_IGNORE_EMPTYROWS ) )
939 {
940 aRet = ::cppu::bool2any( aNewData.GetIgnoreEmptyRows() );
941 }
942 else if ( aNameString.equalsAscii( SC_UNO_DP_REPEATEMPTY ) )
943 {
944 aRet = ::cppu::bool2any( aNewData.GetRepeatIfEmpty() );
945 }
946 else if ( aNameString.equalsAscii( SC_UNO_DP_ROWGRAND ) )
947 {
948 aRet = ::cppu::bool2any( aNewData.GetRowGrand() );
949 }
950 else if ( aNameString.equalsAscii( SC_UNO_DP_SHOWFILTER ) )
951 {
952 aRet = ::cppu::bool2any( aNewData.GetFilterButton() );
953 }
954 else if ( aNameString.equalsAscii( SC_UNO_DP_DRILLDOWN ) )
955 {
956 aRet = ::cppu::bool2any( aNewData.GetDrillDown() );
957 }
958 else if ( aNameString.equalsAscii( SC_UNO_DP_GRANDTOTAL_NAME ) )
959 {
960 const OUString* pGrandTotalName = aNewData.GetGrandTotalName();
961 if (pGrandTotalName)
962 aRet <<= *pGrandTotalName; // same behavior as in ScDPSource
963 }
964 else if ( aNameString.equalsAscii( SC_UNO_DP_IMPORTDESC ) )
965 {
966 const ScImportSourceDesc* pImportDesc = pDPObject->GetImportSourceDesc();
967 if ( pImportDesc )
968 {
969 // fill ScImportParam so ScImportDescriptor::FillProperties can be used
970 ScImportParam aParam;
971 aParam.bImport = ( pImportDesc->nType != sheet::DataImportMode_NONE );
972 aParam.aDBName = pImportDesc->aDBName;
973 aParam.aStatement = pImportDesc->aObject;
974 aParam.bNative = pImportDesc->bNative;
975 aParam.bSql = ( pImportDesc->nType == sheet::DataImportMode_SQL );
976 aParam.nType = static_cast<sal_uInt8>(( pImportDesc->nType == sheet::DataImportMode_QUERY ) ? ScDbQuery : ScDbTable);
977
978 uno::Sequence<beans::PropertyValue> aSeq( ScImportDescriptor::GetPropertyCount() );
979 ScImportDescriptor::FillProperties( aSeq, aParam );
980 aRet <<= aSeq;
981 }
982 else
983 {
984 // empty sequence
985 uno::Sequence<beans::PropertyValue> aEmpty(0);
986 aRet <<= aEmpty;
987 }
988 }
989 else if ( aNameString.equalsAscii( SC_UNO_DP_SOURCESERVICE ) )
990 {
991 OUString aServiceName;
992 const ScDPServiceDesc* pServiceDesc = pDPObject->GetDPServiceDesc();
993 if (pServiceDesc)
994 aServiceName = pServiceDesc->aServiceName;
995 aRet <<= aServiceName; // empty string if no ServiceDesc set
996 }
997 else if ( aNameString.equalsAscii( SC_UNO_DP_SERVICEARG ) )
998 {
999 const ScDPServiceDesc* pServiceDesc = pDPObject->GetDPServiceDesc();
1000 if (pServiceDesc)
1001 {
1002 uno::Sequence<beans::PropertyValue> aSeq( 4 );
1003 beans::PropertyValue* pArray = aSeq.getArray();
1004 pArray[0].Name = OUString( SC_UNO_DP_SOURCENAME );
1005 pArray[0].Value <<= pServiceDesc->aParSource;
1006 pArray[1].Name = OUString( SC_UNO_DP_OBJECTNAME );
1007 pArray[1].Value <<= pServiceDesc->aParName;
1008 pArray[2].Name = OUString( SC_UNO_DP_USERNAME );
1009 pArray[2].Value <<= pServiceDesc->aParUser;
1010 pArray[3].Name = OUString( SC_UNO_DP_PASSWORD );
1011 pArray[3].Value <<= pServiceDesc->aParPass;
1012 aRet <<= aSeq;
1013 }
1014 else
1015 {
1016 // empty sequence
1017 uno::Sequence<beans::PropertyValue> aEmpty(0);
1018 aRet <<= aEmpty;
1019 }
1020 }
1021 else
1022 throw UnknownPropertyException();
1023 }
1024 }
1025
1026 return aRet;
1027 }
1028
1029 void SAL_CALL ScDataPilotDescriptorBase::addPropertyChangeListener(
1030 const OUString& /* aPropertyName */, const Reference<XPropertyChangeListener >& /* xListener */ )
1031 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1032 {
1033 }
1034
1035 void SAL_CALL ScDataPilotDescriptorBase::removePropertyChangeListener(
1036 const OUString& /* aPropertyName */, const Reference<XPropertyChangeListener >& /* aListener */ )
1037 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1038 {
1039 }
1040
1041 void SAL_CALL ScDataPilotDescriptorBase::addVetoableChangeListener(
1042 const OUString& /* PropertyName */, const Reference<XVetoableChangeListener >& /* aListener */ )
1043 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1044 {
1045 }
1046
1047 void SAL_CALL ScDataPilotDescriptorBase::removeVetoableChangeListener(
1048 const OUString& /* PropertyName */, const Reference<XVetoableChangeListener >& /* aListener */ )
1049 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1050 {
1051 }
1052
1053 // XDataPilotDataLayoutFieldSupplier
1054
1055 Reference< XDataPilotField > SAL_CALL ScDataPilotDescriptorBase::getDataLayoutField() throw(RuntimeException)
1056 {
1057 SolarMutexGuard aGuard;
1058 if( ScDPObject* pDPObject = GetDPObject() )
1059 {
1060 if( ScDPSaveData* pSaveData = pDPObject->GetSaveData() )
1061 {
1062 if( pSaveData->GetDataLayoutDimension() )
1063 {
1064 ScFieldIdentifier aFieldId( OUString( SC_DATALAYOUT_NAME ), 0, true );
1065 return new ScDataPilotFieldObj( *this, aFieldId );
1066 }
1067 }
1068 }
1069 return 0;
1070 }
1071
1072 // XUnoTunnel
1073
1074 sal_Int64 SAL_CALL ScDataPilotDescriptorBase::getSomething(
1075 const Sequence<sal_Int8 >& rId ) throw(RuntimeException)
1076 {
1077 if ( rId.getLength() == 16 &&
1078 0 == memcmp( getUnoTunnelId().getConstArray(),
1079 rId.getConstArray(), 16 ) )
1080 {
1081 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
1082 }
1083 return 0;
1084 }
1085
1086 namespace
1087 {
1088 class theScDataPilotDescriptorBaseUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScDataPilotDescriptorBaseUnoTunnelId> {};
1089 }
1090
1091 const Sequence<sal_Int8>& ScDataPilotDescriptorBase::getUnoTunnelId()
1092 {
1093 return theScDataPilotDescriptorBaseUnoTunnelId::get().getSeq();
1094 }
1095
1096 ScDataPilotDescriptorBase* ScDataPilotDescriptorBase::getImplementation(
1097 const Reference<XDataPilotDescriptor> xObj )
1098 {
1099 ScDataPilotDescriptorBase* pRet = NULL;
1100 Reference<lang::XUnoTunnel> xUT( xObj, UNO_QUERY );
1101 if (xUT.is())
1102 pRet = reinterpret_cast<ScDataPilotDescriptorBase*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
1103 return pRet;
1104 }
1105
1106 //------------------------------------------------------------------------
1107
1108 ScDataPilotTableObj::ScDataPilotTableObj(ScDocShell* pDocSh, SCTAB nT, const OUString& rN) :
1109 ScDataPilotDescriptorBase( pDocSh ),
1110 nTab( nT ),
1111 aName( rN ),
1112 aModifyListeners( 0 )
1113 {
1114 }
1115
1116 ScDataPilotTableObj::~ScDataPilotTableObj()
1117 {
1118 }
1119
1120 Any SAL_CALL ScDataPilotTableObj::queryInterface( const uno::Type& rType )
1121 throw(RuntimeException)
1122 {
1123 // since we manually do resolve the query for XDataPilotTable2
1124 // we also need to do the same for XDataPilotTable
1125 SC_QUERYINTERFACE( XDataPilotTable )
1126 SC_QUERYINTERFACE( XDataPilotTable2 )
1127 SC_QUERYINTERFACE( XModifyBroadcaster )
1128
1129 return ScDataPilotDescriptorBase::queryInterface( rType );
1130 }
1131
1132 void SAL_CALL ScDataPilotTableObj::acquire() throw()
1133 {
1134 ScDataPilotDescriptorBase::acquire();
1135 }
1136
1137 void SAL_CALL ScDataPilotTableObj::release() throw()
1138 {
1139 ScDataPilotDescriptorBase::release();
1140 }
1141
1142 Sequence< uno::Type > SAL_CALL ScDataPilotTableObj::getTypes() throw(RuntimeException)
1143 {
1144 static Sequence< uno::Type > aTypes;
1145 if ( aTypes.getLength() == 0 )
1146 {
1147 Sequence< uno::Type > aParentTypes = ScDataPilotDescriptorBase::getTypes();
1148 sal_Int32 nParentLen = aParentTypes.getLength();
1149 const uno::Type* pParentPtr = aParentTypes.getConstArray();
1150
1151 aTypes.realloc( nParentLen + 2 );
1152 uno::Type* pPtr = aTypes.getArray();
1153 for (sal_Int32 i = 0; i < nParentLen; ++i)
1154 pPtr[ i ] = pParentPtr[ i ]; // parent types first
1155
1156 pPtr[ nParentLen ] = getCppuType( (const Reference< XDataPilotTable2 >*)0 );
1157 pPtr[ nParentLen+1 ] = getCppuType( (const Reference< XModifyBroadcaster >*)0 );
1158 }
1159 return aTypes;
1160 }
1161
1162 namespace
1163 {
1164 class theScDataPilotTableObjImplementationId : public rtl::Static< UnoTunnelIdInit, theScDataPilotTableObjImplementationId > {};
1165 }
1166
1167 Sequence<sal_Int8> SAL_CALL ScDataPilotTableObj::getImplementationId()
1168 throw(RuntimeException)
1169 {
1170 return theScDataPilotTableObjImplementationId::get().getSeq();
1171 }
1172
1173 // ---
1174 ScDPObject* ScDataPilotTableObj::GetDPObject() const
1175 {
1176 return lcl_GetDPObject(GetDocShell(), nTab, aName);
1177 }
1178
1179 void ScDataPilotTableObj::SetDPObject( ScDPObject* pDPObject )
1180 {
1181 ScDocShell* pDocSh = GetDocShell();
1182 ScDPObject* pDPObj = lcl_GetDPObject(pDocSh, nTab, aName);
1183 if ( pDPObj && pDocSh )
1184 {
1185 ScDBDocFunc aFunc(*pDocSh);
1186 aFunc.DataPilotUpdate( pDPObj, pDPObject, true, true );
1187 }
1188 }
1189
1190 // "rest of XDataPilotDescriptor"
1191
1192 OUString SAL_CALL ScDataPilotTableObj::getName() throw(RuntimeException)
1193 {
1194 SolarMutexGuard aGuard;
1195 ScDPObject* pDPObj = lcl_GetDPObject(GetDocShell(), nTab, aName);
1196 if (pDPObj)
1197 return pDPObj->GetName();
1198 return OUString();
1199 }
1200
1201 void SAL_CALL ScDataPilotTableObj::setName( const OUString& aNewName )
1202 throw(RuntimeException)
1203 {
1204 SolarMutexGuard aGuard;
1205 ScDPObject* pDPObj = lcl_GetDPObject(GetDocShell(), nTab, aName);
1206 if (pDPObj)
1207 {
1208 //! test for existing names !!!
1209
1210 OUString aString(aNewName);
1211 pDPObj->SetName( aString ); //! Undo - DBDocFunc ???
1212 aName = aString;
1213
1214 // DataPilotUpdate would do too much (output table is not changed)
1215 GetDocShell()->SetDocumentModified();
1216 }
1217 }
1218
1219 OUString SAL_CALL ScDataPilotTableObj::getTag() throw(RuntimeException)
1220 {
1221 SolarMutexGuard aGuard;
1222 ScDPObject* pDPObj = lcl_GetDPObject(GetDocShell(), nTab, aName);
1223 if (pDPObj)
1224 return pDPObj->GetTag();
1225 return OUString();
1226 }
1227
1228 void SAL_CALL ScDataPilotTableObj::setTag( const OUString& aNewTag )
1229 throw(RuntimeException)
1230 {
1231 SolarMutexGuard aGuard;
1232 ScDPObject* pDPObj = lcl_GetDPObject(GetDocShell(), nTab, aName);
1233 if (pDPObj)
1234 {
1235 pDPObj->SetTag( aNewTag ); //! Undo - DBDocFunc ???
1236
1237 // DataPilotUpdate would do too much (output table is not changed)
1238 GetDocShell()->SetDocumentModified();
1239 }
1240 }
1241
1242 // XDataPilotTable
1243
1244 CellRangeAddress SAL_CALL ScDataPilotTableObj::getOutputRange() throw(RuntimeException)
1245 {
1246 SolarMutexGuard aGuard;
1247 CellRangeAddress aRet;
1248 ScDPObject* pDPObj = lcl_GetDPObject(GetDocShell(), nTab, aName);
1249 if (pDPObj)
1250 {
1251 ScRange aRange(pDPObj->GetOutRange());
1252 aRet.Sheet = aRange.aStart.Tab();
1253 aRet.StartColumn = aRange.aStart.Col();
1254 aRet.StartRow = aRange.aStart.Row();
1255 aRet.EndColumn = aRange.aEnd.Col();
1256 aRet.EndRow = aRange.aEnd.Row();
1257 }
1258 return aRet;
1259 }
1260
1261 void SAL_CALL ScDataPilotTableObj::refresh() throw(RuntimeException)
1262 {
1263 SolarMutexGuard aGuard;
1264 ScDPObject* pDPObj = lcl_GetDPObject(GetDocShell(), nTab, aName);
1265 if (pDPObj)
1266 {
1267 ScDBDocFunc aFunc(*GetDocShell());
1268 aFunc.RefreshPivotTables(pDPObj, true);
1269 }
1270 }
1271
1272 Sequence< Sequence<Any> > SAL_CALL ScDataPilotTableObj::getDrillDownData(const CellAddress& aAddr)
1273 throw (RuntimeException)
1274 {
1275 SolarMutexGuard aGuard;
1276 Sequence< Sequence<Any> > aTabData;
1277 ScAddress aAddr2(static_cast<SCCOL>(aAddr.Column), static_cast<SCROW>(aAddr.Row), aAddr.Sheet);
1278 ScDPObject* pObj = GetDPObject();
1279 if (!pObj)
1280 throw RuntimeException();
1281
1282 pObj->GetDrillDownData(aAddr2, aTabData);
1283 return aTabData;
1284 }
1285
1286 DataPilotTablePositionData SAL_CALL ScDataPilotTableObj::getPositionData(const CellAddress& aAddr)
1287 throw (RuntimeException)
1288 {
1289 SolarMutexGuard aGuard;
1290 DataPilotTablePositionData aPosData;
1291 ScAddress aAddr2(static_cast<SCCOL>(aAddr.Column), static_cast<SCROW>(aAddr.Row), aAddr.Sheet);
1292 ScDPObject* pObj = GetDPObject();
1293 if (!pObj)
1294 throw RuntimeException();
1295
1296 pObj->GetPositionData(aAddr2, aPosData);
1297 return aPosData;
1298 }
1299
1300 void SAL_CALL ScDataPilotTableObj::insertDrillDownSheet(const CellAddress& aAddr)
1301 throw (RuntimeException)
1302 {
1303 SolarMutexGuard aGuard;
1304 ScDPObject* pDPObj = GetDPObject();
1305 if (!pDPObj)
1306 throw RuntimeException();
1307
1308 Sequence<DataPilotFieldFilter> aFilters;
1309 pDPObj->GetDataFieldPositionData(
1310 ScAddress(static_cast<SCCOL>(aAddr.Column), static_cast<SCROW>(aAddr.Row), aAddr.Sheet), aFilters);
1311 GetDocShell()->GetBestViewShell()->ShowDataPilotSourceData(*pDPObj, aFilters);
1312 }
1313
1314 CellRangeAddress SAL_CALL ScDataPilotTableObj::getOutputRangeByType( sal_Int32 nType )
1315 throw (IllegalArgumentException, RuntimeException)
1316 {
1317 SolarMutexGuard aGuard;
1318 if (nType < 0 || nType > DataPilotOutputRangeType::RESULT)
1319 throw IllegalArgumentException();
1320
1321 CellRangeAddress aRet;
1322 if (ScDPObject* pDPObj = lcl_GetDPObject(GetDocShell(), nTab, aName))
1323 ScUnoConversion::FillApiRange( aRet, pDPObj->GetOutputRangeByType( nType ) );
1324 return aRet;
1325 }
1326
1327 void SAL_CALL ScDataPilotTableObj::addModifyListener( const uno::Reference<util::XModifyListener>& aListener )
1328 throw (uno::RuntimeException)
1329 {
1330 SolarMutexGuard aGuard;
1331
1332 uno::Reference<util::XModifyListener> *pObj = new uno::Reference<util::XModifyListener>( aListener );
1333 aModifyListeners.push_back( pObj );
1334
1335 if ( aModifyListeners.size() == 1 )
1336 {
1337 acquire(); // don't lose this object (one ref for all listeners)
1338 }
1339 }
1340
1341 void SAL_CALL ScDataPilotTableObj::removeModifyListener( const uno::Reference<util::XModifyListener>& aListener )
1342 throw (uno::RuntimeException)
1343 {
1344 SolarMutexGuard aGuard;
1345
1346 acquire(); // in case the listeners have the last ref - released below
1347
1348 sal_uInt16 nCount = aModifyListeners.size();
1349 for ( sal_uInt16 n=nCount; n--; )
1350 {
1351 uno::Reference<util::XModifyListener>& rObj = aModifyListeners[n];
1352 if ( rObj == aListener )
1353 {
1354 aModifyListeners.erase( aModifyListeners.begin() + n );
1355
1356 if ( aModifyListeners.empty() )
1357 {
1358 release(); // release the ref for the listeners
1359 }
1360
1361 break;
1362 }
1363 }
1364
1365 release(); // might delete this object
1366 }
1367
1368 void ScDataPilotTableObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1369 {
1370 if ( rHint.ISA(ScDataPilotModifiedHint) &&
1371 static_cast<const ScDataPilotModifiedHint&>(rHint).GetName() == aName )
1372 {
1373 Refreshed_Impl();
1374 }
1375 else if ( rHint.ISA( ScUpdateRefHint ) )
1376 {
1377 ScRange aRange( 0, 0, nTab );
1378 ScRangeList aRanges;
1379 aRanges.Append( aRange );
1380 const ScUpdateRefHint& rRef = static_cast< const ScUpdateRefHint& >( rHint );
1381 if ( aRanges.UpdateReference( rRef.GetMode(), GetDocShell()->GetDocument(), rRef.GetRange(),
1382 rRef.GetDx(), rRef.GetDy(), rRef.GetDz() ) &&
1383 aRanges.size() == 1 )
1384 {
1385 const ScRange* pRange = aRanges.front();
1386 if ( pRange )
1387 {
1388 nTab = pRange->aStart.Tab();
1389 }
1390 }
1391 }
1392
1393 ScDataPilotDescriptorBase::Notify( rBC, rHint );
1394 }
1395
1396 void ScDataPilotTableObj::Refreshed_Impl()
1397 {
1398 lang::EventObject aEvent;
1399 aEvent.Source.set((cppu::OWeakObject*)this);
1400
1401 // the EventObject holds a Ref to this object until after the listener calls
1402
1403 ScDocument* pDoc = GetDocShell()->GetDocument();
1404 for ( sal_uInt16 n=0; n<aModifyListeners.size(); n++ )
1405 pDoc->AddUnoListenerCall( aModifyListeners[n], aEvent );
1406 }
1407
1408 // ============================================================================
1409
1410 ScDataPilotDescriptor::ScDataPilotDescriptor(ScDocShell* pDocSh) :
1411 ScDataPilotDescriptorBase( pDocSh ),
1412 mpDPObject(new ScDPObject(pDocSh ? pDocSh->GetDocument() : NULL) )
1413 {
1414 ScDPSaveData aSaveData;
1415 // set defaults like in ScPivotParam constructor
1416 aSaveData.SetColumnGrand( sal_True );
1417 aSaveData.SetRowGrand( sal_True );
1418 aSaveData.SetIgnoreEmptyRows( false );
1419 aSaveData.SetRepeatIfEmpty( false );
1420 mpDPObject->SetSaveData(aSaveData);
1421 ScSheetSourceDesc aSheetDesc(pDocSh ? pDocSh->GetDocument() : NULL);
1422 mpDPObject->SetSheetDesc(aSheetDesc);
1423 mpDPObject->GetSource();
1424 }
1425
1426 ScDataPilotDescriptor::~ScDataPilotDescriptor()
1427 {
1428 delete mpDPObject;
1429 }
1430
1431 ScDPObject* ScDataPilotDescriptor::GetDPObject() const
1432 {
1433 return mpDPObject;
1434 }
1435
1436 void ScDataPilotDescriptor::SetDPObject( ScDPObject* pDPObject )
1437 {
1438 if (mpDPObject != pDPObject)
1439 {
1440 delete mpDPObject;
1441 mpDPObject = pDPObject;
1442 OSL_FAIL("replace DPObject should not happen");
1443 }
1444 }
1445
1446 // "rest of XDataPilotDescriptor"
1447
1448 OUString SAL_CALL ScDataPilotDescriptor::getName() throw(RuntimeException)
1449 {
1450 SolarMutexGuard aGuard;
1451 return mpDPObject->GetName();
1452 }
1453
1454 void SAL_CALL ScDataPilotDescriptor::setName( const OUString& aNewName )
1455 throw(RuntimeException)
1456 {
1457 SolarMutexGuard aGuard;
1458 mpDPObject->SetName( aNewName );
1459 }
1460
1461 OUString SAL_CALL ScDataPilotDescriptor::getTag() throw(RuntimeException)
1462 {
1463 SolarMutexGuard aGuard;
1464 return mpDPObject->GetTag();
1465 }
1466
1467 void SAL_CALL ScDataPilotDescriptor::setTag( const OUString& aNewTag )
1468 throw(RuntimeException)
1469 {
1470 SolarMutexGuard aGuard;
1471 mpDPObject->SetTag( aNewTag );
1472 }
1473
1474 // ============================================================================
1475
1476 ScDataPilotChildObjBase::ScDataPilotChildObjBase( ScDataPilotDescriptorBase& rParent ) :
1477 mrParent( rParent )
1478 {
1479 mrParent.acquire();
1480 }
1481
1482 ScDataPilotChildObjBase::ScDataPilotChildObjBase( ScDataPilotDescriptorBase& rParent, const ScFieldIdentifier& rFieldId ) :
1483 mrParent( rParent ),
1484 maFieldId( rFieldId )
1485 {
1486 mrParent.acquire();
1487 }
1488
1489 ScDataPilotChildObjBase::~ScDataPilotChildObjBase()
1490 {
1491 mrParent.release();
1492 }
1493
1494 ScDPObject* ScDataPilotChildObjBase::GetDPObject() const
1495 {
1496 return mrParent.GetDPObject();
1497 }
1498
1499 void ScDataPilotChildObjBase::SetDPObject( ScDPObject* pDPObject )
1500 {
1501 mrParent.SetDPObject( pDPObject );
1502 }
1503
1504 ScDPSaveDimension* ScDataPilotChildObjBase::GetDPDimension( ScDPObject** ppDPObject ) const
1505 {
1506 if( ScDPObject* pDPObj = GetDPObject() )
1507 {
1508 if( ppDPObject ) *ppDPObject = pDPObj;
1509 if( ScDPSaveData* pSaveData = pDPObj->GetSaveData() )
1510 {
1511 if( maFieldId.mbDataLayout )
1512 return pSaveData->GetDataLayoutDimension();
1513
1514 if( maFieldId.mnFieldIdx == 0 )
1515 return pSaveData->GetDimensionByName( maFieldId.maFieldName );
1516
1517 // find dimension with specified index (search in duplicated dimensions)
1518 const boost::ptr_vector<ScDPSaveDimension>& rDimensions = pSaveData->GetDimensions();
1519
1520 sal_Int32 nFoundIdx = 0;
1521 boost::ptr_vector<ScDPSaveDimension>::const_iterator it;
1522 for(it = rDimensions.begin(); it != rDimensions.end(); ++it)
1523 {
1524 if( !it->IsDataLayout() && (it->GetName() == maFieldId.maFieldName) )
1525 {
1526 if( nFoundIdx == maFieldId.mnFieldIdx )
1527 return const_cast<ScDPSaveDimension*>(&(*it));
1528 ++nFoundIdx;
1529 }
1530 }
1531 }
1532 }
1533 return 0;
1534 }
1535
1536 sal_Int32 ScDataPilotChildObjBase::GetMemberCount() const
1537 {
1538 sal_Int32 nRet = 0;
1539 Reference<XNameAccess> xMembersNA = GetMembers();
1540 if (xMembersNA.is())
1541 {
1542 Reference< XIndexAccess > xMembersIA( new ScNameToIndexAccess( xMembersNA ) );
1543 nRet = xMembersIA->getCount();
1544 }
1545 return nRet;
1546 }
1547
1548 Reference< XNameAccess > ScDataPilotChildObjBase::GetMembers() const
1549 {
1550 Reference< XNameAccess > xMembersNA;
1551 if( ScDPObject* pDPObj = GetDPObject() )
1552 pDPObj->GetMembersNA( lcl_GetObjectIndex( pDPObj, maFieldId ), xMembersNA );
1553 return xMembersNA;
1554 }
1555
1556 ScDocShell* ScDataPilotChildObjBase::GetDocShell() const
1557 {
1558 return mrParent.GetDocShell();
1559 }
1560
1561 // ============================================================================
1562
1563 ScDataPilotFieldsObj::ScDataPilotFieldsObj( ScDataPilotDescriptorBase& rParent ) :
1564 ScDataPilotChildObjBase( rParent )
1565 {
1566 }
1567
1568 ScDataPilotFieldsObj::ScDataPilotFieldsObj( ScDataPilotDescriptorBase& rParent, DataPilotFieldOrientation eOrient ) :
1569 ScDataPilotChildObjBase( rParent ),
1570 maOrient( eOrient )
1571 {
1572 }
1573
1574 ScDataPilotFieldsObj::~ScDataPilotFieldsObj()
1575 {
1576 }
1577
1578 static sal_Int32 lcl_GetFieldCount( const Reference<XDimensionsSupplier>& rSource, const Any& rOrient )
1579 {
1580 if (!rSource.is())
1581 throw RuntimeException();
1582
1583 sal_Int32 nRet = 0;
1584
1585 Reference<XNameAccess> xDimsName(rSource->getDimensions());
1586 Reference<XIndexAccess> xIntDims(new ScNameToIndexAccess( xDimsName ));
1587 sal_Int32 nIntCount = xIntDims->getCount();
1588 if (rOrient.hasValue())
1589 {
1590 // all fields of the specified orientation, including duplicated
1591 Reference<XPropertySet> xDim;
1592 for (sal_Int32 i = 0; i < nIntCount; ++i)
1593 {
1594 xDim.set(xIntDims->getByIndex(i), UNO_QUERY);
1595 if (xDim.is() && (xDim->getPropertyValue(OUString(SC_UNO_DP_ORIENTATION)) == rOrient))
1596 ++nRet;
1597 }
1598 }
1599 else
1600 {
1601 // count all non-duplicated fields
1602
1603 Reference<XPropertySet> xDim;
1604 for (sal_Int32 i = 0; i < nIntCount; ++i)
1605 {
1606 xDim.set(xIntDims->getByIndex(i), UNO_QUERY);
1607 if ( xDim.is() && !lcl_IsDuplicated( xDim ) )
1608 ++nRet;
1609 }
1610 }
1611
1612 return nRet;
1613 }
1614
1615 static sal_Bool lcl_GetFieldDataByIndex( const Reference<XDimensionsSupplier>& rSource,
1616 const Any& rOrient, SCSIZE nIndex, ScFieldIdentifier& rFieldId )
1617 {
1618 if (!rSource.is())
1619 throw RuntimeException();
1620
1621 sal_Bool bOk = false;
1622 SCSIZE nPos = 0;
1623 sal_Int32 nDimIndex = 0;
1624
1625 Reference<XNameAccess> xDimsName(rSource->getDimensions());
1626 Reference<XIndexAccess> xIntDims(new ScNameToIndexAccess( xDimsName ));
1627 sal_Int32 nIntCount = xIntDims->getCount();
1628 Reference<XPropertySet> xDim;
1629 if (rOrient.hasValue())
1630 {
1631 sal_Int32 i = 0;
1632 while (i < nIntCount && !bOk)
1633 {
1634 xDim.set(xIntDims->getByIndex(i), UNO_QUERY);
1635 if (xDim.is() && (xDim->getPropertyValue(OUString(SC_UNO_DP_ORIENTATION)) == rOrient))
1636 {
1637 if (nPos == nIndex)
1638 {
1639 bOk = sal_True;
1640 nDimIndex = i;
1641 }
1642 else
1643 ++nPos;
1644 }
1645 ++i;
1646 }
1647 }
1648 else
1649 {
1650 sal_Int32 i = 0;
1651 while (i < nIntCount && !bOk)
1652 {
1653 xDim.set(xIntDims->getByIndex(i), UNO_QUERY);
1654 if ( xDim.is() && !lcl_IsDuplicated( xDim ) )
1655 {
1656 if (nPos == nIndex)
1657 {
1658 bOk = sal_True;
1659 nDimIndex = i;
1660 }
1661 else
1662 ++nPos;
1663 }
1664 ++i;
1665 }
1666 }
1667
1668 if ( bOk )
1669 {
1670 xDim.set( xIntDims->getByIndex(nDimIndex), UNO_QUERY );
1671 Reference<XNamed> xDimName( xDim, UNO_QUERY );
1672 if ( xDimName.is() )
1673 {
1674 OUString sOriginalName( lcl_GetOriginalName( xDimName ) );
1675 rFieldId.maFieldName = sOriginalName;
1676 rFieldId.mbDataLayout = ScUnoHelpFunctions::GetBoolProperty( xDim,
1677 OUString(SC_UNO_DP_ISDATALAYOUT) );
1678
1679 sal_Int32 nRepeat = 0;
1680 if ( rOrient.hasValue() && lcl_IsDuplicated( xDim ) )
1681 {
1682 // find the repeat count
1683 // (this relies on the original dimension always being before the duplicates)
1684
1685 Reference<XNamed> xPrevName;
1686 for (sal_Int32 i = 0; i < nDimIndex; ++i)
1687 {
1688 xPrevName.set( xIntDims->getByIndex(i), UNO_QUERY );
1689 if ( xPrevName.is() && lcl_GetOriginalName( xPrevName ) == sOriginalName )
1690 ++nRepeat;
1691 }
1692 }
1693 rFieldId.mnFieldIdx = nRepeat;
1694 }
1695 else
1696 bOk = false;
1697 }
1698
1699 return bOk;
1700 }
1701
1702 static sal_Bool lcl_GetFieldDataByName( ScDPObject* pDPObj, const OUString& rFieldName, ScFieldIdentifier& rFieldId )
1703 {
1704 // "By name" is always the first match.
1705 // The name "Data" always refers to the data layout field.
1706 rFieldId.maFieldName = rFieldName;
1707 rFieldId.mnFieldIdx = 0;
1708 rFieldId.mbDataLayout = rFieldName == SC_DATALAYOUT_NAME;
1709
1710 pDPObj->GetSource(); // IsDimNameInUse doesn't update source data
1711
1712 // check if the named field exists (not for data layout)
1713 return rFieldId.mbDataLayout || pDPObj->IsDimNameInUse( rFieldName );
1714 }
1715
1716 // XDataPilotFields
1717
1718 ScDataPilotFieldObj* ScDataPilotFieldsObj::GetObjectByIndex_Impl( sal_Int32 nIndex ) const
1719 {
1720 // TODO
1721 if (ScDPObject* pObj = GetDPObject())
1722 {
1723 ScFieldIdentifier aFieldId;
1724 if (lcl_GetFieldDataByIndex( pObj->GetSource(), maOrient, nIndex, aFieldId ))
1725 return new ScDataPilotFieldObj( mrParent, aFieldId, maOrient );
1726 }
1727 return 0;
1728 }
1729
1730 ScDataPilotFieldObj* ScDataPilotFieldsObj::GetObjectByName_Impl(const OUString& aName) const
1731 {
1732 if (ScDPObject* pDPObj = GetDPObject())
1733 {
1734 ScFieldIdentifier aFieldId;
1735 if (lcl_GetFieldDataByName( pDPObj, aName, aFieldId ))
1736 return new ScDataPilotFieldObj( mrParent, aFieldId, maOrient );
1737 }
1738 return 0;
1739 }
1740
1741 // XEnumerationAccess
1742
1743 Reference<XEnumeration> SAL_CALL ScDataPilotFieldsObj::createEnumeration()
1744 throw(RuntimeException)
1745 {
1746 SolarMutexGuard aGuard;
1747 return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.DataPilotFieldsEnumeration"));
1748 }
1749
1750 // XIndexAccess
1751
1752 sal_Int32 SAL_CALL ScDataPilotFieldsObj::getCount() throw(RuntimeException)
1753 {
1754 SolarMutexGuard aGuard;
1755 // TODO
1756 ScDPObject* pDPObj = GetDPObject();
1757 return pDPObj ? lcl_GetFieldCount( pDPObj->GetSource(), maOrient ) : 0;
1758 }
1759
1760 Any SAL_CALL ScDataPilotFieldsObj::getByIndex( sal_Int32 nIndex )
1761 throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
1762 {
1763 SolarMutexGuard aGuard;
1764 Reference< XPropertySet > xField( GetObjectByIndex_Impl( nIndex ) );
1765 if (!xField.is())
1766 throw IndexOutOfBoundsException();
1767 return Any( xField );
1768 }
1769
1770 uno::Type SAL_CALL ScDataPilotFieldsObj::getElementType() throw(RuntimeException)
1771 {
1772 SolarMutexGuard aGuard;
1773 return getCppuType((Reference<XPropertySet>*)0);
1774 }
1775
1776 sal_Bool SAL_CALL ScDataPilotFieldsObj::hasElements() throw(RuntimeException)
1777 {
1778 SolarMutexGuard aGuard;
1779 return ( getCount() != 0 );
1780 }
1781
1782 Any SAL_CALL ScDataPilotFieldsObj::getByName( const OUString& aName )
1783 throw(NoSuchElementException, WrappedTargetException, RuntimeException)
1784 {
1785 SolarMutexGuard aGuard;
1786 Reference<XPropertySet> xField(GetObjectByName_Impl(aName));
1787 if (!xField.is())
1788 throw NoSuchElementException();
1789 return Any( xField );
1790 }
1791
1792 Sequence<OUString> SAL_CALL ScDataPilotFieldsObj::getElementNames()
1793 throw(RuntimeException)
1794 {
1795 SolarMutexGuard aGuard;
1796 // TODO
1797 if (ScDPObject* pDPObj = GetDPObject())
1798 {
1799 Sequence< OUString > aSeq( lcl_GetFieldCount( pDPObj->GetSource(), maOrient ) );
1800 OUString* pAry = aSeq.getArray();
1801
1802 const boost::ptr_vector<ScDPSaveDimension>& rDimensions = pDPObj->GetSaveData()->GetDimensions();
1803 boost::ptr_vector<ScDPSaveDimension>::const_iterator it;
1804 for (it = rDimensions.begin(); it != rDimensions.end(); ++it)
1805 {
1806 if(maOrient.hasValue() && (it->GetOrientation() == maOrient.get< DataPilotFieldOrientation >()))
1807 {
1808 *pAry = it->GetName();
1809 ++pAry;
1810 }
1811 }
1812 return aSeq;
1813 }
1814 return Sequence<OUString>();
1815 }
1816
1817 sal_Bool SAL_CALL ScDataPilotFieldsObj::hasByName( const OUString& aName )
1818 throw(RuntimeException)
1819 {
1820 SolarMutexGuard aGuard;
1821
1822 return GetObjectByName_Impl(aName) != NULL;
1823 }
1824
1825 //------------------------------------------------------------------------
1826
1827 ScDataPilotFieldObj::ScDataPilotFieldObj(
1828 ScDataPilotDescriptorBase& rParent, const ScFieldIdentifier& rFieldId ) :
1829 ScDataPilotChildObjBase( rParent, rFieldId ),
1830 maPropSet( lcl_GetDataPilotFieldMap() )
1831 {
1832 }
1833
1834 ScDataPilotFieldObj::ScDataPilotFieldObj( ScDataPilotDescriptorBase& rParent,
1835 const ScFieldIdentifier& rFieldId, const Any& rOrient ) :
1836 ScDataPilotChildObjBase( rParent, rFieldId ),
1837 maPropSet( lcl_GetDataPilotFieldMap() ),
1838 maOrient( rOrient )
1839 {
1840 }
1841
1842 ScDataPilotFieldObj::~ScDataPilotFieldObj()
1843 {
1844 }
1845
1846 // XNamed
1847
1848 OUString SAL_CALL ScDataPilotFieldObj::getName() throw(RuntimeException)
1849 {
1850 SolarMutexGuard aGuard;
1851 OUString aName;
1852 if( ScDPSaveDimension* pDim = GetDPDimension() )
1853 {
1854 if( pDim->IsDataLayout() )
1855 aName = OUString( SC_DATALAYOUT_NAME );
1856 else
1857 {
1858 const OUString* pLayoutName = pDim->GetLayoutName();
1859 if (pLayoutName)
1860 aName = *pLayoutName;
1861 else
1862 aName = pDim->GetName();
1863 } }
1864 return aName;
1865 }
1866
1867 void SAL_CALL ScDataPilotFieldObj::setName( const OUString& rName ) throw(RuntimeException)
1868 {
1869 SolarMutexGuard aGuard;
1870 ScDPObject* pDPObj = 0;
1871 ScDPSaveDimension* pDim = GetDPDimension( &pDPObj );
1872 if( pDim && !pDim->IsDataLayout() )
1873 {
1874 pDim->SetLayoutName(rName);
1875 SetDPObject( pDPObj );
1876 }
1877 }
1878
1879 // XPropertySet
1880
1881 Reference<XPropertySetInfo> SAL_CALL ScDataPilotFieldObj::getPropertySetInfo()
1882 throw(RuntimeException)
1883 {
1884 SolarMutexGuard aGuard;
1885 static Reference<XPropertySetInfo> aRef(
1886 new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
1887 return aRef;
1888 }
1889
1890 void SAL_CALL ScDataPilotFieldObj::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
1891 throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1892 {
1893 SolarMutexGuard aGuard;
1894 OUString aNameString(aPropertyName);
1895 if ( aNameString.equalsAscii( SC_UNONAME_FUNCTION ) )
1896 {
1897 // #i109350# use GetEnumFromAny because it also allows sal_Int32
1898 GeneralFunction eFunction = (GeneralFunction)
1899 ScUnoHelpFunctions::GetEnumFromAny( aValue );
1900 setFunction( eFunction );
1901 }
1902 else if ( aNameString.equalsAscii( SC_UNONAME_SUBTOTALS ) )
1903 {
1904 Sequence< GeneralFunction > aSubtotals;
1905 if( aValue >>= aSubtotals )
1906 setSubtotals( aSubtotals );
1907 }
1908 else if ( aNameString.equalsAscii( SC_UNONAME_ORIENT ) )
1909 {
1910 //! test for correct enum type?
1911 DataPilotFieldOrientation eOrient = (DataPilotFieldOrientation)
1912 ScUnoHelpFunctions::GetEnumFromAny( aValue );
1913 setOrientation( eOrient );
1914 }
1915 else if ( aNameString.equalsAscii( SC_UNONAME_SELPAGE ) )
1916 {
1917 OUString sCurrentPage;
1918 if (aValue >>= sCurrentPage)
1919 setCurrentPage(sCurrentPage);
1920 }
1921 else if ( aNameString.equalsAscii( SC_UNONAME_USESELPAGE ) )
1922 {
1923 setUseCurrentPage(cppu::any2bool(aValue));
1924 }
1925 else if ( aNameString.equalsAscii( SC_UNONAME_HASAUTOSHOW ) )
1926 {
1927 if (!cppu::any2bool(aValue))
1928 setAutoShowInfo(NULL);
1929 }
1930 else if ( aNameString.equalsAscii( SC_UNONAME_AUTOSHOW ) )
1931 {
1932 DataPilotFieldAutoShowInfo aInfo;
1933 if (aValue >>= aInfo)
1934 setAutoShowInfo(&aInfo);
1935 }
1936 else if ( aNameString.equalsAscii( SC_UNONAME_HASLAYOUTINFO ) )
1937 {
1938 if (!cppu::any2bool(aValue))
1939 setLayoutInfo(NULL);
1940 }
1941 else if ( aNameString.equalsAscii( SC_UNONAME_LAYOUTINFO ) )
1942 {
1943 DataPilotFieldLayoutInfo aInfo;
1944 if (aValue >>= aInfo)
1945 setLayoutInfo(&aInfo);
1946 }
1947 else if ( aNameString.equalsAscii( SC_UNONAME_HASREFERENCE ) )
1948 {
1949 if (!cppu::any2bool(aValue))
1950 setReference(NULL);
1951 }
1952 else if ( aNameString.equalsAscii( SC_UNONAME_REFERENCE ) )
1953 {
1954 DataPilotFieldReference aRef;
1955 if (aValue >>= aRef)
1956 setReference(&aRef);
1957 }
1958 else if ( aNameString.equalsAscii( SC_UNONAME_HASSORTINFO ) )
1959 {
1960 if (!cppu::any2bool(aValue))
1961 setSortInfo(NULL);
1962 }
1963 else if ( aNameString.equalsAscii( SC_UNONAME_SORTINFO ) )
1964 {
1965 DataPilotFieldSortInfo aInfo;
1966 if (aValue >>= aInfo)
1967 setSortInfo(&aInfo);
1968 }
1969 else if ( aNameString.equalsAscii( SC_UNONAME_ISGROUP ) )
1970 {
1971 if (!cppu::any2bool(aValue))
1972 setGroupInfo(NULL);
1973 }
1974 else if ( aNameString.equalsAscii( SC_UNONAME_GROUPINFO ) )
1975 {
1976 DataPilotFieldGroupInfo aInfo;
1977 if (aValue >>= aInfo)
1978 setGroupInfo(&aInfo);
1979 }
1980 else if ( aNameString.equalsAscii( SC_UNONAME_SHOWEMPTY ) )
1981 {
1982 setShowEmpty(cppu::any2bool(aValue));
1983 }
1984 }
1985
1986 Any SAL_CALL ScDataPilotFieldObj::getPropertyValue( const OUString& aPropertyName )
1987 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1988 {
1989 SolarMutexGuard aGuard;
1990 OUString aNameString(aPropertyName);
1991 Any aRet;
1992
1993 if ( aNameString.equalsAscii( SC_UNONAME_FUNCTION ) )
1994 aRet <<= getFunction();
1995 else if ( aNameString.equalsAscii( SC_UNONAME_SUBTOTALS ) )
1996 aRet <<= getSubtotals();
1997 else if ( aNameString.equalsAscii( SC_UNONAME_ORIENT ) )
1998 aRet <<= getOrientation();
1999 else if ( aNameString.equalsAscii( SC_UNONAME_SELPAGE ) )
2000 aRet <<= getCurrentPage();
2001 else if ( aNameString.equalsAscii( SC_UNONAME_USESELPAGE ) )
2002 aRet <<= getUseCurrentPage();
2003 else if ( aNameString.equalsAscii( SC_UNONAME_HASAUTOSHOW ) )
2004 aRet = ::cppu::bool2any(getAutoShowInfo() != NULL);
2005 else if ( aNameString.equalsAscii( SC_UNONAME_AUTOSHOW ) )
2006 {
2007 const DataPilotFieldAutoShowInfo* pInfo = getAutoShowInfo();
2008 if (pInfo)
2009 aRet <<= DataPilotFieldAutoShowInfo(*pInfo);
2010 }
2011 else if ( aNameString.equalsAscii( SC_UNONAME_HASLAYOUTINFO ) )
2012 aRet = ::cppu::bool2any(getLayoutInfo() != NULL);
2013 else if ( aNameString.equalsAscii( SC_UNONAME_LAYOUTINFO ) )
2014 {
2015 const DataPilotFieldLayoutInfo* pInfo = getLayoutInfo();
2016 if (pInfo)
2017 aRet <<= DataPilotFieldLayoutInfo(*pInfo);
2018 }
2019 else if ( aNameString.equalsAscii( SC_UNONAME_HASREFERENCE ) )
2020 aRet = ::cppu::bool2any(getReference() != NULL);
2021 else if ( aNameString.equalsAscii( SC_UNONAME_REFERENCE ) )
2022 {
2023 const DataPilotFieldReference* pRef = getReference();
2024 if (pRef)
2025 aRet <<= DataPilotFieldReference(*pRef);
2026 }
2027 else if ( aNameString.equalsAscii( SC_UNONAME_HASSORTINFO ) )
2028 aRet = ::cppu::bool2any(getSortInfo() != NULL);
2029 else if ( aNameString.equalsAscii( SC_UNONAME_SORTINFO ) )
2030 {
2031 const DataPilotFieldSortInfo* pInfo = getSortInfo();
2032 if (pInfo)
2033 aRet <<= DataPilotFieldSortInfo(*pInfo);
2034 }
2035 else if ( aNameString.equalsAscii( SC_UNONAME_ISGROUP ) )
2036 aRet = ::cppu::bool2any(hasGroupInfo());
2037 else if ( aNameString.equalsAscii( SC_UNONAME_GROUPINFO ) )
2038 {
2039 aRet <<= getGroupInfo();
2040 }
2041 else if ( aNameString.equalsAscii( SC_UNONAME_SHOWEMPTY ) )
2042 aRet <<= getShowEmpty();
2043
2044 return aRet;
2045 }
2046
2047 // XDatePilotField
2048
2049 Reference<XIndexAccess> SAL_CALL ScDataPilotFieldObj::getItems()
2050 throw (RuntimeException)
2051 {
2052 SolarMutexGuard aGuard;
2053 if (!mxItems.is())
2054 mxItems.set( new ScDataPilotItemsObj( mrParent, maFieldId ) );
2055 return mxItems;
2056 }
2057
2058 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDataPilotFieldObj )
2059
2060 DataPilotFieldOrientation ScDataPilotFieldObj::getOrientation() const
2061 {
2062 SolarMutexGuard aGuard;
2063 ScDPSaveDimension* pDim = GetDPDimension();
2064 return pDim ? static_cast< DataPilotFieldOrientation >( pDim->GetOrientation() ) : DataPilotFieldOrientation_HIDDEN;
2065 }
2066
2067 void ScDataPilotFieldObj::setOrientation(DataPilotFieldOrientation eNew)
2068 {
2069 SolarMutexGuard aGuard;
2070 if (maOrient.hasValue() && (eNew == maOrient.get< DataPilotFieldOrientation >()))
2071 return;
2072
2073 ScDPObject* pDPObj = 0;
2074 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2075 {
2076 ScDPSaveData* pSaveData = pDPObj->GetSaveData();
2077
2078 /* If the field was taken from getDataPilotFields(), don't reset the
2079 orientation for an existing use, but create a duplicated field
2080 instead (for "Data" orientation only). */
2081 if ( !maOrient.hasValue() && !maFieldId.mbDataLayout &&
2082 (pDim->GetOrientation() != DataPilotFieldOrientation_HIDDEN) &&
2083 (eNew == DataPilotFieldOrientation_DATA) )
2084 {
2085
2086 ScDPSaveDimension* pNewDim = 0;
2087
2088 // look for existing duplicate with orientation "hidden"
2089
2090 sal_Int32 nFound = 0;
2091 const boost::ptr_vector<ScDPSaveDimension>& rDimensions = pSaveData->GetDimensions();
2092 boost::ptr_vector<ScDPSaveDimension>::const_iterator it;
2093 for ( it = rDimensions.begin(); it != rDimensions.end() && !pNewDim; ++it )
2094 {
2095 if ( !it->IsDataLayout() && (it->GetName() == maFieldId.maFieldName) )
2096 {
2097 if ( it->GetOrientation() == DataPilotFieldOrientation_HIDDEN )
2098 pNewDim = const_cast<ScDPSaveDimension*>(&(*it)); // use this one
2099 else
2100 ++nFound; // count existing non-hidden occurrences
2101 }
2102 }
2103
2104 if ( !pNewDim ) // if none found, create a new duplicated dimension
2105 pNewDim = &pSaveData->DuplicateDimension( *pDim );
2106
2107 maFieldId.mnFieldIdx = nFound; // keep accessing the new one
2108 pDim = pNewDim;
2109 }
2110
2111 pDim->SetOrientation(sal::static_int_cast<sal_uInt16>(eNew));
2112
2113 // move changed field behind all other fields (make it the last field in dimension)
2114 pSaveData->SetPosition( pDim, pSaveData->GetDimensions().size() );
2115
2116 SetDPObject( pDPObj );
2117
2118 maOrient <<= eNew; // modifying the same object's orientation again doesn't create another duplicate
2119 }
2120 }
2121
2122 GeneralFunction ScDataPilotFieldObj::getFunction() const
2123 {
2124 SolarMutexGuard aGuard;
2125 GeneralFunction eRet = GeneralFunction_NONE;
2126 if( ScDPSaveDimension* pDim = GetDPDimension() )
2127 {
2128 if( pDim->GetOrientation() != DataPilotFieldOrientation_DATA )
2129 {
2130 // for non-data fields, property Function is the subtotals
2131 long nSubCount = pDim->GetSubTotalsCount();
2132 if ( nSubCount > 0 )
2133 eRet = (GeneralFunction)pDim->GetSubTotalFunc(0); // always use the first one
2134 // else keep NONE
2135 }
2136 else
2137 eRet = (GeneralFunction)pDim->GetFunction();
2138 }
2139 return eRet;
2140 }
2141
2142 void ScDataPilotFieldObj::setFunction(GeneralFunction eNewFunc)
2143 {
2144 SolarMutexGuard aGuard;
2145 ScDPObject* pDPObj = 0;
2146 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2147 {
2148 if( pDim->GetOrientation() != DataPilotFieldOrientation_DATA )
2149 {
2150 // for non-data fields, property Function is the subtotals
2151 if ( eNewFunc == GeneralFunction_NONE )
2152 pDim->SetSubTotals( 0, NULL );
2153 else
2154 {
2155 sal_uInt16 nFunc = sal::static_int_cast<sal_uInt16>( eNewFunc );
2156 pDim->SetSubTotals( 1, &nFunc );
2157 }
2158 }
2159 else
2160 pDim->SetFunction( sal::static_int_cast<sal_uInt16>( eNewFunc ) );
2161 SetDPObject( pDPObj );
2162 }
2163 }
2164
2165 Sequence< GeneralFunction > ScDataPilotFieldObj::getSubtotals() const
2166 {
2167 SolarMutexGuard aGuard;
2168 Sequence< GeneralFunction > aRet;
2169 if( ScDPSaveDimension* pDim = GetDPDimension() )
2170 {
2171 if( pDim->GetOrientation() != DataPilotFieldOrientation_DATA )
2172 {
2173 // for non-data fields, property Functions is the sequence of subtotals
2174 sal_Int32 nCount = static_cast< sal_Int32 >( pDim->GetSubTotalsCount() );
2175 if ( nCount > 0 )
2176 {
2177 aRet.realloc( nCount );
2178 for( sal_Int32 nIdx = 0; nIdx < nCount; ++nIdx )
2179 aRet[ nIdx ] = (GeneralFunction)pDim->GetSubTotalFunc( nIdx );
2180 }
2181 }
2182 }
2183 return aRet;
2184 }
2185
2186 void ScDataPilotFieldObj::setSubtotals( const Sequence< GeneralFunction >& rSubtotals )
2187 {
2188 SolarMutexGuard aGuard;
2189 ScDPObject* pDPObj = 0;
2190 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2191 {
2192 if( pDim->GetOrientation() != DataPilotFieldOrientation_DATA )
2193 {
2194 sal_Int32 nCount = rSubtotals.getLength();
2195 if( nCount == 1 )
2196 {
2197 // count 1: all values are allowed (including NONE and AUTO)
2198 if( rSubtotals[ 0 ] == GeneralFunction_NONE )
2199 pDim->SetSubTotals( 0, NULL );
2200 else
2201 {
2202 sal_uInt16 nFunc = sal::static_int_cast<sal_uInt16>( rSubtotals[ 0 ] );
2203 pDim->SetSubTotals( 1, &nFunc );
2204 }
2205 }
2206 else if( nCount > 1 )
2207 {
2208 // set multiple functions, ignore NONE and AUTO in this case
2209 ::std::vector< sal_uInt16 > aSubt;
2210 for( sal_Int32 nIdx = 0; nIdx < nCount; ++nIdx )
2211 {
2212 GeneralFunction eFunc = rSubtotals[ nIdx ];
2213 if( (eFunc != GeneralFunction_NONE) && (eFunc != GeneralFunction_AUTO) )
2214 {
2215 // do not insert functions twice
2216 sal_uInt16 nFunc = static_cast< sal_uInt16 >( eFunc );
2217 if( ::std::find( aSubt.begin(), aSubt.end(), nFunc ) == aSubt.end() )
2218 aSubt.push_back( nFunc );
2219 }
2220 }
2221 // set values from vector to ScDPSaveDimension
2222 if ( aSubt.empty() )
2223 pDim->SetSubTotals( 0, NULL );
2224 else
2225 pDim->SetSubTotals( static_cast< long >( aSubt.size() ), &aSubt.front() );
2226 }
2227 }
2228 SetDPObject( pDPObj );
2229 }
2230 }
2231
2232 OUString ScDataPilotFieldObj::getCurrentPage() const
2233 {
2234 return OUString();
2235 }
2236
2237 void ScDataPilotFieldObj::setCurrentPage( const OUString& rPage )
2238 {
2239 SolarMutexGuard aGuard;
2240 ScDPObject* pDPObj = 0;
2241 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2242 {
2243 pDim->SetCurrentPage( &rPage );
2244 SetDPObject( pDPObj );
2245 }
2246 }
2247
2248 sal_Bool ScDataPilotFieldObj::getUseCurrentPage() const
2249 {
2250 return false;
2251 }
2252
2253 void ScDataPilotFieldObj::setUseCurrentPage( sal_Bool bUse )
2254 {
2255 SolarMutexGuard aGuard;
2256 ScDPObject* pDPObj = 0;
2257 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2258 {
2259 if( bUse )
2260 {
2261 /* It is somehow useless to set the property "HasSelectedPage" to
2262 true, because it is still needed to set an explicit page name. */
2263 const OUString aPage;
2264 pDim->SetCurrentPage( &aPage );
2265 }
2266 else
2267 pDim->SetCurrentPage( 0 );
2268 SetDPObject( pDPObj );
2269 }
2270 }
2271
2272 const DataPilotFieldAutoShowInfo* ScDataPilotFieldObj::getAutoShowInfo()
2273 {
2274 SolarMutexGuard aGuard;
2275 ScDPSaveDimension* pDim = GetDPDimension();
2276 return pDim ? pDim->GetAutoShowInfo() : 0;
2277 }
2278
2279 void ScDataPilotFieldObj::setAutoShowInfo( const DataPilotFieldAutoShowInfo* pInfo )
2280 {
2281 SolarMutexGuard aGuard;
2282 ScDPObject* pDPObj = 0;
2283 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2284 {
2285 pDim->SetAutoShowInfo( pInfo );
2286 SetDPObject( pDPObj );
2287 }
2288 }
2289
2290 const DataPilotFieldLayoutInfo* ScDataPilotFieldObj::getLayoutInfo()
2291 {
2292 SolarMutexGuard aGuard;
2293 ScDPSaveDimension* pDim = GetDPDimension();
2294 return pDim ? pDim->GetLayoutInfo() : 0;
2295 }
2296
2297 void ScDataPilotFieldObj::setLayoutInfo( const DataPilotFieldLayoutInfo* pInfo )
2298 {
2299 SolarMutexGuard aGuard;
2300 ScDPObject* pDPObj = 0;
2301 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2302 {
2303 pDim->SetLayoutInfo( pInfo );
2304 SetDPObject( pDPObj );
2305 }
2306 }
2307
2308 const DataPilotFieldReference* ScDataPilotFieldObj::getReference()
2309 {
2310 SolarMutexGuard aGuard;
2311 ScDPSaveDimension* pDim = GetDPDimension();
2312 return pDim ? pDim->GetReferenceValue() : 0;
2313 }
2314
2315 void ScDataPilotFieldObj::setReference( const DataPilotFieldReference* pInfo )
2316 {
2317 SolarMutexGuard aGuard;
2318 ScDPObject* pDPObj = 0;
2319 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2320 {
2321 pDim->SetReferenceValue( pInfo );
2322 SetDPObject( pDPObj );
2323 }
2324 }
2325
2326 const DataPilotFieldSortInfo* ScDataPilotFieldObj::getSortInfo()
2327 {
2328 SolarMutexGuard aGuard;
2329 ScDPSaveDimension* pDim = GetDPDimension();
2330 return pDim ? pDim->GetSortInfo() : 0;
2331 }
2332
2333 void ScDataPilotFieldObj::setSortInfo( const DataPilotFieldSortInfo* pInfo )
2334 {
2335 SolarMutexGuard aGuard;
2336 ScDPObject* pDPObj = 0;
2337 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2338 {
2339 pDim->SetSortInfo( pInfo );
2340 SetDPObject( pDPObj );
2341 }
2342 }
2343
2344 sal_Bool ScDataPilotFieldObj::getShowEmpty() const
2345 {
2346 SolarMutexGuard aGuard;
2347 ScDPSaveDimension* pDim = GetDPDimension();
2348 return pDim && pDim->GetShowEmpty();
2349 }
2350
2351 void ScDataPilotFieldObj::setShowEmpty( sal_Bool bShow )
2352 {
2353 SolarMutexGuard aGuard;
2354 ScDPObject* pDPObj = 0;
2355 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2356 {
2357 pDim->SetShowEmpty( bShow );
2358 SetDPObject( pDPObj );
2359 }
2360 }
2361
2362 sal_Bool ScDataPilotFieldObj::hasGroupInfo()
2363 {
2364 SolarMutexGuard aGuard;
2365 ScDPObject* pDPObj = 0;
2366 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2367 if( const ScDPDimensionSaveData* pDimData = pDPObj->GetSaveData()->GetExistingDimensionData() )
2368 return pDimData->GetNamedGroupDim( pDim->GetName() ) || pDimData->GetNumGroupDim( pDim->GetName() );
2369 return false;
2370 }
2371
2372 DataPilotFieldGroupInfo ScDataPilotFieldObj::getGroupInfo()
2373 {
2374 SolarMutexGuard aGuard;
2375 DataPilotFieldGroupInfo aInfo;
2376 ScDPObject* pDPObj = 0;
2377 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2378 {
2379 if( const ScDPDimensionSaveData* pDimData = pDPObj->GetSaveData()->GetExistingDimensionData() )
2380 {
2381 if( const ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDim( pDim->GetName() ) )
2382 {
2383 // grouped by ...
2384 aInfo.GroupBy = pGroupDim->GetDatePart();
2385
2386 // find source field
2387 try
2388 {
2389 Reference< XNameAccess > xFields( mrParent.getDataPilotFields(), UNO_QUERY_THROW );
2390 aInfo.SourceField.set( xFields->getByName( pGroupDim->GetSourceDimName() ), UNO_QUERY );
2391 }
2392 catch( Exception& )
2393 {
2394 }
2395
2396 ScDataPilotConversion::FillGroupInfo( aInfo, pGroupDim->GetDateInfo() );
2397 if( pGroupDim->GetDatePart() == 0 )
2398 {
2399 // fill vector of group and group member information
2400 ScFieldGroups aGroups;
2401 for( sal_Int32 nIdx = 0, nCount = pGroupDim->GetGroupCount(); nIdx < nCount; ++nIdx )
2402 {
2403 if( const ScDPSaveGroupItem* pGroup = pGroupDim->GetGroupByIndex( nIdx ) )
2404 {
2405 ScFieldGroup aGroup;
2406 aGroup.maName = pGroup->GetGroupName();
2407 for( sal_Int32 nMemIdx = 0, nMemCount = pGroup->GetElementCount(); nMemIdx < nMemCount; ++nMemIdx )
2408 if (const OUString* pMem = pGroup->GetElementByIndex(nMemIdx))
2409 aGroup.maMembers.push_back( *pMem );
2410 aGroups.push_back( aGroup );
2411 }
2412 }
2413 aInfo.Groups = new ScDataPilotFieldGroupsObj( aGroups );
2414 }
2415 }
2416 else if( const ScDPSaveNumGroupDimension* pNumGroupDim = pDimData->GetNumGroupDim( pDim->GetName() ) )
2417 {
2418 if (pNumGroupDim->GetDatePart())
2419 {
2420 ScDataPilotConversion::FillGroupInfo( aInfo, pNumGroupDim->GetDateInfo() );
2421 aInfo.GroupBy = pNumGroupDim->GetDatePart();
2422 }
2423 else
2424 {
2425 ScDataPilotConversion::FillGroupInfo( aInfo, pNumGroupDim->GetInfo() );
2426 }
2427 }
2428 }
2429 }
2430 return aInfo;
2431 }
2432
2433 void ScDataPilotFieldObj::setGroupInfo( const DataPilotFieldGroupInfo* pInfo )
2434 {
2435 SolarMutexGuard aGuard;
2436 ScDPObject* pDPObj = 0;
2437 if( /*ScDPSaveDimension* pDim =*/ GetDPDimension( &pDPObj ) )
2438 {
2439 ScDPSaveData* pSaveData = pDPObj->GetSaveData();
2440 if( pInfo && lclCheckMinMaxStep( *pInfo ) )
2441 {
2442 ScDPNumGroupInfo aInfo;
2443 aInfo.mbEnable = sal_True;
2444 aInfo.mbDateValues = pInfo->HasDateValues;
2445 aInfo.mbAutoStart = pInfo->HasAutoStart;
2446 aInfo.mbAutoEnd = pInfo->HasAutoEnd;
2447 aInfo.mfStart = pInfo->Start;
2448 aInfo.mfEnd = pInfo->End;
2449 aInfo.mfStep = pInfo->Step;
2450 Reference< XNamed > xNamed( pInfo->SourceField, UNO_QUERY );
2451 if( xNamed.is() )
2452 {
2453 ScDPSaveGroupDimension aGroupDim( xNamed->getName(), getName() );
2454 if( pInfo->GroupBy )
2455 aGroupDim.SetDateInfo(aInfo, pInfo->GroupBy);
2456 else
2457 {
2458 Reference<XIndexAccess> xIndex(pInfo->Groups, UNO_QUERY);
2459 if (xIndex.is())
2460 {
2461 sal_Int32 nCount(xIndex->getCount());
2462 for(sal_Int32 i = 0; i < nCount; i++)
2463 {
2464 Reference<XNamed> xGroupNamed(xIndex->getByIndex(i), UNO_QUERY);
2465 if (xGroupNamed.is())
2466 {
2467 ScDPSaveGroupItem aItem(xGroupNamed->getName());
2468 Reference<XIndexAccess> xGroupIndex(xGroupNamed, UNO_QUERY);
2469 if (xGroupIndex.is())
2470 {
2471 sal_Int32 nItemCount(xGroupIndex->getCount());
2472 for (sal_Int32 j = 0; j < nItemCount; ++j)
2473 {
2474 Reference<XNamed> xItemNamed(xGroupIndex->getByIndex(j), UNO_QUERY);
2475 if (xItemNamed.is())
2476 aItem.AddElement(xItemNamed->getName());
2477 }
2478 }
2479 aGroupDim.AddGroupItem(aItem);
2480 }
2481 }
2482 }
2483 }
2484
2485 // get dimension savedata or create new if none
2486 ScDPDimensionSaveData& rDimSaveData = *pSaveData->GetDimensionData();
2487 rDimSaveData.ReplaceGroupDimension( aGroupDim );
2488 }
2489 else // no source field in group info -> numeric group
2490 {
2491 ScDPDimensionSaveData* pDimData = pSaveData->GetDimensionData(); // created if not there
2492
2493 ScDPSaveNumGroupDimension* pExisting = pDimData->GetNumGroupDimAcc( getName() );
2494 if ( pExisting )
2495 {
2496 if (pInfo->GroupBy)
2497 pExisting->SetDateInfo(aInfo, pInfo->GroupBy);
2498 // modify existing group dimension
2499 pExisting->SetGroupInfo( aInfo );
2500 }
2501 else if (pInfo->GroupBy)
2502 {
2503 // create new group dimension
2504 ScDPSaveNumGroupDimension aNumGroupDim( getName(), aInfo, pInfo->GroupBy );
2505 pDimData->AddNumGroupDimension( aNumGroupDim );
2506 }
2507 else
2508 {
2509 // create new group dimension
2510 ScDPSaveNumGroupDimension aNumGroupDim( getName(), aInfo );
2511 pDimData->AddNumGroupDimension( aNumGroupDim );
2512 }
2513 }
2514 }
2515 else // null passed as argument
2516 {
2517 pSaveData->SetDimensionData( 0 );
2518 }
2519
2520 pDPObj->SetSaveData( *pSaveData );
2521 SetDPObject( pDPObj );
2522 }
2523 }
2524
2525 sal_Bool ScDataPilotFieldObj::HasString(const Sequence< OUString >& rItems, const OUString& aString)
2526 {
2527 sal_Bool bRet = false;
2528
2529 sal_Int32 nCount(rItems.getLength());
2530 sal_Int32 nItem(0);
2531 while (nItem < nCount && !bRet)
2532 {
2533 bRet = rItems[nItem] == aString;
2534 ++nItem;
2535 }
2536
2537 return bRet;
2538 }
2539
2540 // XDataPilotFieldGrouping
2541 Reference< XDataPilotField > SAL_CALL ScDataPilotFieldObj::createNameGroup( const Sequence< OUString >& rItems )
2542 throw (RuntimeException, IllegalArgumentException)
2543 {
2544 SolarMutexGuard aGuard;
2545
2546 Reference< XDataPilotField > xRet;
2547 OUString sNewDim;
2548
2549 if( !rItems.hasElements() )
2550 throw IllegalArgumentException();
2551
2552 ScDPObject* pDPObj = 0;
2553 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2554 {
2555 OUString aDimName = pDim->GetName();
2556
2557 ScDPSaveData aSaveData = *pDPObj->GetSaveData();
2558 ScDPDimensionSaveData* pDimData = aSaveData.GetDimensionData(); // created if not there
2559
2560 // find original base
2561 OUString aBaseDimName( aDimName );
2562 const ScDPSaveGroupDimension* pBaseGroupDim = pDimData->GetNamedGroupDim( aDimName );
2563 if ( pBaseGroupDim )
2564 {
2565 // any entry's SourceDimName is the original base
2566 aBaseDimName = pBaseGroupDim->GetSourceDimName();
2567 }
2568
2569 // find existing group dimension
2570 // (using the selected dim, can be intermediate group dim)
2571 ScDPSaveGroupDimension* pGroupDimension = pDimData->GetGroupDimAccForBase( aDimName );
2572
2573 // remove the selected items from their groups
2574 // (empty groups are removed, too)
2575 sal_Int32 nEntryCount = rItems.getLength();
2576 sal_Int32 nEntry;
2577 if ( pGroupDimension )
2578 {
2579 for (nEntry=0; nEntry<nEntryCount; nEntry++)
2580 {
2581 const OUString& aEntryName = rItems[nEntry];
2582 if ( pBaseGroupDim )
2583 {
2584 // for each selected (intermediate) group, remove all its items
2585 // (same logic as for adding, below)
2586 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetNamedGroup( aEntryName );
2587 if ( pBaseGroup )
2588 pBaseGroup->RemoveElementsFromGroups( *pGroupDimension ); // remove all elements
2589 else
2590 pGroupDimension->RemoveFromGroups( aEntryName );
2591 }
2592 else
2593 pGroupDimension->RemoveFromGroups( aEntryName );
2594 }
2595 }
2596
2597 ScDPSaveGroupDimension* pNewGroupDim = 0;
2598 if ( !pGroupDimension )
2599 {
2600 // create a new group dimension
2601 sNewDim = pDimData->CreateGroupDimName( aBaseDimName, *pDPObj, false, NULL );
2602 pNewGroupDim = new ScDPSaveGroupDimension( aBaseDimName, sNewDim );
2603
2604 pGroupDimension = pNewGroupDim; // make changes to the new dim if none existed
2605
2606 if ( pBaseGroupDim )
2607 {
2608 // If it's a higher-order group dimension, pre-allocate groups for all
2609 // non-selected original groups, so the individual base members aren't
2610 // used for automatic groups (this would make the original groups hard
2611 // to find).
2612 //! Also do this when removing groups?
2613 //! Handle this case dynamically with automatic groups?
2614
2615 long nGroupCount = pBaseGroupDim->GetGroupCount();
2616 for ( long nGroup = 0; nGroup < nGroupCount; nGroup++ )
2617 {
2618 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetGroupByIndex( nGroup );
2619
2620 if (!HasString(rItems, pBaseGroup->GetGroupName())) //! ignore case?
2621 {
2622 // add an additional group for each item that is not in the selection
2623 ScDPSaveGroupItem aGroup( pBaseGroup->GetGroupName() );
2624 aGroup.AddElementsFromGroup( *pBaseGroup );
2625 pGroupDimension->AddGroupItem( aGroup );
2626 }
2627 }
2628 }
2629 }
2630 OUString aGroupDimName = pGroupDimension->GetGroupDimName();
2631
2632 //! localized prefix string
2633 OUString aGroupName = pGroupDimension->CreateGroupName( OUString( "Group" ) );
2634 ScDPSaveGroupItem aGroup( aGroupName );
2635 Reference< XNameAccess > xMembers = GetMembers();
2636 if (!xMembers.is())
2637 {
2638 delete pNewGroupDim;
2639 throw RuntimeException();
2640 }
2641
2642 for (nEntry=0; nEntry<nEntryCount; nEntry++)
2643 {
2644 OUString aEntryName(rItems[nEntry]);
2645
2646 if (!xMembers->hasByName(aEntryName))
2647 {
2648 delete pNewGroupDim;
2649 throw IllegalArgumentException();
2650 }
2651
2652 if ( pBaseGroupDim )
2653 {
2654 // for each selected (intermediate) group, add all its items
2655 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetNamedGroup( aEntryName );
2656 if ( pBaseGroup )
2657 aGroup.AddElementsFromGroup( *pBaseGroup );
2658 else
2659 aGroup.AddElement( aEntryName ); // no group found -> automatic group, add the item itself
2660 }
2661 else
2662 aGroup.AddElement( aEntryName ); // no group dimension, add all items directly
2663 }
2664
2665 pGroupDimension->AddGroupItem( aGroup );
2666
2667 if ( pNewGroupDim )
2668 {
2669 pDimData->AddGroupDimension( *pNewGroupDim );
2670 delete pNewGroupDim; // AddGroupDimension copies the object
2671 // don't access pGroupDimension after here
2672 }
2673 pGroupDimension = pNewGroupDim = NULL;
2674
2675 // set orientation
2676 ScDPSaveDimension* pSaveDimension = aSaveData.GetDimensionByName( aGroupDimName );
2677 if ( pSaveDimension->GetOrientation() == DataPilotFieldOrientation_HIDDEN )
2678 {
2679 ScDPSaveDimension* pOldDimension = aSaveData.GetDimensionByName( aDimName );
2680 pSaveDimension->SetOrientation( pOldDimension->GetOrientation() );
2681 long nPosition = 0; //! before (immediate) base
2682 aSaveData.SetPosition( pSaveDimension, nPosition );
2683 }
2684
2685 // apply changes
2686 pDPObj->SetSaveData( aSaveData );
2687 ScDBDocFunc(*GetDocShell()).RefreshPivotTableGroups(pDPObj);
2688 }
2689
2690 // if new grouping field has been created (on first group), return it
2691 if( !sNewDim.isEmpty() )
2692 {
2693 Reference< XNameAccess > xFields(mrParent.getDataPilotFields(), UNO_QUERY);
2694 if (xFields.is())
2695 {
2696 try
2697 {
2698 xRet.set(xFields->getByName(sNewDim), UNO_QUERY);
2699 OSL_ENSURE(xRet.is(), "there is a name, so there should be also a field");
2700 }
2701 catch (const container::NoSuchElementException&)
2702 {
2703 // Avoid throwing exception that's not specified in the method signature.
2704 throw RuntimeException();
2705 }
2706 }
2707 }
2708 return xRet;
2709 }
2710
2711 Reference < XDataPilotField > SAL_CALL ScDataPilotFieldObj::createDateGroup( const DataPilotFieldGroupInfo& rInfo )
2712 throw (RuntimeException, IllegalArgumentException)
2713 {
2714 SolarMutexGuard aGuard;
2715 using namespace ::com::sun::star::sheet::DataPilotFieldGroupBy;
2716
2717 // check min/max/step, HasDateValues must be set always
2718 if( !rInfo.HasDateValues || !lclCheckMinMaxStep( rInfo ) )
2719 throw IllegalArgumentException();
2720 // only a single date flag is allowed
2721 if( (rInfo.GroupBy == 0) || (rInfo.GroupBy > YEARS) || ((rInfo.GroupBy & (rInfo.GroupBy - 1)) != 0) )
2722 throw IllegalArgumentException();
2723 // step must be zero, if something else than DAYS is specified
2724 if( rInfo.Step >= ((rInfo.GroupBy == DAYS) ? 32768.0 : 1.0) )
2725 throw IllegalArgumentException();
2726
2727 OUString aGroupDimName;
2728 ScDPObject* pDPObj = 0;
2729 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
2730 {
2731 ScDPNumGroupInfo aInfo;
2732 aInfo.mbEnable = true;
2733 aInfo.mbDateValues = (rInfo.GroupBy == DAYS) && (rInfo.Step >= 1.0);
2734 aInfo.mbAutoStart = rInfo.HasAutoStart;
2735 aInfo.mbAutoEnd = rInfo.HasAutoEnd;
2736 aInfo.mfStart = rInfo.Start;
2737 aInfo.mfEnd = rInfo.End;
2738 aInfo.mfStep = static_cast< sal_Int32 >( rInfo.Step );
2739
2740 // create a local copy of the entire save data (will be written back below)
2741 ScDPSaveData aSaveData = *pDPObj->GetSaveData();
2742 // get or create dimension save data
2743 ScDPDimensionSaveData& rDimData = *aSaveData.GetDimensionData();
2744
2745 // find source dimension name
2746 const OUString& rDimName = pDim->GetName();
2747 const ScDPSaveGroupDimension* pGroupDim = rDimData.GetNamedGroupDim( rDimName );
2748 OUString aSrcDimName = pGroupDim ? pGroupDim->GetSourceDimName() : rDimName;
2749
2750 // find a group dimension for the base field, or get numeric grouping
2751 pGroupDim = rDimData.GetFirstNamedGroupDim( aSrcDimName );
2752 const ScDPSaveNumGroupDimension* pNumGroupDim = rDimData.GetNumGroupDim( aSrcDimName );
2753
2754 // do not group by dates, if named groups or numeric grouping is present
2755 bool bHasNamedGrouping = pGroupDim && !pGroupDim->GetDateInfo().mbEnable;
2756 bool bHasNumGrouping = pNumGroupDim && pNumGroupDim->GetInfo().mbEnable && !pNumGroupDim->GetInfo().mbDateValues && !pNumGroupDim->GetDateInfo().mbEnable;
2757 if( bHasNamedGrouping || bHasNumGrouping )
2758 throw IllegalArgumentException();
2759
2760 if( aInfo.mbDateValues ) // create day ranges grouping
2761 {
2762 // first remove all named group dimensions
2763 while( pGroupDim )
2764 {
2765 OUString aGroupDimName2 = pGroupDim->GetGroupDimName();
2766 // find next group dimension before deleting this group
2767 pGroupDim = rDimData.GetNextNamedGroupDim( aGroupDimName2 );
2768 // remove from dimension save data
2769 rDimData.RemoveGroupDimension( aGroupDimName2 );
2770 // also remove save data settings for the dimension that no longer exists
2771 aSaveData.RemoveDimensionByName( aGroupDimName2 );
2772 }
2773 // create or replace the number grouping dimension
2774 ScDPSaveNumGroupDimension aNumGroupDim( aSrcDimName, aInfo );
2775 rDimData.ReplaceNumGroupDimension( aNumGroupDim );
2776 }
2777 else // create date grouping
2778 {
2779 // collect all existing date flags
2780 sal_Int32 nDateParts = rDimData.CollectDateParts( aSrcDimName );
2781 if( nDateParts == 0 )
2782 {
2783 // insert numeric group dimension, if no date groups exist yet (or replace day range grouping)
2784 ScDPSaveNumGroupDimension aNumGroupDim( aSrcDimName, aInfo, rInfo.GroupBy );
2785 rDimData.ReplaceNumGroupDimension( aNumGroupDim );
2786 }
2787 else if( (nDateParts & rInfo.GroupBy) == 0 ) // do nothing if date field exists already
2788 {
2789 // create new named group dimension for additional date groups
2790 aGroupDimName = rDimData.CreateDateGroupDimName( rInfo.GroupBy, *pDPObj, true, 0 );
2791 ScDPSaveGroupDimension aGroupDim( aSrcDimName, aGroupDimName, aInfo, rInfo.GroupBy );
2792 rDimData.AddGroupDimension( aGroupDim );
2793
2794 // set orientation of new named group dimension
2795 ScDPSaveDimension& rSaveDim = *aSaveData.GetDimensionByName( aGroupDimName );
2796 if( rSaveDim.GetOrientation() == DataPilotFieldOrientation_HIDDEN )
2797 {
2798 ScDPSaveDimension& rOldDim = *aSaveData.GetDimensionByName( aSrcDimName );
2799 rSaveDim.SetOrientation( rOldDim.GetOrientation() );
2800 aSaveData.SetPosition( &rSaveDim, 0 ); //! before (immediate) base
2801 }
2802 }
2803 }
2804
2805 // apply changes
2806 pDPObj->SetSaveData( aSaveData );
2807 SetDPObject( pDPObj );
2808 }
2809
2810 // return the UNO object of the new dimension, after writing back saved data
2811 Reference< XDataPilotField > xRet;
2812 if( !aGroupDimName.isEmpty() )
2813 try
2814 {
2815 Reference< XNameAccess > xFields( mrParent.getDataPilotFields(), UNO_QUERY_THROW );
2816 xRet.set( xFields->getByName( aGroupDimName ), UNO_QUERY );
2817 }
2818 catch( Exception& )
2819 {
2820 }
2821 return xRet;
2822 }
2823
2824 // ============================================================================
2825
2826 namespace {
2827
2828 bool lclExtractGroupMembers( ScFieldGroupMembers& rMembers, const Any& rElement )
2829 {
2830 // allow empty value to create a new group
2831 if( !rElement.hasValue() )
2832 return true;
2833
2834 // try to extract a simple sequence of strings
2835 Sequence< OUString > aSeq;
2836 if( rElement >>= aSeq )
2837 {
2838 if( aSeq.hasElements() )
2839 rMembers.insert( rMembers.end(), aSeq.getConstArray(), aSeq.getConstArray() + aSeq.getLength() );
2840 return true;
2841 }
2842
2843 // try to use XIndexAccess providing objects that support XNamed
2844 Reference< XIndexAccess > xItemsIA( rElement, UNO_QUERY );
2845 if( xItemsIA.is() )
2846 {
2847 for( sal_Int32 nIdx = 0, nCount = xItemsIA->getCount(); nIdx < nCount; ++nIdx )
2848 {
2849 try // getByIndex() should not throw, but we cannot be sure
2850 {
2851 Reference< XNamed > xItemName( xItemsIA->getByIndex( nIdx ), UNO_QUERY_THROW );
2852 rMembers.push_back( xItemName->getName() );
2853 }
2854 catch( Exception& )
2855 {
2856 // ignore exceptions, go ahead with next element in the array
2857 }
2858 }
2859 return true;
2860 }
2861
2862 // nothing valid inside the Any -> return false
2863 return false;
2864 }
2865
2866 } // namespace
2867
2868 // ----------------------------------------------------------------------------
2869
2870 ScDataPilotFieldGroupsObj::ScDataPilotFieldGroupsObj( const ScFieldGroups& rGroups ) :
2871 maGroups( rGroups )
2872 {
2873 }
2874
2875 ScDataPilotFieldGroupsObj::~ScDataPilotFieldGroupsObj()
2876 {
2877 }
2878
2879 // XNameAccess
2880
2881 Any SAL_CALL ScDataPilotFieldGroupsObj::getByName( const OUString& rName )
2882 throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2883 {
2884 SolarMutexGuard aGuard;
2885 if( implFindByName( rName ) == maGroups.end() )
2886 throw NoSuchElementException();
2887 return Any( Reference< XNameAccess >( new ScDataPilotFieldGroupObj( *this, rName ) ) );
2888 }
2889
2890 Sequence< OUString > SAL_CALL ScDataPilotFieldGroupsObj::getElementNames() throw(RuntimeException)
2891 {
2892 SolarMutexGuard aGuard;
2893 Sequence< OUString > aSeq;
2894 if( !maGroups.empty() )
2895 {
2896 aSeq.realloc( static_cast< sal_Int32 >( maGroups.size() ) );
2897 OUString* pName = aSeq.getArray();
2898 for( ScFieldGroups::iterator aIt = maGroups.begin(), aEnd = maGroups.end(); aIt != aEnd; ++aIt, ++pName )
2899 *pName = aIt->maName;
2900 }
2901 return aSeq;
2902 }
2903
2904 sal_Bool SAL_CALL ScDataPilotFieldGroupsObj::hasByName( const OUString& rName ) throw(RuntimeException)
2905 {
2906 SolarMutexGuard aGuard;
2907 return implFindByName( rName ) != maGroups.end();
2908 }
2909
2910 // XNameReplace
2911
2912 void SAL_CALL ScDataPilotFieldGroupsObj::replaceByName( const OUString& rName, const Any& rElement )
2913 throw (IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
2914 {
2915 SolarMutexGuard aGuard;
2916
2917 if( rName.isEmpty() )
2918 throw IllegalArgumentException();
2919
2920 ScFieldGroups::iterator aIt = implFindByName( rName );
2921 if( aIt == maGroups.end() )
2922 throw NoSuchElementException();
2923
2924 // read all item names provided by the passed object
2925 ScFieldGroupMembers aMembers;
2926 if( !lclExtractGroupMembers( aMembers, rElement ) )
2927 throw IllegalArgumentException();
2928
2929 // copy and forget, faster than vector assignment
2930 aIt->maMembers.swap( aMembers );
2931 }
2932
2933 // XNameContainer
2934
2935 void SAL_CALL ScDataPilotFieldGroupsObj::insertByName( const OUString& rName, const Any& rElement )
2936 throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
2937 {
2938 SolarMutexGuard aGuard;
2939
2940 if( rName.isEmpty() )
2941 throw IllegalArgumentException();
2942
2943 ScFieldGroups::iterator aIt = implFindByName( rName );
2944 if( aIt != maGroups.end() )
2945 throw ElementExistException();
2946
2947 // read all item names provided by the passed object
2948 ScFieldGroupMembers aMembers;
2949 if( !lclExtractGroupMembers( aMembers, rElement ) )
2950 throw IllegalArgumentException();
2951
2952 // create the new entry if no error has been occurred
2953 maGroups.resize( maGroups.size() + 1 );
2954 ScFieldGroup& rGroup = maGroups.back();
2955 rGroup.maName = rName;
2956 rGroup.maMembers.swap( aMembers );
2957 }
2958
2959 void SAL_CALL ScDataPilotFieldGroupsObj::removeByName( const OUString& rName )
2960 throw (NoSuchElementException, WrappedTargetException, RuntimeException)
2961 {
2962 SolarMutexGuard aGuard;
2963
2964 if( rName.isEmpty() )
2965 throw IllegalArgumentException();
2966
2967 ScFieldGroups::iterator aIt = implFindByName( rName );
2968 if( aIt == maGroups.end() )
2969 throw NoSuchElementException();
2970
2971 maGroups.erase( aIt );
2972 }
2973
2974 // XIndexAccess
2975
2976 sal_Int32 SAL_CALL ScDataPilotFieldGroupsObj::getCount() throw(RuntimeException)
2977 {
2978 SolarMutexGuard aGuard;
2979 return static_cast< sal_Int32 >( maGroups.size() );
2980 }
2981
2982 Any SAL_CALL ScDataPilotFieldGroupsObj::getByIndex( sal_Int32 nIndex )
2983 throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
2984 {
2985 SolarMutexGuard aGuard;
2986 if ((nIndex < 0) || (nIndex >= static_cast< sal_Int32 >( maGroups.size() )))
2987 throw IndexOutOfBoundsException();
2988 return Any( Reference< XNameAccess >( new ScDataPilotFieldGroupObj( *this, maGroups[ nIndex ].maName ) ) );
2989 }
2990
2991 // XEnumerationAccess
2992
2993 Reference<XEnumeration> SAL_CALL ScDataPilotFieldGroupsObj::createEnumeration() throw(RuntimeException)
2994 {
2995 SolarMutexGuard aGuard;
2996 return new ScIndexEnumeration( this, OUString( "com.sun.star.sheet.DataPilotFieldGroupsEnumeration" ) );
2997 }
2998
2999 // XElementAccess
3000
3001 uno::Type SAL_CALL ScDataPilotFieldGroupsObj::getElementType() throw(RuntimeException)
3002 {
3003 SolarMutexGuard aGuard;
3004 return getCppuType( (Reference< XNameAccess >*)0 );
3005 }
3006
3007 sal_Bool SAL_CALL ScDataPilotFieldGroupsObj::hasElements() throw(RuntimeException)
3008 {
3009 SolarMutexGuard aGuard;
3010 return !maGroups.empty();
3011 }
3012
3013 // implementation
3014
3015 ScFieldGroup& ScDataPilotFieldGroupsObj::getFieldGroup( const OUString& rName ) throw(RuntimeException)
3016 {
3017 SolarMutexGuard aGuard;
3018 ScFieldGroups::iterator aIt = implFindByName( rName );
3019 if( aIt == maGroups.end() )
3020 throw RuntimeException();
3021 return *aIt;
3022 }
3023
3024 void ScDataPilotFieldGroupsObj::renameFieldGroup( const OUString& rOldName, const OUString& rNewName ) throw(RuntimeException)
3025 {
3026 SolarMutexGuard aGuard;
3027 ScFieldGroups::iterator aOldIt = implFindByName( rOldName );
3028 ScFieldGroups::iterator aNewIt = implFindByName( rNewName );
3029 // new name must not exist yet
3030 if( (aOldIt == maGroups.end()) || ((aNewIt != maGroups.end()) && (aNewIt != aOldIt)) )
3031 throw RuntimeException();
3032 aOldIt->maName = rNewName;
3033 }
3034
3035 ScFieldGroups::iterator ScDataPilotFieldGroupsObj::implFindByName( const OUString& rName )
3036 {
3037 for( ScFieldGroups::iterator aIt = maGroups.begin(), aEnd = maGroups.end(); aIt != aEnd; ++aIt )
3038 if( aIt->maName == rName )
3039 return aIt;
3040 return maGroups.end();
3041 }
3042
3043 // ============================================================================
3044
3045 namespace {
3046
3047 OUString lclExtractMember( const Any& rElement )
3048 {
3049 if( rElement.has< OUString >() )
3050 return rElement.get< OUString >();
3051
3052 Reference< XNamed > xNamed( rElement, UNO_QUERY );
3053 if( xNamed.is() )
3054 return xNamed->getName();
3055
3056 return OUString();
3057 }
3058
3059 } // namespace
3060
3061 // ----------------------------------------------------------------------------
3062
3063 ScDataPilotFieldGroupObj::ScDataPilotFieldGroupObj( ScDataPilotFieldGroupsObj& rParent, const OUString& rGroupName ) :
3064 mrParent( rParent ),
3065 maGroupName( rGroupName )
3066 {
3067 mrParent.acquire();
3068 }
3069
3070 ScDataPilotFieldGroupObj::~ScDataPilotFieldGroupObj()
3071 {
3072 mrParent.release();
3073 }
3074
3075 // XNameAccess
3076
3077 Any SAL_CALL ScDataPilotFieldGroupObj::getByName( const OUString& rName )
3078 throw(NoSuchElementException, WrappedTargetException, RuntimeException)
3079 {
3080 SolarMutexGuard aGuard;
3081 ScFieldGroupMembers& rMembers = mrParent.getFieldGroup( maGroupName ).maMembers;
3082 ScFieldGroupMembers::iterator aIt = ::std::find( rMembers.begin(), rMembers.end(), rName );
3083 if( aIt == rMembers.end() )
3084 throw NoSuchElementException();
3085 return Any( Reference< XNamed >( new ScDataPilotFieldGroupItemObj( *this, *aIt ) ) );
3086 }
3087
3088 Sequence< OUString > SAL_CALL ScDataPilotFieldGroupObj::getElementNames() throw(RuntimeException)
3089 {
3090 SolarMutexGuard aGuard;
3091 return ::comphelper::containerToSequence( mrParent.getFieldGroup( maGroupName ).maMembers );
3092 }
3093
3094 sal_Bool SAL_CALL ScDataPilotFieldGroupObj::hasByName( const OUString& rName ) throw(RuntimeException)
3095 {
3096 SolarMutexGuard aGuard;
3097 ScFieldGroupMembers& rMembers = mrParent.getFieldGroup( maGroupName ).maMembers;
3098 return ::std::find( rMembers.begin(), rMembers.end(), rName ) != rMembers.end();
3099 }
3100
3101 // XNameReplace
3102
3103 void SAL_CALL ScDataPilotFieldGroupObj::replaceByName( const OUString& rName, const Any& rElement )
3104 throw (IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
3105 {
3106 SolarMutexGuard aGuard;
3107
3108 // it should be possible to quickly rename an item -> accept string or XNamed
3109 OUString aNewName = lclExtractMember( rElement );
3110 if( rName.isEmpty() || aNewName.isEmpty() )
3111 throw IllegalArgumentException();
3112 if( rName == aNewName )
3113 return;
3114
3115 ScFieldGroupMembers& rMembers = mrParent.getFieldGroup( maGroupName ).maMembers;
3116 ScFieldGroupMembers::iterator aOldIt = ::std::find( rMembers.begin(), rMembers.end(), rName );
3117 ScFieldGroupMembers::iterator aNewIt = ::std::find( rMembers.begin(), rMembers.end(), aNewName );
3118 // throw if passed member name does not exist
3119 if( aOldIt == rMembers.end() )
3120 throw NoSuchElementException();
3121 // throw if new name already exists
3122 if( aNewIt != rMembers.end() )
3123 throw IllegalArgumentException();
3124 *aOldIt = aNewName;
3125 }
3126
3127 // XNameContainer
3128
3129 void SAL_CALL ScDataPilotFieldGroupObj::insertByName( const OUString& rName, const Any& /*rElement*/ )
3130 throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
3131 {
3132 SolarMutexGuard aGuard;
3133
3134 // we will ignore the passed element and just try to insert the name
3135 if( rName.isEmpty() )
3136 throw IllegalArgumentException();
3137
3138 ScFieldGroupMembers& rMembers = mrParent.getFieldGroup( maGroupName ).maMembers;
3139 ScFieldGroupMembers::iterator aIt = ::std::find( rMembers.begin(), rMembers.end(), rName );
3140 // throw if passed name already exists
3141 if( aIt != rMembers.end() )
3142 throw IllegalArgumentException();
3143 rMembers.push_back( rName );
3144 }
3145
3146 void SAL_CALL ScDataPilotFieldGroupObj::removeByName( const OUString& rName )
3147 throw (NoSuchElementException, WrappedTargetException, RuntimeException)
3148 {
3149 SolarMutexGuard aGuard;
3150
3151 if( rName.isEmpty() )
3152 throw IllegalArgumentException();
3153 ScFieldGroupMembers& rMembers = mrParent.getFieldGroup( maGroupName ).maMembers;
3154 ScFieldGroupMembers::iterator aIt = ::std::find( rMembers.begin(), rMembers.end(), rName );
3155 // throw if passed name does not exist
3156 if( aIt == rMembers.end() )
3157 throw NoSuchElementException();
3158 rMembers.erase( aIt );
3159 }
3160
3161 // XIndexAccess
3162
3163 sal_Int32 SAL_CALL ScDataPilotFieldGroupObj::getCount() throw(RuntimeException)
3164 {
3165 SolarMutexGuard aGuard;
3166 return static_cast< sal_Int32 >( mrParent.getFieldGroup( maGroupName ).maMembers.size() );
3167 }
3168
3169 Any SAL_CALL ScDataPilotFieldGroupObj::getByIndex( sal_Int32 nIndex )
3170 throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
3171 {
3172 SolarMutexGuard aGuard;
3173 ScFieldGroupMembers& rMembers = mrParent.getFieldGroup( maGroupName ).maMembers;
3174 if ((nIndex < 0) || (nIndex >= static_cast< sal_Int32 >( rMembers.size() )))
3175 throw IndexOutOfBoundsException();
3176 return Any( Reference< XNamed >( new ScDataPilotFieldGroupItemObj( *this, rMembers[ nIndex ] ) ) );
3177 }
3178
3179 // XEnumerationAccess
3180
3181 Reference< XEnumeration > SAL_CALL ScDataPilotFieldGroupObj::createEnumeration() throw(RuntimeException)
3182 {
3183 SolarMutexGuard aGuard;
3184 return new ScIndexEnumeration( this, OUString( "com.sun.star.sheet.DataPilotFieldGroupEnumeration" ) );
3185 }
3186
3187 // XElementAccess
3188
3189 uno::Type SAL_CALL ScDataPilotFieldGroupObj::getElementType() throw(RuntimeException)
3190 {
3191 SolarMutexGuard aGuard;
3192 return getCppuType( (Reference< XNamed >*)0 );
3193 }
3194
3195 sal_Bool SAL_CALL ScDataPilotFieldGroupObj::hasElements() throw(RuntimeException)
3196 {
3197 SolarMutexGuard aGuard;
3198 return !mrParent.getFieldGroup( maGroupName ).maMembers.empty();
3199 }
3200
3201 // XNamed
3202
3203 OUString SAL_CALL ScDataPilotFieldGroupObj::getName() throw(RuntimeException)
3204 {
3205 SolarMutexGuard aGuard;
3206 return maGroupName;
3207 }
3208
3209 void SAL_CALL ScDataPilotFieldGroupObj::setName( const OUString& rName ) throw(RuntimeException)
3210 {
3211 SolarMutexGuard aGuard;
3212 mrParent.renameFieldGroup( maGroupName, rName );
3213 // if call to renameFieldGroup() did not throw, remember the new name
3214 maGroupName = rName;
3215 }
3216
3217 // ============================================================================
3218
3219 ScDataPilotFieldGroupItemObj::ScDataPilotFieldGroupItemObj( ScDataPilotFieldGroupObj& rParent, const OUString& rName ) :
3220 mrParent( rParent ),
3221 maName( rName )
3222 {
3223 mrParent.acquire();
3224 }
3225
3226 ScDataPilotFieldGroupItemObj::~ScDataPilotFieldGroupItemObj()
3227 {
3228 mrParent.release();
3229 }
3230
3231 // XNamed
3232
3233 OUString SAL_CALL ScDataPilotFieldGroupItemObj::getName() throw(RuntimeException)
3234 {
3235 SolarMutexGuard aGuard;
3236 return maName;
3237 }
3238
3239 void SAL_CALL ScDataPilotFieldGroupItemObj::setName( const OUString& rName ) throw(RuntimeException)
3240 {
3241 SolarMutexGuard aGuard;
3242 mrParent.replaceByName( maName, Any( rName ) );
3243 // if call to replaceByName() did not throw, remember the new name
3244 maName = rName;
3245 }
3246
3247 // ============================================================================
3248
3249 ScDataPilotItemsObj::ScDataPilotItemsObj( ScDataPilotDescriptorBase& rParent, const ScFieldIdentifier& rFieldId ) :
3250 ScDataPilotChildObjBase( rParent, rFieldId )
3251 {
3252 }
3253
3254 ScDataPilotItemsObj::~ScDataPilotItemsObj()
3255 {
3256 }
3257
3258 // XDataPilotItems
3259
3260 ScDataPilotItemObj* ScDataPilotItemsObj::GetObjectByIndex_Impl( sal_Int32 nIndex ) const
3261 {
3262 return ((0 <= nIndex) && (nIndex < GetMemberCount())) ?
3263 new ScDataPilotItemObj( mrParent, maFieldId, nIndex ) : 0;
3264 }
3265
3266 // XNameAccess
3267
3268 Any SAL_CALL ScDataPilotItemsObj::getByName( const OUString& aName )
3269 throw(NoSuchElementException, WrappedTargetException, RuntimeException)
3270 {
3271 SolarMutexGuard aGuard;
3272 Reference<XNameAccess> xMembers = GetMembers();
3273 if (xMembers.is())
3274 {
3275 Reference<XIndexAccess> xMembersIndex(new ScNameToIndexAccess( xMembers ));
3276 sal_Int32 nCount = xMembersIndex->getCount();
3277 sal_Bool bFound(false);
3278 sal_Int32 nItem = 0;
3279 while (nItem < nCount && !bFound )
3280 {
3281 Reference<XNamed> xMember(xMembersIndex->getByIndex(nItem), UNO_QUERY);
3282 if (xMember.is() && (aName == xMember->getName()))
3283 return Any( Reference< XPropertySet >( GetObjectByIndex_Impl( nItem ) ) );
3284 ++nItem;
3285 }
3286 if (!bFound)
3287 throw NoSuchElementException();
3288 }
3289 return Any();
3290 }
3291
3292 Sequence<OUString> SAL_CALL ScDataPilotItemsObj::getElementNames()
3293 throw(RuntimeException)
3294 {
3295 SolarMutexGuard aGuard;
3296 Sequence< OUString > aSeq;
3297 if( ScDPObject* pDPObj = GetDPObject() )
3298 pDPObj->GetMemberNames( lcl_GetObjectIndex( pDPObj, maFieldId ), aSeq );
3299 return aSeq;
3300 }
3301
3302 sal_Bool SAL_CALL ScDataPilotItemsObj::hasByName( const OUString& aName )
3303 throw(RuntimeException)
3304 {
3305 SolarMutexGuard aGuard;
3306 sal_Bool bFound = false;
3307 Reference<XNameAccess> xMembers = GetMembers();
3308 if (xMembers.is())
3309 {
3310 Reference<XIndexAccess> xMembersIndex(new ScNameToIndexAccess( xMembers ));
3311 sal_Int32 nCount = xMembersIndex->getCount();
3312 sal_Int32 nItem = 0;
3313 while (nItem < nCount && !bFound )
3314 {
3315 Reference<XNamed> xMember(xMembersIndex->getByIndex(nItem), UNO_QUERY);
3316 if (xMember.is() && aName == xMember->getName())
3317 bFound = sal_True;
3318 else
3319 nItem++;
3320 }
3321 }
3322 return bFound;
3323 }
3324
3325 // XEnumerationAccess
3326
3327 Reference<XEnumeration> SAL_CALL ScDataPilotItemsObj::createEnumeration()
3328 throw(RuntimeException)
3329 {
3330 SolarMutexGuard aGuard;
3331 return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.DataPilotItemsEnumeration"));
3332 }
3333
3334 // XIndexAccess
3335
3336 sal_Int32 SAL_CALL ScDataPilotItemsObj::getCount() throw(RuntimeException)
3337 {
3338 SolarMutexGuard aGuard;
3339 return GetMemberCount();
3340 }
3341
3342 Any SAL_CALL ScDataPilotItemsObj::getByIndex( sal_Int32 nIndex )
3343 throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
3344 {
3345 SolarMutexGuard aGuard;
3346 Reference< XPropertySet > xItem( GetObjectByIndex_Impl( nIndex ) );
3347 if (!xItem.is())
3348 throw IndexOutOfBoundsException();
3349 return Any( xItem );
3350 }
3351
3352 uno::Type SAL_CALL ScDataPilotItemsObj::getElementType() throw(RuntimeException)
3353 {
3354 SolarMutexGuard aGuard;
3355 return getCppuType((Reference<XPropertySet>*)0);
3356 }
3357
3358 sal_Bool SAL_CALL ScDataPilotItemsObj::hasElements() throw(RuntimeException)
3359 {
3360 SolarMutexGuard aGuard;
3361 return ( getCount() != 0 );
3362 }
3363
3364 //------------------------------------------------------------------------
3365
3366 ScDataPilotItemObj::ScDataPilotItemObj( ScDataPilotDescriptorBase& rParent, const ScFieldIdentifier& rFieldId, sal_Int32 nIndex ) :
3367 ScDataPilotChildObjBase( rParent, rFieldId ),
3368 maPropSet( lcl_GetDataPilotItemMap() ),
3369 mnIndex( nIndex )
3370 {
3371 }
3372
3373 ScDataPilotItemObj::~ScDataPilotItemObj()
3374 {
3375 }
3376
3377 // XNamed
3378 OUString SAL_CALL ScDataPilotItemObj::getName() throw(RuntimeException)
3379 {
3380 SolarMutexGuard aGuard;
3381 OUString sRet;
3382 Reference<XNameAccess> xMembers = GetMembers();
3383 if (xMembers.is())
3384 {
3385 Reference<XIndexAccess> xMembersIndex(new ScNameToIndexAccess( xMembers ));
3386 sal_Int32 nCount = xMembersIndex->getCount();
3387 if (mnIndex < nCount)
3388 {
3389 Reference<XNamed> xMember(xMembersIndex->getByIndex(mnIndex), UNO_QUERY);
3390 sRet = xMember->getName();
3391 }
3392 }
3393 return sRet;
3394 }
3395
3396 void SAL_CALL ScDataPilotItemObj::setName( const OUString& /* aName */ )
3397 throw(RuntimeException)
3398 {
3399 }
3400
3401 // XPropertySet
3402 Reference< XPropertySetInfo >
3403 SAL_CALL ScDataPilotItemObj::getPropertySetInfo( )
3404 throw(RuntimeException)
3405 {
3406 SolarMutexGuard aGuard;
3407 static Reference<XPropertySetInfo> aRef =
3408 new SfxItemPropertySetInfo( maPropSet.getPropertyMap() );
3409 return aRef;
3410 }
3411
3412 void SAL_CALL ScDataPilotItemObj::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
3413 throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
3414 {
3415 SolarMutexGuard aGuard;
3416 ScDPObject* pDPObj = 0;
3417 if( ScDPSaveDimension* pDim = GetDPDimension( &pDPObj ) )
3418 {
3419 Reference<XNameAccess> xMembers = GetMembers();
3420 if( xMembers.is() )
3421 {
3422 Reference<XIndexAccess> xMembersIndex( new ScNameToIndexAccess( xMembers ) );
3423 sal_Int32 nCount = xMembersIndex->getCount();
3424 if( mnIndex < nCount )
3425 {
3426 Reference<XNamed> xMember(xMembersIndex->getByIndex(mnIndex), UNO_QUERY);
3427 OUString sName(xMember->getName());
3428 ScDPSaveMember* pMember = pDim->GetMemberByName(sName);
3429 if (pMember)
3430 {
3431 bool bGetNewIndex = false;
3432 if ( aPropertyName == SC_UNONAME_SHOWDETAIL )
3433 pMember->SetShowDetails(cppu::any2bool(aValue));
3434 else if ( aPropertyName == SC_UNONAME_ISHIDDEN )
3435 pMember->SetIsVisible(!cppu::any2bool(aValue));
3436 else if ( aPropertyName == SC_UNONAME_POS )
3437 {
3438 sal_Int32 nNewPos = 0;
3439 if ( ( aValue >>= nNewPos ) && nNewPos >= 0 && nNewPos < nCount )
3440 {
3441 pDim->SetMemberPosition( sName, nNewPos );
3442 // get new effective index (depends on sorting mode, which isn't modified)
3443 bGetNewIndex = true;
3444 }
3445 else
3446 throw IllegalArgumentException();
3447 }
3448 SetDPObject( pDPObj );
3449
3450 if ( bGetNewIndex ) // after SetDPObject, get the new index
3451 {
3452 OUString aOUName( sName );
3453 Sequence< OUString > aItemNames = xMembers->getElementNames();
3454 sal_Int32 nItemCount = aItemNames.getLength();
3455 for (sal_Int32 nItem=0; nItem<nItemCount; ++nItem)
3456 if (aItemNames[nItem] == aOUName)
3457 mnIndex = nItem;
3458 }
3459 }
3460 }
3461 }
3462 }
3463 }
3464
3465 Any SAL_CALL ScDataPilotItemObj::getPropertyValue( const OUString& aPropertyName )
3466 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
3467 {
3468 SolarMutexGuard aGuard;
3469 Any aRet;
3470 if( ScDPSaveDimension* pDim = GetDPDimension() )
3471 {
3472 Reference< XNameAccess > xMembers = GetMembers();
3473 if( xMembers.is() )
3474 {
3475 Reference< XIndexAccess > xMembersIndex( new ScNameToIndexAccess( xMembers ) );
3476 sal_Int32 nCount = xMembersIndex->getCount();
3477 if( mnIndex < nCount )
3478 {
3479 Reference< XNamed > xMember( xMembersIndex->getByIndex( mnIndex ), UNO_QUERY );
3480 OUString sName( xMember->getName() );
3481 ScDPSaveMember* pMember = pDim->GetExistingMemberByName( sName );
3482 if ( aPropertyName == SC_UNONAME_SHOWDETAIL )
3483 {
3484 if (pMember && pMember->HasShowDetails())
3485 {
3486 aRet <<= (bool)pMember->GetShowDetails();
3487 }
3488 else
3489 {
3490 Reference< XPropertySet > xMemberProps( xMember, UNO_QUERY );
3491 if( xMemberProps.is() )
3492 aRet = xMemberProps->getPropertyValue( OUString( SC_UNO_DP_SHOWDETAILS ) );
3493 else
3494 aRet <<= true;
3495 }
3496 }
3497 else if ( aPropertyName == SC_UNONAME_ISHIDDEN )
3498 {
3499 if (pMember && pMember->HasIsVisible())
3500 {
3501 aRet <<= !pMember->GetIsVisible();
3502 }
3503 else
3504 {
3505 Reference< XPropertySet > xMemberProps( xMember, UNO_QUERY );
3506 if( xMemberProps.is() )
3507 aRet <<= !cppu::any2bool( xMemberProps->getPropertyValue( OUString( SC_UNO_DP_ISVISIBLE ) ) );
3508 else
3509 aRet <<= false;
3510 }
3511 }
3512 else if ( aPropertyName == SC_UNONAME_POS )
3513 {
3514 aRet <<= mnIndex;
3515 }
3516 }
3517 }
3518 }
3519 return aRet;
3520 }
3521
3522 void SAL_CALL ScDataPilotItemObj::addPropertyChangeListener(
3523 const OUString& /* aPropertyName */, const Reference< XPropertyChangeListener >& /* xListener */ )
3524 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
3525 {
3526 }
3527
3528 void SAL_CALL ScDataPilotItemObj::removePropertyChangeListener(
3529 const OUString& /* aPropertyName */, const Reference< XPropertyChangeListener >& /* aListener */ )
3530 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
3531 {
3532 }
3533
3534 void SAL_CALL ScDataPilotItemObj::addVetoableChangeListener(
3535 const OUString& /* PropertyName */, const Reference< XVetoableChangeListener >& /* aListener */ )
3536 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
3537 {
3538 }
3539
3540 void SAL_CALL ScDataPilotItemObj::removeVetoableChangeListener(
3541 const OUString& /* PropertyName */, const Reference< XVetoableChangeListener >& /* aListener */ )
3542 throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
3543 {
3544 }
3545
3546 //------------------------------------------------------------------------
3547
3548
3549
3550
3551 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE