?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update ooo310-m15
[ooovba.git] / sc / source / core / data / dptabsrc.cxx
bloba00c2068c34f491b48e252010ca5143564ce7e59
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: dptabsrc.cxx,v $
10 * $Revision: 1.27 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34
35
36
37 // INCLUDE ---------------------------------------------------------------
38
39 #include <algorithm>
40 #include <vector>
41 #include <set>
42 #include <hash_map>
43 #include <hash_set>
44
45 #include <tools/debug.hxx>
46 #include <rtl/math.hxx>
47 #include <svtools/itemprop.hxx>
48 #include <svtools/intitem.hxx>
49
50 #include "scitems.hxx"
51 #include "document.hxx"
52 #include "docpool.hxx"
53 #include "patattr.hxx"
54 #include "cell.hxx"
55
56 #include "dptabsrc.hxx"
57 #include "dptabres.hxx"
58 #include "dptabdat.hxx"
59 #include "global.hxx"
60 #include "collect.hxx"
61 #include "datauno.hxx" // ScDataUnoConversion
62 #include "unoguard.hxx"
63 #include "miscuno.hxx"
64 #include "unonames.hxx"
65
66 #include <com/sun/star/beans/PropertyAttribute.hpp>
67 #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
68 #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
69 #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
70 #include <com/sun/star/sheet/DataPilotFieldReferenceType.hpp>
71 #include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
72 #include <com/sun/star/sheet/DataPilotFieldAutoShowInfo.hpp>
73 #include <com/sun/star/table/CellAddress.hpp>
74
75 #include <unotools/collatorwrapper.hxx>
76 #include <unotools/calendarwrapper.hxx>
77 #include <com/sun/star/i18n/CalendarDisplayIndex.hpp>
78
79 using namespace com::sun::star;
80 using ::std::vector;
81 using ::std::set;
82 using ::std::hash_map;
83 using ::std::hash_set;
84 using ::com::sun::star::uno::Reference;
85 using ::com::sun::star::uno::Sequence;
86 using ::com::sun::star::uno::Any;
87 using ::com::sun::star::sheet::DataPilotFieldAutoShowInfo;
88 using ::rtl::OUString;
89
90 // -----------------------------------------------------------------------
91
92 #define SC_MINCOUNT_LIMIT 1000000
93
94 // -----------------------------------------------------------------------
95
96 SC_SIMPLE_SERVICE_INFO( ScDPSource, "ScDPSource", "com.sun.star.sheet.DataPilotSource" )
97 SC_SIMPLE_SERVICE_INFO( ScDPDimensions, "ScDPDimensions", "com.sun.star.sheet.DataPilotSourceDimensions" )
98 SC_SIMPLE_SERVICE_INFO( ScDPDimension, "ScDPDimension", "com.sun.star.sheet.DataPilotSourceDimension" )
99 SC_SIMPLE_SERVICE_INFO( ScDPHierarchies, "ScDPHierarchies", "com.sun.star.sheet.DataPilotSourceHierarcies" )
100 SC_SIMPLE_SERVICE_INFO( ScDPHierarchy, "ScDPHierarchy", "com.sun.star.sheet.DataPilotSourceHierarcy" )
101 SC_SIMPLE_SERVICE_INFO( ScDPLevels, "ScDPLevels", "com.sun.star.sheet.DataPilotSourceLevels" )
102 SC_SIMPLE_SERVICE_INFO( ScDPLevel, "ScDPLevel", "com.sun.star.sheet.DataPilotSourceLevel" )
103 SC_SIMPLE_SERVICE_INFO( ScDPMembers, "ScDPMembers", "com.sun.star.sheet.DataPilotSourceMembers" )
104 SC_SIMPLE_SERVICE_INFO( ScDPMember, "ScDPMember", "com.sun.star.sheet.DataPilotSourceMember" )
105
106 // -----------------------------------------------------------------------
107
108 // property maps for PropertySetInfo
109 // DataDescription / NumberFormat are internal
110
111 // -----------------------------------------------------------------------
112
113 //! move to a header?
114 BOOL lcl_GetBoolFromAny( const uno::Any& aAny )
115 {
116 if ( aAny.getValueTypeClass() == uno::TypeClass_BOOLEAN )
117 return *(sal_Bool*)aAny.getValue();
118 return FALSE;
119 }
120
121 void lcl_SetBoolInAny( uno::Any& rAny, BOOL bValue )
122 {
123 rAny.setValue( &bValue, getBooleanCppuType() );
124 }
125
126 // -----------------------------------------------------------------------
127
128 ScDPSource::ScDPSource( ScDPTableData* pD ) :
129 pData( pD ),
130 pDimensions( NULL ),
131 nColDimCount( 0 ),
132 nRowDimCount( 0 ),
133 nDataDimCount( 0 ),
134 nPageDimCount( 0 ),
135 bColumnGrand( TRUE ), // default is true
136 bRowGrand( TRUE ),
137 bIgnoreEmptyRows( FALSE ),
138 bRepeatIfEmpty( FALSE ),
139 nDupCount( 0 ),
140 pResData( NULL ),
141 pColResRoot( NULL ),
142 pRowResRoot( NULL ),
143 pColResults( NULL ),
144 pRowResults( NULL ),
145 bResultOverflow( FALSE ),
146 mpGrandTotalName(NULL)
147 {
148 pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty );
149 }
150
151 ScDPSource::~ScDPSource()
152 {
153 if (pDimensions)
154 pDimensions->release(); // ref-counted
155
156 //! free lists
157
158 delete[] pColResults;
159 delete[] pRowResults;
160
161 delete pColResRoot;
162 delete pRowResRoot;
163 delete pResData;
164 }
165
166 void ScDPSource::SetGrandTotalName(const ::rtl::OUString& rName)
167 {
168 mpGrandTotalName.reset(new ::rtl::OUString(rName));
169 }
170
171 const ::rtl::OUString* ScDPSource::GetGrandTotalName() const
172 {
173 return mpGrandTotalName.get();
174 }
175
176 USHORT ScDPSource::GetOrientation(long nColumn)
177 {
178 long i;
179 for (i=0; i<nColDimCount; i++)
180 if (nColDims[i] == nColumn)
181 return sheet::DataPilotFieldOrientation_COLUMN;
182 for (i=0; i<nRowDimCount; i++)
183 if (nRowDims[i] == nColumn)
184 return sheet::DataPilotFieldOrientation_ROW;
185 for (i=0; i<nDataDimCount; i++)
186 if (nDataDims[i] == nColumn)
187 return sheet::DataPilotFieldOrientation_DATA;
188 for (i=0; i<nPageDimCount; i++)
189 if (nPageDims[i] == nColumn)
190 return sheet::DataPilotFieldOrientation_PAGE;
191 return sheet::DataPilotFieldOrientation_HIDDEN;
192 }
193
194 long ScDPSource::GetDataDimensionCount()
195 {
196 return nDataDimCount;
197 }
198
199 ScDPDimension* ScDPSource::GetDataDimension(long nIndex)
200 {
201 if (nIndex < 0 || nIndex >= nDataDimCount)
202 return NULL;
203
204 long nDimIndex = nDataDims[nIndex];
205 return GetDimensionsObject()->getByIndex(nDimIndex);
206 }
207
208 String ScDPSource::GetDataDimName( long nIndex )
209 {
210 String aRet;
211 ScDPDimension* pDim = GetDataDimension(nIndex);
212 if (pDim)
213 aRet = String(pDim->getName());
214 return aRet;
215 }
216
217 long ScDPSource::GetPosition(long nColumn)
218 {
219 long i;
220 for (i=0; i<nColDimCount; i++)
221 if (nColDims[i] == nColumn)
222 return i;
223 for (i=0; i<nRowDimCount; i++)
224 if (nRowDims[i] == nColumn)
225 return i;
226 for (i=0; i<nDataDimCount; i++)
227 if (nDataDims[i] == nColumn)
228 return i;
229 for (i=0; i<nPageDimCount; i++)
230 if (nPageDims[i] == nColumn)
231 return i;
232 return 0;
233 }
234
235 BOOL lcl_TestSubTotal( BOOL& rAllowed, long nColumn, long* pArray, long nCount, ScDPSource* pSource )
236 {
237 for (long i=0; i<nCount; i++)
238 if (pArray[i] == nColumn)
239 {
240 // no subtotals for data layout dim, no matter where
241 if ( pSource->IsDataLayoutDimension(nColumn) )
242 rAllowed = FALSE;
243 else
244 {
245 // no subtotals if no other dim but data layout follows
246 long nNextIndex = i+1;
247 if ( nNextIndex < nCount && pSource->IsDataLayoutDimension(pArray[nNextIndex]) )
248 ++nNextIndex;
249 if ( nNextIndex >= nCount )
250 rAllowed = FALSE;
251 }
252
253 return TRUE; // found
254 }
255 return FALSE;
256 }
257
258 BOOL ScDPSource::SubTotalAllowed(long nColumn)
259 {
260 //! cache this at ScDPResultData
261 BOOL bAllowed = TRUE;
262 if ( lcl_TestSubTotal( bAllowed, nColumn, nColDims, nColDimCount, this ) )
263 return bAllowed;
264 if ( lcl_TestSubTotal( bAllowed, nColumn, nRowDims, nRowDimCount, this ) )
265 return bAllowed;
266 return bAllowed;
267 }
268
269 void lcl_RemoveDim( long nRemove, long* pDims, long& rCount )
270 {
271 for (long i=0; i<rCount; i++)
272 if ( pDims[i] == nRemove )
273 {
274 for (long j=i; j+1<rCount; j++)
275 pDims[j] = pDims[j+1];
276 --rCount;
277 return;
278 }
279 }
280
281 void ScDPSource::SetOrientation(long nColumn, USHORT nNew)
282 {
283 //! change to no-op if new orientation is equal to old?
284
285 // remove from old list
286 lcl_RemoveDim( nColumn, nColDims, nColDimCount );
287 lcl_RemoveDim( nColumn, nRowDims, nRowDimCount );
288 lcl_RemoveDim( nColumn, nDataDims, nDataDimCount );
289 lcl_RemoveDim( nColumn, nPageDims, nPageDimCount );
290
291 // add to new list
292 switch (nNew)
293 {
294 case sheet::DataPilotFieldOrientation_COLUMN:
295 nColDims[nColDimCount++] = nColumn;
296 break;
297 case sheet::DataPilotFieldOrientation_ROW:
298 nRowDims[nRowDimCount++] = nColumn;
299 break;
300 case sheet::DataPilotFieldOrientation_DATA:
301 nDataDims[nDataDimCount++] = nColumn;
302 break;
303 case sheet::DataPilotFieldOrientation_PAGE:
304 nPageDims[nPageDimCount++] = nColumn;
305 break;
306 default:
307 DBG_ERROR( "ScDPSource::SetOrientation: unexpected orientation" );
308 break;
309 }
310 }
311
312 BOOL ScDPSource::IsDataLayoutDimension(long nDim)
313 {
314 return nDim == pData->GetColumnCount();
315 }
316
317 USHORT ScDPSource::GetDataLayoutOrientation()
318 {
319 return GetOrientation(pData->GetColumnCount());
320 }
321
322 BOOL ScDPSource::IsDateDimension(long nDim)
323 {
324 return pData->IsDateDimension(nDim);
325 }
326
327 ScDPDimensions* ScDPSource::GetDimensionsObject()
328 {
329 if (!pDimensions)
330 {
331 pDimensions = new ScDPDimensions(this);
332 pDimensions->acquire(); // ref-counted
333 }
334 return pDimensions;
335 }
336
337 uno::Reference<container::XNameAccess> SAL_CALL ScDPSource::getDimensions() throw(uno::RuntimeException)
338 {
339 return GetDimensionsObject();
340 }
341
342 void ScDPSource::SetDupCount( long nNew )
343 {
344 nDupCount = nNew;
345 }
346
347 ScDPDimension* ScDPSource::AddDuplicated(long /* nSource */, const String& rNewName)
348 {
349 DBG_ASSERT( pDimensions, "AddDuplicated without dimensions?" );
350
351 // re-use
352
353 long nOldDimCount = pDimensions->getCount();
354 for (long i=0; i<nOldDimCount; i++)
355 {
356 ScDPDimension* pDim = pDimensions->getByIndex(i);
357 if (pDim && String(pDim->getName()) == rNewName)
358 {
359 //! test if pDim is a duplicate of source
360 return pDim;
361 }
362 }
363
364 SetDupCount( nDupCount + 1 );
365 pDimensions->CountChanged(); // uses nDupCount
366
367 return pDimensions->getByIndex( pDimensions->getCount() - 1 );
368 }
369
370 long ScDPSource::GetSourceDim(long nDim)
371 {
372 // original source dimension or data layout dimension?
373 if ( nDim <= pData->GetColumnCount() )
374 return nDim;
375
376 if ( nDim < pDimensions->getCount() )
377 {
378 ScDPDimension* pDimObj = pDimensions->getByIndex( nDim );
379 if ( pDimObj )
380 {
381 long nSource = pDimObj->GetSourceDim();
382 if ( nSource >= 0 )
383 return nSource;
384 }
385 }
386
387 DBG_ERROR("GetSourceDim: wrong dim");
388 return nDim;
389 }
390
391 uno::Sequence< uno::Sequence<sheet::DataResult> > SAL_CALL ScDPSource::getResults()
392 throw(uno::RuntimeException)
393 {
394 CreateRes_Impl(); // create pColResRoot and pRowResRoot
395
396 if ( bResultOverflow ) // set in CreateRes_Impl
397 {
398 // no results available
399 throw uno::RuntimeException();
400 }
401
402 long nColCount = pColResRoot->GetSize(pResData->GetColStartMeasure());
403 long nRowCount = pRowResRoot->GetSize(pResData->GetRowStartMeasure());
404
405 // allocate full sequence
406 //! leave out empty rows???
407
408 uno::Sequence< uno::Sequence<sheet::DataResult> > aSeq( nRowCount );
409 uno::Sequence<sheet::DataResult>* pRowAry = aSeq.getArray();
410 for (long nRow = 0; nRow < nRowCount; nRow++)
411 {
412 uno::Sequence<sheet::DataResult> aColSeq( nColCount );
413 // use default values of DataResult
414 pRowAry[nRow] = aColSeq;
415 }
416
417 long nSeqRow = 0;
418 pRowResRoot->FillDataResults( pColResRoot, aSeq, nSeqRow, pResData->GetRowStartMeasure() );
419
420 return aSeq;
421 }
422
423 void SAL_CALL ScDPSource::refresh() throw(uno::RuntimeException)
424 {
425 disposeData();
426 }
427
428 void SAL_CALL ScDPSource::addRefreshListener( const uno::Reference<util::XRefreshListener >& )
429 throw(uno::RuntimeException)
430 {
431 DBG_ERROR("not implemented"); //! exception?
432 }
433
434 void SAL_CALL ScDPSource::removeRefreshListener( const uno::Reference<util::XRefreshListener >& )
435 throw(uno::RuntimeException)
436 {
437 DBG_ERROR("not implemented"); //! exception?
438 }
439
440 Sequence< Sequence<Any> > SAL_CALL ScDPSource::getDrillDownData(const Sequence<sheet::DataPilotFieldFilter>& aFilters)
441 throw (uno::RuntimeException)
442 {
443 long nColumnCount = GetData()->GetColumnCount();
444 ScSimpleSharedString& rSharedString = GetData()->GetSharedString();
445
446 typedef hash_map<String, long, ScStringHashCode> FieldNameMapType;
447 FieldNameMapType aFieldNames;
448 for (long i = 0; i < nColumnCount; ++i)
449 {
450 aFieldNames.insert(
451 FieldNameMapType::value_type(GetData()->getDimensionName(i), i));
452 }
453
454 // collect ScDPItemData for each filtered column
455 vector<ScDPCacheTable::Criterion> aFilterCriteria;
456 sal_Int32 nFilterCount = aFilters.getLength();
457 for (sal_Int32 i = 0; i < nFilterCount; ++i)
458 {
459 const sheet::DataPilotFieldFilter& rFilter = aFilters[i];
460 String aFieldName( rFilter.FieldName );
461 for (long nCol = 0; nCol < nColumnCount; ++nCol)
462 {
463 if ( aFieldName == pData->getDimensionName(nCol) )
464 {
465 ScDPDimension* pDim = GetDimensionsObject()->getByIndex( nCol );
466 ScDPMembers* pMembers = pDim->GetHierarchiesObject()->getByIndex(0)->
467 GetLevelsObject()->getByIndex(0)->GetMembersObject();
468 sal_Int32 nIndex = pMembers->GetIndexFromName( rFilter.MatchValue );
469 if ( nIndex >= 0 )
470 {
471 ScDPItemData aItem;
472 pMembers->getByIndex(nIndex)->FillItemData( aItem );
473 aFilterCriteria.push_back( ScDPCacheTable::Criterion() );
474 sal_Int32 nMatchStrId = rSharedString.getStringId(aItem.aString);
475 aFilterCriteria.back().mnFieldIndex = nCol;
476 aFilterCriteria.back().mpFilter.reset(
477 new ScDPCacheTable::SingleFilter(rSharedString, nMatchStrId, aItem.fValue, aItem.bHasValue) );
478 }
479 }
480 }
481 }
482
483 // Take into account the visibilities of field members.
484 ScDPResultVisibilityData aResVisData(rSharedString, this);
485 pRowResRoot->FillVisibilityData(aResVisData);
486 pColResRoot->FillVisibilityData(aResVisData);
487 aResVisData.fillFieldFilters(aFilterCriteria);
488
489 Sequence< Sequence<Any> > aTabData;
490 hash_set<sal_Int32> aCatDims;
491 GetCategoryDimensionIndices(aCatDims);
492 pData->GetDrillDownData(aFilterCriteria, aCatDims, aTabData);
493 return aTabData;
494 }
495
496 String ScDPSource::getDataDescription()
497 {
498 CreateRes_Impl(); // create pResData
499
500 String aRet;
501 if ( pResData->GetMeasureCount() == 1 )
502 {
503 bool bTotalResult = false;
504 aRet = pResData->GetMeasureString( 0, TRUE, SUBTOTAL_FUNC_NONE, bTotalResult );
505 }
506
507 // empty for more than one measure
508
509 return aRet;
510 }
511
512 BOOL ScDPSource::getColumnGrand() const
513 {
514 return bColumnGrand;
515 }
516
517 void ScDPSource::setColumnGrand(BOOL bSet)
518 {
519 bColumnGrand = bSet;
520 }
521
522 BOOL ScDPSource::getRowGrand() const
523 {
524 return bRowGrand;
525 }
526
527 void ScDPSource::setRowGrand(BOOL bSet)
528 {
529 bRowGrand = bSet;
530 }
531
532 BOOL ScDPSource::getIgnoreEmptyRows() const
533 {
534 return bIgnoreEmptyRows;
535 }
536
537 void ScDPSource::setIgnoreEmptyRows(BOOL bSet)
538 {
539 bIgnoreEmptyRows = bSet;
540 pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty );
541 }
542
543 BOOL ScDPSource::getRepeatIfEmpty() const
544 {
545 return bRepeatIfEmpty;
546 }
547
548 void ScDPSource::setRepeatIfEmpty(BOOL bSet)
549 {
550 bRepeatIfEmpty = bSet;
551 pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty );
552 }
553
554 void ScDPSource::validate() //! ???
555 {
556 CreateRes_Impl();
557 }
558
559 void ScDPSource::disposeData()
560 {
561 if ( pResData )
562 {
563 // reset all data...
564
565 DELETEZ(pColResRoot);
566 DELETEZ(pRowResRoot);
567 DELETEZ(pResData);
568 delete[] pColResults;
569 delete[] pRowResults;
570 pColResults = NULL;
571 pRowResults = NULL;
572 aColLevelList.Clear();
573 aRowLevelList.Clear();
574 }
575
576 if ( pDimensions )
577 {
578 pDimensions->release(); // ref-counted
579 pDimensions = NULL; // settings have to be applied (from SaveData) again!
580 }
581 SetDupCount( 0 );
582
583 //! Test ????
584 nColDimCount = nRowDimCount = nDataDimCount = nPageDimCount = 0;
585
586 pData->DisposeData(); // cached entries etc.
587 bResultOverflow = FALSE;
588 }
589
590 long lcl_CountMinMembers(const vector<ScDPDimension*>& ppDim, const vector<ScDPLevel*>& ppLevel, long nLevels )
591 {
592 // Calculate the product of the member count for those consecutive levels that
593 // have the "show all" flag, one following level, and the data layout dimension.
594
595 long nTotal = 1;
596 long nDataCount = 1;
597 BOOL bWasShowAll = TRUE;
598 long nPos = nLevels;
599 while ( nPos > 0 )
600 {
601 --nPos;
602
603 if ( nPos+1 < nLevels && ppDim[nPos] == ppDim[nPos+1] )
604 {
605 DBG_ERROR("lcl_CountMinMembers: multiple levels from one dimension not implemented");
606 return 0;
607 }
608
609 BOOL bDo = FALSE;
610 if ( ppDim[nPos]->getIsDataLayoutDimension() )
611 {
612 // data layout dim doesn't interfere with "show all" flags
613 nDataCount = ppLevel[nPos]->GetMembersObject()->getCount();
614 if ( nDataCount == 0 )
615 nDataCount = 1;
616 }
617 else if ( bWasShowAll ) // "show all" set for all following levels?
618 {
619 bDo = TRUE;
620 if ( !ppLevel[nPos]->getShowEmpty() )
621 {
622 // this level is counted, following ones are not
623 bWasShowAll = FALSE;
624 }
625 }
626 if ( bDo )
627 {
628 long nThisCount = ppLevel[nPos]->GetMembersObject()->getMinMembers();
629 if ( nThisCount == 0 )
630 {
631 nTotal = 1; // empty level -> start counting from here
632 //! start with visible elements in this level?
633 }
634 else
635 {
636 if ( nTotal >= LONG_MAX / nThisCount )
637 return LONG_MAX; // overflow
638 nTotal *= nThisCount;
639 }
640 }
641 }
642
643 // always include data layout dim, even after restarting
644 if ( nTotal >= LONG_MAX / nDataCount )
645 return LONG_MAX; // overflow
646 nTotal *= nDataCount;
647
648 return nTotal;
649 }
650
651 long lcl_GetIndexFromName( const rtl::OUString rName, const uno::Sequence<rtl::OUString>& rElements )
652 {
653 long nCount = rElements.getLength();
654 const rtl::OUString* pArray = rElements.getConstArray();
655 for (long nPos=0; nPos<nCount; nPos++)
656 if (pArray[nPos] == rName)
657 return nPos;
658
659 return -1; // not found
660 }
661
662 void ScDPSource::FillCalcInfo(bool bIsRow, ScDPTableData::CalcInfo& rInfo, bool &rHasAutoShow)
663 {
664 long* nDims = bIsRow ? nRowDims : nColDims;
665 long nDimCount = bIsRow ? nRowDimCount : nColDimCount;
666
667 for (long i = 0; i < nDimCount; ++i)
668 {
669 ScDPDimension* pDim = GetDimensionsObject()->getByIndex( nDims[i] );
670 long nHierarchy = pDim->getUsedHierarchy();
671 if ( nHierarchy >= pDim->GetHierarchiesObject()->getCount() )
672 nHierarchy = 0;
673 ScDPLevels* pLevels = pDim->GetHierarchiesObject()->getByIndex(nHierarchy)->GetLevelsObject();
674 long nCount = pLevels->getCount();
675
676 //! Test
677 if ( pDim->getIsDataLayoutDimension() && nDataDimCount < 2 )
678 nCount = 0;
679 //! Test
680
681 for (long j = 0; j < nCount; ++j)
682 {
683 ScDPLevel* pLevel = pLevels->getByIndex(j);
684 pLevel->EvaluateSortOrder();
685
686 // no layout flags for column fields, only for row fields
687 pLevel->SetEnableLayout( bIsRow );
688
689 if ( pLevel->GetAutoShow().IsEnabled )
690 rHasAutoShow = TRUE;
691
692 if (bIsRow)
693 {
694 rInfo.aRowLevelDims.push_back(nDims[i]);
695 rInfo.aRowDims.push_back(pDim);
696 rInfo.aRowLevels.push_back(pLevel);
697 }
698 else
699 {
700 rInfo.aColLevelDims.push_back(nDims[i]);
701 rInfo.aColDims.push_back(pDim);
702 rInfo.aColLevels.push_back(pLevel);
703 }
704
705 pLevel->GetMembersObject(); // initialize for groups
706 }
707 }
708 }
709
710 void ScDPSource::GetCategoryDimensionIndices(hash_set<sal_Int32>& rCatDims)
711 {
712 hash_set<sal_Int32> aCatDims;
713 for (long i = 0; i < nColDimCount; ++i)
714 {
715 sal_Int32 nDim = static_cast<sal_Int32>(nColDims[i]);
716 if (!IsDataLayoutDimension(nDim))
717 aCatDims.insert(nDim);
718 }
719
720 for (long i = 0; i < nRowDimCount; ++i)
721 {
722 sal_Int32 nDim = static_cast<sal_Int32>(nRowDims[i]);
723 if (!IsDataLayoutDimension(nDim))
724 aCatDims.insert(nDim);
725 }
726
727 for (long i = 0; i < nPageDimCount; ++i)
728 {
729 sal_Int32 nDim = static_cast<sal_Int32>(nPageDims[i]);
730 if (!IsDataLayoutDimension(nDim))
731 aCatDims.insert(nDim);
732 }
733
734 rCatDims.swap(aCatDims);
735 }
736
737 void ScDPSource::FilterCacheTableByPageDimensions()
738 {
739 ScSimpleSharedString& rSharedString = GetData()->GetSharedString();
740
741 // filter table by page dimensions.
742 vector<ScDPCacheTable::Criterion> aCriteria;
743 for (long i = 0; i < nPageDimCount; ++i)
744 {
745 ScDPDimension* pDim = GetDimensionsObject()->getByIndex(nPageDims[i]);
746 long nField = pDim->GetDimension();
747
748 ScDPMembers* pMems = pDim->GetHierarchiesObject()->getByIndex(0)->
749 GetLevelsObject()->getByIndex(0)->GetMembersObject();
750
751 long nMemCount = pMems->getCount();
752 ScDPCacheTable::Criterion aFilter;
753 aFilter.mnFieldIndex = static_cast<sal_Int32>(nField);
754 aFilter.mpFilter.reset(new ScDPCacheTable::GroupFilter(rSharedString));
755 ScDPCacheTable::GroupFilter* pGrpFilter =
756 static_cast<ScDPCacheTable::GroupFilter*>(aFilter.mpFilter.get());
757 for (long j = 0; j < nMemCount; ++j)
758 {
759 ScDPMember* pMem = pMems->getByIndex(j);
760 if (pMem->getIsVisible())
761 {
762 ScDPItemData aData;
763 pMem->FillItemData(aData);
764 pGrpFilter->addMatchItem(aData.aString, aData.fValue, aData.bHasValue);
765 }
766 }
767 if (pGrpFilter->getMatchItemCount() < static_cast<size_t>(nMemCount))
768 // there is at least one invisible item. Add this filter criterion to the mix.
769 aCriteria.push_back(aFilter);
770
771 if (!pDim || !pDim->HasSelectedPage())
772 continue;
773
774 const ScDPItemData& rData = pDim->GetSelectedData();
775 aCriteria.push_back(ScDPCacheTable::Criterion());
776 ScDPCacheTable::Criterion& r = aCriteria.back();
777 r.mnFieldIndex = static_cast<sal_Int32>(nField);
778 sal_Int32 nStrId = rSharedString.getStringId(rData.aString);
779 r.mpFilter.reset(
780 new ScDPCacheTable::SingleFilter(rSharedString, nStrId, rData.fValue, rData.bHasValue));
781 }
782 if (!aCriteria.empty())
783 {
784 hash_set<sal_Int32> aCatDims;
785 GetCategoryDimensionIndices(aCatDims);
786 pData->FilterCacheTable(aCriteria, aCatDims);
787 }
788 }
789
790 void ScDPSource::CreateRes_Impl()
791 {
792 if ( !pResData )
793 {
794 USHORT nDataOrient = GetDataLayoutOrientation();
795 if ( nDataDimCount > 1 && ( nDataOrient != sheet::DataPilotFieldOrientation_COLUMN &&
796 nDataOrient != sheet::DataPilotFieldOrientation_ROW ) )
797 {
798 // if more than one data dimension, data layout orientation must be set
799 SetOrientation( pData->GetColumnCount(), sheet::DataPilotFieldOrientation_ROW );
800 nDataOrient = sheet::DataPilotFieldOrientation_ROW;
801 }
802
803 // TODO: Aggreate pDataNames, pDataRefValues, nDataRefOrient, and
804 // eDataFunctions into a structure and use vector instead of static
805 // or pointer arrays.
806 String* pDataNames = NULL;
807 sheet::DataPilotFieldReference* pDataRefValues = NULL;
808 ScSubTotalFunc eDataFunctions[SC_DAPI_MAXFIELDS];
809 USHORT nDataRefOrient[SC_DAPI_MAXFIELDS];
810 if (nDataDimCount)
811 {
812 pDataNames = new String[nDataDimCount];
813 pDataRefValues = new sheet::DataPilotFieldReference[nDataDimCount];
814 }
815
816 ScDPTableData::CalcInfo aInfo;
817
818
819 // LateInit (initialize only those rows/children that are used) can be used unless
820 // any data dimension needs reference values from column/row dimensions
821 BOOL bLateInit = TRUE;
822
823 // Go through all data dimensions (i.e. fields) and build their meta data
824 // so that they can be passed on to ScDPResultData instance later.
825 // TODO: aggregate all of data dimension info into a structure.
826 long i;
827 for (i=0; i<nDataDimCount; i++)
828 {
829 // Get function for each data field.
830 long nDimIndex = nDataDims[i];
831 ScDPDimension* pDim = GetDimensionsObject()->getByIndex(nDimIndex);
832 sheet::GeneralFunction eUser = (sheet::GeneralFunction)pDim->getFunction();
833 if (eUser == sheet::GeneralFunction_AUTO)
834 {
835 //! test for numeric data
836 eUser = sheet::GeneralFunction_SUM;
837 }
838
839 // Map UNO's enum to internal enum ScSubTotalFunc.
840 eDataFunctions[i] = ScDataUnoConversion::GeneralToSubTotal( eUser );
841
842 // Get reference field/item information.
843 pDataRefValues[i] = pDim->GetReferenceValue();
844 nDataRefOrient[i] = sheet::DataPilotFieldOrientation_HIDDEN; // default if not used
845 sal_Int32 eRefType = pDataRefValues[i].ReferenceType;
846 if ( eRefType == sheet::DataPilotFieldReferenceType::ITEM_DIFFERENCE ||
847 eRefType == sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE ||
848 eRefType == sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE ||
849 eRefType == sheet::DataPilotFieldReferenceType::RUNNING_TOTAL )
850 {
851 long nColumn = lcl_GetIndexFromName( pDataRefValues[i].ReferenceField,
852 GetDimensionsObject()->getElementNames() );
853 if ( nColumn >= 0 )
854 {
855 nDataRefOrient[i] = GetOrientation( nColumn );
856 // need fully initialized results to find reference values
857 // (both in column or row dimensions), so updated values or
858 // differences to 0 can be displayed even for empty results.
859 bLateInit = FALSE;
860 }
861 }
862
863 pDataNames[i] = String( pDim->getName() ); //! label?
864
865 // asterisk is added to duplicated dimension names by ScDPSaveData::WriteToSource
866 //! modify user visible strings as in ScDPResultData::GetMeasureString instead!
867
868 pDataNames[i].EraseTrailingChars('*');
869
870 //! if the name is overridden by user, a flag must be set
871 //! so the user defined name replaces the function string and field name.
872
873 //! the complete name (function and field) must be stored at the dimension
874
875 long nSource = ((ScDPDimension*)pDim)->GetSourceDim();
876 if (nSource >= 0)
877 aInfo.aDataSrcCols.push_back(nSource);
878 else
879 aInfo.aDataSrcCols.push_back(nDimIndex);
880 }
881
882 pResData = new ScDPResultData( this );
883 pResData->SetMeasureData( nDataDimCount, eDataFunctions, pDataRefValues, nDataRefOrient, pDataNames );
884 pResData->SetDataLayoutOrientation(nDataOrient);
885 pResData->SetLateInit( bLateInit );
886
887 delete[] pDataNames;
888 delete[] pDataRefValues;
889
890 bool bHasAutoShow = false;
891
892 ScDPInitState aInitState;
893
894 // Page field selections restrict the members shown in related fields
895 // (both in column and row fields). aInitState is filled with the page
896 // field selections, they are kept across the data iterator loop.
897
898 for (i=0; i<nPageDimCount; i++)
899 {
900 ScDPDimension* pDim = GetDimensionsObject()->getByIndex( nPageDims[i] );
901 if ( pDim->HasSelectedPage() )
902 aInitState.AddMember( nPageDims[i], pDim->GetSelectedData() );
903 }
904
905 pColResRoot = new ScDPResultMember( pResData, NULL, NULL, NULL, bColumnGrand );
906 pRowResRoot = new ScDPResultMember( pResData, NULL, NULL, NULL, bRowGrand );
907
908 FillCalcInfo(false, aInfo, bHasAutoShow);
909 long nColLevelCount = aInfo.aColLevels.size();
910
911 pColResRoot->InitFrom( aInfo.aColDims, aInfo.aColLevels, 0, aInitState );
912 pColResRoot->SetHasElements();
913
914 FillCalcInfo(true, aInfo, bHasAutoShow);
915 long nRowLevelCount = aInfo.aRowLevels.size();
916
917 if ( nRowLevelCount > 0 )
918 {
919 // disable layout flags for the innermost row field (level)
920 aInfo.aRowLevels[nRowLevelCount-1]->SetEnableLayout( FALSE );
921 }
922
923 pRowResRoot->InitFrom( aInfo.aRowDims, aInfo.aRowLevels, 0, aInitState );
924 pRowResRoot->SetHasElements();
925
926 // initialize members object also for all page dimensions (needed for numeric groups)
927 for (i=0; i<nPageDimCount; i++)
928 {
929 ScDPDimension* pDim = GetDimensionsObject()->getByIndex( nPageDims[i] );
930 long nHierarchy = pDim->getUsedHierarchy();
931 if ( nHierarchy >= pDim->GetHierarchiesObject()->getCount() )
932 nHierarchy = 0;
933
934 ScDPLevels* pLevels = pDim->GetHierarchiesObject()->getByIndex(nHierarchy)->GetLevelsObject();
935 long nCount = pLevels->getCount();
936 for (long j=0; j<nCount; j++)
937 pLevels->getByIndex(j)->GetMembersObject(); // initialize for groups
938 }
939
940 // pre-check: calculate minimum number of result columns / rows from
941 // levels that have the "show all" flag set
942
943 long nMinColMembers = lcl_CountMinMembers( aInfo.aColDims, aInfo.aColLevels, nColLevelCount );
944 long nMinRowMembers = lcl_CountMinMembers( aInfo.aRowDims, aInfo.aRowLevels, nRowLevelCount );
945
946 if ( nMinColMembers > SC_MINCOUNT_LIMIT || nMinRowMembers > SC_MINCOUNT_LIMIT )
947 {
948 // resulting table is too big -> abort before calculating
949 // (this relies on late init, so no members are allocated in InitFrom above)
950
951 bResultOverflow = TRUE;
952 }
953 else
954 {
955 FilterCacheTableByPageDimensions();
956
957 aInfo.aPageDims.reserve(nPageDimCount);
958 for (i = 0; i < nPageDimCount; ++i)
959 aInfo.aPageDims.push_back(nPageDims[i]);
960
961 aInfo.pInitState = &aInitState;
962 aInfo.pColRoot = pColResRoot;
963 aInfo.pRowRoot = pRowResRoot;
964 pData->CalcResults(aInfo, false);
965
966 // ----------------------------------------------------------------
967 // With all data processed, calculate the final results:
968
969 // UpdateDataResults calculates all original results from the collected values,
970 // and stores them as reference values if needed.
971 pRowResRoot->UpdateDataResults( pColResRoot, pResData->GetRowStartMeasure() );
972
973 if ( bHasAutoShow ) // do the double calculation only if AutoShow is used
974 {
975 // Find the desired members and set bAutoHidden flag for the others
976 pRowResRoot->DoAutoShow( pColResRoot );
977
978 // Reset all results to empty, so they can be built again with data for the
979 // desired members only.
980 pColResRoot->ResetResults( TRUE );
981 pRowResRoot->ResetResults( TRUE );
982 pData->CalcResults(aInfo, true);
983
984 // Call UpdateDataResults again, with the new (limited) values.
985 pRowResRoot->UpdateDataResults( pColResRoot, pResData->GetRowStartMeasure() );
986 }
987
988 // SortMembers does the sorting by a result dimension, using the orginal results,
989 // but not running totals etc.
990 pRowResRoot->SortMembers( pColResRoot );
991
992 // UpdateRunningTotals calculates running totals along column/row dimensions,
993 // differences from other members (named or relative), and column/row percentages
994 // or index values.
995 // Running totals and relative differences need to be done using the sorted values.
996 // Column/row percentages and index values must be done after sorting, because the
997 // results may no longer be in the right order (row total for percentage of row is
998 // always 1).
999 ScDPRunningTotalState aRunning( pColResRoot, pRowResRoot );
1000 ScDPRowTotals aTotals;
1001 pRowResRoot->UpdateRunningTotals( pColResRoot, pResData->GetRowStartMeasure(), aRunning, aTotals );
1002
1003 // ----------------------------------------------------------------
1004 }
1005 }
1006 }
1007
1008 void ScDPSource::DumpState( ScDocument* pDoc, const ScAddress& rPos )
1009 {
1010 CreateRes_Impl();
1011
1012 ScAddress aDocPos( rPos );
1013
1014 if (pColResRoot->GetChildDimension())
1015 pColResRoot->GetChildDimension()->DumpState( NULL, pDoc, aDocPos );
1016 pRowResRoot->DumpState( pColResRoot, pDoc, aDocPos );
1017 }
1018
1019 void ScDPSource::FillLevelList( USHORT nOrientation, List& rList )
1020 {
1021 rList.Clear();
1022
1023 long nDimCount = 0;
1024 long* pDimIndex = NULL;
1025 switch (nOrientation)
1026 {
1027 case sheet::DataPilotFieldOrientation_COLUMN:
1028 pDimIndex = nColDims;
1029 nDimCount = nColDimCount;
1030 break;
1031 case sheet::DataPilotFieldOrientation_ROW:
1032 pDimIndex = nRowDims;
1033 nDimCount = nRowDimCount;
1034 break;
1035 case sheet::DataPilotFieldOrientation_DATA:
1036 pDimIndex = nDataDims;
1037 nDimCount = nDataDimCount;
1038 break;
1039 case sheet::DataPilotFieldOrientation_PAGE:
1040 pDimIndex = nPageDims;
1041 nDimCount = nPageDimCount;
1042 break;
1043 default:
1044 DBG_ERROR( "ScDPSource::FillLevelList: unexpected orientation" );
1045 break;
1046 }
1047 if (!pDimIndex)
1048 {
1049 DBG_ERROR("invalid orientation");
1050 return;
1051 }
1052
1053 ScDPDimensions* pDims = GetDimensionsObject();
1054 for (long nDim=0; nDim<nDimCount; nDim++)
1055 {
1056 ScDPDimension* pDim = pDims->getByIndex(pDimIndex[nDim]);
1057 DBG_ASSERT( pDim->getOrientation() == nOrientation, "orientations are wrong" );
1058
1059 ScDPHierarchies* pHiers = pDim->GetHierarchiesObject();
1060 long nHierarchy = pDim->getUsedHierarchy();
1061 if ( nHierarchy >= pHiers->getCount() )
1062 nHierarchy = 0;
1063 ScDPHierarchy* pHier = pHiers->getByIndex(nHierarchy);
1064 ScDPLevels* pLevels = pHier->GetLevelsObject();
1065 long nLevCount = pLevels->getCount();
1066 for (long nLev=0; nLev<nLevCount; nLev++)
1067 {
1068 ScDPLevel* pLevel = pLevels->getByIndex(nLev);
1069 rList.Insert( pLevel, LIST_APPEND );
1070 }
1071 }
1072 }
1073
1074 void ScDPSource::FillMemberResults()
1075 {
1076 if ( !pColResults && !pRowResults )
1077 {
1078 CreateRes_Impl();
1079
1080 if ( bResultOverflow ) // set in CreateRes_Impl
1081 {
1082 // no results available -> abort (leave empty)
1083 // exception is thrown in ScDPSource::getResults
1084 return;
1085 }
1086
1087 FillLevelList( sheet::DataPilotFieldOrientation_COLUMN, aColLevelList );
1088 long nColLevelCount = aColLevelList.Count();
1089 if (nColLevelCount)
1090 {
1091 long nColDimSize = pColResRoot->GetSize(pResData->GetColStartMeasure());
1092 pColResults = new uno::Sequence<sheet::MemberResult>[nColLevelCount];
1093 for (long i=0; i<nColLevelCount; i++)
1094 pColResults[i].realloc(nColDimSize);
1095
1096 // ScDPResultDimension* pColResDim = pColResRoot->GetChildDimension();
1097 // pColResDim->FillMemberResults( pColResults, 0, pResData->GetColStartMeasure() );
1098 long nPos = 0;
1099 pColResRoot->FillMemberResults( pColResults, nPos, pResData->GetColStartMeasure(),
1100 TRUE, NULL, NULL );
1101 }
1102
1103 FillLevelList( sheet::DataPilotFieldOrientation_ROW, aRowLevelList );
1104 long nRowLevelCount = aRowLevelList.Count();
1105 if (nRowLevelCount)
1106 {
1107 long nRowDimSize = pRowResRoot->GetSize(pResData->GetRowStartMeasure());
1108 pRowResults = new uno::Sequence<sheet::MemberResult>[nRowLevelCount];
1109 for (long i=0; i<nRowLevelCount; i++)
1110 pRowResults[i].realloc(nRowDimSize);
1111
1112 // ScDPResultDimension* pRowResDim = pRowResRoot->GetChildDimension();
1113 // pRowResDim->FillMemberResults( pRowResults, 0, pResData->GetRowStartMeasure() );
1114 long nPos = 0;
1115 pRowResRoot->FillMemberResults( pRowResults, nPos, pResData->GetRowStartMeasure(),
1116 TRUE, NULL, NULL );
1117 }
1118 }
1119 }
1120
1121 const uno::Sequence<sheet::MemberResult>* ScDPSource::GetMemberResults( ScDPLevel* pLevel )
1122 {
1123 FillMemberResults();
1124
1125 long i;
1126 long nColCount = aColLevelList.Count();
1127 for (i=0; i<nColCount; i++)
1128 {
1129 ScDPLevel* pColLevel = (ScDPLevel*)aColLevelList.GetObject(i);
1130 if ( pColLevel == pLevel )
1131 return pColResults+i;
1132 }
1133 long nRowCount = aRowLevelList.Count();
1134 for (i=0; i<nRowCount; i++)
1135 {
1136 ScDPLevel* pRowLevel = (ScDPLevel*)aRowLevelList.GetObject(i);
1137 if ( pRowLevel == pLevel )
1138 return pRowResults+i;
1139 }
1140 return NULL;
1141 }
1142
1143 // XPropertySet
1144
1145 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPSource::getPropertySetInfo()
1146 throw(uno::RuntimeException)
1147 {
1148 ScUnoGuard aGuard;
1149 using beans::PropertyAttribute::READONLY;
1150
1151 static SfxItemPropertyMap aDPSourceMap_Impl[] =
1152 {
1153 {MAP_CHAR_LEN(SC_UNO_COLGRAND), 0, &getBooleanCppuType(), 0, 0 },
1154 {MAP_CHAR_LEN(SC_UNO_DATADESC), 0, &getCppuType((rtl::OUString*)0), beans::PropertyAttribute::READONLY, 0 },
1155 {MAP_CHAR_LEN(SC_UNO_IGNOREEM), 0, &getBooleanCppuType(), 0, 0 }, // for sheet data only
1156 {MAP_CHAR_LEN(SC_UNO_REPEATIF), 0, &getBooleanCppuType(), 0, 0 }, // for sheet data only
1157 {MAP_CHAR_LEN(SC_UNO_ROWGRAND), 0, &getBooleanCppuType(), 0, 0 },
1158 {MAP_CHAR_LEN(SC_UNO_ROWFIELDCOUNT), 0, &getCppuType(static_cast<sal_Int32*>(0)), READONLY, 0 },
1159 {MAP_CHAR_LEN(SC_UNO_COLUMNFIELDCOUNT), 0, &getCppuType(static_cast<sal_Int32*>(0)), READONLY, 0 },
1160 {MAP_CHAR_LEN(SC_UNO_DATAFIELDCOUNT), 0, &getCppuType(static_cast<sal_Int32*>(0)), READONLY, 0 },
1161 {MAP_CHAR_LEN(SC_UNO_GRANDTOTAL_NAME), 0, &getCppuType(static_cast<OUString*>(0)), 0, 0 },
1162 {0,0,0,0,0,0}
1163 };
1164 static uno::Reference<beans::XPropertySetInfo> aRef =
1165 new SfxItemPropertySetInfo( aDPSourceMap_Impl );
1166 return aRef;
1167 }
1168
1169 void SAL_CALL ScDPSource::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue )
1170 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1171 lang::IllegalArgumentException, lang::WrappedTargetException,
1172 uno::RuntimeException)
1173 {
1174 String aNameStr = aPropertyName;
1175 if ( aNameStr.EqualsAscii( SC_UNO_COLGRAND ) )
1176 setColumnGrand( lcl_GetBoolFromAny( aValue ) );
1177 else if ( aNameStr.EqualsAscii( SC_UNO_ROWGRAND ) )
1178 setRowGrand( lcl_GetBoolFromAny( aValue ) );
1179 else if ( aNameStr.EqualsAscii( SC_UNO_IGNOREEM ) )
1180 setIgnoreEmptyRows( lcl_GetBoolFromAny( aValue ) );
1181 else if ( aNameStr.EqualsAscii( SC_UNO_REPEATIF ) )
1182 setRepeatIfEmpty( lcl_GetBoolFromAny( aValue ) );
1183 else if (aNameStr.EqualsAscii(SC_UNO_GRANDTOTAL_NAME))
1184 {
1185 OUString aName;
1186 if (aValue >>= aName)
1187 mpGrandTotalName.reset(new OUString(aName));
1188 }
1189 else
1190 {
1191 DBG_ERROR("unknown property");
1192 //! THROW( UnknownPropertyException() );
1193 }
1194 }
1195
1196 uno::Any SAL_CALL ScDPSource::getPropertyValue( const rtl::OUString& aPropertyName )
1197 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1198 uno::RuntimeException)
1199 {
1200 uno::Any aRet;
1201 String aNameStr = aPropertyName;
1202 if ( aNameStr.EqualsAscii( SC_UNO_COLGRAND ) )
1203 lcl_SetBoolInAny( aRet, getColumnGrand() );
1204 else if ( aNameStr.EqualsAscii( SC_UNO_ROWGRAND ) )
1205 lcl_SetBoolInAny( aRet, getRowGrand() );
1206 else if ( aNameStr.EqualsAscii( SC_UNO_IGNOREEM ) )
1207 lcl_SetBoolInAny( aRet, getIgnoreEmptyRows() );
1208 else if ( aNameStr.EqualsAscii( SC_UNO_REPEATIF ) )
1209 lcl_SetBoolInAny( aRet, getRepeatIfEmpty() );
1210 else if ( aNameStr.EqualsAscii( SC_UNO_DATADESC ) ) // read-only
1211 aRet <<= rtl::OUString( getDataDescription() );
1212 else if ( aNameStr.EqualsAscii( SC_UNO_ROWFIELDCOUNT ) ) // read-only
1213 aRet <<= static_cast<sal_Int32>(nRowDimCount);
1214 else if ( aNameStr.EqualsAscii( SC_UNO_COLUMNFIELDCOUNT ) ) // read-only
1215 aRet <<= static_cast<sal_Int32>(nColDimCount);
1216 else if ( aNameStr.EqualsAscii( SC_UNO_DATAFIELDCOUNT ) ) // read-only
1217 aRet <<= static_cast<sal_Int32>(nDataDimCount);
1218 else if (aNameStr.EqualsAscii(SC_UNO_GRANDTOTAL_NAME))
1219 {
1220 if (mpGrandTotalName.get())
1221 aRet <<= *mpGrandTotalName;
1222 }
1223 else
1224 {
1225 DBG_ERROR("unknown property");
1226 //! THROW( UnknownPropertyException() );
1227 }
1228 return aRet;
1229 }
1230
1231 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPSource )
1232
1233 // -----------------------------------------------------------------------
1234
1235 ScDPDimensions::ScDPDimensions( ScDPSource* pSrc ) :
1236 pSource( pSrc ),
1237 ppDims( NULL )
1238 {
1239 //! hold pSource
1240
1241 // include data layout dimension and duplicated dimensions
1242 nDimCount = pSource->GetData()->GetColumnCount() + 1 + pSource->GetDupCount();
1243 }
1244
1245 ScDPDimensions::~ScDPDimensions()
1246 {
1247 //! release pSource
1248
1249 if (ppDims)
1250 {
1251 for (long i=0; i<nDimCount; i++)
1252 if ( ppDims[i] )
1253 ppDims[i]->release(); // ref-counted
1254 delete[] ppDims;
1255 }
1256 }
1257
1258 void ScDPDimensions::CountChanged()
1259 {
1260 // include data layout dimension and duplicated dimensions
1261 long nNewCount = pSource->GetData()->GetColumnCount() + 1 + pSource->GetDupCount();
1262 if ( ppDims )
1263 {
1264 long i;
1265 long nCopy = Min( nNewCount, nDimCount );
1266 ScDPDimension** ppNew = new ScDPDimension*[nNewCount];
1267
1268 for (i=0; i<nCopy; i++) // copy existing dims
1269 ppNew[i] = ppDims[i];
1270 for (i=nCopy; i<nNewCount; i++) // clear additional pointers
1271 ppNew[i] = NULL;
1272 for (i=nCopy; i<nDimCount; i++) // delete old dims if count is decreased
1273 if ( ppDims[i] )
1274 ppDims[i]->release(); // ref-counted
1275
1276 delete[] ppDims;
1277 ppDims = ppNew;
1278 }
1279 nDimCount = nNewCount;
1280 }
1281
1282 // very simple XNameAccess implementation using getCount/getByIndex
1283
1284 uno::Any SAL_CALL ScDPDimensions::getByName( const rtl::OUString& aName )
1285 throw(container::NoSuchElementException,
1286 lang::WrappedTargetException, uno::RuntimeException)
1287 {
1288 long nCount = getCount();
1289 for (long i=0; i<nCount; i++)
1290 if ( getByIndex(i)->getName() == aName )
1291 {
1292 uno::Reference<container::XNamed> xNamed = getByIndex(i);
1293 uno::Any aRet;
1294 aRet <<= xNamed;
1295 return aRet;
1296 }
1297
1298 throw container::NoSuchElementException();
1299 // return uno::Any();
1300 }
1301
1302 uno::Sequence<rtl::OUString> SAL_CALL ScDPDimensions::getElementNames() throw(uno::RuntimeException)
1303 {
1304 long nCount = getCount();
1305 uno::Sequence<rtl::OUString> aSeq(nCount);
1306 rtl::OUString* pArr = aSeq.getArray();
1307 for (long i=0; i<nCount; i++)
1308 pArr[i] = getByIndex(i)->getName();
1309 return aSeq;
1310 }
1311
1312 sal_Bool SAL_CALL ScDPDimensions::hasByName( const rtl::OUString& aName ) throw(uno::RuntimeException)
1313 {
1314 long nCount = getCount();
1315 for (long i=0; i<nCount; i++)
1316 if ( getByIndex(i)->getName() == aName )
1317 return TRUE;
1318 return FALSE;
1319 }
1320
1321 uno::Type SAL_CALL ScDPDimensions::getElementType() throw(uno::RuntimeException)
1322 {
1323 return getCppuType((uno::Reference<container::XNamed>*)0);
1324 }
1325
1326 sal_Bool SAL_CALL ScDPDimensions::hasElements() throw(uno::RuntimeException)
1327 {
1328 return ( getCount() > 0 );
1329 }
1330
1331 // end of XNameAccess implementation
1332
1333 long ScDPDimensions::getCount() const
1334 {
1335 // in tabular data, every column of source data is a dimension
1336
1337 return nDimCount;
1338 }
1339
1340 ScDPDimension* ScDPDimensions::getByIndex(long nIndex) const
1341 {
1342 if ( nIndex >= 0 && nIndex < nDimCount )
1343 {
1344 if ( !ppDims )
1345 {
1346 ((ScDPDimensions*)this)->ppDims = new ScDPDimension*[nDimCount];
1347 for (long i=0; i<nDimCount; i++)
1348 ppDims[i] = NULL;
1349 }
1350 if ( !ppDims[nIndex] )
1351 {
1352 ppDims[nIndex] = new ScDPDimension( pSource, nIndex );
1353 ppDims[nIndex]->acquire(); // ref-counted
1354 }
1355
1356 return ppDims[nIndex];
1357 }
1358
1359 return NULL; //! exception?
1360 }
1361
1362 // -----------------------------------------------------------------------
1363
1364 ScDPDimension::ScDPDimension( ScDPSource* pSrc, long nD ) :
1365 pSource( pSrc ),
1366 nDim( nD ),
1367 pHierarchies( NULL ),
1368 nUsedHier( 0 ),
1369 nFunction( SUBTOTAL_FUNC_SUM ), // sum is default
1370 mpLayoutName(NULL),
1371 mpSubtotalName(NULL),
1372 nSourceDim( -1 ),
1373 bHasSelectedPage( FALSE ),
1374 pSelectedData( NULL ),
1375 mbHasHiddenMember(false)
1376 {
1377 //! hold pSource
1378 }
1379
1380 ScDPDimension::~ScDPDimension()
1381 {
1382 //! release pSource
1383
1384 if ( pHierarchies )
1385 pHierarchies->release(); // ref-counted
1386
1387 delete pSelectedData;
1388 }
1389
1390 ScDPHierarchies* ScDPDimension::GetHierarchiesObject()
1391 {
1392 if (!pHierarchies)
1393 {
1394 pHierarchies = new ScDPHierarchies( pSource, nDim );
1395 pHierarchies->acquire(); // ref-counted
1396 }
1397 return pHierarchies;
1398 }
1399
1400 const rtl::OUString* ScDPDimension::GetLayoutName() const
1401 {
1402 return mpLayoutName.get();
1403 }
1404
1405 const rtl::OUString* ScDPDimension::GetSubtotalName() const
1406 {
1407 return mpSubtotalName.get();
1408 }
1409
1410 uno::Reference<container::XNameAccess> SAL_CALL ScDPDimension::getHierarchies()
1411 throw(uno::RuntimeException)
1412 {
1413 return GetHierarchiesObject();
1414 }
1415
1416 ::rtl::OUString SAL_CALL ScDPDimension::getName() throw(uno::RuntimeException)
1417 {
1418 if (aName.Len())
1419 return aName;
1420 else
1421 return pSource->GetData()->getDimensionName( nDim );
1422 }
1423
1424 void SAL_CALL ScDPDimension::setName( const ::rtl::OUString& rNewName ) throw(uno::RuntimeException)
1425 {
1426 // used after cloning
1427 aName = String( rNewName );
1428 }
1429
1430 USHORT ScDPDimension::getOrientation() const
1431 {
1432 return pSource->GetOrientation( nDim );
1433 }
1434
1435 void ScDPDimension::setOrientation(USHORT nNew)
1436 {
1437 pSource->SetOrientation( nDim, nNew );
1438 }
1439
1440 long ScDPDimension::getPosition() const
1441 {
1442 return pSource->GetPosition( nDim );
1443 }
1444
1445 void ScDPDimension::setPosition(long /* nNew */)
1446 {
1447 //! ...
1448 }
1449
1450 BOOL ScDPDimension::getIsDataLayoutDimension() const
1451 {
1452 return pSource->GetData()->getIsDataLayoutDimension( nDim );
1453 }
1454
1455 USHORT ScDPDimension::getFunction() const
1456 {
1457 return nFunction;
1458 }
1459
1460 void ScDPDimension::setFunction(USHORT nNew)
1461 {
1462 nFunction = nNew;
1463 }
1464
1465 long ScDPDimension::getUsedHierarchy() const
1466 {
1467 return nUsedHier;
1468 }
1469
1470 void ScDPDimension::setUsedHierarchy(long /* nNew */)
1471 {
1472 // #i52547# don't use the incomplete date hierarchy implementation - ignore the call
1473 // nUsedHier = nNew;
1474 }
1475
1476 ScDPDimension* ScDPDimension::CreateCloneObject()
1477 {
1478 DBG_ASSERT( nSourceDim < 0, "recursive duplicate - not implemented" );
1479
1480 //! set new name here, or temporary name ???
1481 String aNewName = aName;
1482
1483 ScDPDimension* pNew = pSource->AddDuplicated( nDim, aNewName );
1484
1485 pNew->aName = aNewName; //! here or in source?
1486 pNew->nSourceDim = nDim; //! recursive?
1487
1488 return pNew;
1489 }
1490
1491 uno::Reference<util::XCloneable> SAL_CALL ScDPDimension::createClone() throw(uno::RuntimeException)
1492 {
1493 return CreateCloneObject();
1494 }
1495
1496 BOOL ScDPDimension::isDuplicated() const
1497 {
1498 return (nSourceDim >= 0);
1499 }
1500
1501 const sheet::DataPilotFieldReference& ScDPDimension::GetReferenceValue() const
1502 {
1503 return aReferenceValue;
1504 }
1505
1506 const ScDPItemData& ScDPDimension::GetSelectedData()
1507 {
1508 if ( !pSelectedData )
1509 {
1510 // find the named member to initialize pSelectedData from it, with name and value
1511
1512 long nLevel = 0; // same as in ScDPObject::FillPageList
1513
1514 long nHierarchy = getUsedHierarchy();
1515 if ( nHierarchy >= GetHierarchiesObject()->getCount() )
1516 nHierarchy = 0;
1517 ScDPLevels* pLevels = GetHierarchiesObject()->getByIndex(nHierarchy)->GetLevelsObject();
1518 long nLevCount = pLevels->getCount();
1519 if ( nLevel < nLevCount )
1520 {
1521 ScDPMembers* pMembers = pLevels->getByIndex(nLevel)->GetMembersObject();
1522
1523 //! merge with ScDPMembers::getByName
1524 long nCount = pMembers->getCount();
1525 for (long i=0; i<nCount && !pSelectedData; i++)
1526 {
1527 ScDPMember* pMember = pMembers->getByIndex(i);
1528 if ( pMember->GetNameStr() == aSelectedPage )
1529 {
1530 pSelectedData = new ScDPItemData();
1531 pMember->FillItemData( *pSelectedData );
1532 }
1533 }
1534 }
1535
1536 if ( !pSelectedData )
1537 pSelectedData = new ScDPItemData( aSelectedPage, 0.0, FALSE ); // default - name only
1538 }
1539
1540 return *pSelectedData;
1541 }
1542
1543 BOOL ScDPDimension::IsValidPage( const ScDPItemData& rData )
1544 {
1545 if ( bHasSelectedPage )
1546 return rData.IsCaseInsEqual( GetSelectedData() );
1547
1548 return TRUE; // no selection -> all data
1549 }
1550
1551 // XPropertySet
1552
1553 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPDimension::getPropertySetInfo()
1554 throw(uno::RuntimeException)
1555 {
1556 ScUnoGuard aGuard;
1557
1558 static SfxItemPropertyMap aDPDimensionMap_Impl[] =
1559 {
1560 {MAP_CHAR_LEN(SC_UNO_FILTER), 0, &getCppuType((uno::Sequence<sheet::TableFilterField>*)0), 0, 0 },
1561 {MAP_CHAR_LEN(SC_UNO_FUNCTION), 0, &getCppuType((sheet::GeneralFunction*)0), 0, 0 },
1562 {MAP_CHAR_LEN(SC_UNO_ISDATALA), 0, &getBooleanCppuType(), beans::PropertyAttribute::READONLY, 0 },
1563 {MAP_CHAR_LEN(SC_UNO_NUMBERFO), 0, &getCppuType((sal_Int32*)0), beans::PropertyAttribute::READONLY, 0 },
1564 {MAP_CHAR_LEN(SC_UNO_ORIENTAT), 0, &getCppuType((sheet::DataPilotFieldOrientation*)0), 0, 0 },
1565 {MAP_CHAR_LEN(SC_UNO_ORIGINAL), 0, &getCppuType((uno::Reference<container::XNamed>*)0), beans::PropertyAttribute::READONLY, 0 },
1566 {MAP_CHAR_LEN(SC_UNO_POSITION), 0, &getCppuType((sal_Int32*)0), 0, 0 },
1567 {MAP_CHAR_LEN(SC_UNO_REFVALUE), 0, &getCppuType((sheet::DataPilotFieldReference*)0), 0, 0 },
1568 {MAP_CHAR_LEN(SC_UNO_USEDHIER), 0, &getCppuType((sal_Int32*)0), 0, 0 },
1569 {MAP_CHAR_LEN(SC_UNO_LAYOUTNAME), 0, &getCppuType(static_cast<rtl::OUString*>(0)), 0, 0 },
1570 {MAP_CHAR_LEN(SC_UNO_FIELD_SUBTOTALNAME), 0, &getCppuType(static_cast<rtl::OUString*>(0)), 0, 0 },
1571 {MAP_CHAR_LEN(SC_UNO_HAS_HIDDEN_MEMBER), 0, &getBooleanCppuType(), 0, 0 },
1572 {0,0,0,0,0,0}
1573 };
1574 static uno::Reference<beans::XPropertySetInfo> aRef =
1575 new SfxItemPropertySetInfo( aDPDimensionMap_Impl );
1576 return aRef;
1577 }
1578
1579 void SAL_CALL ScDPDimension::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue )
1580 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1581 lang::IllegalArgumentException, lang::WrappedTargetException,
1582 uno::RuntimeException)
1583 {
1584 String aNameStr = aPropertyName;
1585 if ( aNameStr.EqualsAscii( SC_UNO_POSITION ) )
1586 {
1587 INT32 nInt = 0;
1588 if (aValue >>= nInt)
1589 setPosition( nInt );
1590 }
1591 else if ( aNameStr.EqualsAscii( SC_UNO_USEDHIER ) )
1592 {
1593 INT32 nInt = 0;
1594 if (aValue >>= nInt)
1595 setUsedHierarchy( nInt );
1596 }
1597 else if ( aNameStr.EqualsAscii( SC_UNO_ORIENTAT ) )
1598 {
1599 sheet::DataPilotFieldOrientation eEnum;
1600 if (aValue >>= eEnum)
1601 setOrientation( sal::static_int_cast<USHORT>(eEnum) );
1602 }
1603 else if ( aNameStr.EqualsAscii( SC_UNO_FUNCTION ) )
1604 {
1605 sheet::GeneralFunction eEnum;
1606 if (aValue >>= eEnum)
1607 setFunction( sal::static_int_cast<USHORT>(eEnum) );
1608 }
1609 else if ( aNameStr.EqualsAscii( SC_UNO_REFVALUE ) )
1610 aValue >>= aReferenceValue;
1611 else if ( aNameStr.EqualsAscii( SC_UNO_FILTER ) )
1612 {
1613 BOOL bDone = FALSE;
1614 uno::Sequence<sheet::TableFilterField> aSeq;
1615 if (aValue >>= aSeq)
1616 {
1617 sal_Int32 nLength = aSeq.getLength();
1618 if ( nLength == 0 )
1619 {
1620 aSelectedPage.Erase();
1621 bHasSelectedPage = FALSE;
1622 bDone = TRUE;
1623 }
1624 else if ( nLength == 1 )
1625 {
1626 const sheet::TableFilterField& rField = aSeq[0];
1627 if ( rField.Field == 0 && rField.Operator == sheet::FilterOperator_EQUAL && !rField.IsNumeric )
1628 {
1629 aSelectedPage = rField.StringValue;
1630 bHasSelectedPage = TRUE;
1631 bDone = TRUE;
1632 }
1633 }
1634 }
1635 if ( !bDone )
1636 {
1637 DBG_ERROR("Filter property is not a single string");
1638 throw lang::IllegalArgumentException();
1639 }
1640 DELETEZ( pSelectedData ); // invalid after changing aSelectedPage
1641 }
1642 else if (aNameStr.EqualsAscii(SC_UNO_LAYOUTNAME))
1643 {
1644 OUString aTmpName;
1645 if (aValue >>= aTmpName)
1646 mpLayoutName.reset(new OUString(aTmpName));
1647 }
1648 else if (aNameStr.EqualsAscii(SC_UNO_FIELD_SUBTOTALNAME))
1649 {
1650 OUString aTmpName;
1651 if (aValue >>= aTmpName)
1652 mpSubtotalName.reset(new OUString(aTmpName));
1653 }
1654 else if (aNameStr.EqualsAscii(SC_UNO_HAS_HIDDEN_MEMBER))
1655 aValue >>= mbHasHiddenMember;
1656 else
1657 {
1658 DBG_ERROR("unknown property");
1659 //! THROW( UnknownPropertyException() );
1660 }
1661 }
1662
1663 uno::Any SAL_CALL ScDPDimension::getPropertyValue( const rtl::OUString& aPropertyName )
1664 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1665 uno::RuntimeException)
1666 {
1667 uno::Any aRet;
1668 String aNameStr = aPropertyName;
1669 if ( aNameStr.EqualsAscii( SC_UNO_POSITION ) )
1670 aRet <<= (sal_Int32) getPosition();
1671 else if ( aNameStr.EqualsAscii( SC_UNO_USEDHIER ) )
1672 aRet <<= (sal_Int32) getUsedHierarchy();
1673 else if ( aNameStr.EqualsAscii( SC_UNO_ORIENTAT ) )
1674 {
1675 sheet::DataPilotFieldOrientation eVal = (sheet::DataPilotFieldOrientation)getOrientation();
1676 aRet <<= eVal;
1677 }
1678 else if ( aNameStr.EqualsAscii( SC_UNO_FUNCTION ) )
1679 {
1680 sheet::GeneralFunction eVal = (sheet::GeneralFunction)getFunction();
1681 aRet <<= eVal;
1682 }
1683 else if ( aNameStr.EqualsAscii( SC_UNO_REFVALUE ) )
1684 aRet <<= aReferenceValue;
1685 else if ( aNameStr.EqualsAscii( SC_UNO_ISDATALA ) ) // read-only properties
1686 lcl_SetBoolInAny( aRet, getIsDataLayoutDimension() );
1687 else if ( aNameStr.EqualsAscii( SC_UNO_NUMBERFO ) )
1688 {
1689 sal_Int32 nFormat = 0;
1690 sheet::GeneralFunction eFunc = (sheet::GeneralFunction)getFunction();
1691 // #i63745# don't use source format for "count"
1692 if ( eFunc != sheet::GeneralFunction_COUNT && eFunc != sheet::GeneralFunction_COUNTNUMS )
1693 nFormat = pSource->GetData()->GetNumberFormat( ( nSourceDim >= 0 ) ? nSourceDim : nDim );
1694 aRet <<= nFormat;
1695 }
1696 else if ( aNameStr.EqualsAscii( SC_UNO_ORIGINAL ) )
1697 {
1698 uno::Reference<container::XNamed> xOriginal;
1699 if (nSourceDim >= 0)
1700 xOriginal = pSource->GetDimensionsObject()->getByIndex(nSourceDim);
1701 aRet <<= xOriginal;
1702 }
1703 else if ( aNameStr.EqualsAscii( SC_UNO_FILTER ) )
1704 {
1705 if ( bHasSelectedPage )
1706 {
1707 // single filter field: first field equal to selected string
1708 sheet::TableFilterField aField( sheet::FilterConnection_AND, 0,
1709 sheet::FilterOperator_EQUAL, sal_False, 0.0, aSelectedPage );
1710 aRet <<= uno::Sequence<sheet::TableFilterField>( &aField, 1 );
1711 }
1712 else
1713 aRet <<= uno::Sequence<sheet::TableFilterField>(0);
1714 }
1715 else if (aNameStr.EqualsAscii(SC_UNO_LAYOUTNAME))
1716 aRet <<= mpLayoutName.get() ? *mpLayoutName : OUString::createFromAscii("");
1717 else if (aNameStr.EqualsAscii(SC_UNO_FIELD_SUBTOTALNAME))
1718 aRet <<= mpSubtotalName.get() ? *mpSubtotalName : OUString::createFromAscii("");
1719 else if (aNameStr.EqualsAscii(SC_UNO_HAS_HIDDEN_MEMBER))
1720 aRet <<= mbHasHiddenMember;
1721 else
1722 {
1723 DBG_ERROR("unknown property");
1724 //! THROW( UnknownPropertyException() );
1725 }
1726 return aRet;
1727 }
1728
1729 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPDimension )
1730
1731 // -----------------------------------------------------------------------
1732
1733 ScDPHierarchies::ScDPHierarchies( ScDPSource* pSrc, long nD ) :
1734 pSource( pSrc ),
1735 nDim( nD ),
1736 ppHiers( NULL )
1737 {
1738 //! hold pSource
1739
1740 #if 0
1741 // date columns have 3 hierarchies (flat/quarter/week), other columns only one
1742 long nSrcDim = pSource->GetSourceDim( nDim );
1743 if ( pSource->IsDateDimension( nSrcDim ) )
1744 nHierCount = SC_DAPI_DATE_HIERARCHIES;
1745 else
1746 nHierCount = 1;
1747 #endif
1748
1749 // #i52547# don't offer the incomplete date hierarchy implementation
1750 nHierCount = 1;
1751 }
1752
1753 ScDPHierarchies::~ScDPHierarchies()
1754 {
1755 //! release pSource
1756
1757 if (ppHiers)
1758 {
1759 for (long i=0; i<nHierCount; i++)
1760 if ( ppHiers[i] )
1761 ppHiers[i]->release(); // ref-counted
1762 delete[] ppHiers;
1763 }
1764 }
1765
1766 // very simple XNameAccess implementation using getCount/getByIndex
1767
1768 uno::Any SAL_CALL ScDPHierarchies::getByName( const rtl::OUString& aName )
1769 throw(container::NoSuchElementException,
1770 lang::WrappedTargetException, uno::RuntimeException)
1771 {
1772 long nCount = getCount();
1773 for (long i=0; i<nCount; i++)
1774 if ( getByIndex(i)->getName() == aName )
1775 {
1776 uno::Reference<container::XNamed> xNamed = getByIndex(i);
1777 uno::Any aRet;
1778 aRet <<= xNamed;
1779 return aRet;
1780 }
1781
1782 throw container::NoSuchElementException();
1783 // return uno::Any();
1784 }
1785
1786 uno::Sequence<rtl::OUString> SAL_CALL ScDPHierarchies::getElementNames() throw(uno::RuntimeException)
1787 {
1788 long nCount = getCount();
1789 uno::Sequence<rtl::OUString> aSeq(nCount);
1790 rtl::OUString* pArr = aSeq.getArray();
1791 for (long i=0; i<nCount; i++)
1792 pArr[i] = getByIndex(i)->getName();
1793 return aSeq;
1794 }
1795
1796 sal_Bool SAL_CALL ScDPHierarchies::hasByName( const rtl::OUString& aName ) throw(uno::RuntimeException)
1797 {
1798 long nCount = getCount();
1799 for (long i=0; i<nCount; i++)
1800 if ( getByIndex(i)->getName() == aName )
1801 return TRUE;
1802 return FALSE;
1803 }
1804
1805 uno::Type SAL_CALL ScDPHierarchies::getElementType() throw(uno::RuntimeException)
1806 {
1807 return getCppuType((uno::Reference<container::XNamed>*)0);
1808 }
1809
1810 sal_Bool SAL_CALL ScDPHierarchies::hasElements() throw(uno::RuntimeException)
1811 {
1812 return ( getCount() > 0 );
1813 }
1814
1815 // end of XNameAccess implementation
1816
1817 long ScDPHierarchies::getCount() const
1818 {
1819 return nHierCount;
1820 }
1821
1822 ScDPHierarchy* ScDPHierarchies::getByIndex(long nIndex) const
1823 {
1824 // pass hierarchy index to new object in case the implementation
1825 // will be extended to more than one hierarchy
1826
1827 if ( nIndex >= 0 && nIndex < nHierCount )
1828 {
1829 if ( !ppHiers )
1830 {
1831 ((ScDPHierarchies*)this)->ppHiers = new ScDPHierarchy*[nHierCount];
1832 for (long i=0; i<nHierCount; i++)
1833 ppHiers[i] = NULL;
1834 }
1835 if ( !ppHiers[nIndex] )
1836 {
1837 ppHiers[nIndex] = new ScDPHierarchy( pSource, nDim, nIndex );
1838 ppHiers[nIndex]->acquire(); // ref-counted
1839 }
1840
1841 return ppHiers[nIndex];
1842 }
1843
1844 return NULL; //! exception?
1845 }
1846
1847 // -----------------------------------------------------------------------
1848
1849 ScDPHierarchy::ScDPHierarchy( ScDPSource* pSrc, long nD, long nH ) :
1850 pSource( pSrc ),
1851 nDim( nD ),
1852 nHier( nH ),
1853 pLevels( NULL )
1854 {
1855 //! hold pSource
1856 }
1857
1858 ScDPHierarchy::~ScDPHierarchy()
1859 {
1860 //! release pSource
1861
1862 if (pLevels)
1863 pLevels->release(); // ref-counted
1864 }
1865
1866 ScDPLevels* ScDPHierarchy::GetLevelsObject()
1867 {
1868 if (!pLevels)
1869 {
1870 pLevels = new ScDPLevels( pSource, nDim, nHier );
1871 pLevels->acquire(); // ref-counted
1872 }
1873 return pLevels;
1874 }
1875
1876 uno::Reference<container::XNameAccess> SAL_CALL ScDPHierarchy::getLevels()
1877 throw(uno::RuntimeException)
1878 {
1879 return GetLevelsObject();
1880 }
1881
1882 ::rtl::OUString SAL_CALL ScDPHierarchy::getName() throw(uno::RuntimeException)
1883 {
1884 String aRet; //! globstr-ID !!!!
1885 switch (nHier)
1886 {
1887 case SC_DAPI_HIERARCHY_FLAT:
1888 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("flat"));
1889 break; //! name ???????
1890 case SC_DAPI_HIERARCHY_QUARTER:
1891 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Quarter"));
1892 break; //! name ???????
1893 case SC_DAPI_HIERARCHY_WEEK:
1894 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Week"));
1895 break; //! name ???????
1896 default:
1897 DBG_ERROR( "ScDPHierarchy::getName: unexpected hierarchy" );
1898 break;
1899 }
1900 return aRet;
1901 }
1902
1903 void SAL_CALL ScDPHierarchy::setName( const ::rtl::OUString& /* rNewName */ ) throw(uno::RuntimeException)
1904 {
1905 DBG_ERROR("not implemented"); //! exception?
1906 }
1907
1908 // -----------------------------------------------------------------------
1909
1910 ScDPLevels::ScDPLevels( ScDPSource* pSrc, long nD, long nH ) :
1911 pSource( pSrc ),
1912 nDim( nD ),
1913 nHier( nH ),
1914 ppLevs( NULL )
1915 {
1916 //! hold pSource
1917
1918 // text columns have only one level
1919
1920 long nSrcDim = pSource->GetSourceDim( nDim );
1921 if ( pSource->IsDateDimension( nSrcDim ) )
1922 {
1923 switch ( nHier )
1924 {
1925 case SC_DAPI_HIERARCHY_FLAT: nLevCount = SC_DAPI_FLAT_LEVELS; break;
1926 case SC_DAPI_HIERARCHY_QUARTER: nLevCount = SC_DAPI_QUARTER_LEVELS; break;
1927 case SC_DAPI_HIERARCHY_WEEK: nLevCount = SC_DAPI_WEEK_LEVELS; break;
1928 default:
1929 DBG_ERROR("wrong hierarchy");
1930 nLevCount = 0;
1931 }
1932 }
1933 else
1934 nLevCount = 1;
1935 }
1936
1937 ScDPLevels::~ScDPLevels()
1938 {
1939 //! release pSource
1940
1941 if (ppLevs)
1942 {
1943 for (long i=0; i<nLevCount; i++)
1944 if ( ppLevs[i] )
1945 ppLevs[i]->release(); // ref-counted
1946 delete[] ppLevs;
1947 }
1948 }
1949
1950 // very simple XNameAccess implementation using getCount/getByIndex
1951
1952 uno::Any SAL_CALL ScDPLevels::getByName( const rtl::OUString& aName )
1953 throw(container::NoSuchElementException,
1954 lang::WrappedTargetException, uno::RuntimeException)
1955 {
1956 long nCount = getCount();
1957 for (long i=0; i<nCount; i++)
1958 if ( getByIndex(i)->getName() == aName )
1959 {
1960 uno::Reference<container::XNamed> xNamed = getByIndex(i);
1961 uno::Any aRet;
1962 aRet <<= xNamed;
1963 return aRet;
1964 }
1965
1966 throw container::NoSuchElementException();
1967 // return uno::Any();
1968 }
1969
1970 uno::Sequence<rtl::OUString> SAL_CALL ScDPLevels::getElementNames() throw(uno::RuntimeException)
1971 {
1972 long nCount = getCount();
1973 uno::Sequence<rtl::OUString> aSeq(nCount);
1974 rtl::OUString* pArr = aSeq.getArray();
1975 for (long i=0; i<nCount; i++)
1976 pArr[i] = getByIndex(i)->getName();
1977 return aSeq;
1978 }
1979
1980 sal_Bool SAL_CALL ScDPLevels::hasByName( const rtl::OUString& aName ) throw(uno::RuntimeException)
1981 {
1982 long nCount = getCount();
1983 for (long i=0; i<nCount; i++)
1984 if ( getByIndex(i)->getName() == aName )
1985 return TRUE;
1986 return FALSE;
1987 }
1988
1989 uno::Type SAL_CALL ScDPLevels::getElementType() throw(uno::RuntimeException)
1990 {
1991 return getCppuType((uno::Reference<container::XNamed>*)0);
1992 }
1993
1994 sal_Bool SAL_CALL ScDPLevels::hasElements() throw(uno::RuntimeException)
1995 {
1996 return ( getCount() > 0 );
1997 }
1998
1999 // end of XNameAccess implementation
2000
2001 long ScDPLevels::getCount() const
2002 {
2003 return nLevCount;
2004 }
2005
2006 ScDPLevel* ScDPLevels::getByIndex(long nIndex) const
2007 {
2008 if ( nIndex >= 0 && nIndex < nLevCount )
2009 {
2010 if ( !ppLevs )
2011 {
2012 ((ScDPLevels*)this)->ppLevs = new ScDPLevel*[nLevCount];
2013 for (long i=0; i<nLevCount; i++)
2014 ppLevs[i] = NULL;
2015 }
2016 if ( !ppLevs[nIndex] )
2017 {
2018 ppLevs[nIndex] = new ScDPLevel( pSource, nDim, nHier, nIndex );
2019 ppLevs[nIndex]->acquire(); // ref-counted
2020 }
2021
2022 return ppLevs[nIndex];
2023 }
2024
2025 return NULL; //! exception?
2026 }
2027
2028 // -----------------------------------------------------------------------
2029
2030 class ScDPGlobalMembersOrder
2031 {
2032 ScDPLevel& rLevel;
2033 BOOL bAscending;
2034
2035 public:
2036 ScDPGlobalMembersOrder( ScDPLevel& rLev, BOOL bAsc ) :
2037 rLevel(rLev),
2038 bAscending(bAsc)
2039 {}
2040 ~ScDPGlobalMembersOrder() {}
2041
2042 BOOL operator()( sal_Int32 nIndex1, sal_Int32 nIndex2 ) const;
2043 };
2044
2045 BOOL ScDPGlobalMembersOrder::operator()( sal_Int32 nIndex1, sal_Int32 nIndex2 ) const
2046 {
2047 ScDPMembers* pMembers = rLevel.GetMembersObject();
2048 ScDPMember* pMember1 = pMembers->getByIndex(nIndex1);
2049 ScDPMember* pMember2 = pMembers->getByIndex(nIndex2);
2050
2051 sal_Int32 nCompare = pMember1->Compare( *pMember2 );
2052
2053 return bAscending ? ( nCompare < 0 ) : ( nCompare > 0 );
2054 }
2055
2056 // -----------------------------------------------------------------------
2057
2058 ScDPLevel::ScDPLevel( ScDPSource* pSrc, long nD, long nH, long nL ) :
2059 pSource( pSrc ),
2060 nDim( nD ),
2061 nHier( nH ),
2062 nLev( nL ),
2063 pMembers( NULL ),
2064 bShowEmpty( FALSE ),
2065 aSortInfo( EMPTY_STRING, sal_True, sheet::DataPilotFieldSortMode::NAME ), // default: sort by name
2066 nSortMeasure( 0 ),
2067 nAutoMeasure( 0 ),
2068 bEnableLayout( FALSE )
2069 {
2070 //! hold pSource
2071 // aSubTotals is empty
2072 }
2073
2074 ScDPLevel::~ScDPLevel()
2075 {
2076 //! release pSource
2077
2078 if ( pMembers )
2079 pMembers->release(); // ref-counted
2080 }
2081
2082 void ScDPLevel::EvaluateSortOrder()
2083 {
2084 switch (aSortInfo.Mode)
2085 {
2086 case sheet::DataPilotFieldSortMode::DATA:
2087 {
2088 // find index of measure (index among data dimensions)
2089
2090 String aDataFieldName = aSortInfo.Field;
2091 long nMeasureCount = pSource->GetDataDimensionCount();
2092 for (long nMeasure=0; nMeasure<nMeasureCount; nMeasure++)
2093 {
2094 if ( pSource->GetDataDimName(nMeasure) == aDataFieldName )
2095 {
2096 nSortMeasure = nMeasure;
2097 break;
2098 }
2099 }
2100
2101 //! error if not found?
2102 }
2103 break;
2104 case sheet::DataPilotFieldSortMode::MANUAL:
2105 case sheet::DataPilotFieldSortMode::NAME:
2106 {
2107 ScDPMembers* pLocalMembers = GetMembersObject();
2108 long nCount = pLocalMembers->getCount();
2109
2110 DBG_ASSERT( aGlobalOrder.empty(), "sort twice?" );
2111 aGlobalOrder.resize( nCount );
2112 for (long nPos=0; nPos<nCount; nPos++)
2113 aGlobalOrder[nPos] = nPos;
2114
2115 // allow manual or name (manual is always ascending)
2116 BOOL bAscending = ( aSortInfo.Mode == sheet::DataPilotFieldSortMode::MANUAL || aSortInfo.IsAscending );
2117 ScDPGlobalMembersOrder aComp( *this, bAscending );
2118 ::std::sort( aGlobalOrder.begin(), aGlobalOrder.end(), aComp );
2119 }
2120 break;
2121 }
2122
2123 if ( aAutoShowInfo.IsEnabled )
2124 {
2125 // find index of measure (index among data dimensions)
2126
2127 String aDataFieldName = aAutoShowInfo.DataField;
2128 long nMeasureCount = pSource->GetDataDimensionCount();
2129 for (long nMeasure=0; nMeasure<nMeasureCount; nMeasure++)
2130 {
2131 if ( pSource->GetDataDimName(nMeasure) == aDataFieldName )
2132 {
2133 nAutoMeasure = nMeasure;
2134 break;
2135 }
2136 }
2137
2138 //! error if not found?
2139 }
2140 }
2141
2142 void ScDPLevel::SetEnableLayout( BOOL bSet )
2143 {
2144 bEnableLayout = bSet;
2145 }
2146
2147 ScDPMembers* ScDPLevel::GetMembersObject()
2148 {
2149 if (!pMembers)
2150 {
2151 pMembers = new ScDPMembers( pSource, nDim, nHier, nLev );
2152 pMembers->acquire(); // ref-counted
2153 }
2154 return pMembers;
2155 }
2156
2157 uno::Reference<container::XNameAccess> SAL_CALL ScDPLevel::getMembers() throw(uno::RuntimeException)
2158 {
2159 return GetMembersObject();
2160 }
2161
2162 uno::Sequence<sheet::MemberResult> SAL_CALL ScDPLevel::getResults() throw(uno::RuntimeException)
2163 {
2164 const uno::Sequence<sheet::MemberResult>* pRes = pSource->GetMemberResults( this );
2165 if (pRes)
2166 return *pRes;
2167
2168 return uno::Sequence<sheet::MemberResult>(0); //! Error?
2169 }
2170
2171 ::rtl::OUString SAL_CALL ScDPLevel::getName() throw(uno::RuntimeException)
2172 {
2173 long nSrcDim = pSource->GetSourceDim( nDim );
2174 if ( pSource->IsDateDimension( nSrcDim ) )
2175 {
2176 String aRet; //! globstr-ID !!!!
2177
2178 if ( nHier == SC_DAPI_HIERARCHY_QUARTER )
2179 {
2180 switch ( nLev )
2181 {
2182 case SC_DAPI_LEVEL_YEAR:
2183 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Year"));
2184 break;
2185 case SC_DAPI_LEVEL_QUARTER:
2186 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Quarter"));
2187 break;
2188 case SC_DAPI_LEVEL_MONTH:
2189 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Month"));
2190 break;
2191 case SC_DAPI_LEVEL_DAY:
2192 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Day"));
2193 break;
2194 default:
2195 DBG_ERROR( "ScDPLevel::getName: unexpected level" );
2196 break;
2197 }
2198 }
2199 else if ( nHier == SC_DAPI_HIERARCHY_WEEK )
2200 {
2201 switch ( nLev )
2202 {
2203 case SC_DAPI_LEVEL_YEAR:
2204 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Year"));
2205 break;
2206 case SC_DAPI_LEVEL_WEEK:
2207 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Week"));
2208 break;
2209 case SC_DAPI_LEVEL_WEEKDAY:
2210 aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Weekday"));
2211 break;
2212 default:
2213 DBG_ERROR( "ScDPLevel::getName: unexpected level" );
2214 break;
2215 }
2216 }
2217 if (aRet.Len())
2218 return aRet;
2219 }
2220
2221 ScDPDimension* pDim = pSource->GetDimensionsObject()->getByIndex(nSrcDim);
2222 if (!pDim)
2223 return rtl::OUString();
2224
2225 return pDim->getName();
2226 }
2227
2228 void SAL_CALL ScDPLevel::setName( const ::rtl::OUString& /* rNewName */ ) throw(uno::RuntimeException)
2229 {
2230 DBG_ERROR("not implemented"); //! exception?
2231 }
2232
2233 uno::Sequence<sheet::GeneralFunction> ScDPLevel::getSubTotals() const
2234 {
2235 //! separate functions for settings and evaluation?
2236
2237 long nSrcDim = pSource->GetSourceDim( nDim );
2238 if ( !pSource->SubTotalAllowed( nSrcDim ) )
2239 return uno::Sequence<sheet::GeneralFunction>(0);
2240
2241 return aSubTotals;
2242 }
2243
2244 void ScDPLevel::setSubTotals(const uno::Sequence<sheet::GeneralFunction>& rNew)
2245 {
2246 aSubTotals = rNew;
2247 //! set "manual change" flag?
2248 }
2249
2250 BOOL ScDPLevel::getShowEmpty() const
2251 {
2252 return bShowEmpty;
2253 }
2254
2255 void ScDPLevel::setShowEmpty(BOOL bSet)
2256 {
2257 bShowEmpty = bSet;
2258 }
2259
2260 // XPropertySet
2261
2262 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPLevel::getPropertySetInfo()
2263 throw(uno::RuntimeException)
2264 {
2265 ScUnoGuard aGuard;
2266
2267 static SfxItemPropertyMap aDPLevelMap_Impl[] =
2268 {
2269 //! change type of AutoShow/Layout/Sorting to API struct when available
2270 {MAP_CHAR_LEN(SC_UNO_AUTOSHOW), 0, &getCppuType((sheet::DataPilotFieldAutoShowInfo*)0), 0, 0 },
2271 {MAP_CHAR_LEN(SC_UNO_LAYOUT), 0, &getCppuType((sheet::DataPilotFieldLayoutInfo*)0), 0, 0 },
2272 {MAP_CHAR_LEN(SC_UNO_SHOWEMPT), 0, &getBooleanCppuType(), 0, 0 },
2273 {MAP_CHAR_LEN(SC_UNO_SORTING), 0, &getCppuType((sheet::DataPilotFieldSortInfo*)0), 0, 0 },
2274 {MAP_CHAR_LEN(SC_UNO_SUBTOTAL), 0, &getCppuType((uno::Sequence<sheet::GeneralFunction>*)0), 0, 0 },
2275 {0,0,0,0,0,0}
2276 };
2277 static uno::Reference<beans::XPropertySetInfo> aRef =
2278 new SfxItemPropertySetInfo( aDPLevelMap_Impl );
2279 return aRef;
2280 }
2281
2282 void SAL_CALL ScDPLevel::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue )
2283 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
2284 lang::IllegalArgumentException, lang::WrappedTargetException,
2285 uno::RuntimeException)
2286 {
2287 String aNameStr = aPropertyName;
2288 if ( aNameStr.EqualsAscii( SC_UNO_SHOWEMPT ) )
2289 setShowEmpty( lcl_GetBoolFromAny( aValue ) );
2290 else if ( aNameStr.EqualsAscii( SC_UNO_SUBTOTAL ) )
2291 {
2292 uno::Sequence<sheet::GeneralFunction> aSeq;
2293 if ( aValue >>= aSeq )
2294 setSubTotals( aSeq );
2295 }
2296 else if ( aNameStr.EqualsAscii( SC_UNO_SORTING ) )
2297 aValue >>= aSortInfo;
2298 else if ( aNameStr.EqualsAscii( SC_UNO_AUTOSHOW ) )
2299 aValue >>= aAutoShowInfo;
2300 else if ( aNameStr.EqualsAscii( SC_UNO_LAYOUT ) )
2301 aValue >>= aLayoutInfo;
2302 else
2303 {
2304 DBG_ERROR("unknown property");
2305 //! THROW( UnknownPropertyException() );
2306 }
2307 }
2308
2309 uno::Any SAL_CALL ScDPLevel::getPropertyValue( const rtl::OUString& aPropertyName )
2310 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
2311 uno::RuntimeException)
2312 {
2313 uno::Any aRet;
2314 String aNameStr = aPropertyName;
2315 if ( aNameStr.EqualsAscii( SC_UNO_SHOWEMPT ) )
2316 lcl_SetBoolInAny( aRet, getShowEmpty() );
2317 else if ( aNameStr.EqualsAscii( SC_UNO_SUBTOTAL ) )
2318 {
2319 uno::Sequence<sheet::GeneralFunction> aSeq = getSubTotals(); //! avoid extra copy?
2320 aRet <<= aSeq;
2321 }
2322 else if ( aNameStr.EqualsAscii( SC_UNO_SORTING ) )
2323 aRet <<= aSortInfo;
2324 else if ( aNameStr.EqualsAscii( SC_UNO_AUTOSHOW ) )
2325 aRet <<= aAutoShowInfo;
2326 else if ( aNameStr.EqualsAscii( SC_UNO_LAYOUT ) )
2327 aRet <<= aLayoutInfo;
2328 else if (aNameStr.EqualsAscii(SC_UNO_LAYOUTNAME))
2329 {
2330 // read only property
2331 long nSrcDim = pSource->GetSourceDim(nDim);
2332 ScDPDimension* pDim = pSource->GetDimensionsObject()->getByIndex(nSrcDim);
2333 if (!pDim)
2334 return aRet;
2335
2336 const OUString* pLayoutName = pDim->GetLayoutName();
2337 if (!pLayoutName)
2338 return aRet;
2339
2340 aRet <<= *pLayoutName;
2341 }
2342 else
2343 {
2344 DBG_ERROR("unknown property");
2345 //! THROW( UnknownPropertyException() );
2346 }
2347 return aRet;
2348 }
2349
2350 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPLevel )
2351
2352 // -----------------------------------------------------------------------
2353
2354 USHORT lcl_GetFirstStringPos( const TypedScStrCollection& rColl )
2355 {
2356 USHORT nPos = 0;
2357 USHORT nCount = rColl.GetCount();
2358 while ( nPos < nCount && !rColl[nPos]->IsStrData() )
2359 ++nPos;
2360 return nPos;
2361 }
2362
2363 ScDPMembers::ScDPMembers( ScDPSource* pSrc, long nD, long nH, long nL ) :
2364 pSource( pSrc ),
2365 nDim( nD ),
2366 nHier( nH ),
2367 nLev( nL ),
2368 ppMbrs( NULL )
2369 {
2370 //! hold pSource
2371
2372 long nSrcDim = pSource->GetSourceDim( nDim );
2373 if ( pSource->IsDataLayoutDimension(nSrcDim) )
2374 nMbrCount = pSource->GetDataDimensionCount();
2375 else if ( nHier != SC_DAPI_HIERARCHY_FLAT && pSource->IsDateDimension( nSrcDim ) )
2376 {
2377 nMbrCount = 0;
2378 if ( nHier == SC_DAPI_HIERARCHY_QUARTER )
2379 {
2380 switch (nLev)
2381 {
2382 case SC_DAPI_LEVEL_YEAR:
2383 {
2384 const TypedScStrCollection& rStrings = pSource->GetData()->GetColumnEntries(nSrcDim);
2385 USHORT nFirstString = lcl_GetFirstStringPos( rStrings );
2386 if ( nFirstString > 0 )
2387 {
2388 double fFirstVal = rStrings[0]->GetValue();
2389 double fLastVal = rStrings[nFirstString-1]->GetValue();
2390
2391 long nFirstYear = pSource->GetData()->GetDatePart(
2392 (long)::rtl::math::approxFloor( fFirstVal ),
2393 nHier, nLev );
2394 long nLastYear = pSource->GetData()->GetDatePart(
2395 (long)::rtl::math::approxFloor( fLastVal ),
2396 nHier, nLev );
2397
2398 nMbrCount = nLastYear + 1 - nFirstYear;
2399 }
2400 else
2401 nMbrCount = 0; // no values
2402 }
2403 break;
2404 case SC_DAPI_LEVEL_QUARTER: nMbrCount = 4; break;
2405 case SC_DAPI_LEVEL_MONTH: nMbrCount = 12; break;
2406 case SC_DAPI_LEVEL_DAY: nMbrCount = 31; break;
2407 default:
2408 DBG_ERROR( "ScDPMembers::ScDPMembers: unexpected level" );
2409 break;
2410 }
2411 }
2412 else if ( nHier == SC_DAPI_HIERARCHY_WEEK )
2413 {
2414 switch (nLev)
2415 {
2416 case SC_DAPI_LEVEL_YEAR: nMbrCount = 1; break; //! get years from source
2417 case SC_DAPI_LEVEL_WEEK: nMbrCount = 53; break;
2418 case SC_DAPI_LEVEL_WEEKDAY: nMbrCount = 7; break;
2419 default:
2420 DBG_ERROR( "ScDPMembers::ScDPMembers: unexpected level" );
2421 break;
2422 }
2423 }
2424 }
2425 else
2426 {
2427 // StringCollection is cached at TableData
2428 const TypedScStrCollection& rStrings = pSource->GetData()->GetColumnEntries(nSrcDim);
2429 nMbrCount = rStrings.GetCount();
2430 }
2431 }
2432
2433 ScDPMembers::~ScDPMembers()
2434 {
2435 //! release pSource
2436
2437 if (ppMbrs)
2438 {
2439 for (long i=0; i<nMbrCount; i++)
2440 if ( ppMbrs[i] )
2441 ppMbrs[i]->release(); // ref-counted
2442 delete[] ppMbrs;
2443 }
2444 }
2445
2446 // XNameAccess implementation using getCount/getByIndex
2447
2448 sal_Int32 ScDPMembers::GetIndexFromName( const ::rtl::OUString& rName ) const
2449 {
2450 if ( aHashMap.empty() )
2451 {
2452 // store the index for each name
2453
2454 sal_Int32 nCount = getCount();
2455 for (sal_Int32 i=0; i<nCount; i++)
2456 aHashMap[ getByIndex(i)->getName() ] = i;
2457 }
2458
2459 ScDPMembersHashMap::const_iterator aIter = aHashMap.find( rName );
2460 if ( aIter != aHashMap.end() )
2461 return aIter->second; // found index
2462 else
2463 return -1; // not found
2464 }
2465
2466 uno::Any SAL_CALL ScDPMembers::getByName( const rtl::OUString& aName )
2467 throw(container::NoSuchElementException,
2468 lang::WrappedTargetException, uno::RuntimeException)
2469 {
2470 sal_Int32 nIndex = GetIndexFromName( aName );
2471 if ( nIndex >= 0 )
2472 {
2473 uno::Reference<container::XNamed> xNamed = getByIndex(nIndex);
2474 uno::Any aRet;
2475 aRet <<= xNamed;
2476 return aRet;
2477 }
2478
2479 throw container::NoSuchElementException();
2480 // return uno::Any();
2481 }
2482
2483 uno::Sequence<rtl::OUString> SAL_CALL ScDPMembers::getElementNames() throw(uno::RuntimeException)
2484 {
2485 // Return list of names in sorted order,
2486 // so it's displayed in that order in the field options dialog.
2487 // Sorting is done at the level object (parent of this).
2488
2489 ScDPLevel* pLevel = pSource->GetDimensionsObject()->getByIndex(nDim)->
2490 GetHierarchiesObject()->getByIndex(nHier)->GetLevelsObject()->getByIndex(nLev);
2491 pLevel->EvaluateSortOrder();
2492 const std::vector<sal_Int32>& rGlobalOrder = pLevel->GetGlobalOrder();
2493 bool bSort = !rGlobalOrder.empty();
2494
2495 long nCount = getCount();
2496 uno::Sequence<rtl::OUString> aSeq(nCount);
2497 rtl::OUString* pArr = aSeq.getArray();
2498 for (long i=0; i<nCount; i++)
2499 pArr[i] = getByIndex(bSort ? rGlobalOrder[i] : i)->getName();
2500 return aSeq;
2501 }
2502
2503 sal_Bool SAL_CALL ScDPMembers::hasByName( const rtl::OUString& aName ) throw(uno::RuntimeException)
2504 {
2505 return ( GetIndexFromName( aName ) >= 0 );
2506 }
2507
2508 uno::Type SAL_CALL ScDPMembers::getElementType() throw(uno::RuntimeException)
2509 {
2510 return getCppuType((uno::Reference<container::XNamed>*)0);
2511 }
2512
2513 sal_Bool SAL_CALL ScDPMembers::hasElements() throw(uno::RuntimeException)
2514 {
2515 return ( getCount() > 0 );
2516 }
2517
2518 // end of XNameAccess implementation
2519
2520 long ScDPMembers::getCount() const
2521 {
2522 return nMbrCount;
2523 }
2524
2525 long ScDPMembers::getMinMembers() const
2526 {
2527 // used in lcl_CountMinMembers
2528
2529 long nVisCount = 0;
2530 if ( ppMbrs )
2531 {
2532 for (long i=0; i<nMbrCount; i++)
2533 {
2534 // count only visible with details (default is true for both)
2535 const ScDPMember* pMbr = ppMbrs[i];
2536 if ( !pMbr || ( pMbr->getIsVisible() && pMbr->getShowDetails() ) )
2537 ++nVisCount;
2538 }
2539 }
2540 else
2541 nVisCount = nMbrCount; // default for all
2542
2543 return nVisCount;
2544 }
2545
2546 ScDPMember* ScDPMembers::getByIndex(long nIndex) const
2547 {
2548 // result of GetColumnEntries must not change between ScDPMembers ctor
2549 // and all calls to getByIndex
2550
2551 if ( nIndex >= 0 && nIndex < nMbrCount )
2552 {
2553 if ( !ppMbrs )
2554 {
2555 ((ScDPMembers*)this)->ppMbrs = new ScDPMember*[nMbrCount];
2556 for (long i=0; i<nMbrCount; i++)
2557 ppMbrs[i] = NULL;
2558 }
2559 if ( !ppMbrs[nIndex] )
2560 {
2561 ScDPMember* pNew;
2562 long nSrcDim = pSource->GetSourceDim( nDim );
2563 if ( pSource->IsDataLayoutDimension(nSrcDim) )
2564 {
2565 // empty name (never shown, not used for lookup)
2566 pNew = new ScDPMember( pSource, nDim, nHier, nLev,
2567 String(), 0.0, FALSE );
2568 }
2569 else if ( nHier != SC_DAPI_HIERARCHY_FLAT && pSource->IsDateDimension( nSrcDim ) )
2570 {
2571 long nVal = 0;
2572 String aName;
2573
2574 if ( nLev == SC_DAPI_LEVEL_YEAR ) // YEAR is in both hierarchies
2575 {
2576 //! cache year range here!
2577
2578 const TypedScStrCollection& rStrings = pSource->GetData()->GetColumnEntries(nSrcDim);
2579 double fFirstVal = rStrings[0]->GetValue();
2580 long nFirstYear = pSource->GetData()->GetDatePart(
2581 (long)::rtl::math::approxFloor( fFirstVal ),
2582 nHier, nLev );
2583
2584 nVal = nFirstYear + nIndex;
2585 }
2586 else if ( nHier == SC_DAPI_HIERARCHY_WEEK && nLev == SC_DAPI_LEVEL_WEEKDAY )
2587 {
2588 nVal = nIndex; // DayOfWeek is 0-based
2589 aName = ScGlobal::pCalendar->getDisplayName(
2590 ::com::sun::star::i18n::CalendarDisplayIndex::DAY,
2591 sal::static_int_cast<sal_Int16>(nVal), 0 );
2592 }
2593 else if ( nHier == SC_DAPI_HIERARCHY_QUARTER && nLev == SC_DAPI_LEVEL_MONTH )
2594 {
2595 nVal = nIndex; // Month is 0-based
2596 aName = ScGlobal::pCalendar->getDisplayName(
2597 ::com::sun::star::i18n::CalendarDisplayIndex::MONTH,
2598 sal::static_int_cast<sal_Int16>(nVal), 0 );
2599 }
2600 else
2601 nVal = nIndex + 1; // Quarter, Day, Week are 1-based
2602
2603 if ( !aName.Len() )
2604 aName = String::CreateFromInt32(nVal);
2605
2606 pNew = new ScDPMember( pSource, nDim, nHier, nLev, aName, nVal, TRUE );
2607 }
2608 else
2609 {
2610 const TypedScStrCollection& rStrings = pSource->GetData()->GetColumnEntries(nSrcDim);
2611 const TypedStrData* pData = rStrings[(USHORT)nIndex];
2612 pNew = new ScDPMember( pSource, nDim, nHier, nLev,
2613 pData->GetString(), pData->GetValue(), !pData->IsStrData() );
2614 }
2615 pNew->acquire(); // ref-counted
2616 ppMbrs[nIndex] = pNew;
2617 }
2618
2619 return ppMbrs[nIndex];
2620 }
2621
2622 return NULL; //! exception?
2623 }
2624
2625 // -----------------------------------------------------------------------
2626
2627 ScDPMember::ScDPMember( ScDPSource* pSrc, long nD, long nH, long nL,
2628 const String& rN, double fV, BOOL bHV ) :
2629 pSource( pSrc ),
2630 nDim( nD ),
2631 nHier( nH ),
2632 nLev( nL ),
2633 maData( rN, fV, bHV ),
2634 mpLayoutName(NULL),
2635 nPosition( -1 ),
2636 bVisible( TRUE ),
2637 bShowDet( TRUE )
2638 {
2639 //! hold pSource
2640 }
2641
2642 ScDPMember::~ScDPMember()
2643 {
2644 //! release pSource
2645 }
2646
2647 BOOL ScDPMember::IsNamedItem( const ScDPItemData& r ) const
2648 {
2649 long nSrcDim = pSource->GetSourceDim( nDim );
2650 if ( nHier != SC_DAPI_HIERARCHY_FLAT && pSource->IsDateDimension( nSrcDim ) && r.bHasValue )
2651 {
2652 long nComp = pSource->GetData()->GetDatePart(
2653 (long)::rtl::math::approxFloor( r.fValue ),
2654 nHier, nLev );
2655
2656 // fValue is converted from integer, so simple comparison works
2657 return nComp == maData.fValue;
2658 }
2659
2660 return r.IsCaseInsEqual( maData );
2661 }
2662
2663 sal_Int32 ScDPMember::Compare( const ScDPMember& rOther ) const
2664 {
2665 if ( nPosition >= 0 )
2666 {
2667 if ( rOther.nPosition >= 0 )
2668 {
2669 DBG_ASSERT( nPosition != rOther.nPosition, "same position for two members" );
2670 return ( nPosition < rOther.nPosition ) ? -1 : 1;
2671 }
2672 else
2673 {
2674 // only this has a position - members with specified positions come before those without
2675 return -1;
2676 }
2677 }
2678 else if ( rOther.nPosition >= 0 )
2679 {
2680 // only rOther has a position
2681 return 1;
2682 }
2683
2684 // no positions set - compare names
2685 return ScDPItemData::Compare( maData, rOther.maData );
2686 }
2687
2688 void ScDPMember::FillItemData( ScDPItemData& rData ) const
2689 {
2690 //! handle date hierarchy...
2691
2692 rData = maData;
2693 }
2694
2695 const OUString* ScDPMember::GetLayoutName() const
2696 {
2697 return mpLayoutName.get();
2698 }
2699
2700 String ScDPMember::GetNameStr() const
2701 {
2702 return maData.aString;
2703 }
2704
2705 ::rtl::OUString SAL_CALL ScDPMember::getName() throw(uno::RuntimeException)
2706 {
2707 return maData.aString;
2708 }
2709
2710 void SAL_CALL ScDPMember::setName( const ::rtl::OUString& /* rNewName */ ) throw(uno::RuntimeException)
2711 {
2712 DBG_ERROR("not implemented"); //! exception?
2713 }
2714
2715 BOOL ScDPMember::getIsVisible() const
2716 {
2717 return bVisible;
2718 }
2719
2720 void ScDPMember::setIsVisible(BOOL bSet)
2721 {
2722 bVisible = bSet;
2723 //! set "manual change" flag
2724 }
2725
2726 BOOL ScDPMember::getShowDetails() const
2727 {
2728 return bShowDet;
2729 }
2730
2731 void ScDPMember::setShowDetails(BOOL bSet)
2732 {
2733 bShowDet = bSet;
2734 //! set "manual change" flag
2735 }
2736
2737 sal_Int32 ScDPMember::getPosition() const
2738 {
2739 return nPosition;
2740 }
2741
2742 void ScDPMember::setPosition(sal_Int32 nNew)
2743 {
2744 nPosition = nNew;
2745 }
2746
2747 // XPropertySet
2748
2749 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPMember::getPropertySetInfo()
2750 throw(uno::RuntimeException)
2751 {
2752 ScUnoGuard aGuard;
2753
2754 static SfxItemPropertyMap aDPMemberMap_Impl[] =
2755 {
2756 {MAP_CHAR_LEN(SC_UNO_ISVISIBL), 0, &getBooleanCppuType(), 0, 0 },
2757 {MAP_CHAR_LEN(SC_UNO_POSITION), 0, &getCppuType((sal_Int32*)0), 0, 0 },
2758 {MAP_CHAR_LEN(SC_UNO_SHOWDETA), 0, &getBooleanCppuType(), 0, 0 },
2759 {MAP_CHAR_LEN(SC_UNO_LAYOUTNAME), 0, &getCppuType(static_cast<rtl::OUString*>(0)), 0, 0 },
2760 {0,0,0,0,0,0}
2761 };
2762 static uno::Reference<beans::XPropertySetInfo> aRef =
2763 new SfxItemPropertySetInfo( aDPMemberMap_Impl );
2764 return aRef;
2765 }
2766
2767 void SAL_CALL ScDPMember::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue )
2768 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
2769 lang::IllegalArgumentException, lang::WrappedTargetException,
2770 uno::RuntimeException)
2771 {
2772 String aNameStr = aPropertyName;
2773 if ( aNameStr.EqualsAscii( SC_UNO_ISVISIBL ) )
2774 setIsVisible( lcl_GetBoolFromAny( aValue ) );
2775 else if ( aNameStr.EqualsAscii( SC_UNO_SHOWDETA ) )
2776 setShowDetails( lcl_GetBoolFromAny( aValue ) );
2777 else if ( aNameStr.EqualsAscii( SC_UNO_POSITION ) )
2778 {
2779 sal_Int32 nInt = 0;
2780 if (aValue >>= nInt)
2781 setPosition( nInt );
2782 }
2783 else if (aNameStr.EqualsAscii(SC_UNO_LAYOUTNAME))
2784 {
2785 rtl::OUString aName;
2786 if (aValue >>= aName)
2787 mpLayoutName.reset(new rtl::OUString(aName));
2788 }
2789 else
2790 {
2791 DBG_ERROR("unknown property");
2792 //! THROW( UnknownPropertyException() );
2793 }
2794 }
2795
2796 uno::Any SAL_CALL ScDPMember::getPropertyValue( const rtl::OUString& aPropertyName )
2797 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
2798 uno::RuntimeException)
2799 {
2800 uno::Any aRet;
2801 String aNameStr = aPropertyName;
2802 if ( aNameStr.EqualsAscii( SC_UNO_ISVISIBL ) )
2803 lcl_SetBoolInAny( aRet, getIsVisible() );
2804 else if ( aNameStr.EqualsAscii( SC_UNO_SHOWDETA ) )
2805 lcl_SetBoolInAny( aRet, getShowDetails() );
2806 else if ( aNameStr.EqualsAscii( SC_UNO_POSITION ) )
2807 aRet <<= (sal_Int32) getPosition();
2808 else if (aNameStr.EqualsAscii(SC_UNO_LAYOUTNAME))
2809 aRet <<= mpLayoutName.get() ? *mpLayoutName : rtl::OUString();
2810 else
2811 {
2812 DBG_ERROR("unknown property");
2813 //! THROW( UnknownPropertyException() );
2814 }
2815 return aRet;
2816 }
2817
2818 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPMember )
2819
2820
2821
vba interoperability for OOo