xref: /aoo41x/main/sc/source/core/data/dpsave.cxx (revision 3d762826)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"



// INCLUDE ---------------------------------------------------------------

#include "dpsave.hxx"
#include "dpdimsave.hxx"
#include "dpobject.hxx"     // GetMemberNames used in BuildAllDimensionMembersFromSource
#include "miscuno.hxx"
#include "scerrors.hxx"
#include "unonames.hxx"
#include "global.hxx"

#include <tools/debug.hxx>

#include <com/sun/star/sheet/GeneralFunction.hpp>
#include <com/sun/star/sheet/DataPilotFieldAutoShowInfo.hpp>
#include <com/sun/star/sheet/DataPilotFieldLayoutInfo.hpp>
#include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
#include <com/sun/star/sheet/DataPilotFieldReference.hpp>
#include <com/sun/star/sheet/DataPilotFieldSortInfo.hpp>
#include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
#include <com/sun/star/sheet/TableFilterField.hpp>
#include <com/sun/star/sheet/XHierarchiesSupplier.hpp>
#include <com/sun/star/sheet/XLevelsSupplier.hpp>
#include <com/sun/star/sheet/XMembersSupplier.hpp>
#include <com/sun/star/container/XNamed.hpp>
#include <com/sun/star/util/XCloneable.hpp>
// Wang Xu Ming -- 2009-8-17
// DataPilot Migration - Cache&&Performance
#include "dptabsrc.hxx"
#include "dpglobal.hxx"
using namespace ScDPGlobal;
#ifndef _COM_SUN_STAR_SHEET_DATAPILOTFIELDREFERENCETYPE_HPP_
#include <com/sun/star/sheet/DataPilotFieldReferenceType.hpp>
#endif
#ifndef _COM_SUN_STAR_SHEET_DATAPILOTFIELDREFERENCEITEMTYPE_HPP_
#include <com/sun/star/sheet/DataPilotFieldReferenceItemType.hpp>
#endif
using namespace com::sun::star::sheet;
// End Comments

#include <hash_map>

using namespace com::sun::star;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Any;
using ::rtl::OUString;
using ::rtl::OUStringHash;
using ::std::hash_map;
using ::std::auto_ptr;

// -----------------------------------------------------------------------

#define SC_DPSAVEMODE_NO		0
#define SC_DPSAVEMODE_YES		1
#define SC_DPSAVEMODE_DONTKNOW	2

// -----------------------------------------------------------------------

void lcl_SetBoolProperty( const uno::Reference<beans::XPropertySet>& xProp,
							const rtl::OUString& rName, sal_Bool bValue )
{
	//!	move to ScUnoHelpFunctions?

	xProp->setPropertyValue( rName, uno::Any( &bValue, getBooleanCppuType() ) );
}

// -----------------------------------------------------------------------

ScDPSaveMember::ScDPSaveMember(const String& rName) :
	aName( rName ),
    mpLayoutName(NULL),
	nVisibleMode( SC_DPSAVEMODE_DONTKNOW ),
	nShowDetailsMode( SC_DPSAVEMODE_DONTKNOW )
{
}

ScDPSaveMember::ScDPSaveMember(const ScDPSaveMember& r) :
	aName( r.aName ),
    mpLayoutName(NULL),
	nVisibleMode( r.nVisibleMode ),
	nShowDetailsMode( r.nShowDetailsMode )
{
    if (r.mpLayoutName.get())
        mpLayoutName.reset(new OUString(*r.mpLayoutName));
}

ScDPSaveMember::~ScDPSaveMember()
{
}

sal_Bool ScDPSaveMember::operator== ( const ScDPSaveMember& r ) const
{
	if ( aName			  != r.aName 			||
		 nVisibleMode	  != r.nVisibleMode		||
		 nShowDetailsMode != r.nShowDetailsMode )
		return sal_False;

	return sal_True;
}

sal_Bool ScDPSaveMember::HasIsVisible() const
{
    return nVisibleMode != SC_DPSAVEMODE_DONTKNOW;
}

void ScDPSaveMember::SetIsVisible(sal_Bool bSet)
{
	nVisibleMode = bSet;
}

sal_Bool ScDPSaveMember::HasShowDetails() const
{
    return nShowDetailsMode != SC_DPSAVEMODE_DONTKNOW;
}

void ScDPSaveMember::SetShowDetails(sal_Bool bSet)
{
	nShowDetailsMode = bSet;
}

void ScDPSaveMember::SetName( const String& rNew )
{
    // Used only if the source member was renamed (groups).
    // For UI renaming of members, a layout name must be used.

    aName = rNew;
}

void ScDPSaveMember::SetLayoutName( const OUString& rName )
{
    mpLayoutName.reset(new OUString(rName));
}

const OUString* ScDPSaveMember::GetLayoutName() const
{
    return mpLayoutName.get();
}

void ScDPSaveMember::RemoveLayoutName()
{
    mpLayoutName.reset();
}

void ScDPSaveMember::WriteToSource( const uno::Reference<uno::XInterface>& xMember, sal_Int32 nPosition )
{
	uno::Reference<beans::XPropertySet> xMembProp( xMember, uno::UNO_QUERY );
	DBG_ASSERT( xMembProp.is(), "no properties at member" );
	if ( xMembProp.is() )
	{
		// exceptions are caught at ScDPSaveData::WriteToSource

		if ( nVisibleMode != SC_DPSAVEMODE_DONTKNOW )
			lcl_SetBoolProperty( xMembProp,
					rtl::OUString::createFromAscii(DP_PROP_ISVISIBLE), (sal_Bool)nVisibleMode );

		if ( nShowDetailsMode != SC_DPSAVEMODE_DONTKNOW )
			lcl_SetBoolProperty( xMembProp,
					rtl::OUString::createFromAscii(DP_PROP_SHOWDETAILS), (sal_Bool)nShowDetailsMode );

        if (mpLayoutName.get())
            ScUnoHelpFunctions::SetOptionalPropertyValue(xMembProp, SC_UNO_LAYOUTNAME, *mpLayoutName);

        if ( nPosition >= 0 )
            ScUnoHelpFunctions::SetOptionalPropertyValue(xMembProp, DP_PROP_POSITION, nPosition);
	}
}

// -----------------------------------------------------------------------

ScDPSaveDimension::ScDPSaveDimension(const String& rName, sal_Bool bDataLayout) :
	aName( rName ),
	pSelectedPage( NULL ),
	mpLayoutName(NULL),
	mpSubtotalName(NULL),
	bIsDataLayout( bDataLayout ),
	bDupFlag( sal_False ),
	nOrientation( sheet::DataPilotFieldOrientation_HIDDEN ),
	nFunction( sheet::GeneralFunction_AUTO ),
	nUsedHierarchy( -1 ),
	nShowEmptyMode( SC_DPSAVEMODE_DONTKNOW ),
	bSubTotalDefault( sal_True ),
	nSubTotalCount( 0 ),
	pSubTotalFuncs( NULL ),
	pReferenceValue( NULL ),
	pSortInfo( NULL ),
	pAutoShowInfo( NULL ),
	pLayoutInfo( NULL )
{
}

