sc/source/core/data/dpsave.cxx

   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: dpsave.cxx,v $
  10  * $Revision: 1.13.32.3 $
  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 // INCLUDE ---------------------------------------------------------------
  37
  38 #include "dpsave.hxx"
  39 #include "dpdimsave.hxx"
  40 #include "miscuno.hxx"
  41 #include "scerrors.hxx"
  42 #include "unonames.hxx"
  43 #include "global.hxx"
  44
  45 #include <tools/debug.hxx>
  46
  47 #include <com/sun/star/sheet/GeneralFunction.hpp>
  48 #include <com/sun/star/sheet/DataPilotFieldAutoShowInfo.hpp>
  49 #include <com/sun/star/sheet/DataPilotFieldLayoutInfo.hpp>
  50 #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
  51 #include <com/sun/star/sheet/DataPilotFieldReference.hpp>
  52 #include <com/sun/star/sheet/DataPilotFieldSortInfo.hpp>
  53 #include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
  54 #include <com/sun/star/sheet/TableFilterField.hpp>
  55 #include <com/sun/star/sheet/XHierarchiesSupplier.hpp>
  56 #include <com/sun/star/sheet/XLevelsSupplier.hpp>
  57 #include <com/sun/star/sheet/XMembersSupplier.hpp>
  58 #include <com/sun/star/container/XNamed.hpp>
  59 #include <com/sun/star/util/XCloneable.hpp>
  60
  61 #include <hash_map>
  62
  63 using namespace com::sun::star;
  64 using ::rtl::OUString;
  65 using ::rtl::OUStringHash;
  66 using ::std::hash_map;
  67 using ::std::auto_ptr;
  68
  69 // -----------------------------------------------------------------------
  70
  71 #define SC_DPSAVEMODE_NO                0
  72 #define SC_DPSAVEMODE_YES               1
  73 #define SC_DPSAVEMODE_DONTKNOW  2
  74
  75 // -----------------------------------------------------------------------
  76
  77 //!     move to a header file
  78 //! use names from unonames.hxx?
  79 #define DP_PROP_COLUMNGRAND                     "ColumnGrand"
  80 #define DP_PROP_FUNCTION                        "Function"
  81 #define DP_PROP_IGNOREEMPTY                     "IgnoreEmptyRows"
  82 #define DP_PROP_ISDATALAYOUT            "IsDataLayoutDimension"
  83 #define DP_PROP_ISVISIBLE                       "IsVisible"
  84 #define DP_PROP_ORIENTATION                     "Orientation"
  85 #define DP_PROP_REPEATIFEMPTY           "RepeatIfEmpty"
  86 #define DP_PROP_ROWGRAND                        "RowGrand"
  87 #define DP_PROP_SHOWDETAILS                     "ShowDetails"
  88 #define DP_PROP_SHOWEMPTY                       "ShowEmpty"
  89 #define DP_PROP_SUBTOTALS                       "SubTotals"
  90 #define DP_PROP_USEDHIERARCHY           "UsedHierarchy"
  91 #define DP_PROP_FILTER                          "Filter"
  92 #define DP_PROP_POSITION            "Position"
  93
  94 // -----------------------------------------------------------------------
  95
  96 void lcl_SetBoolProperty( const uno::Reference<beans::XPropertySet>& xProp,
  97                             const rtl::OUString& rName, sal_Bool bValue )
  98 {
  99     //! move to ScUnoHelpFunctions?
 100
 101     xProp->setPropertyValue( rName, uno::Any( &bValue, getBooleanCppuType() ) );
 102 }
 103
 104 // -----------------------------------------------------------------------
 105
 106 ScDPSaveMember::ScDPSaveMember(const String& rName) :
 107     aName( rName ),
 108     mpLayoutName(NULL),
 109     nVisibleMode( SC_DPSAVEMODE_DONTKNOW ),
 110     nShowDetailsMode( SC_DPSAVEMODE_DONTKNOW )
 111 {
 112 }
 113
 114 ScDPSaveMember::ScDPSaveMember(const ScDPSaveMember& r) :
 115     aName( r.aName ),
 116     mpLayoutName(NULL),
 117     nVisibleMode( r.nVisibleMode ),
 118     nShowDetailsMode( r.nShowDetailsMode )
 119 {
 120     if (r.mpLayoutName.get())
 121         mpLayoutName.reset(new OUString(*r.mpLayoutName));
 122 }
 123
 124 ScDPSaveMember::~ScDPSaveMember()
 125 {
 126 }
 127
 128 BOOL ScDPSaveMember::operator== ( const ScDPSaveMember& r ) const
 129 {
 130     if ( aName                    != r.aName                    ||
 131          nVisibleMode     != r.nVisibleMode             ||
 132          nShowDetailsMode != r.nShowDetailsMode )
 133         return FALSE;
 134
 135     return TRUE;
 136 }
 137
 138 BOOL ScDPSaveMember::HasIsVisible() const
 139 {
 140     return nVisibleMode != SC_DPSAVEMODE_DONTKNOW;
 141 }
 142
 143 void ScDPSaveMember::SetIsVisible(BOOL bSet)
 144 {
 145     nVisibleMode = bSet;
 146 }
 147
 148 BOOL ScDPSaveMember::HasShowDetails() const
 149 {
 150     return nShowDetailsMode != SC_DPSAVEMODE_DONTKNOW;
 151 }
 152
 153 void ScDPSaveMember::SetShowDetails(BOOL bSet)
 154 {
 155     nShowDetailsMode = bSet;
 156 }
 157
 158 void ScDPSaveMember::SetName( const String& rNew )
 159 {
 160     // Used only if the source member was renamed (groups).
 161     // For UI renaming of members, a layout name must be used.
 162
 163     aName = rNew;
 164 }
 165
 166 void ScDPSaveMember::SetLayoutName( const OUString& rName )
 167 {
 168     mpLayoutName.reset(new OUString(rName));
 169 }
 170
 171 const OUString* ScDPSaveMember::GetLayoutName() const
 172 {
 173     return mpLayoutName.get();
 174 }
 175
 176 void ScDPSaveMember::RemoveLayoutName()
 177 {
 178     mpLayoutName.reset(NULL);
 179 }
 180
 181 void ScDPSaveMember::WriteToSource( const uno::Reference<uno::XInterface>& xMember, sal_Int32 nPosition )
 182 {
 183     //  nothing to do?
 184     if ( nVisibleMode == SC_DPSAVEMODE_DONTKNOW && nShowDetailsMode == SC_DPSAVEMODE_DONTKNOW && nPosition < 0 )
 185         return;
 186
 187     uno::Reference<beans::XPropertySet> xMembProp( xMember, uno::UNO_QUERY );
 188     DBG_ASSERT( xMembProp.is(), "no properties at member" );
 189     if ( xMembProp.is() )
 190     {
 191         // exceptions are caught at ScDPSaveData::WriteToSource
 192
 193         if ( nVisibleMode != SC_DPSAVEMODE_DONTKNOW )
 194             lcl_SetBoolProperty( xMembProp,
 195                     rtl::OUString::createFromAscii(DP_PROP_ISVISIBLE), (BOOL)nVisibleMode );
 196
 197         if ( nShowDetailsMode != SC_DPSAVEMODE_DONTKNOW )
 198             lcl_SetBoolProperty( xMembProp,
 199                     rtl::OUString::createFromAscii(DP_PROP_SHOWDETAILS), (BOOL)nShowDetailsMode );
 200
 201         if (mpLayoutName.get())
 202         {
 203             try
 204             {
 205                 uno::Any any;
 206                 any <<= rtl::OUString(*mpLayoutName);
 207                 xMembProp->setPropertyValue(rtl::OUString::createFromAscii(SC_UNO_LAYOUTNAME), any);
 208             }
 209             catch (uno::Exception&)
 210             {
 211             }
 212         }
 213         if ( nPosition >= 0 )
 214         {
 215             try
 216             {
 217                 xMembProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_POSITION), uno::Any(nPosition) );
 218             }
 219             catch ( uno::Exception& )
 220             {
 221                 // position is optional - exception must be ignored
 222             }
 223         }
 224     }
 225 }
 226
 227 // -----------------------------------------------------------------------
 228
 229 ScDPSaveDimension::ScDPSaveDimension(const String& rName, BOOL bDataLayout) :
 230     aName( rName ),
 231     pSelectedPage( NULL ),
 232         mpLayoutName(NULL),
 233         mpSubtotalName(NULL),
 234     bIsDataLayout( bDataLayout ),
 235     bDupFlag( FALSE ),
 236     nOrientation( sheet::DataPilotFieldOrientation_HIDDEN ),
 237     nFunction( sheet::GeneralFunction_AUTO ),
 238     nUsedHierarchy( -1 ),
 239     nShowEmptyMode( SC_DPSAVEMODE_DONTKNOW ),
 240     bSubTotalDefault( TRUE ),
 241     nSubTotalCount( 0 ),
 242     pSubTotalFuncs( NULL ),
 243     pReferenceValue( NULL ),
 244     pSortInfo( NULL ),
 245     pAutoShowInfo( NULL ),
 246     pLayoutInfo( NULL )
 247 {
 248 }
 249
 250 ScDPSaveDimension::ScDPSaveDimension(const ScDPSaveDimension& r) :
 251     aName( r.aName ),
 252         mpLayoutName(NULL),
 253         mpSubtotalName(NULL),
 254     bIsDataLayout( r.bIsDataLayout ),
 255     bDupFlag( r.bDupFlag ),
 256     nOrientation( r.nOrientation ),
 257     nFunction( r.nFunction ),
 258     nUsedHierarchy( r.nUsedHierarchy ),
 259     nShowEmptyMode( r.nShowEmptyMode ),
 260     bSubTotalDefault( r.bSubTotalDefault ),
 261     nSubTotalCount( r.nSubTotalCount ),
 262     pSubTotalFuncs( NULL )
 263 {
 264     if ( nSubTotalCount && r.pSubTotalFuncs )
 265     {
 266         pSubTotalFuncs = new USHORT[nSubTotalCount];
 267         for (long nSub=0; nSub<nSubTotalCount; nSub++)
 268             pSubTotalFuncs[nSub] = r.pSubTotalFuncs[nSub];
 269     }
 270
 271     for (MemberList::const_iterator i=r.maMemberList.begin(); i != r.maMemberList.end() ; i++)
 272     {
 273         const String& rName =  (*i)->GetName();
 274         ScDPSaveMember* pNew = new ScDPSaveMember( **i );
 275         maMemberHash[rName] = pNew;
 276         maMemberList.push_back( pNew );
 277     }
 278     if (r.pReferenceValue)
 279         pReferenceValue = new sheet::DataPilotFieldReference( *(r.pReferenceValue) );
 280     else
 281         pReferenceValue = NULL;
 282     if (r.pSortInfo)
 283         pSortInfo = new sheet::DataPilotFieldSortInfo( *(r.pSortInfo) );
 284     else
 285         pSortInfo = NULL;
 286     if (r.pAutoShowInfo)
 287         pAutoShowInfo = new sheet::DataPilotFieldAutoShowInfo( *(r.pAutoShowInfo) );
 288     else
 289         pAutoShowInfo = NULL;
 290     if (r.pLayoutInfo)
 291         pLayoutInfo = new sheet::DataPilotFieldLayoutInfo( *(r.pLayoutInfo) );
 292     else
 293         pLayoutInfo = NULL;
 294     if (r.pSelectedPage)
 295         pSelectedPage = new String( *(r.pSelectedPage) );
 296     else
 297         pSelectedPage = NULL;
 298         if (r.mpLayoutName.get())
 299         mpLayoutName.reset(new OUString(*r.mpLayoutName));
 300         if (r.mpSubtotalName.get())
 301                 mpSubtotalName.reset(new OUString(*r.mpSubtotalName));
 302 }
 303
 304 ScDPSaveDimension::~ScDPSaveDimension()
 305 {
 306     for (MemberHash::const_iterator i=maMemberHash.begin(); i != maMemberHash.end() ; i++)
 307         delete i->second;
 308     delete pReferenceValue;
 309     delete pSortInfo;
 310     delete pAutoShowInfo;
 311     delete pLayoutInfo;
 312     delete pSelectedPage;
 313     delete [] pSubTotalFuncs;
 314 }
 315
 316 BOOL ScDPSaveDimension::operator== ( const ScDPSaveDimension& r ) const
 317 {
 318     if ( aName                    != r.aName                    ||
 319          bIsDataLayout    != r.bIsDataLayout    ||
 320          bDupFlag                 != r.bDupFlag                 ||
 321          nOrientation     != r.nOrientation             ||
 322          nFunction                != r.nFunction                ||
 323          nUsedHierarchy   != r.nUsedHierarchy   ||
 324          nShowEmptyMode   != r.nShowEmptyMode   ||
 325          bSubTotalDefault != r.bSubTotalDefault ||
 326          nSubTotalCount   != r.nSubTotalCount )
 327         return FALSE;
 328
 329     if ( nSubTotalCount && ( !pSubTotalFuncs || !r.pSubTotalFuncs ) )   // should not happen
 330         return FALSE;
 331
 332     long i;
 333     for (i=0; i<nSubTotalCount; i++)
 334         if ( pSubTotalFuncs[i] != r.pSubTotalFuncs[i] )
 335             return FALSE;
 336
 337     if (maMemberHash.size() != r.maMemberHash.size() )
 338         return FALSE;
 339
 340     MemberList::const_iterator a=maMemberList.begin();
 341     MemberList::const_iterator b=r.maMemberList.begin();
 342     for (; a != maMemberList.end() ; ++a, ++b)
 343         if (!(**a == **b))
 344             return FALSE;
 345
 346     return TRUE;
 347 }
 348
 349 void ScDPSaveDimension::AddMember(ScDPSaveMember* pMember)
 350 {
 351     const String & rName =  pMember->GetName();
 352     MemberHash::iterator aExisting = maMemberHash.find( rName );
 353     if ( aExisting == maMemberHash.end() )
 354     {
 355         std::pair< const String, ScDPSaveMember *> key( rName, pMember );
 356         maMemberHash.insert ( key );
 357     }
 358     else
 359     {
 360         maMemberList.remove( aExisting->second );
 361         delete aExisting->second;
 362         aExisting->second = pMember;
 363     }
 364     maMemberList.push_back( pMember );
 365 }
 366
 367 void ScDPSaveDimension::SetName( const String& rNew )
 368 {
 369     // Used only if the source dim was renamed (groups).
 370     // For UI renaming of dimensions, the layout name must be used.
 371
 372     aName = rNew;
 373 }
 374
 375 void ScDPSaveDimension::SetOrientation(USHORT nNew)
 376 {
 377     nOrientation = nNew;
 378 }
 379
 380 void ScDPSaveDimension::SetSubTotals(long nCount, const USHORT* pFuncs)
 381 {
 382     if (pSubTotalFuncs)
 383         delete [] pSubTotalFuncs;
 384     nSubTotalCount = nCount;
 385     if ( nCount && pFuncs )
 386     {
 387         pSubTotalFuncs = new USHORT[nCount];
 388         for (long i=0; i<nCount; i++)
 389             pSubTotalFuncs[i] = pFuncs[i];
 390     }
 391     else
 392         pSubTotalFuncs = NULL;
 393
 394     bSubTotalDefault = FALSE;
 395 }
 396
 397 void ScDPSaveDimension::SetShowEmpty(BOOL bSet)
 398 {
 399     nShowEmptyMode = bSet;
 400 }
 401
 402 void ScDPSaveDimension::SetFunction(USHORT nNew)
 403 {
 404     nFunction = nNew;
 405 }
 406
 407 void ScDPSaveDimension::SetUsedHierarchy(long nNew)
 408 {
 409     nUsedHierarchy = nNew;
 410 }
 411
 412 void ScDPSaveDimension::SetSubtotalName(const OUString& rName)
 413 {
 414         mpSubtotalName.reset(new OUString(rName));
 415 }
 416
 417 const OUString* ScDPSaveDimension::GetSubtotalName() const
 418 {
 419         return mpSubtotalName.get();
 420 }
 421
 422 bool ScDPSaveDimension::IsMemberNameInUse(const OUString& rName) const
 423 {
 424     MemberList::const_iterator itr = maMemberList.begin(), itrEnd = maMemberList.end();
 425     for (; itr != itrEnd; ++itr)
 426     {
 427         const ScDPSaveMember* pMem = *itr;
 428         if (rName.equalsIgnoreAsciiCase(pMem->GetName()))
 429             return true;
 430
 431         const OUString* pLayoutName = pMem->GetLayoutName();
 432         if (pLayoutName && rName.equalsIgnoreAsciiCase(*pLayoutName))
 433             return true;
 434     }
 435     return false;
 436 }
 437
 438 void ScDPSaveDimension::SetLayoutName(const OUString& rName)
 439 {
 440     mpLayoutName.reset(new OUString(rName));
 441 }
 442
 443 const OUString* ScDPSaveDimension::GetLayoutName() const
 444 {
 445         return mpLayoutName.get();
 446 }
 447
 448 void ScDPSaveDimension::RemoveLayoutName()
 449 {
 450     mpLayoutName.reset(NULL);
 451 }
 452
 453 void ScDPSaveDimension::SetReferenceValue(const sheet::DataPilotFieldReference* pNew)
 454 {
 455     delete pReferenceValue;
 456     if (pNew)
 457         pReferenceValue = new sheet::DataPilotFieldReference(*pNew);
 458     else
 459         pReferenceValue = NULL;
 460 }
 461
 462 void ScDPSaveDimension::SetSortInfo(const sheet::DataPilotFieldSortInfo* pNew)
 463 {
 464     delete pSortInfo;
 465     if (pNew)
 466         pSortInfo = new sheet::DataPilotFieldSortInfo(*pNew);
 467     else
 468         pSortInfo = NULL;
 469 }
 470
 471 void ScDPSaveDimension::SetAutoShowInfo(const sheet::DataPilotFieldAutoShowInfo* pNew)
 472 {
 473     delete pAutoShowInfo;
 474     if (pNew)
 475         pAutoShowInfo = new sheet::DataPilotFieldAutoShowInfo(*pNew);
 476     else
 477         pAutoShowInfo = NULL;
 478 }
 479
 480 void ScDPSaveDimension::SetLayoutInfo(const sheet::DataPilotFieldLayoutInfo* pNew)
 481 {
 482     delete pLayoutInfo;
 483     if (pNew)
 484         pLayoutInfo = new sheet::DataPilotFieldLayoutInfo(*pNew);
 485     else
 486         pLayoutInfo = NULL;
 487 }
 488
 489 void ScDPSaveDimension::SetCurrentPage( const String* pPage )
 490 {
 491     delete pSelectedPage;
 492     if (pPage)
 493         pSelectedPage = new String( *pPage );
 494     else
 495         pSelectedPage = NULL;
 496 }
 497
 498 BOOL ScDPSaveDimension::HasCurrentPage() const
 499 {
 500     return ( pSelectedPage != NULL );
 501 }
 502
 503 const String& ScDPSaveDimension::GetCurrentPage() const
 504 {
 505     if (pSelectedPage)
 506         return *pSelectedPage;
 507     return EMPTY_STRING;
 508 }
 509
 510 ScDPSaveMember* ScDPSaveDimension::GetExistingMemberByName(const String& rName)
 511 {
 512     MemberHash::const_iterator res = maMemberHash.find (rName);
 513     if (res != maMemberHash.end())
 514         return res->second;
 515     return NULL;
 516 }
 517
 518
 519 ScDPSaveMember* ScDPSaveDimension::GetMemberByName(const String& rName)
 520 {
 521     MemberHash::const_iterator res = maMemberHash.find (rName);
 522     if (res != maMemberHash.end())
 523         return res->second;
 524
 525     ScDPSaveMember* pNew = new ScDPSaveMember( rName );
 526     maMemberHash[rName] = pNew;
 527     maMemberList.push_back( pNew );
 528     return pNew;
 529 }
 530
 531 void ScDPSaveDimension::SetMemberPosition( const String& rName, sal_Int32 nNewPos )
 532 {
 533     ScDPSaveMember* pMember = GetMemberByName( rName );     // make sure it exists and is in the hash
 534
 535     maMemberList.remove( pMember );
 536
 537     MemberList::iterator aIter = maMemberList.begin();
 538     for (sal_Int32 i=0; i<nNewPos && aIter != maMemberList.end(); i++)
 539         ++aIter;
 540     maMemberList.insert( aIter, pMember );
 541 }
 542
 543 void ScDPSaveDimension::WriteToSource( const uno::Reference<uno::XInterface>& xDim )
 544 {
 545     uno::Reference<beans::XPropertySet> xDimProp( xDim, uno::UNO_QUERY );
 546     DBG_ASSERT( xDimProp.is(), "no properties at dimension" );
 547     if ( xDimProp.is() )
 548     {
 549         // exceptions are caught at ScDPSaveData::WriteToSource
 550         uno::Any aAny;
 551
 552         sheet::DataPilotFieldOrientation eOrient = (sheet::DataPilotFieldOrientation)nOrientation;
 553         aAny <<= eOrient;
 554         xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), aAny );
 555
 556         sheet::GeneralFunction eFunc = (sheet::GeneralFunction)nFunction;
 557         aAny <<= eFunc;
 558         xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_FUNCTION), aAny );
 559
 560         if ( nUsedHierarchy >= 0 )
 561         {
 562             aAny <<= (INT32)nUsedHierarchy;
 563             xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_USEDHIERARCHY), aAny );
 564         }
 565
 566         if ( pReferenceValue )
 567         {
 568             aAny <<= *pReferenceValue;
 569             xDimProp->setPropertyValue( rtl::OUString::createFromAscii(SC_UNO_REFVALUE), aAny );
 570         }
 571
 572         uno::Sequence<sheet::TableFilterField> aFilter;
 573         // set the selected page field only if the dimension is used as page dimension
 574         if ( pSelectedPage && nOrientation == sheet::DataPilotFieldOrientation_PAGE )
 575         {
 576             // single filter field: first field equal to selected string
 577             sheet::TableFilterField aField( sheet::FilterConnection_AND, 0,
 578                     sheet::FilterOperator_EQUAL, sal_False, 0.0, *pSelectedPage );
 579             aFilter = uno::Sequence<sheet::TableFilterField>( &aField, 1 );
 580         }
 581         // else keep empty sequence
 582         try
 583         {
 584             aAny <<= aFilter;
 585             xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_FILTER), aAny );
 586             if (mpLayoutName.get())
 587             {
 588                 aAny <<= *mpLayoutName;
 589                 xDimProp->setPropertyValue(rtl::OUString::createFromAscii(SC_UNO_LAYOUTNAME), aAny);
 590             }
 591
 592             const OUString* pSubTotalName = GetSubtotalName();
 593             if (pSubTotalName)
 594             {
 595                 // Custom subtotal name, with '?' being replaced by the visible field name later.
 596                 aAny <<= *pSubTotalName;
 597                 xDimProp->setPropertyValue(OUString::createFromAscii(SC_UNO_FIELD_SUBTOTALNAME), aAny);
 598             }
 599         }
 600         catch ( beans::UnknownPropertyException& )
 601         {
 602             // recent addition - allow source to not handle it (no error)
 603         }
 604     }
 605
 606     //  Level loop outside of maMemberList loop
 607     //  because SubTotals have to be set independently of known members
 608
 609     long nCount = maMemberHash.size();
 610
 611     long nHierCount = 0;
 612     uno::Reference<container::XIndexAccess> xHiers;
 613     uno::Reference<sheet::XHierarchiesSupplier> xHierSupp( xDim, uno::UNO_QUERY );
 614     if ( xHierSupp.is() )
 615     {
 616         uno::Reference<container::XNameAccess> xHiersName = xHierSupp->getHierarchies();
 617         xHiers = new ScNameToIndexAccess( xHiersName );
 618         nHierCount = xHiers->getCount();
 619     }
 620
 621     sal_Bool bHasHiddenMember = false;
 622
 623     for (long nHier=0; nHier<nHierCount; nHier++)
 624     {
 625         uno::Reference<uno::XInterface> xHierarchy = ScUnoHelpFunctions::AnyToInterface( xHiers->getByIndex(nHier) );
 626
 627         long nLevCount = 0;
 628         uno::Reference<container::XIndexAccess> xLevels;
 629         uno::Reference<sheet::XLevelsSupplier> xLevSupp( xHierarchy, uno::UNO_QUERY );
 630         if ( xLevSupp.is() )
 631         {
 632             uno::Reference<container::XNameAccess> xLevelsName = xLevSupp->getLevels();
 633             xLevels = new ScNameToIndexAccess( xLevelsName );
 634             nLevCount = xLevels->getCount();
 635         }
 636
 637         for (long nLev=0; nLev<nLevCount; nLev++)
 638         {
 639             uno::Reference<uno::XInterface> xLevel = ScUnoHelpFunctions::AnyToInterface( xLevels->getByIndex(nLev) );
 640             uno::Reference<beans::XPropertySet> xLevProp( xLevel, uno::UNO_QUERY );
 641             DBG_ASSERT( xLevProp.is(), "no properties at level" );
 642             if ( xLevProp.is() )
 643             {
 644                 uno::Any aAny;
 645                 if ( !bSubTotalDefault )
 646                 {
 647                     if ( !pSubTotalFuncs )
 648                         nSubTotalCount = 0;
 649
 650                     uno::Sequence<sheet::GeneralFunction> aSeq(nSubTotalCount);
 651                     sheet::GeneralFunction* pArray = aSeq.getArray();
 652                     for (long i=0; i<nSubTotalCount; i++)
 653                         pArray[i] = (sheet::GeneralFunction)pSubTotalFuncs[i];
 654                     aAny <<= aSeq;
 655                     xLevProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_SUBTOTALS), aAny );
 656                 }
 657                 if ( nShowEmptyMode != SC_DPSAVEMODE_DONTKNOW )
 658                     lcl_SetBoolProperty( xLevProp,
 659                         rtl::OUString::createFromAscii(DP_PROP_SHOWEMPTY), (BOOL)nShowEmptyMode );
 660
 661                 if ( pSortInfo )
 662                 {
 663                     aAny <<= *pSortInfo;
 664                     try
 665                     {
 666                         xLevProp->setPropertyValue( rtl::OUString::createFromAscii(SC_UNO_SORTING), aAny );
 667                     }
 668                     catch ( beans::UnknownPropertyException& )
 669                     {
 670                         // recent addition - allow source to not handle it (no error)
 671                     }
 672                 }
 673                 if ( pAutoShowInfo )
 674                 {
 675                     aAny <<= *pAutoShowInfo;
 676                     try
 677                     {
 678                         xLevProp->setPropertyValue( rtl::OUString::createFromAscii(SC_UNO_AUTOSHOW), aAny );
 679                     }
 680                     catch ( beans::UnknownPropertyException& )
 681                     {
 682                         // recent addition - allow source to not handle it (no error)
 683                     }
 684                 }
 685                 if ( pLayoutInfo )
 686                 {
 687                     aAny <<= *pLayoutInfo;
 688                     try
 689                     {
 690                         xLevProp->setPropertyValue( rtl::OUString::createFromAscii(SC_UNO_LAYOUT), aAny );
 691                     }
 692                     catch ( beans::UnknownPropertyException& )
 693                     {
 694                         // recent addition - allow source to not handle it (no error)
 695                     }
 696                 }
 697
 698                 // exceptions are caught at ScDPSaveData::WriteToSource
 699             }
 700
 701             if ( nCount > 0 )
 702             {
 703                 uno::Reference<sheet::XMembersSupplier> xMembSupp( xLevel, uno::UNO_QUERY );
 704                 if ( xMembSupp.is() )
 705                 {
 706                     uno::Reference<container::XNameAccess> xMembers = xMembSupp->getMembers();
 707                     if ( xMembers.is() )
 708                     {
 709                         sal_Int32 nPosition = -1;           // set position only in manual mode
 710                         if ( !pSortInfo || pSortInfo->Mode == sheet::DataPilotFieldSortMode::MANUAL )
 711                             nPosition = 0;
 712
 713                         for (MemberList::const_iterator i=maMemberList.begin(); i != maMemberList.end() ; i++)
 714                         {
 715                             ScDPSaveMember* pMember = *i;
 716                             if (!pMember->GetIsVisible())
 717                                 bHasHiddenMember = true;
 718                             rtl::OUString aMemberName = pMember->GetName();
 719                             if ( xMembers->hasByName( aMemberName ) )
 720                             {
 721                                 uno::Reference<uno::XInterface> xMemberInt = ScUnoHelpFunctions::AnyToInterface(
 722                                     xMembers->getByName( aMemberName ) );
 723                                                                 pMember->WriteToSource( xMemberInt, nPosition );
 724
 725                                 if ( nPosition >= 0 )
 726                                     ++nPosition;            // increase if initialized
 727                             }
 728                             // missing member is no error
 729                         }
 730                     }
 731                 }
 732             }
 733         }
 734     }
 735
 736     if (xDimProp.is())
 737     {
 738         uno::Any any;
 739         any <<= bHasHiddenMember;
 740         xDimProp->setPropertyValue(
 741             OUString::createFromAscii(SC_UNO_HAS_HIDDEN_MEMBER), any);
 742     }
 743 }
 744
 745 void ScDPSaveDimension::UpdateMemberVisibility(const hash_map<OUString, bool, OUStringHash>& rData)
 746 {
 747     typedef hash_map<OUString, bool, OUStringHash> DataMap;
 748     MemberList::iterator itrMem = maMemberList.begin(), itrMemEnd = maMemberList.end();
 749     for (; itrMem != itrMemEnd; ++itrMem)
 750     {
 751         ScDPSaveMember* pMem = *itrMem;
 752         const String& rMemName = pMem->GetName();
 753         DataMap::const_iterator itr = rData.find(rMemName);
 754         if (itr != rData.end())
 755             pMem->SetIsVisible(itr->second);
 756     }
 757 }
 758
 759 bool ScDPSaveDimension::HasInvisibleMember() const
 760 {
 761     MemberList::const_iterator itrMem = maMemberList.begin(), itrMemEnd = maMemberList.end();
 762     for (; itrMem != itrMemEnd; ++itrMem)
 763     {
 764         const ScDPSaveMember* pMem = *itrMem;
 765         if (!pMem->GetIsVisible())
 766             return true;
 767     }
 768     return false;
 769 }
 770
 771 // -----------------------------------------------------------------------
 772
 773 ScDPSaveData::ScDPSaveData() :
 774     pDimensionData( NULL ),
 775     nColumnGrandMode( SC_DPSAVEMODE_DONTKNOW ),
 776     nRowGrandMode( SC_DPSAVEMODE_DONTKNOW ),
 777     nIgnoreEmptyMode( SC_DPSAVEMODE_DONTKNOW ),
 778     nRepeatEmptyMode( SC_DPSAVEMODE_DONTKNOW ),
 779     bFilterButton( TRUE ),
 780     bDrillDown( TRUE ),
 781     mbDimensionMembersBuilt(false),
 782     mpGrandTotalName(NULL)
 783 {
 784 }
 785
 786 ScDPSaveData::ScDPSaveData(const ScDPSaveData& r) :
 787     nColumnGrandMode( r.nColumnGrandMode ),
 788     nRowGrandMode( r.nRowGrandMode ),
 789     nIgnoreEmptyMode( r.nIgnoreEmptyMode ),
 790     nRepeatEmptyMode( r.nRepeatEmptyMode ),
 791     bFilterButton( r.bFilterButton ),
 792     bDrillDown( r.bDrillDown ),
 793     mbDimensionMembersBuilt(r.mbDimensionMembersBuilt),
 794     mpGrandTotalName(NULL)
 795 {
 796     if ( r.pDimensionData )
 797         pDimensionData = new ScDPDimensionSaveData( *r.pDimensionData );
 798     else
 799         pDimensionData = NULL;
 800
 801     long nCount = r.aDimList.Count();
 802     for (long i=0; i<nCount; i++)
 803     {
 804         ScDPSaveDimension* pNew = new ScDPSaveDimension( *(ScDPSaveDimension*)r.aDimList.GetObject(i) );
 805         aDimList.Insert( pNew, LIST_APPEND );
 806     }
 807
 808     if (r.mpGrandTotalName.get())
 809         mpGrandTotalName.reset(new OUString(*r.mpGrandTotalName));
 810 }
 811
 812 ScDPSaveData& ScDPSaveData::operator= ( const ScDPSaveData& r )
 813 {
 814     if ( &r != this )
 815     {
 816         delete pDimensionData;
 817         if ( r.pDimensionData )
 818             pDimensionData = new ScDPDimensionSaveData( *r.pDimensionData );
 819         else
 820             pDimensionData = NULL;
 821
 822         nColumnGrandMode = r.nColumnGrandMode;
 823         nRowGrandMode    = r.nRowGrandMode;
 824         nIgnoreEmptyMode = r.nIgnoreEmptyMode;
 825         nRepeatEmptyMode = r.nRepeatEmptyMode;
 826         bFilterButton    = r.bFilterButton;
 827         bDrillDown       = r.bDrillDown;
 828         mbDimensionMembersBuilt = r.mbDimensionMembersBuilt;
 829
 830         //      remove old dimensions
 831
 832         long nCount = aDimList.Count();
 833         long i;
 834         for (i=0; i<nCount; i++)
 835             delete (ScDPSaveDimension*)aDimList.GetObject(i);
 836         aDimList.Clear();
 837
 838         //      copy new dimensions
 839
 840         nCount = r.aDimList.Count();
 841         for (i=0; i<nCount; i++)
 842         {
 843             ScDPSaveDimension* pNew =
 844                 new ScDPSaveDimension( *(ScDPSaveDimension*)r.aDimList.GetObject(i) );
 845             aDimList.Insert( pNew, LIST_APPEND );
 846         }
 847
 848         if (r.mpGrandTotalName.get())
 849             mpGrandTotalName.reset(new OUString(*r.mpGrandTotalName));
 850     }
 851     return *this;
 852 }
 853
 854 BOOL ScDPSaveData::operator== ( const ScDPSaveData& r ) const
 855 {
 856     if ( nColumnGrandMode != r.nColumnGrandMode ||
 857          nRowGrandMode    != r.nRowGrandMode    ||
 858          nIgnoreEmptyMode != r.nIgnoreEmptyMode ||
 859          nRepeatEmptyMode != r.nRepeatEmptyMode ||
 860          bFilterButton    != r.bFilterButton    ||
 861          bDrillDown       != r.bDrillDown ||
 862          mbDimensionMembersBuilt != r.mbDimensionMembersBuilt)
 863         return FALSE;
 864
 865     if ( pDimensionData || r.pDimensionData )
 866         if ( !pDimensionData || !r.pDimensionData || !( *pDimensionData == *r.pDimensionData ) )
 867             return FALSE;
 868
 869     ULONG nCount = aDimList.Count();
 870     if ( nCount != r.aDimList.Count() )
 871         return FALSE;
 872
 873     for (ULONG i=0; i<nCount; i++)
 874         if ( !( *(ScDPSaveDimension*)aDimList.GetObject(i) ==
 875                 *(ScDPSaveDimension*)r.aDimList.GetObject(i) ) )
 876             return FALSE;
 877
 878     if (mpGrandTotalName.get())
 879     {
 880         if (!r.mpGrandTotalName.get())
 881             return false;
 882         if (!mpGrandTotalName->equals(*r.mpGrandTotalName))
 883             return false;
 884     }
 885     else if (r.mpGrandTotalName.get())
 886         return false;
 887
 888     return TRUE;
 889 }
 890
 891 ScDPSaveData::~ScDPSaveData()
 892 {
 893     long nCount = aDimList.Count();
 894     for (long i=0; i<nCount; i++)
 895         delete (ScDPSaveDimension*)aDimList.GetObject(i);
 896     aDimList.Clear();
 897
 898     delete pDimensionData;
 899 }
 900
 901 void ScDPSaveData::SetGrandTotalName(const OUString& rName)
 902 {
 903     mpGrandTotalName.reset(new OUString(rName));
 904 }
 905
 906 const OUString* ScDPSaveData::GetGrandTotalName() const
 907 {
 908     return mpGrandTotalName.get();
 909 }
 910
 911 ScDPSaveDimension* ScDPSaveData::GetDimensionByName(const String& rName)
 912 {
 913     long nCount = aDimList.Count();
 914     for (long i=0; i<nCount; i++)
 915     {
 916         ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
 917         if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
 918             return pDim;
 919     }
 920     ScDPSaveDimension* pNew = new ScDPSaveDimension( rName, FALSE );
 921     aDimList.Insert( pNew, LIST_APPEND );
 922     return pNew;
 923 }
 924
 925 ScDPSaveDimension* ScDPSaveData::GetExistingDimensionByName(const String& rName) const
 926 {
 927     long nCount = aDimList.Count();
 928     for (long i=0; i<nCount; i++)
 929     {
 930         ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
 931         if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
 932             return pDim;
 933     }
 934     return NULL;                // don't create new
 935 }
 936
 937 ScDPSaveDimension* ScDPSaveData::GetNewDimensionByName(const String& rName)
 938 {
 939     long nCount = aDimList.Count();
 940     for (long i=0; i<nCount; i++)
 941     {
 942         ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
 943         if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
 944             return DuplicateDimension(rName);
 945     }
 946     ScDPSaveDimension* pNew = new ScDPSaveDimension( rName, FALSE );
 947     aDimList.Insert( pNew, LIST_APPEND );
 948     return pNew;
 949 }
 950
 951 ScDPSaveDimension* ScDPSaveData::GetDataLayoutDimension()
 952 {
 953     ScDPSaveDimension* pDim = GetExistingDataLayoutDimension();
 954     if (pDim)
 955         return pDim;
 956
 957         ScDPSaveDimension* pNew = new ScDPSaveDimension( String(), TRUE );
 958         aDimList.Insert( pNew, LIST_APPEND );
 959         return pNew;
 960 }
 961
 962 ScDPSaveDimension* ScDPSaveData::GetExistingDataLayoutDimension() const
 963 {
 964     ULONG nCount = aDimList.Count();
 965     for (ULONG i=0; i<nCount; i++)
 966     {
 967         ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
 968         if ( pDim->IsDataLayout() )
 969             return pDim;
 970     }
 971     return NULL;
 972 }
 973
 974 ScDPSaveDimension* ScDPSaveData::DuplicateDimension(const String& rName)
 975 {
 976     //  always insert new
 977     //! check if dimension is there?
 978
 979     ScDPSaveDimension* pOld = GetDimensionByName( rName );
 980     ScDPSaveDimension* pNew = new ScDPSaveDimension( *pOld );
 981     pNew->SetDupFlag( TRUE );
 982     aDimList.Insert( pNew, LIST_APPEND );
 983     return pNew;
 984 }
 985
 986 void ScDPSaveData::RemoveDimensionByName(const String& rName)
 987 {
 988     long nCount = aDimList.Count();
 989     for (long i=0; i<nCount; i++)
 990     {
 991         ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
 992         if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
 993         {
 994             delete pDim;
 995             aDimList.Remove(i);
 996             break;
 997         }
 998     }
 999 }