ScDPSaveDimension::ScDPSaveDimension(const ScDPSaveDimension& r) :
	aName( r.aName ),
	mpLayoutName(NULL),
	mpSubtotalName(NULL),
	bIsDataLayout( r.bIsDataLayout ),
	bDupFlag( r.bDupFlag ),
	nOrientation( r.nOrientation ),
	nFunction( r.nFunction ),
	nUsedHierarchy( r.nUsedHierarchy ),
	nShowEmptyMode( r.nShowEmptyMode ),
	bSubTotalDefault( r.bSubTotalDefault ),
	nSubTotalCount( r.nSubTotalCount ),
	pSubTotalFuncs( NULL )
{
	if ( nSubTotalCount && r.pSubTotalFuncs )
	{
		pSubTotalFuncs = new sal_uInt16[nSubTotalCount];
		for (long nSub=0; nSub<nSubTotalCount; nSub++)
			pSubTotalFuncs[nSub] = r.pSubTotalFuncs[nSub];
	}

	for (MemberList::const_iterator i=r.maMemberList.begin(); i != r.maMemberList.end() ; i++)
	{
		const String& rName =  (*i)->GetName();
		ScDPSaveMember* pNew = new ScDPSaveMember( **i );
		maMemberHash[rName] = pNew;
		maMemberList.push_back( pNew );
	}
	if (r.pReferenceValue)
		pReferenceValue = new sheet::DataPilotFieldReference( *(r.pReferenceValue) );
	else
		pReferenceValue = NULL;
    if (r.pSortInfo)
        pSortInfo = new sheet::DataPilotFieldSortInfo( *(r.pSortInfo) );
    else
        pSortInfo = NULL;
    if (r.pAutoShowInfo)
        pAutoShowInfo = new sheet::DataPilotFieldAutoShowInfo( *(r.pAutoShowInfo) );
    else
        pAutoShowInfo = NULL;
    if (r.pLayoutInfo)
        pLayoutInfo = new sheet::DataPilotFieldLayoutInfo( *(r.pLayoutInfo) );
    else
        pLayoutInfo = NULL;
	if (r.pSelectedPage)
		pSelectedPage = new String( *(r.pSelectedPage) );
	else
		pSelectedPage = NULL;
	if (r.mpLayoutName.get())
        mpLayoutName.reset(new OUString(*r.mpLayoutName));
	if (r.mpSubtotalName.get())
		mpSubtotalName.reset(new OUString(*r.mpSubtotalName));
}

ScDPSaveDimension::~ScDPSaveDimension()
{
	for (MemberHash::const_iterator i=maMemberHash.begin(); i != maMemberHash.end() ; i++)
		delete i->second;
	delete pReferenceValue;
    delete pSortInfo;
    delete pAutoShowInfo;
    delete pLayoutInfo;
	delete pSelectedPage;
    delete [] pSubTotalFuncs;
}

sal_Bool ScDPSaveDimension::operator== ( const ScDPSaveDimension& r ) const
{
	if ( aName			  != r.aName			||
		 bIsDataLayout    != r.bIsDataLayout	||
		 bDupFlag		  != r.bDupFlag			||
		 nOrientation	  != r.nOrientation		||
		 nFunction		  != r.nFunction		||
		 nUsedHierarchy   != r.nUsedHierarchy   ||
		 nShowEmptyMode   != r.nShowEmptyMode   ||
		 bSubTotalDefault != r.bSubTotalDefault ||
		 nSubTotalCount   != r.nSubTotalCount )
		return sal_False;

	if ( nSubTotalCount && ( !pSubTotalFuncs || !r.pSubTotalFuncs ) )	// should not happen
		return sal_False;

	long i;
	for (i=0; i<nSubTotalCount; i++)
		if ( pSubTotalFuncs[i] != r.pSubTotalFuncs[i] )
			return sal_False;

	if (maMemberHash.size() != r.maMemberHash.size() )
		return sal_False;

	MemberList::const_iterator a=maMemberList.begin();
	MemberList::const_iterator b=r.maMemberList.begin();
	for (; a != maMemberList.end() ; ++a, ++b)
		if (!(**a == **b))
			return sal_False;

	if ( this->HasCurrentPage() && r.HasCurrentPage() )
	{
		if ( this->GetCurrentPage() != r.GetCurrentPage() )
		{
			return sal_False;
		}
	}
	else if ( this->HasCurrentPage() || r.HasCurrentPage() )
	{
		return sal_False;
	}
	if( pReferenceValue && r.pReferenceValue )
	{
		if ( !(*pReferenceValue == *r.pReferenceValue) )
		{
			return sal_False;
		}
	}
	else if ( pReferenceValue || r.pReferenceValue )
	{
		return sal_False;
	}
	if( this->pSortInfo && r.pSortInfo )
	{
		if ( !(*this->pSortInfo == *r.pSortInfo) )
		{
			return sal_False;
		}
	}
	else if ( this->pSortInfo || r.pSortInfo )
	{
		return sal_False;
	}
	if( this->pAutoShowInfo && r.pAutoShowInfo )
	{
		if ( !(*this->pAutoShowInfo == *r.pAutoShowInfo) )
		{
			return sal_False;
		}
	}
	else if ( this->pAutoShowInfo || r.pAutoShowInfo )
	{
		return sal_False;
	}

	return sal_True;
}

void ScDPSaveDimension::AddMember(ScDPSaveMember* pMember)
{
	const String & rName =  pMember->GetName();
	MemberHash::iterator aExisting = maMemberHash.find( rName );
	if ( aExisting == maMemberHash.end() )
	{
        std::pair< const String, ScDPSaveMember *> key( rName, pMember );
		maMemberHash.insert ( key );
	}
	else
	{
		maMemberList.remove( aExisting->second );
		delete aExisting->second;
		aExisting->second = pMember;
	}
	maMemberList.push_back( pMember );
}

void ScDPSaveDimension::SetName( const String& rNew )
{
    // Used only if the source dim was renamed (groups).
    // For UI renaming of dimensions, the layout name must be used.

    aName = rNew;
}

void ScDPSaveDimension::SetOrientation(sal_uInt16 nNew)
{
	nOrientation = nNew;
}

void ScDPSaveDimension::SetSubTotals(long nCount, const sal_uInt16* pFuncs)
{
	if (pSubTotalFuncs)
        delete [] pSubTotalFuncs;
	nSubTotalCount = nCount;
	if ( nCount && pFuncs )
	{
		pSubTotalFuncs = new sal_uInt16[nCount];
		for (long i=0; i<nCount; i++)
			pSubTotalFuncs[i] = pFuncs[i];
	}
	else
		pSubTotalFuncs = NULL;

	bSubTotalDefault = sal_False;
}

bool ScDPSaveDimension::HasShowEmpty() const
{
    return nShowEmptyMode != SC_DPSAVEMODE_DONTKNOW;
}

void ScDPSaveDimension::SetShowEmpty(sal_Bool bSet)
{
	nShowEmptyMode = bSet;
}

void ScDPSaveDimension::SetFunction(sal_uInt16 nNew)
{
	nFunction = nNew;
}

void ScDPSaveDimension::SetUsedHierarchy(long nNew)
{
	nUsedHierarchy = nNew;
}

void ScDPSaveDimension::SetSubtotalName(const OUString& rName)
{
	mpSubtotalName.reset(new OUString(rName));
}

const OUString* ScDPSaveDimension::GetSubtotalName() const
{
	return mpSubtotalName.get();
}

bool ScDPSaveDimension::IsMemberNameInUse(const OUString& rName) const
{
    MemberList::const_iterator itr = maMemberList.begin(), itrEnd = maMemberList.end();
    for (; itr != itrEnd; ++itr)
    {
        const ScDPSaveMember* pMem = *itr;
        if (rName.equalsIgnoreAsciiCase(pMem->GetName()))
            return true;

        const OUString* pLayoutName = pMem->GetLayoutName();
        if (pLayoutName && rName.equalsIgnoreAsciiCase(*pLayoutName))
            return true;
    }
    return false;
}

void ScDPSaveDimension::SetLayoutName(const OUString& rName)
{
    mpLayoutName.reset(new OUString(rName));
}

const OUString* ScDPSaveDimension::GetLayoutName() const
{
	return mpLayoutName.get();
}

void ScDPSaveDimension::RemoveLayoutName()
{
    mpLayoutName.reset();
}

void ScDPSaveDimension::SetReferenceValue(const sheet::DataPilotFieldReference* pNew)
{
    delete pReferenceValue;
    if (pNew)
        pReferenceValue = new sheet::DataPilotFieldReference(*pNew);
    else
        pReferenceValue = NULL;
}

void ScDPSaveDimension::SetSortInfo(const sheet::DataPilotFieldSortInfo* pNew)
{
    delete pSortInfo;
    if (pNew)
        pSortInfo = new sheet::DataPilotFieldSortInfo(*pNew);
    else
        pSortInfo = NULL;
}

void ScDPSaveDimension::SetAutoShowInfo(const sheet::DataPilotFieldAutoShowInfo* pNew)
{
    delete pAutoShowInfo;
    if (pNew)
        pAutoShowInfo = new sheet::DataPilotFieldAutoShowInfo(*pNew);
    else
        pAutoShowInfo = NULL;
}

void ScDPSaveDimension::SetLayoutInfo(const sheet::DataPilotFieldLayoutInfo* pNew)
{
    delete pLayoutInfo;
    if (pNew)
        pLayoutInfo = new sheet::DataPilotFieldLayoutInfo(*pNew);
    else
        pLayoutInfo = NULL;
}

void ScDPSaveDimension::SetCurrentPage( const String* pPage )
{
	delete pSelectedPage;
	if (pPage)
		pSelectedPage = new String( *pPage );
	else
		pSelectedPage = NULL;
}

sal_Bool ScDPSaveDimension::HasCurrentPage() const
{
	return ( pSelectedPage != NULL );
}

const String& ScDPSaveDimension::GetCurrentPage() const
{
	if (pSelectedPage)
		return *pSelectedPage;
	return EMPTY_STRING;
}

ScDPSaveMember* ScDPSaveDimension::GetExistingMemberByName(const String& rName)
{
	MemberHash::const_iterator res = maMemberHash.find (rName);
    if (res != maMemberHash.end())
		return res->second;
    return NULL;
}


ScDPSaveMember* ScDPSaveDimension::GetMemberByName(const String& rName)
{
	MemberHash::const_iterator res = maMemberHash.find (rName);
    if (res != maMemberHash.end())
		return res->second;

	ScDPSaveMember* pNew = new ScDPSaveMember( rName );
	maMemberHash[rName] = pNew;
	maMemberList.push_back( pNew );
	return pNew;
}

void ScDPSaveDimension::SetMemberPosition( const String& rName, sal_Int32 nNewPos )
{
    ScDPSaveMember* pMember = GetMemberByName( rName );     // make sure it exists and is in the hash

    maMemberList.remove( pMember );

    MemberList::iterator aIter = maMemberList.begin();
    for (sal_Int32 i=0; i<nNewPos && aIter != maMemberList.end(); i++)
        ++aIter;
    maMemberList.insert( aIter, pMember );
}