1000
1001 ScDPSaveDimension& ScDPSaveData::DuplicateDimension( const ScDPSaveDimension& rDim )
1002 {
1003     ScDPSaveDimension* pNew = new ScDPSaveDimension( rDim );
1004     pNew->SetDupFlag( TRUE );
1005     aDimList.Insert( pNew, LIST_APPEND );
1006     return *pNew;
1007 }
1008
1009 ScDPSaveDimension* ScDPSaveData::GetInnermostDimension(USHORT nOrientation)
1010 {
1011     //  return the innermost dimension for the given orientation,
1012     //  excluding data layout dimension
1013
1014     ScDPSaveDimension* pInner = NULL;
1015     long nCount = aDimList.Count();
1016     for (long i=0; i<nCount; i++)
1017     {
1018         ScDPSaveDimension* pDim = static_cast<ScDPSaveDimension*>(aDimList.GetObject(i));
1019         if ( pDim->GetOrientation() == nOrientation && !pDim->IsDataLayout() )
1020             pInner = pDim;
1021     }
1022     return pInner;      // the last matching one
1023 }
1024
1025 ScDPSaveDimension* ScDPSaveData::GetFirstDimension(sheet::DataPilotFieldOrientation eOrientation)
1026 {
1027     long nCount = aDimList.Count();
1028     for (long i = 0; i < nCount; ++i)
1029     {
1030         ScDPSaveDimension* pDim = static_cast<ScDPSaveDimension*>(aDimList.GetObject(i));
1031         if (pDim->GetOrientation() == eOrientation && !pDim->IsDataLayout())
1032             return pDim;
1033     }
1034     return NULL;
1035 }
1036
1037 long ScDPSaveData::GetDataDimensionCount() const
1038 {
1039     long nDataCount = 0;
1040
1041     long nCount = aDimList.Count();
1042     for (long i=0; i<nCount; i++)
1043     {
1044         const ScDPSaveDimension* pDim = static_cast<const ScDPSaveDimension*>(aDimList.GetObject(i));
1045         if ( pDim->GetOrientation() == sheet::DataPilotFieldOrientation_DATA )
1046             ++nDataCount;
1047     }
1048
1049     return nDataCount;
1050 }
1051
1052 void ScDPSaveData::SetPosition( ScDPSaveDimension* pDim, long nNew )
1053 {
1054     //  position (nNew) is counted within dimensions of the same orientation
1055
1056     USHORT nOrient = pDim->GetOrientation();
1057
1058     aDimList.Remove( pDim );
1059     ULONG nCount = aDimList.Count();            // after remove
1060
1061     ULONG nInsPos = 0;
1062     while ( nNew > 0 && nInsPos < nCount )
1063     {
1064         if ( ((ScDPSaveDimension*)aDimList.GetObject(nInsPos))->GetOrientation() == nOrient )
1065             --nNew;
1066         ++nInsPos;
1067     }
1068
1069     aDimList.Insert( pDim, nInsPos );
1070 }
1071
1072 void ScDPSaveData::SetColumnGrand(BOOL bSet)
1073 {
1074     nColumnGrandMode = bSet;
1075 }
1076
1077 void ScDPSaveData::SetRowGrand(BOOL bSet)
1078 {
1079     nRowGrandMode = bSet;
1080 }
1081
1082 void ScDPSaveData::SetIgnoreEmptyRows(BOOL bSet)
1083 {
1084     nIgnoreEmptyMode = bSet;
1085 }
1086
1087 void ScDPSaveData::SetRepeatIfEmpty(BOOL bSet)
1088 {
1089     nRepeatEmptyMode = bSet;
1090 }
1091
1092 void ScDPSaveData::SetFilterButton(BOOL bSet)
1093 {
1094     bFilterButton = bSet;
1095 }
1096
1097 void ScDPSaveData::SetDrillDown(BOOL bSet)
1098 {
1099     bDrillDown = bSet;
1100 }
1101
1102 void lcl_ResetOrient( const uno::Reference<sheet::XDimensionsSupplier>& xSource )
1103 {
1104     sheet::DataPilotFieldOrientation eOrient = sheet::DataPilotFieldOrientation_HIDDEN;
1105
1106     uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
1107     uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
1108     long nIntCount = xIntDims->getCount();
1109     for (long nIntDim=0; nIntDim<nIntCount; nIntDim++)
1110     {
1111         uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) );
1112         uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
1113         if (xDimProp.is())
1114         {
1115             uno::Any aAny;
1116             aAny <<= eOrient;
1117             xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), aAny );
1118         }
1119     }
1120 }
1121
1122 void ScDPSaveData::WriteToSource( const uno::Reference<sheet::XDimensionsSupplier>& xSource )
1123 {
1124     if (!xSource.is())
1125         return;
1126
1127     //  source options must be first!
1128
1129     uno::Reference<beans::XPropertySet> xSourceProp( xSource, uno::UNO_QUERY );
1130     DBG_ASSERT( xSourceProp.is(), "no properties at source" );
1131     if ( xSourceProp.is() )
1132     {
1133         //      source options are not available for external sources
1134         //!     use XPropertySetInfo to test for availability?
1135
1136         try
1137         {
1138             if ( nIgnoreEmptyMode != SC_DPSAVEMODE_DONTKNOW )
1139                 lcl_SetBoolProperty( xSourceProp,
1140                     rtl::OUString::createFromAscii(DP_PROP_IGNOREEMPTY), (BOOL)nIgnoreEmptyMode );
1141             if ( nRepeatEmptyMode != SC_DPSAVEMODE_DONTKNOW )
1142                 lcl_SetBoolProperty( xSourceProp,
1143                     rtl::OUString::createFromAscii(DP_PROP_REPEATIFEMPTY), (BOOL)nRepeatEmptyMode );
1144
1145             const OUString* pGrandTotalName = GetGrandTotalName();
1146             if (pGrandTotalName)
1147             {
1148                 uno::Any any;
1149                 any <<= *pGrandTotalName;
1150                 xSourceProp->setPropertyValue(OUString::createFromAscii(SC_UNO_GRANDTOTAL_NAME), any);
1151             }
1152         }
1153         catch(uno::Exception&)
1154         {
1155             // no error
1156         }
1157     }
1158
1159     // exceptions in the other calls are errors
1160     try
1161     {
1162         //      reset all orientations
1163         //!     "forgetSettings" or similar at source ?????
1164         //!     reset all duplicated dimensions, or reuse them below !!!
1165
1166         lcl_ResetOrient( xSource );
1167
1168         long nCount = aDimList.Count();
1169         for (long i=0; i<nCount; i++)
1170         {
1171             ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
1172             rtl::OUString aName = pDim->GetName();
1173             BOOL bData = pDim->IsDataLayout();
1174
1175             //! getByName for ScDPSource, including DataLayoutDimension !!!!!!!!
1176
1177             uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
1178             uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
1179             long nIntCount = xIntDims->getCount();
1180             BOOL bFound = FALSE;
1181             for (long nIntDim=0; nIntDim<nIntCount && !bFound; nIntDim++)
1182             {
1183                 uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) );
1184                 if ( bData )
1185                 {
1186                     uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
1187                     if ( xDimProp.is() )
1188                     {
1189                         bFound = ScUnoHelpFunctions::GetBoolProperty( xDimProp,
1190                                     rtl::OUString::createFromAscii(DP_PROP_ISDATALAYOUT) );
1191                         //!     error checking -- is "IsDataLayoutDimension" property required??
1192                     }
1193                 }
1194                 else
1195                 {
1196                     uno::Reference<container::XNamed> xDimName( xIntDim, uno::UNO_QUERY );
1197                     if ( xDimName.is() && xDimName->getName() == aName )
1198                         bFound = TRUE;
1199                 }
1200
1201                 if ( bFound )
1202                 {
1203                     if ( pDim->GetDupFlag() )
1204                     {
1205                         String aNewName = pDim->GetName();
1206
1207                         // different name for each duplication of a (real) dimension...
1208                         for (long j=0; j<=i; j++)       //! Test !!!!!!
1209                             aNewName += '*';            //! modify name at creation of SaveDimension
1210
1211                         uno::Reference<util::XCloneable> xCloneable( xIntDim, uno::UNO_QUERY );
1212                         DBG_ASSERT( xCloneable.is(), "cannot clone dimension" );
1213                         if (xCloneable.is())
1214                         {
1215                             uno::Reference<util::XCloneable> xNew = xCloneable->createClone();
1216                             uno::Reference<container::XNamed> xNewName( xNew, uno::UNO_QUERY );
1217                             if (xNewName.is())
1218                             {
1219                                 xNewName->setName( aNewName );
1220                                 pDim->WriteToSource( xNew );
1221                             }
1222                         }
1223                     }
1224                     else
1225                         pDim->WriteToSource( xIntDim );
1226                 }
1227             }
1228             DBG_ASSERT(bFound, "WriteToSource: Dimension not found");
1229         }
1230
1231         if ( xSourceProp.is() )
1232         {
1233             if ( nColumnGrandMode != SC_DPSAVEMODE_DONTKNOW )
1234                 lcl_SetBoolProperty( xSourceProp,
1235                     rtl::OUString::createFromAscii(DP_PROP_COLUMNGRAND), (BOOL)nColumnGrandMode );
1236             if ( nRowGrandMode != SC_DPSAVEMODE_DONTKNOW )
1237                 lcl_SetBoolProperty( xSourceProp,
1238                     rtl::OUString::createFromAscii(DP_PROP_ROWGRAND), (BOOL)nRowGrandMode );
1239         }
1240     }
1241     catch(uno::Exception&)
1242     {
1243         DBG_ERROR("exception in WriteToSource");
1244     }
1245 }
1246
1247 BOOL ScDPSaveData::IsEmpty() const
1248 {
1249     long nCount = aDimList.Count();
1250     for (long i=0; i<nCount; i++)
1251     {
1252         ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
1253         if ( pDim->GetOrientation() != sheet::DataPilotFieldOrientation_HIDDEN && !pDim->IsDataLayout() )
1254             return FALSE;
1255     }
1256     return TRUE;        // no entries that are not hidden
1257 }
1258
1259 ScDPDimensionSaveData* ScDPSaveData::GetDimensionData()
1260 {
1261     if (!pDimensionData)
1262         pDimensionData = new ScDPDimensionSaveData;
1263     return pDimensionData;
1264 }
1265
1266 void ScDPSaveData::SetDimensionData( const ScDPDimensionSaveData* pNew )
1267 {
1268     delete pDimensionData;
1269     if ( pNew )
1270         pDimensionData = new ScDPDimensionSaveData( *pNew );
1271     else
1272         pDimensionData = NULL;
1273 }
1274
1275 void ScDPSaveData::BuildAllDimensionMembers(ScDPTableData* pData)
1276 {
1277     if (mbDimensionMembersBuilt)
1278         return;
1279
1280     // First, build a dimension name-to-index map.
1281     typedef hash_map<OUString, long, ::rtl::OUStringHash> NameIndexMap;
1282     NameIndexMap aMap;
1283     long nColCount = pData->GetColumnCount();
1284     for (long i = 0; i < nColCount; ++i)
1285         aMap.insert( NameIndexMap::value_type(pData->getDimensionName(i), i));
1286
1287     NameIndexMap::const_iterator itrEnd = aMap.end();
1288
1289     sal_uInt32 n = aDimList.Count();
1290     for (sal_uInt32 i = 0; i < n; ++i)
1291     {
1292         ScDPSaveDimension* pDim = static_cast<ScDPSaveDimension*>(aDimList.GetObject(i));
1293         const String& rDimName = pDim->GetName();
1294         if (!rDimName.Len())
1295             // empty dimension name.  It must be data layout.
1296             continue;
1297
1298         NameIndexMap::const_iterator itr = aMap.find(rDimName);
1299         if (itr == itrEnd)
1300             // dimension name not in the data.  This should never happen!
1301             continue;
1302
1303         long nDimIndex = itr->second;
1304         const TypedScStrCollection& rMembers = pData->GetColumnEntries(nDimIndex);
1305         sal_uInt16 nMemberCount = rMembers.GetCount();
1306         for (sal_uInt16 j = 0; j < nMemberCount; ++j)
1307         {
1308             const String& rMemName = rMembers[j]->GetString();
1309             if (pDim->GetExistingMemberByName(rMemName))
1310                 // this member instance already exists.  nothing to do.
1311                 continue;
1312
1313             auto_ptr<ScDPSaveMember> pNewMember(new ScDPSaveMember(rMemName));
1314             pNewMember->SetIsVisible(true);
1315             pDim->AddMember(pNewMember.release());
1316         }
1317     }
1318
1319     mbDimensionMembersBuilt = true;
1320 }
1321
1322 bool ScDPSaveData::HasInvisibleMember(const OUString& rDimName) const
1323 {
1324     ScDPSaveDimension* pDim = GetExistingDimensionByName(rDimName);
1325     if (!pDim)
1326         return false;
1327
1328     return pDim->HasInvisibleMember();
1329 }