void ScDPSaveDimension::WriteToSource( const uno::Reference<uno::XInterface>& xDim )
{
	uno::Reference<beans::XPropertySet> xDimProp( xDim, uno::UNO_QUERY );
	DBG_ASSERT( xDimProp.is(), "no properties at dimension" );
	if ( xDimProp.is() )
	{
		// exceptions are caught at ScDPSaveData::WriteToSource
		uno::Any aAny;

		sheet::DataPilotFieldOrientation eOrient = (sheet::DataPilotFieldOrientation)nOrientation;
		aAny <<= eOrient;
		xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), aAny );

		sheet::GeneralFunction eFunc = (sheet::GeneralFunction)nFunction;
		aAny <<= eFunc;
		xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_FUNCTION), aAny );

		if ( nUsedHierarchy >= 0 )
		{
			aAny <<= (sal_Int32)nUsedHierarchy;
			xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_USEDHIERARCHY), aAny );
		}

		if ( pReferenceValue )
		{
			aAny <<= *pReferenceValue;
			xDimProp->setPropertyValue( rtl::OUString::createFromAscii(SC_UNO_REFVALUE), aAny );
		}

		uno::Sequence<sheet::TableFilterField> aFilter;
		// set the selected page field only if the dimension is used as page dimension
		if ( pSelectedPage && nOrientation == sheet::DataPilotFieldOrientation_PAGE )
		{
			// single filter field: first field equal to selected string
			sheet::TableFilterField aField( sheet::FilterConnection_AND, 0,
					sheet::FilterOperator_EQUAL, sal_False, 0.0, *pSelectedPage );
			aFilter = uno::Sequence<sheet::TableFilterField>( &aField, 1 );
		}
		// else keep empty sequence

        ScUnoHelpFunctions::SetOptionalPropertyValue(xDimProp, DP_PROP_FILTER, aFilter);
        if (mpLayoutName.get())
            ScUnoHelpFunctions::SetOptionalPropertyValue(xDimProp, SC_UNO_LAYOUTNAME, *mpLayoutName);

        const OUString* pSubTotalName = GetSubtotalName();
        if (pSubTotalName)
            // Custom subtotal name, with '?' being replaced by the visible field name later.
            ScUnoHelpFunctions::SetOptionalPropertyValue(xDimProp, SC_UNO_FIELD_SUBTOTALNAME, *pSubTotalName);
	}

	//	Level loop outside of maMemberList loop
	//	because SubTotals have to be set independently of known members

	long nCount = maMemberHash.size();

	long nHierCount = 0;
	uno::Reference<container::XIndexAccess> xHiers;
	uno::Reference<sheet::XHierarchiesSupplier> xHierSupp( xDim, uno::UNO_QUERY );
	if ( xHierSupp.is() )
	{
		uno::Reference<container::XNameAccess> xHiersName = xHierSupp->getHierarchies();
		xHiers = new ScNameToIndexAccess( xHiersName );
		nHierCount = xHiers->getCount();
	}

    sal_Bool bHasHiddenMember = false;

	for (long nHier=0; nHier<nHierCount; nHier++)
	{
		uno::Reference<uno::XInterface> xHierarchy = ScUnoHelpFunctions::AnyToInterface( xHiers->getByIndex(nHier) );

		long nLevCount = 0;
		uno::Reference<container::XIndexAccess> xLevels;
		uno::Reference<sheet::XLevelsSupplier> xLevSupp( xHierarchy, uno::UNO_QUERY );
		if ( xLevSupp.is() )
		{
			uno::Reference<container::XNameAccess> xLevelsName = xLevSupp->getLevels();
			xLevels = new ScNameToIndexAccess( xLevelsName );
			nLevCount = xLevels->getCount();
		}

		for (long nLev=0; nLev<nLevCount; nLev++)
		{
			uno::Reference<uno::XInterface> xLevel = ScUnoHelpFunctions::AnyToInterface( xLevels->getByIndex(nLev) );
			uno::Reference<beans::XPropertySet> xLevProp( xLevel, uno::UNO_QUERY );
			DBG_ASSERT( xLevProp.is(), "no properties at level" );
			if ( xLevProp.is() )
			{
                uno::Any aAny;
				if ( !bSubTotalDefault )
				{
					if ( !pSubTotalFuncs )
						nSubTotalCount = 0;

					uno::Sequence<sheet::GeneralFunction> aSeq(nSubTotalCount);
					sheet::GeneralFunction* pArray = aSeq.getArray();
					for (long i=0; i<nSubTotalCount; i++)
						pArray[i] = (sheet::GeneralFunction)pSubTotalFuncs[i];
					aAny <<= aSeq;
					xLevProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_SUBTOTALS), aAny );
				}
				if ( nShowEmptyMode != SC_DPSAVEMODE_DONTKNOW )
					lcl_SetBoolProperty( xLevProp,
						rtl::OUString::createFromAscii(DP_PROP_SHOWEMPTY), (sal_Bool)nShowEmptyMode );

                if ( pSortInfo )
                    ScUnoHelpFunctions::SetOptionalPropertyValue(xLevProp, SC_UNO_SORTING, *pSortInfo);

                if ( pAutoShowInfo )
                    ScUnoHelpFunctions::SetOptionalPropertyValue(xLevProp, SC_UNO_AUTOSHOW, *pAutoShowInfo);

                if ( pLayoutInfo )
                    ScUnoHelpFunctions::SetOptionalPropertyValue(xLevProp, SC_UNO_LAYOUT, *pLayoutInfo);

				// exceptions are caught at ScDPSaveData::WriteToSource
			}

			if ( nCount > 0 )
			{
				uno::Reference<sheet::XMembersSupplier> xMembSupp( xLevel, uno::UNO_QUERY );
				if ( xMembSupp.is() )
				{
					uno::Reference<container::XNameAccess> xMembers = xMembSupp->getMembers();
					if ( xMembers.is() )
					{
                        sal_Int32 nPosition = -1;           // set position only in manual mode
                        if ( !pSortInfo || pSortInfo->Mode == sheet::DataPilotFieldSortMode::MANUAL )
                            nPosition = 0;

						for (MemberList::const_iterator i=maMemberList.begin(); i != maMemberList.end() ; i++)
						{
                            ScDPSaveMember* pMember = *i;
                            if (!pMember->GetIsVisible())
                                bHasHiddenMember = true;
                            rtl::OUString aMemberName = pMember->GetName();
                            if ( xMembers->hasByName( aMemberName ) )
							{
								uno::Reference<uno::XInterface> xMemberInt = ScUnoHelpFunctions::AnyToInterface(
                                    xMembers->getByName( aMemberName ) );
								pMember->WriteToSource( xMemberInt, nPosition );

								if ( nPosition >= 0 )
    								++nPosition;            // increase if initialized
							}
							// missing member is no error
						}
					}
				}
			}
		}
	}

    if (xDimProp.is())
        ScUnoHelpFunctions::SetOptionalPropertyValue(xDimProp, SC_UNO_HAS_HIDDEN_MEMBER, bHasHiddenMember);
}

void ScDPSaveDimension::UpdateMemberVisibility(const hash_map<OUString, bool, OUStringHash>& rData)
{
    typedef hash_map<OUString, bool, OUStringHash> DataMap;
    MemberList::iterator itrMem = maMemberList.begin(), itrMemEnd = maMemberList.end();
    for (; itrMem != itrMemEnd; ++itrMem)
    {
        ScDPSaveMember* pMem = *itrMem;
        const String& rMemName = pMem->GetName();
        DataMap::const_iterator itr = rData.find(rMemName);
        if (itr != rData.end())
            pMem->SetIsVisible(itr->second);
    }
}

bool ScDPSaveDimension::HasInvisibleMember() const
{
    MemberList::const_iterator itrMem = maMemberList.begin(), itrMemEnd = maMemberList.end();
    for (; itrMem != itrMemEnd; ++itrMem)
    {
        const ScDPSaveMember* pMem = *itrMem;
        if (!pMem->GetIsVisible())
            return true;
    }
    return false;
}

// -----------------------------------------------------------------------

ScDPSaveData::ScDPSaveData() :
    pDimensionData( NULL ),
	nColumnGrandMode( SC_DPSAVEMODE_DONTKNOW ),
	nRowGrandMode( SC_DPSAVEMODE_DONTKNOW ),
	nIgnoreEmptyMode( SC_DPSAVEMODE_DONTKNOW ),
    nRepeatEmptyMode( SC_DPSAVEMODE_DONTKNOW ),
    bFilterButton( sal_True ),
    bDrillDown( sal_True ),
    // Wang Xu Ming -- 2009-8-17
    // DataPilot Migration - Cache&&Performance
    mnCacheId( -1),
    // End Comments
    mbDimensionMembersBuilt(false),
    mpGrandTotalName(NULL)
{
}

ScDPSaveData::ScDPSaveData(const ScDPSaveData& r) :
	nColumnGrandMode( r.nColumnGrandMode ),
	nRowGrandMode( r.nRowGrandMode ),
	nIgnoreEmptyMode( r.nIgnoreEmptyMode ),
	nRepeatEmptyMode( r.nRepeatEmptyMode ),
    bFilterButton( r.bFilterButton ),
    bDrillDown( r.bDrillDown ),
    // Wang Xu Ming -- 2009-8-17
    // DataPilot Migration - Cache&&Performance
    mnCacheId(  r.mnCacheId ),
    // End Comments
    mbDimensionMembersBuilt(r.mbDimensionMembersBuilt),
    mpGrandTotalName(NULL)
{
    if ( r.pDimensionData )
        pDimensionData = new ScDPDimensionSaveData( *r.pDimensionData );
    else
        pDimensionData = NULL;

	long nCount = r.aDimList.Count();
	for (long i=0; i<nCount; i++)
	{
		ScDPSaveDimension* pNew = new ScDPSaveDimension( *(ScDPSaveDimension*)r.aDimList.GetObject(i) );
		aDimList.Insert( pNew, LIST_APPEND );
	}

    if (r.mpGrandTotalName.get())
        mpGrandTotalName.reset(new OUString(*r.mpGrandTotalName));
}

ScDPSaveData& ScDPSaveData::operator= ( const ScDPSaveData& r )
{
	if ( &r != this )
	{
        // Wang Xu Ming -- 2009-8-17
        // DataPilot Migration - Cache&&Performance
        this->~ScDPSaveData();
        new( this ) ScDPSaveData ( r );
        // End Comments
	}
	return *this;
}

sal_Bool ScDPSaveData::operator== ( const ScDPSaveData& r ) const
{
	if ( nColumnGrandMode != r.nColumnGrandMode ||
		 nRowGrandMode    != r.nRowGrandMode	||
		 nIgnoreEmptyMode != r.nIgnoreEmptyMode ||
		 nRepeatEmptyMode != r.nRepeatEmptyMode ||
         bFilterButton    != r.bFilterButton    ||
         mnCacheId		  != r.mnCacheId ||/// Wang Xu Ming -- 2009-6-18 DataPilot Migration
         bDrillDown       != r.bDrillDown ||
         mbDimensionMembersBuilt != r.mbDimensionMembersBuilt)
		return sal_False;

    if ( pDimensionData || r.pDimensionData )
        if ( !pDimensionData || !r.pDimensionData || !( *pDimensionData == *r.pDimensionData ) )
            return sal_False;

	sal_uLong nCount = aDimList.Count();
	if ( nCount != r.aDimList.Count() )
		return sal_False;

	for (sal_uLong i=0; i<nCount; i++)
		if ( !( *(ScDPSaveDimension*)aDimList.GetObject(i) ==
				*(ScDPSaveDimension*)r.aDimList.GetObject(i) ) )
			return sal_False;

    if (mpGrandTotalName.get())
    {
        if (!r.mpGrandTotalName.get())
            return false;
        if (!mpGrandTotalName->equals(*r.mpGrandTotalName))
            return false;
    }
    else if (r.mpGrandTotalName.get())
        return false;

	return sal_True;
}

ScDPSaveData::~ScDPSaveData()
{
	long nCount = aDimList.Count();
	for (long i=0; i<nCount; i++)
		delete (ScDPSaveDimension*)aDimList.GetObject(i);
	aDimList.Clear();

    delete pDimensionData;
}

void ScDPSaveData::SetGrandTotalName(const OUString& rName)
{
    mpGrandTotalName.reset(new OUString(rName));
}

const OUString* ScDPSaveData::GetGrandTotalName() const
{
    return mpGrandTotalName.get();
}

ScDPSaveDimension* ScDPSaveData::GetDimensionByName(const String& rName)
{
	long nCount = aDimList.Count();
	for (long i=0; i<nCount; i++)
	{
		ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
		if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
			return pDim;
	}
	ScDPSaveDimension* pNew = new ScDPSaveDimension( rName, sal_False );
	aDimList.Insert( pNew, LIST_APPEND );
    mbDimensionMembersBuilt = false;        // BuildAllDimensionMembers only handles existing entries in aDimList
	return pNew;
}

ScDPSaveDimension* ScDPSaveData::GetExistingDimensionByName(const String& rName) const
{
	long nCount = aDimList.Count();
	for (long i=0; i<nCount; i++)
	{
		ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
		if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
			return pDim;
	}
	return NULL;		// don't create new
}

ScDPSaveDimension* ScDPSaveData::GetNewDimensionByName(const String& rName)
{
	long nCount = aDimList.Count();
	for (long i=0; i<nCount; i++)
	{
		ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
		if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
			return DuplicateDimension(rName);
	}
	ScDPSaveDimension* pNew = new ScDPSaveDimension( rName, sal_False );
	aDimList.Insert( pNew, LIST_APPEND );
    mbDimensionMembersBuilt = false;        // BuildAllDimensionMembers only handles existing entries in aDimList
	return pNew;
}

ScDPSaveDimension* ScDPSaveData::GetDataLayoutDimension()
{
    ScDPSaveDimension* pDim = GetExistingDataLayoutDimension();
    if (pDim)
        return pDim;

	ScDPSaveDimension* pNew = new ScDPSaveDimension( String(), sal_True );
	aDimList.Insert( pNew, LIST_APPEND );
    mbDimensionMembersBuilt = false;        // BuildAllDimensionMembers only handles existing entries in aDimList
	return pNew;
}

ScDPSaveDimension* ScDPSaveData::GetExistingDataLayoutDimension() const
{
    long nCount = aDimList.Count();
    for (long i=0; i<nCount; i++)
    {
		ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
		if ( pDim->IsDataLayout() )
			return pDim;
	}
    return NULL;
}

ScDPSaveDimension* ScDPSaveData::DuplicateDimension(const String& rName)
{
	//	always insert new
	//!	check if dimension is there?

	ScDPSaveDimension* pOld = GetDimensionByName( rName );
	ScDPSaveDimension* pNew = new ScDPSaveDimension( *pOld );
	pNew->SetDupFlag( sal_True );
	aDimList.Insert( pNew, LIST_APPEND );
    mbDimensionMembersBuilt = false;        // BuildAllDimensionMembers only handles existing entries in aDimList
	return pNew;
}

void ScDPSaveData::RemoveDimensionByName(const String& rName)
{
    long nCount = aDimList.Count();
    for (long i=0; i<nCount; i++)
    {
        ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
        if ( pDim->GetName() == rName && !pDim->IsDataLayout() )
        {
            delete pDim;
            aDimList.Remove(i);
            break;
        }
    }
}

ScDPSaveDimension& ScDPSaveData::DuplicateDimension( const ScDPSaveDimension& rDim )
{
    ScDPSaveDimension* pNew = new ScDPSaveDimension( rDim );
    pNew->SetDupFlag( sal_True );
    aDimList.Insert( pNew, LIST_APPEND );
    mbDimensionMembersBuilt = false;        // BuildAllDimensionMembers only handles existing entries in aDimList
    return *pNew;
}

ScDPSaveDimension* ScDPSaveData::GetInnermostDimension(sal_uInt16 nOrientation)
{
    //  return the innermost dimension for the given orientation,
    //  excluding data layout dimension

    ScDPSaveDimension* pInner = NULL;
    long nCount = aDimList.Count();
    for (long i=0; i<nCount; i++)
    {
        ScDPSaveDimension* pDim = static_cast<ScDPSaveDimension*>(aDimList.GetObject(i));
        if ( pDim->GetOrientation() == nOrientation && !pDim->IsDataLayout() )
            pInner = pDim;
    }
    return pInner;      // the last matching one
}

ScDPSaveDimension* ScDPSaveData::GetFirstDimension(sheet::DataPilotFieldOrientation eOrientation)
{
    long nCount = aDimList.Count();
    for (long i = 0; i < nCount; ++i)
    {
        ScDPSaveDimension* pDim = static_cast<ScDPSaveDimension*>(aDimList.GetObject(i));
        if (pDim->GetOrientation() == eOrientation && !pDim->IsDataLayout())
            return pDim;
    }
    return NULL;
}

long ScDPSaveData::GetDataDimensionCount() const
{
    long nDataCount = 0;

    long nCount = aDimList.Count();
    for (long i=0; i<nCount; i++)
    {
        const ScDPSaveDimension* pDim = static_cast<const ScDPSaveDimension*>(aDimList.GetObject(i));
        if ( pDim->GetOrientation() == sheet::DataPilotFieldOrientation_DATA )
            ++nDataCount;
    }

    return nDataCount;
}

void ScDPSaveData::SetPosition( ScDPSaveDimension* pDim, long nNew )
{
	//	position (nNew) is counted within dimensions of the same orientation

	sal_uInt16 nOrient = pDim->GetOrientation();

	aDimList.Remove( pDim );
	sal_uLong nCount = aDimList.Count();		// after remove

	sal_uLong nInsPos = 0;
	while ( nNew > 0 && nInsPos < nCount )
	{
		if ( ((ScDPSaveDimension*)aDimList.GetObject(nInsPos))->GetOrientation() == nOrient )
			--nNew;
		++nInsPos;
	}

	aDimList.Insert( pDim, nInsPos );
}

void ScDPSaveData::SetColumnGrand(sal_Bool bSet)
{
	nColumnGrandMode = bSet;
}

void ScDPSaveData::SetRowGrand(sal_Bool bSet)
{
	nRowGrandMode = bSet;
}

void ScDPSaveData::SetIgnoreEmptyRows(sal_Bool bSet)
{
	nIgnoreEmptyMode = bSet;
}

void ScDPSaveData::SetRepeatIfEmpty(sal_Bool bSet)
{
	nRepeatEmptyMode = bSet;
}

void ScDPSaveData::SetFilterButton(sal_Bool bSet)
{
    bFilterButton = bSet;
}

void ScDPSaveData::SetDrillDown(sal_Bool bSet)
{
    bDrillDown = bSet;
}

void lcl_ResetOrient( const uno::Reference<sheet::XDimensionsSupplier>& xSource )
{
	sheet::DataPilotFieldOrientation eOrient = sheet::DataPilotFieldOrientation_HIDDEN;

	uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
	uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
	long nIntCount = xIntDims->getCount();
	for (long nIntDim=0; nIntDim<nIntCount; nIntDim++)
	{
		uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) );
		uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
		if (xDimProp.is())
		{
			uno::Any aAny;
			aAny <<= eOrient;
			xDimProp->setPropertyValue( rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), aAny );
		}
	}
}

void ScDPSaveData::WriteToSource( const uno::Reference<sheet::XDimensionsSupplier>& xSource )
{
	if (!xSource.is())
		return;

	//	source options must be first!

	uno::Reference<beans::XPropertySet> xSourceProp( xSource, uno::UNO_QUERY );
	DBG_ASSERT( xSourceProp.is(), "no properties at source" );
	if ( xSourceProp.is() )
	{
		//	source options are not available for external sources
		//!	use XPropertySetInfo to test for availability?

		try
		{
			if ( nIgnoreEmptyMode != SC_DPSAVEMODE_DONTKNOW )
				lcl_SetBoolProperty( xSourceProp,
					rtl::OUString::createFromAscii(DP_PROP_IGNOREEMPTY), (sal_Bool)nIgnoreEmptyMode );
			if ( nRepeatEmptyMode != SC_DPSAVEMODE_DONTKNOW )
				lcl_SetBoolProperty( xSourceProp,
					rtl::OUString::createFromAscii(DP_PROP_REPEATIFEMPTY), (sal_Bool)nRepeatEmptyMode );
		}
		catch(uno::Exception&)
		{
			// no error
		}

        const OUString* pGrandTotalName = GetGrandTotalName();
        if (pGrandTotalName)
            ScUnoHelpFunctions::SetOptionalPropertyValue(xSourceProp, SC_UNO_GRANDTOTAL_NAME, *pGrandTotalName);
	}

	// exceptions in the other calls are errors
	try
	{
		//	reset all orientations
		//!	"forgetSettings" or similar at source ?????
		//!	reset all duplicated dimensions, or reuse them below !!!
		DBG_TRACE( "ScDPSaveData::WriteToSource" );

		lcl_ResetOrient( xSource );

		long nCount = aDimList.Count();
		for (long i=0; i<nCount; i++)
		{
			ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
			rtl::OUString aName = pDim->GetName();

			DBG_TRACESTR(pDim->GetName());

			sal_Bool bData = pDim->IsDataLayout();

			//!	getByName for ScDPSource, including DataLayoutDimension !!!!!!!!

			uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
			uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
			long nIntCount = xIntDims->getCount();
			sal_Bool bFound = sal_False;
			for (long nIntDim=0; nIntDim<nIntCount && !bFound; nIntDim++)
			{
				uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) );
				if ( bData )
				{
					uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY );
					if ( xDimProp.is() )
					{
						bFound = ScUnoHelpFunctions::GetBoolProperty( xDimProp,
									rtl::OUString::createFromAscii(DP_PROP_ISDATALAYOUT) );
						//!	error checking -- is "IsDataLayoutDimension" property required??
					}
				}
				else
				{
					uno::Reference<container::XNamed> xDimName( xIntDim, uno::UNO_QUERY );
					if ( xDimName.is() && xDimName->getName() == aName )
						bFound = sal_True;
				}

				if ( bFound )
				{
					if ( pDim->GetDupFlag() )
					{
						String aNewName = pDim->GetName();

						// different name for each duplication of a (real) dimension...
						for (long j=0; j<=i; j++)	//! Test !!!!!!
							aNewName += '*';		//! modify name at creation of SaveDimension

						uno::Reference<util::XCloneable> xCloneable( xIntDim, uno::UNO_QUERY );
						DBG_ASSERT( xCloneable.is(), "cannot clone dimension" );
						if (xCloneable.is())
						{
							uno::Reference<util::XCloneable> xNew = xCloneable->createClone();
							uno::Reference<container::XNamed> xNewName( xNew, uno::UNO_QUERY );
							if (xNewName.is())
							{
								xNewName->setName( aNewName );
								pDim->WriteToSource( xNew );
							}
						}
					}
					else
						pDim->WriteToSource( xIntDim );
				}
			}
			DBG_ASSERT(bFound, "WriteToSource: Dimension not found");
		}

		if ( xSourceProp.is() )
		{
			if ( nColumnGrandMode != SC_DPSAVEMODE_DONTKNOW )
				lcl_SetBoolProperty( xSourceProp,
					rtl::OUString::createFromAscii(DP_PROP_COLUMNGRAND), (sal_Bool)nColumnGrandMode );
			if ( nRowGrandMode != SC_DPSAVEMODE_DONTKNOW )
				lcl_SetBoolProperty( xSourceProp,
					rtl::OUString::createFromAscii(DP_PROP_ROWGRAND), (sal_Bool)nRowGrandMode );
		}
	}
	catch(uno::Exception&)
	{
		DBG_ERROR("exception in WriteToSource");
	}
}

sal_Bool ScDPSaveData::IsEmpty() const
{
	long nCount = aDimList.Count();
	for (long i=0; i<nCount; i++)
	{
		ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);
		if ( pDim->GetOrientation() != sheet::DataPilotFieldOrientation_HIDDEN && !pDim->IsDataLayout() )
			return sal_False;
	}
	return sal_True;	// no entries that are not hidden
}

ScDPDimensionSaveData* ScDPSaveData::GetDimensionData()
{
    if (!pDimensionData)
        pDimensionData = new ScDPDimensionSaveData;
    return pDimensionData;
}

void ScDPSaveData::SetDimensionData( const ScDPDimensionSaveData* pNew )
{
    delete pDimensionData;
    if ( pNew )
        pDimensionData = new ScDPDimensionSaveData( *pNew );
    else
        pDimensionData = NULL;
}

void ScDPSaveData::BuildAllDimensionMembers(ScDPTableData* pData)
{
    if (mbDimensionMembersBuilt)
        return;

    // First, build a dimension name-to-index map.
    typedef hash_map<OUString, long, ::rtl::OUStringHash> NameIndexMap;
    NameIndexMap aMap;
    long nColCount = pData->GetColumnCount();
    for (long i = 0; i < nColCount; ++i)
        aMap.insert( NameIndexMap::value_type(pData->getDimensionName(i), i));

    NameIndexMap::const_iterator itrEnd = aMap.end();

    sal_uInt32 n = aDimList.Count();
    for (sal_uInt32 i = 0; i < n; ++i)
    {
        ScDPSaveDimension* pDim = static_cast<ScDPSaveDimension*>(aDimList.GetObject(i));
        const String& rDimName = pDim->GetName();
        if (!rDimName.Len())
            // empty dimension name.  It must be data layout.
            continue;

        NameIndexMap::const_iterator itr = aMap.find(rDimName);
        if (itr == itrEnd)
            // dimension name not in the data.  This should never happen!
            continue;

        long nDimIndex = itr->second;
        const std::vector<SCROW>& rMembers = pData->GetColumnEntries(nDimIndex);
        size_t mMemberCount = rMembers.size();
        for (size_t j = 0; j < mMemberCount; ++j)
        {
            const ScDPItemData* pMemberData = pData->GetMemberById( nDimIndex, rMembers[j] );
            String aMemName = pMemberData->GetString();
            if (pDim->GetExistingMemberByName(aMemName))
                // this member instance already exists.  nothing to do.
                continue;

            auto_ptr<ScDPSaveMember> pNewMember(new ScDPSaveMember(aMemName));
            pNewMember->SetIsVisible(true);
            pDim->AddMember(pNewMember.release());
        }
    }

    mbDimensionMembersBuilt = true;
}

void ScDPSaveData::BuildAllDimensionMembersFromSource( ScDPObject* pDPObj )
{
    // Initialize all members like BuildAllDimensionMembers, but access only the DataPilotSource, not the table data.
    // This could also replace BuildAllDimensionMembers, but the performance implications still have to be checked.
    // ScDPObject is used for the helper method GetMemberNames.

    if (mbDimensionMembersBuilt)
        return;

    uno::Reference<sheet::XDimensionsSupplier> xSource = pDPObj->GetSource();
    uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
    // GetMemberNames uses the dimension index from getElementNames
    uno::Sequence<OUString> aDimNames = xDimsName->getElementNames();

    // First, build a dimension name-to-index map.
    typedef hash_map<OUString, long, ::rtl::OUStringHash> NameIndexMap;
    NameIndexMap aMap;
    long nColCount = aDimNames.getLength();
    for (long i = 0; i < nColCount; ++i)
        aMap.insert( NameIndexMap::value_type(aDimNames[i], i) );

    NameIndexMap::const_iterator itrEnd = aMap.end();

    sal_uInt32 n = aDimList.Count();
    for (sal_uInt32 i = 0; i < n; ++i)
    {
        ScDPSaveDimension* pDim = static_cast<ScDPSaveDimension*>(aDimList.GetObject(i));
        const String& rDimName = pDim->GetName();
        if (!rDimName.Len())
            // empty dimension name.  It must be data layout.
            continue;

        NameIndexMap::const_iterator itr = aMap.find(rDimName);
        if (itr == itrEnd)
            // dimension name not in the data.  This should never happen!
            continue;

        long nDimIndex = itr->second;
        uno::Sequence<OUString> aMemberNames;
        pDPObj->GetMemberNames( nDimIndex, aMemberNames );
        sal_Int32 nMemberCount = aMemberNames.getLength();
        for (sal_Int32 j = 0; j < nMemberCount; ++j)
        {
            String aMemName = aMemberNames[j];
            if (pDim->GetExistingMemberByName(aMemName))
                // this member instance already exists.  nothing to do.
                continue;

            auto_ptr<ScDPSaveMember> pNewMember(new ScDPSaveMember(aMemName));
            pNewMember->SetIsVisible(true);
            pDim->AddMember(pNewMember.release());
        }
    }

    mbDimensionMembersBuilt = true;
}

bool ScDPSaveData::HasInvisibleMember(const OUString& rDimName) const
{
    ScDPSaveDimension* pDim = GetExistingDimensionByName(rDimName);
    if (!pDim)
        return false;

    return pDim->HasInvisibleMember();
}

void ScDPSaveData::Refresh( const uno::Reference<sheet::XDimensionsSupplier>& xSource )
{
    try
    {
        long nCount = aDimList.Count();
        std::list<String> deletedDims;
        for (long i=nCount-1; i >=0 ; i--)
        {
            ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);

            rtl::OUString aName = pDim->GetName();
            if ( pDim->IsDataLayout() )
                continue;

            uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions();
            uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName );
            long nIntCount = xIntDims->getCount();
            sal_Bool bFound = sal_False;
            for (long nIntDim=0; nIntDim<nIntCount && !bFound; nIntDim++)
            {
                uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) );
                uno::Reference<container::XNamed> xDimName( xIntDim, uno::UNO_QUERY );
                if ( xDimName.is() && xDimName->getName() == aName )
                    bFound = sal_True;
            }
            if ( !bFound )
            {
                deletedDims.push_back( aName );
                aDimList.Remove(i);
                DBG_TRACE( "\n Remove dim: \t" );
                DBG_TRACESTR(  String( aName ) );
            }

        }

        nCount = aDimList.Count();
        for (long  i=nCount-1; i >=0 ; i--) //check every dimension ??
        {
            ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i);

            rtl::OUString aName = pDim->GetName();
            if ( pDim->IsDataLayout() )
                continue;
            pDim->Refresh( xSource, deletedDims );

        }

        mbDimensionMembersBuilt = false;    // there may be new members
    }
    catch(uno::Exception&)
    {
        DBG_ERROR("error in ScDPSaveData::Refresh");
    }

}
void ScDPSaveDimension::Refresh( const com::sun::star::uno::Reference<
                                com::sun::star::sheet::XDimensionsSupplier>& xSource ,
                                const std::list<String>& deletedDims)
{
    if ( xSource.is() )
    {
        ScDPSource* pTabSource = static_cast<ScDPSource*>( xSource.get() );
        ScDPTableDataCache*  pCache = pTabSource->GetCache();
        if ( pCache->GetId() == -1 )
            return;

        SCCOL nSrcDim = pCache->GetDimensionIndex( GetName() );

        if ( nSrcDim == -1 )
            return;
        if ( pSelectedPage )
        {//check pSelected page
            DBG_TRACESTR( (*pSelectedPage) );
            if ( pCache->GetIdByItemData( nSrcDim, *pSelectedPage ) == -1 )
            {
                delete pSelectedPage;
                pSelectedPage = NULL;
            }

        };

        if ( pReferenceValue && pReferenceValue->ReferenceItemType == DataPilotFieldReferenceItemType::NAMED )
        {//check pReferenceValue
#ifdef DEBUG
            switch( pReferenceValue->ReferenceType)
            {
            case sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE: //both
                DBG_TRACE( "\n sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE \n" );
                break;
            case sheet::DataPilotFieldReferenceType::ITEM_DIFFERENCE: //both
                DBG_TRACE( "\n sheet::DataPilotFieldReferenceType::ITEM_DIFFERENCE \n" );
                break;
            case sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE: //both
                DBG_TRACE( "\n sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE \n" );
                break;
            case sheet::DataPilotFieldReferenceType::RUNNING_TOTAL:
                DBG_TRACE( "\n sheet::DataPilotFieldReferenceType::RUNNING_TOTAL \n" ); //enable name
                break;
            }
#endif
            switch( pReferenceValue->ReferenceType)
            {
            case sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE:
            case sheet::DataPilotFieldReferenceType::ITEM_DIFFERENCE:
            case sheet::DataPilotFieldReferenceType::ITEM_PERCENTAGE_DIFFERENCE:
            case sheet::DataPilotFieldReferenceType::RUNNING_TOTAL:
                {
                    if( pReferenceValue->ReferenceItemType == DataPilotFieldReferenceItemType::NAMED  )
                    {
                        const String& sReferenceFieldName = pReferenceValue->ReferenceField;
                        DBG_TRACESTR( sReferenceFieldName );
                        SCCOL nRefDim = pCache->GetDimensionIndex( sReferenceFieldName );
                        bool bValid = true;
                        if ( nRefDim == -1 )
                            bValid = false;
                        else if ( pReferenceValue->ReferenceType != sheet::DataPilotFieldReferenceType::RUNNING_TOTAL )
                        { //running total has not reference item
                            const String& sReferenceItemName = pReferenceValue->ReferenceItemName;
                            DBG_TRACESTR( sReferenceItemName );
                            if ( pCache->GetIdByItemData( nRefDim, sReferenceItemName ) == -1 )
                                bValid = false;
                        }
                        if ( !bValid )
                        {
                            delete pReferenceValue;
                            pReferenceValue = NULL;
                        }
                    }
                }
                break;
            }

        };

        if ( pSortInfo )
        { //check sortinfo
            if ( pSortInfo->Mode == DataPilotFieldSortMode::DATA )
            {
                DBG_TRACE( "\n DataPilotFieldSortMode::DATA \n" );
                const String& sFieldDimName = pSortInfo->Field;
                std::list<String>::const_iterator iter = std::find( deletedDims.begin(), deletedDims.end(), sFieldDimName );
                if ( iter != deletedDims.end() && pCache->GetDimensionIndex( sFieldDimName ) == -1  )
                {
                    pSortInfo->Mode = DataPilotFieldSortMode::MANUAL;
                    pSortInfo->Field = GetName();
                }
            }

        };

        if ( pAutoShowInfo )
        { //check autoshow
            const String& sFieldDimName = pAutoShowInfo->DataField;
            std::list<String>::const_iterator iter = std::find( deletedDims.begin(), deletedDims.end(), sFieldDimName );
            if ( iter != deletedDims.end() && pCache->GetDimensionIndex( sFieldDimName ) == -1  )
            {
                delete pAutoShowInfo;
                pAutoShowInfo = NULL;
            }

        };

        //remove unused members
        for (MemberList::iterator i=maMemberList.begin(); i != maMemberList.end() ; )
        {
            rtl::OUString aMemberName = (*i)->GetName();
            if ( pCache->GetIdByItemData( nSrcDim, aMemberName ) == -1 )
                i = maMemberList.erase( i );
            else
                i++;
        }
    }
}
// End Comments
bool operator == (const ::com::sun::star::sheet::DataPilotFieldSortInfo &l, const ::com::sun::star::sheet::DataPilotFieldSortInfo &r )
{
	return l.Field == r.Field && l.IsAscending == r.IsAscending && l.Mode == r.Mode;
}
bool operator == (const ::com::sun::star::sheet::DataPilotFieldAutoShowInfo &l, const ::com::sun::star::sheet::DataPilotFieldAutoShowInfo &r )
{
	return l.IsEnabled == r.IsEnabled &&
		l.ShowItemsMode == r.ShowItemsMode &&
		l.ItemCount == r.ItemCount &&
		l.DataField == r.DataField;
}
bool operator == (const ::com::sun::star::sheet::DataPilotFieldReference &l, const ::com::sun::star::sheet::DataPilotFieldReference &r )
{
	return l.ReferenceType == r.ReferenceType &&
		l.ReferenceField == r.ReferenceField &&
		l.ReferenceItemType == r.ReferenceItemType &&
		l.ReferenceItemName == r.ReferenceItemName;
}